Yleistä Mathematicasta

Mathematica on matemaattinen ohjelmisto, jossa on mukana sekä symbolinen että numeerinen laskenta. Mathematicalla voidaan myös ohjelmoida ja sen graafiset ominaisuudet ovat erittäin monipuoliset. Muistikirjapohjaisella Mathematicalla  voidaan lisäksi tuottaa kauniita dokumentteja. 
Mathematican päätekijä on Stephen Wolfram ja yhdysvaltalainen yritys Wolfram Research, Inc. Mathematica on saatavissa moniin eri käyttöympäristöihin: Macintosh, Windows, Linux ja erilaiset Unix-ympäristöt. WWW-sivuilta saa ajantasalla olevaa tietoa ohjelmistosta: http://www.wri.com/

Mathematican  rakenne

Mathematica on jaettu kahteen osaan: kerneliin ja front endiin. Kernel eli ydin suorittaa laskennan ja front end on ohjelman käyttöliittymä. Kernel on kaikissa tietokoneissa sama, mutta front end vaihtelee käyttöympäristön mukaan.
Yleisin Mathematican käyttöliittymä on muistikirjapohjainen (notebook-pohjainen). Tämä opas on esimerkki muistikirjasta. Mathematica on varustettu usein myös tekstipohjaisella käyttöliittymällä.

Tekstipohjaisessa käyttöliittymässä syötteet kirjoitetaan näppäimistöltä suoraan komentoikkunaan. Tulosteet ilmestyvät myös komentoikkunaan. Grafiikka tulostuu yleensä omaan ikkunaansa.

Muistikirja-käyttöliittymässä Mathematica-istunnosta muodostuu tallennettava dokumentti, jossa voidaan ajaa syötteitä, tulostaa grafiikkaa, muokata aiempia syötteitä, lisätä tavallista tekstiä jne.

Käyttäjä keskustelee yleensä front endin kanssa. Front end saa käyttäjältä komentoja, jotka se tarvittaessa lähettää kerneliin. Tekstipohjaisessa käyttöliittymässä käyttäjä keskustelee oikeastaan suoraan kernelin kanssa. Tekstipohjainen käyttöliittymä on hyödyllinen, kun Mathematicaa käytetään laskentatyökaluna modeemin välityksellä.

Lisäpaketit

Mathematicalle ominainen piirre on sen laajennettavuus. Tämä perustuu suurelta osin Mathematican omalla ohjelmointikielellä laadittuihin erillisiin lisäpaketteihin. Paketit sisältävät komentoja, joita ei ole sisällytetty kerneliin. Vain kerneliin sisältyvät komennot ladataan automaattisesti käynnistettäessä Mathematica. Paketit on ladattava erikseen. 
Mathematican jakeluversioon sisältyy useita paketteja, jotka on järjestetty hierarkkisesti alihakemistoiksi, ja jotka käyttäjä voi tarvittaessa ladata.  Paketteja voi hankkia myös erilaisista ohjelmistopalvelimista ja käyttäjä voi rakentaa myös omia paketteja.
Katso:  Pakettien lataaminen

Aloitus ja lopetus

Graafisessa käyttöympäristössä Mathematica käynnistetään yleensä kaksoisnäpäyttämällä Mathematica-ikonia \[MathematicaIcon]. Komentoikkunasta Mathematica käynnistetään  yleensä komennolla mathematica (muistikirja-käyttöliittymä) tai math (tekstipohjainen käyttöliittymä). Tekstipohjainen Mathematica voidaan käynnistää graafisessa käyttöliittymässä myös suoraan kernelin ikonista \[KernelIcon].
Muistikirja-käyttöliittymää käytettäessä Mathematica-istunto lopetetaan valitsemalla File-valikosta Exit. Mathematica-istunto lopetetaan tekstipohjaisessa käyttöliittymässä komennolla Quit, Exit tai graafista käyttöliittymää käytettäessä valitsemalla File-valikosta Exit.

Syötteiden ajaminen

Syötteet ajetaan eli lähetetään kerneliin näppäinkomennolla shift-enter eli Shift-näppäin pohjassa painetaan Enter (Return).  Tekstipohjaisissa käyttöliittymissä riittää usein pelkkä enter.
Samaan soluun tai syöteriviin voidaan kirjoittaa myös useita syötteitä erottamalla syötteet toisistaan puolipisteellä. Tällöin vain viimeisen syötteen tulos tulee näkyviin. Muistikirjapohjaisessa käyttöliittymässä syötteiden erottimena toimii myös pelkkä Enter. Tällöin kaikkien syötteiden tulosteet tulevat näkyviin.
Yleensäkin kun syötteen antamaa tulostetta ei haluta näkyviin, syötteen perään lisätään puolipiste ;. Kun piirustuskomento (esimerkiksi Plot tai Show) päätetään puolipisteeseen, kuva kyllä näytetään, mutta  teksti -Graphics- ei tulostu kuvan alle.

Laskennan keskeyttäminen

Päättymätön tai liian pitkä laskenta voidaan keskeyttää muistikirja-käyttöliittymässä joko valitsemalla Kernel-valikosta Interrupt Evaluation tai painamalla alt-piste  eli Alt-näppäin pohjassa painetaan pistettä. Tekstipohjaisessa käyttöliittymässä laskenta keskeytetään komennolla control-c eli Ctrl-näppäin pohjassa painetaan c.

Opastus

Mathematica sisältää monipuolisen opastusjärjestelmän. Lisätietoja saadaan mistä tahansa Mathematicaan valmiiksi määritellystä tai käyttäjän istunnon aikana itse määrittelemästä muuttujasta/komennosta kysymysmerkillä. Esimerkiksi ?Solve antaa tietoa komennon Solve käytöstä. Useissa tapauksissa kaksi kysymysmerkkiä antaa yksityiskohtaisempaa tietoa: ??Solve. Lisätietoa voidaan kysyä myös erikoismerkkijonoista. Esimerkiksi  ?:= antaa lisätietoa sijoitusoperaattorin := käytöstä.
Asteriskilla * voidaan korvata etsittävässä merkkijonossa yksi tai useampia merkkejä. Esimerkiksi ?Int* listaa kaikki Int-alkuiset komennot. Komennossa voi olla myös useampia kuin yksi *-merkki.
Muistikirja-käyttöliittymässä Help Browser tarjoaa erinomaisen opastusjärjestelmän. Tämä saadaan käynnistettyä valitsemalla Help-valikosta Help. Kun Help Browserin tyhjään kenttään kirjoitetaan komennon nimi ja painetaan GoTo-painiketta, ilmestyy sivu, jossa on tietoa ko. komennosta. Yleensä tältä sivulta on linkkejä myös asianomaisiin kohtiin Mathematica Bookissa. Mathematica Bookia voidaan selata Help Browserissa myös sen oman sisällysluettelon avulla. 
Help Browserissa on Back-painike, jonka avulla voidaan selata linkkejä taaksepäin.

Virheilmoitukset

Jos syötteessä on virhe, Mathematica antaa virheilmoituksen. Virheilmoitukset auttavat syötteessä olevan virheen löytämisessä.

Sqrt[3

Sqrt[3, 4]

Muistikirja-käyttöliittymä

Käynnistettäessä muistikirjapohjainen Mathematica  näytölle avautuu tyhjä muistikirja (notebook) ja valikko sekä mahdollisesti erilaisia paletteja. Muistikirjoja voi olla avoinna useita samaan aikaan.
Muistikirja on interaktiivinen dokumentti, jossa syötteiden parametreja voidaan muuttaa, komentoja ajaa uudelleen jne.  Muistikirjaan voidaan kirjoittaa tekstiä, lisätä otsikoita, liittää animaatioita jne. Katso: Muistikirjat dokumentteina

Solut

Muistikirja koostuu soluista. Solut on merkitty muistikirjan oikeassa laidassa olevilla hakasilla. (Tässä oppaassa hakaset on piilotettu.) Syöte on omassa solussaan ja sitä vastaava tuloste omassaan. Uusi syötesolu muodostetaan automaattisesti, kun edellinen komento on suoritettu. Soluja voidaan sijoittaa myös entisten solujen väliin näpäyttämällä hiirellä soluhakasten välistä aluetta ja kirjoittamalla sen jälkeen uuden solun sisältö tähän. 
Solu valitaan näpäyttämällä solun oikeassa reunassa olevaa hakasta. Kun solu on valittu, se voidaan mm. kopioida tai leikata valitsemalla Edit-valikosta sopiva toiminto. 
Aiempien solujen sisältöön voidaan tehdä korjauksia/muutoksia siirtämällä kursori kyseisen solun kohdalle. Muutosten jälkeen solun sisältö voidaan ajaa uudelleen.
Solujen tyylit: Muistikirjat dokumentteina

Solujen ryhmittely

Soluja voidaan koota ryhmiksi. Oletuksena tyhjään muistikirjaan on asetettu automaattinen ryhmittely (Automatic Grouping). Tällöin esimerkiksi syöte ja sitä vastaava tuloste on aina oma ryhmänsä. Soluryhmä voidaan sulkea kaksoisnäpäyttämällä soluryhmän oikeassa reunassa olevaa soluryhmää yhdistävää hakasta. Kun soluryhmä on suljettuna, käyttäjä näkee vain ylimmän solun (syötesolun) sisällön. Soluryhmä avataan vastaavasti kaksoisnäpäyttämällä hakasta. 
Kun muistikirjasta on rakennettu dokumentti, jossa on eritasoisia otsikoita ja tekstiä, automaattinen ryhmittely ryhmittelee solut sisäkkäisiksi ryhmiksi siten, että alemman tason otsikot sisältöineen kuuluvat aina ylemmän tason otsikon alle. 
Ryhmittely voi olla myös manuaalista, jolloin käyttäjä itse valitsee ne solut, jotka kootaan ryhmäksi. Manuaalinen ryhmittely valitaan Cell-valikon kohdasta Cell Grouping, jossa sijaitsevat myös tarvittavat ryhmittelyyn liittyvät komennot.

Muistikirjan tallentaminen ja avaaminen

Muistikirja voidaan tallentaa valitsemalla File-valikosta Save tai Save As. Kun tallennettu muistikirja avataan, siinä olevat tulokset ovat käytettävissä vasta, kun niihin tuloksiin liittyvät käskyt on ajettu uudelleen.

Paletit

Mathematican  mukana on useita paletteja, joita voidaan käyttää apuna syötteiden ja kaavojen kirjoittamisessa. Paletit saadaan käyttöön valitsemalla File-valikosta Palettes. Syötteiden kirjoittamisessa apuna voidaan käyttää paletteja AlgebraicManipulation, BasicCalculations ja BasicInput. 
BasicCalculations-paletti on oikeastaan tiivis Mathematica-opas. Sieltä löytyvät lähes kaikkien tavallisimpien komentojen syntaksit.
Kun kaavoja ja erilaisia matemaattisia symboleita kirjoitetaan tekstin joukkoon, voidaan käyttää apuna mm. paletteja BasicTypesetting ja CompleteCharacters.

Matemaattiset kaavat ja symbolit syötteissä ja tulosteissa

Muistikirjapohjaisessa Mathematicassa syöte voidaan kirjoittaa varsin monella eri tavalla. Syötteen kirjoittaminen suoraan näppäimistöltä tavallisia merkkejä käyttäen (kuten tekstipohjaisessa käyttöliittymässä) on kuitenkin syytä opetella, sillä ohjelmoinnissa se on välttämätön taito.

Syöte voidaan aina kirjoittaa suoraan näppäimistöltä käyttäen tavallisia merkkejä. Tämän oppaan esimerkkisyötteet ovat tämän luvun esimerkkejä lukuunottamatta kirjoitettu tällä tavoin. Esimerkkinä lasketaan  lausekkeen (Sqrt[x]) + cos x määrätty integraali  0:sta 2π:hin.

Integrate[Sqrt[x] + Cos[x], {x, 0, 2  Pi}]

Syötteitä kirjoitettaessa voidaan apuna käyttää myös Mathematican valmiita paletteja. Näiden avulla saadaan matemaattiset symbolit esitettyä kauniisti ja mm. integraalimerkit, neliöjuuret ja potenssit muistuttavat enemmän perinteisestä matemaattista notaatiota kuin edellisessä syötteiden kirjoitustavassa.
TAB-näppäimen avulla voidaan esimerkiksi integraalia syötettäessä siirtyä täytettävästä kohdasta seuraavaan. Esimerkkinä edellinen syöte BasicInput-paletin avulla syötettynä.

(∫_0^(2  π))((Sqrt[x]) + 
            Cos[x]) \[DifferentialD]x

Syötteitä voidaan kirjoittaa matemaattiseen muotoon myös erityisillä näppäinkomennoilla. Tässä alkeisoppaassa keskitytään kuitenkin vain kahteen ensimmäiseksi mainittuun syötteiden kirjoitustapaan.

Kuten edellisistä esimerkeistä havaitaan, tulosteet muistuttavat varsin paljon perinteistä matemaattista notaatiota. Muistikirjan yksittäinen syöte/tuloste voidaan esittää tarvittaessa myös kokonaan perinteisestä matemaattista notaatiota käyttäen valitsemalla kyseinen syöte- tai tulostesolu ja sen jälkeen Cell-valikon kohdasta Convert To vaihtoehto TraditionalForm. Tällä tavoin voidaan helposti liittää saatuja tuloksia tavallisen tekstin joukkoon.

\[MathematicaIcon] Mathematica Book:
Lisää syötteiden ja tulosteiden kirjoittamisesta ja ulkoasusta: luku 1.10

Muistikirjat dokumentteina

Käytettäessä muistikirjapohjaista käyttöliittymää voidaan rakentaa kauniita dokumentteja sekä näytöllä että paperilla luettaviksi. Muistikirjoihin voidaan luoda myös erilaisia painikkeita ja paletteja. Lisäksi dokumentteihin voidaan lisätä hyperlinkkejä, jotka voivat olla joko muistikirjan sisäisiä tai viitata johonkin toiseen muistikirjaan tai johonkin toiseen ohjelmaan.
Muistikirja koostuu soluista. Kullekin solulle on oma tyylinsä.  Syötesolu on tyyliä Input ja tuloste tyyliä Output. Lisäksi muistikirjaan voidaan sijoittaa mm. erilaisia teksti- ja otsikkosoluja. Solun tyyli voidaan valita Format-valikon kohdasta Style. Vaikka solulle on valittu oma tyylinsä, voidaan Format-valikosta löytyvillä työkaluilla muuttaa esimerkiksi yksittäisten sanojen/solujen ulkoasua.
Jokaiselle solulle voidaan määrittää tyyli joko ennen, kuin aloitetaan kirjoittaa solun sisältöä tai sitten jälkeenpäin, jolloin solu valitaan näpäyttämällä hiirellä solun oikeassa reunassa olevaa hakasta. Tyyli valitaan Format-valikon kohdasta Style. Oletustyylinä on Input. 
Mathematicassa on myös valmiina erilaisia tyyliarkkeja, joiden avulla voidaan rakentaa erinäköisiä dokumentteja. Tyyliarkki valitaan Format-valikon kohdasta Style Sheet.

Matemaattiset kaavat ja symbolit tekstin osana

Kaavoja voidaan kopioida tekstin joukkoon suoraan syötteistä/tulosteista tai kaavat voidaan kirjoittaa  palettien avulla tai suoraan näppäimistöltä. Jos kaava kopioidaan syötteestä/tulosteesta, se kannattaa muuntaa perinteiseen matemaattiseen muotoon (Katso: muunto perinteiseen muotoon). Jos kaava kirjoitetaan paletin avulla, se noudattaa valmiiksi perinteistä matemaattista notaatiota. Kirjoitettaessa kaava suoraan näppäimistöltä, se aloitetaan näppäinkomennolla control-9 eli Ctrl-näppäin pohjassa painetaan numeroa 9. Tämän jälkeen kaava kirjoitetaan näppäimistöä ja paletteja käyttäen. Kun kaava on kirjoitettu painetaan control-0.

Yleistä syötteiden kirjoittamisesta

Komennot ja funktiot

Mathematican omat komennot, funktiot ja vakiot alkavat aina isolla alkukirjaimella, ja ne muodostuvat yleensä kokonaisista sanoista, esimerkiksi Integrate ja Round. Jos komennon nimi on yhdyssanan tapainen, molemmat osat alkavat isolla alkukirjaimella: FindRoot, LinearSolve. Poikkeuksiakin on, kuten Eigenvector ja Eigensystem.
Komennon ja funktion argumentit kirjoitetaan hakasulkeissa komennon/funktion perään, esimerkiksi Factor[x^2-1]. Vaihtoehtoisesti komento voidaan kirjoittaa kahdella kauttaviivalla erotettuna argumenttinsa jälkeen, esimerkiksi x^2-1 //Factor.

Sulkeet

Mathematicassa erilaisilla sulkeilla on omat käyttötarkoituksensa.

Komentojen ja funktioiden argumentit ovat aina hakasulkeissa [ ].

Kaarisulkeiden ( ) avulla ohjataan tarvittaessa laskujärjestystä.

Aaltosulkeiden { } avulla muodostetaan listoja.

Tarkat arvot ja likiarvot

Mathematica käsittelee lausekkeita symbolisessa muodossa likiarvojen sijaan. Kokonaisluvut ja murtoluvut ovat tarkkoja esityksiä. Esimerkiksi vakio π ja (Sqrt[2]) säilytetään symbolisessa muodossa. Jos lauseke sisältää vain tarkkoja arvoja, niin tulos esitetään aina tarkassa muodossa.

Pi + Sqrt[2]/5

Likiarvoja saadaan komennolla N. Esimerkiksi N[Sqrt[2]] tai Sqrt[2]//N. Oletuksena komento N pyrkii kuuden merkitsevän numeron tarkkuuteen. Likiarvoa laskettaessa voidaan haluttu tarkkuus määrätä komennon N toisena argumenttina. Esimerkiksi N[Sqrt[2],10] antaa kakkosen neliöjuuren kymmenen merkitsevän numeron tarkkuudella.
Desimaaliluvut Mathematica tulkitsee likiarvoiksi. Kun syötteessä on desimaalilukuja, tulos saadaan likiarvoina.

Pi + Sqrt[2. ]/5

Syötteiden ja tulosteiden numerointi

Mathematica-istunnon aikana jokainen syöte ja tuloste numeroidaan juoksevasti. Jokainen syöte on varustettu kehotteella In[nro]:= ja syötettä vastaava tuloste kehotteella Out[nro]:=. Numerointi mahdollistaa sen, että istunnon aikana voidaan viitata aiempiin syötteisiin ja tulosteisiin. Tulosteeseen, jonka numero on nro, voidaan viitata kirjoittamalla %nro tai Out[nro]. Pelkkä %-merkki viittaa edelliseen tulosteeseen, %% tätä edeltävään tulosteeseen jne. Vastaavasti syötteeseen, jonka numero on nro, voidaan viitata kirjoittamalla In[nro].

Omien muuttujien käyttö

Omat muuttujat

Lausekkeita ja välituloksia talletetaan usein itse määriteltyihin muuttujiin. Tällä tavoin niihin on helpompi viitata. Muuttujalle talletetaan arvo yhtäsuuruusmerkin = avulla. Tämän jälkeen muuttujan arvoon voidaan viitata suoraan muuttujan nimellä. Vertaa: sijoitusoperaattorin := käyttöön.
Omat muuttujat, funktiot ja komennot on selkeyden vuoksi hyvä kirjoittaa aina pienellä kirjaimella.
Muuttujan arvoa kysytään syöttämällä pelkästään muuttujan nimi. Jos muuttujalle on annettu jokin arvo, Mathematica tulostaa tämän arvon. Muussa tapauksessa tulostuu pelkkä muuttujan nimi.
Muuttujan määrittelyä voidaan kysyä kysymysmerkillä, esimerkiksi ?muuttuja. Katso: omien määrittelyjen poistaminen

a = 4;

a

a^2 + 9

a =.

a^2 + 9

Omien määrittelyjen poistaminen

Mathematica-istunnon aikana määritellyt muuttujat niihin talletettuine arvoineen ovat voimassa koko istunnon ajan, jollei arvoja muiksi muuteta tai muuttujan arvoja poisteta.  Muuttujat puhdistetaan määrittelyistä vaihtoehtoisilla komennoilla 
muuttuja=.
Clear[muuttuja] 
Remove[muuttuja]
Kun halutaan puhdistaa tai poistaa kaikki itse määritellyt symbolit, voidaan käyttää komentoa
Clear["Global`*"]	 tai	Remove["Global`*"].
Muuttujan määrittelyä voidaan tarvittaessa kysyä kysymysmerkillä, esimerkiksi ?muuttuja.

Sijoitusoperaattorit = ja :=

Sijoitusoperaattorin = avulla asetetaan muuttujalle arvo, esimerkiksi b=a^3. Tällöin muuttuja b saa arvoksi oikean puolen arvon. Jos oikeana puolena on lauseke, sen arvo lasketaan ja sitten laskettu arvo sijoitetaan muuttujan b arvoksi. Jos esimerkiksi muuttujalla a olisi arvo 2, niin muuttujan b arvoksi tulisi (2^3) = 8. 
Kun muuttujalle sijoitetaan arvo käyttäen sijoitusoperaattoria :=, niin oikean puolen arvo lasketaan vasta, kun muuttujan arvoa kysytään. Kyseessä on ns. viivästetty sijoitus. 
Sijoitusoperaattoreiden ero selviää seuraavasta esimerkistä.

a = 2

b = a^3

c := a^3

c

a = 4

b

c

Peruslaskutoimitukset

Mathematicalla voidaan suorittaa aritmeettisia laskutoimituksia samaan tapaan kuin taskulaskimella. Erona on, että Mathematica käsittelee lukuja symbolisesti eikä muunna niitä desimaalimuotoon. Katso: tarkat arvot ja likiarvot
({{laskutoimitus, \(syöte\ näppäimistöltä\), \(syöte\ paletista\)}, {yhteenlasku, 5 + 6, ei}, {vähennyslasku, 5 - 6, ei}, {kertolasku, 5*6 tai 5 6, 5×6}, {jakolasku, 5/6, (5/(6 ))}, {potenssiin korotus, 5^6, (5^6)}})
Kertomerkki on siis joko * tai välilyönti. Samoja komentoja voidaan käyttää myös operoitaessa lausekkeilla. Laskujärjestys on tavanomainen ja sitä voidaan tarvittaessa muuttaa kaarisulkeilla.

1/3  x

1/(3  x)

Matemaattisia funktioita ja vakioita

Mathematica tuntee suuren määrän funktioita. Seuraavassa on listattu näistä tärkeimpiä.
({{Abs[x], itseisarvofunktio}, {Sqrt[x]      ( paletista (Sqrt[x]) ), neliöjuurifunktio}, {Exp[x], eksponenttifunktio}, {Log[x], luonnollinen logaritmi}, {Log[k, x], k - kantainen logaritmi}, {Sin[x],Cos[x],Tan[x], 
Csc[x],Sec[x], Cot[x], trigonometriset funktiot}, {ArcSin[x],ArcCos[x],
ArcTan[x],ArcCsc[x],
ArcSec[x],ArcCot[x], arkusfunktiot}, {Sinh[x], Cosh[x], 
Tanh[x], Csch[x],
Sech[x], Coth[x], hyperboliset funktiot}, {ArcSinh[x], ArcCosh[x], 
ArcTanh[x], ArcCsch[x],
ArcSech[x], ArcCoth[x], areafunktiot}, {n!, kertoma}, {Round[x], pyöristys}, {Mod[n, m], n modulo m eli jakojäännös 
jakolaskusta n/m}}) 
Trigonometristen funktioiden argumentit ja arkusfunktioiden arvot annetaan radiaaneina. Useampihaaraisten funktioiden arvot lasketaan päähaaran mukaan. 
Suurin osa matemaattisista funktioista on määritelty myös kompleksialueella. Jos funktion argumentti on vektori/matriisi, funktiota sovelletaan alkioittain.
Mathematica tuntee myös suuren joukon erikoisfunktioita: Gamma, Erf jne.

Integrate[
      1/Sqrt[2 Pi]*Exp[-t^2/2], {t, -Infinity, 2}]

Mathematica tuntee mm. seuraavat vakiot: 
({{vakio, \(syöte\ näppäimistöltä\), \(syöte\ paletista\)}, {imaginaariyksikkö, I, i}, {pii,  π, Pi, π}, {Neperin luku, e, E, e}, {ääretön, Infinity, ∞}, {aste (π/180), Degree, °}})
Kulmat annetaan oletusarvoisesti radiaaneina: Sin[Pi/4]. Jos syötteessä halutaan käyttää radiaanien sijasta asteita, kirjoitetaan Sin[45 Degree].

Summa ja tulo

({{\(syöte\ näppäimistöltä\), syöte paletista}, {Sum[f,{i,a,b}], (∑_(i = a)^b) f}, {Sum[f,{i,a,b},{j,c,d}], (∑_(i = a)^b)(∑_(j = c)^d) 
              f}, {Product[f,{i,a,b}], (∏_(i = a)^b) f}})

Sum[i^2, {i, 10}]

Sum[1/2^i, {i, 0, Infinity}]

Product[1/i, {i, 1, s}]

Lista

Listan muodostaminen

Lista on alkioiden järjestetty joukko. Lista muodostetaan aaltosulkeiden avulla. Se on siis muotoa {alkio1, alkio2, alkio3,..., alkioN}. Alkiot voivat olla lukuja, lausekkeita, tekstijonoja jne... . Listan alkiot voivat myös olla listoja. 
Tyhjää listaa merkitään {}.
Vektorit ja matriisit esitetään listoina.

vektori = {1, 4, 8};

matriisi = {{1, 3}, {5, 7}, {11, 13}};

Lampaiden määrä Suomessa (Tilastokeskus). Jokainen listan alkio koostuu listasta, jossa on ensimmäisenä alkiona vuosi ja toisena lampaiden määrä (tuhansina) kyseisenä vuotena.

lampaat = {{1938, 956}, {1960, 341}, {1970, 189}, {1980, 106}, {1990, 
            103}, {1996, 150}, {1997, 150}, {1998, 128}};

Listat voidaan esittää taulukkomuodossa TableForm-komennon avulla. Sarakkeille/riveille voidaan antaa otsikot optiolla TableHeadings.

TableForm[lampaat, 
      TableHeadings -> {None, {vuosi,  maara}}]

\[MathematicaIcon] Mathematica Book:
Lisää TableForm-komennon optioista: luku 2.8.8

Listan alkioon viittaaminen

Listan  n:teen alkioon voidaan viitata komennolla lista[[n]]. Listan n. viimeiseen alkioon viitataan vastaavasti komennolla lista[[-n]]. Jos listan alkiot ovat listoja, niin esimerkiksi komento lista[[n,m]]antaa listan n:nnestä alkiosta m:nnen alkion.

Listasta voidaan poimia alkioita useilla eri tavoilla. 
({{Take[lista,n]
Take[lista, -n]
Take[lista,{m,n}], \(otetaan\ listasta\ n\ ensimmäistä\ alkiota

              otetaan\ listasta\ n\ viimeistä\ alkiota

              otetaan\ listasta\ alkiot\ \ m, \ m + 1,  ... , n\)}, {Drop[lista,n]
Drop[lista, -n]
Drop[lista,{m,n}], \(pudotetaan\ listasta\ n\ ensimmäistä\ alkiota

              pudotetaan\ listasta\ n\ viimeistä\ alkiota

              pudotetaan\ listasta\ alkiot\ \ m, \ m + 1,  ... , n\)}, {First[lista], listan ensimmäinen alkio}, {Last[lista], listan viimeinen alkio}, {Min[lista], listan pienin alkio}, {Max[lista], listan suurin alkio}})

lista = {{a, b}, c, {d, e, f}, g}

lista[[1]]

lista[[3, 2]]

Drop[lista, -2]

Take[lista, 3]

Listojen käsittelyä

({{Flatten[lista]
Flatten[lista,n], \(puretaan\ sisäkkäiset\ listat\)
puretaan listasta n sisintä tasoa}, {Join[lista1,lista2,...], \(yhdistetään\ listat\ yhdeksi\ listaksi\)}, {Append[lista,alkio], \(lisätään\ listan\ loppuun\ alkio\)}, {Length[lista], \(listan\ alkioiden\ lukumäärä\)}})

lista = {{{a, b, c}, d}, e, f};

lista = Append[lista, g]

uusilista = Join[lista, {h, i}]

Length[uusilista]

Flatten[uusilista]

Flatten[uusilista, 1]

\[MathematicaIcon] Mathematica book
Runsaasti erilaisia listojen käsittelyyn liittyviä komentoja: luku 1.8

Table-komento

Kun lista voidaan muodostaa noudattaen jotakin sääntöä, käytetään usein Table-komentoa. Tällöin alkioiden arvot ovat indeksimuuttujan funktioita.
({{Table[lauseke,
{i,imin,imax}], luodaan lista,  jonka alkioina ovat 
lausekkeen arvot, kun i saa arvot 
imin:sta imax:iin}, {Table[lauseke,{imax}], luodaan lista, jossa on imax 
kappaletta lauseketta}, {Table[lauseke,
{i,imin,imax,di}], \(luodaan\ lista, \ jonka\ alkioina\ ovat\ 

                    lausekkeen\ arvot\), kun i saa arvot 
imin:sta imax:iin di:n välein}})

Table[x^i, {i, 1, 4}]

Table[i^3, {i, 1, 4, 1/2}]

Range-komento

Komennolla Range muodostetaan luvuista tasavälisiä listoja.

({{Range[imax], luodaan lista {1, 2, ..., imax}}, {Range[imin,imax], luodaan lista  {imin, ..., imax}}, {Range[imin,imax,di], luodaan lista,  jonka alkioina ovat 
arvot imin:sta imax:iin di:n välein}})

Range[3, 6, 0.25]

Loogiset operaatiot

({{vertailuoperaatio, syöte näppäimistöltä, syöte paletista}, {yhtä suuri kuin, x == y, x == y}, {eri suuri kuin, x != y, x != y}, {suurempi kuin, x > y, ei}, {suurempi tai yhtä suuri kuin, x >= y, x >= y}, {pienempi kuin, x < y, ei}, {pienempi tai yhtä suuri kuin, x <= y, x <= y}})
Numeerisilla arvoilla vertailut palauttavat joko True tai False (tosi tai epätosi). Symbolisille lausekkeille totuusarvoa ei luonnollisestikaan voida laskea.

2 > 3

2 != 3

x > 5

({{looginen operaattori, syöte näppäimistoltä, syöte paletista}, {ja,  and, And[x, y],  
          x  &&  y, x ∧ y}, {tai,  or, Or[x, y],  
          x  ||  y, x ∨ y}, {ei,  not, Not[
            x], ! x , ¬ x}})

2 > 0  &&  1 < 3

2 < 0  ||  1 < 3

Funktiot

Funktion määritteleminen

Omia funktioita voidaan määritellä seuraavaan tapaan:

f[x_] := 2  x^3 - 5  x + 1

g[x_, y_] := x^2 - 3  y

Funktion määrittelyssä käytetään yleensä sijoitusoperaattoria :=, sillä funktion arvo lasketaan vasta, kun funktion arvoa kysytään jollakin argumentin arvolla. Funktion määrittelyn vasemmalla puolella argumenttiin kirjoitetaan alaviiva _ . Se tarkoittaa, että kyseessä on malli, jonka paikalle funktiota kutsuttaessa voidaan sijoittaa mitä tahansa. Oikealla puolella ei ole alaviivaa!

f[2]

g[4, 1 + x]

Funktiolle voidaan antaa sijoitusoperaattorin = avulla arvo myös yksittäisessä pisteessä. Esimerkiksi sijoitus f[3]=5 tarkoittaa, että muuttuja f[3] saa arvon 5.

f[3] = 5;

Kysymysmerkillä nähdään funktion määrittely. Kun itse määriteltyä funktiota ei enää tarvita, se on hyvä poistaa esimerkiksi komennolla Clear, jotta vanha funktio ei aiheuta sekaannusta uusien funktiomäärittelyjen kanssa.

?f

Katso myös: Module-komento

Funktion määrittelyn rajoittaminen

Funktion määrittelyä rajoitetaan asettamalla funktion argumentin perään merkki /; (kauttaviiva ja puolipiste) ja tämän jälkeen loogiset rajoitukset. Vaihtoehtoisesti rajoitukset voidaan sijoittaa määrittelyn loppuun. Funktioon voi liittyä myös useampia ehtoja. Katso: loogiset operaatiot
Esimerkiksi funktio f(x) = (x^2),  x >= 0 voidaan määritellä seuraavilla vaihtoehtoisilla tavoilla:
f[x_ /; x>=0]:= x^2  tai    f[x_]:= x^2 /; x>=0

f[x_  /;  0 < x <= 1] := x^2 + 2;
f[x_  /; x <= 0  ||  x > 1] := -x^2 - 2 ;
Plot[f[x], {x, -2, 2}];

Funktion argumentti voidaan rajoittaa esimerkiksi kokonaisluvuksi, rationaaliluvuksi, reaaliluvuksi tai kompleksiluvuksi. Tällöin funktion arvoa ei lasketa, jos argumentti ei ole oikeaa tyyppiä.
f[x_Integer]:=x^2     f[x_Rational]:=x^2
f[x_Real]:=x^2        f[x_Complex]:=x^2
Näihin voidaan lisätä myös loogisia rajoituksia kuten edellä.

Rekursiiviset funktiot

Funktion määrittely voi olla rekursiivinen, jolloin määrittelyyn kuuluu saman funktion arvon laskeminen jossakin toisessa pisteessä. Tällöin rekursion pitää jossakin vaiheessa päättyä ts. pitää päästä tilanteeseen, jossa tulee laskettavaksi funktion arvo pisteessä, jossa funktion arvo tunnetaan.
Seuraavassa on kaksi esimerkkiä rekursiivisesta funktion määrittelystä. Esimerkeissä lasketaan luonnollisen luvun kertoma muodostamalla rekursiivinen funktio hieman eri tavoin. Sinänsä kertomafunktion muodostaminen on tarpeetonta, sillä Mathematicassa luvun n kertoma on n!.

kertoma[0] = 1;

kertoma[n_Integer  /;  n >= 0] := n*kertoma[n - 1]

kertoma[4]

?kertoma

Clear[kertoma]

Kun kertoma määritellään edellä esitellyllä tavalla, lasketaan kaikki funktion arvot aina uudelleen, kun kysytään jonkin luvun kertomaa. Seuraavassa tavassa sijoitetaan laskettu arvo muuttujan kertoma[n] arvoksi, jolloin jo laskettuja funktion arvoja ei tarvitse jonkin toisen luvun kertomaa laskettaessa laskea uudelleen.

kertoma[0] = 1;

kertoma[n_Integer  /;  n >= 0] := kertoma[n] = 
        n*kertoma[n - 1]

kertoma[4]

?kertoma

Jos rekursiivinen lasku on kovin pitkä, Mathematican rekursiolle asettama yläraja 256 tulee vastaan. Tällöin vakiolle $RecursionLimit voidaan antaa suurempi arvo.

Puhtaat funktiot

Jos tiettyä funktiota käytetään toistuvasti, se kannattaa määritellä funktioksi. Jos taas funktiota tarvitaan vain kerran, niin silloin voidaan käyttää puhdasta funktiota. Puhtaalla funktiolla ei ole nimeä, vaan se sijoitetaan sellaisenaan siihen paikkaan, jossa sitä tarvitaan. 
Function[x,lauseke] on puhdas funktio, jossa x on muodollinen parametri. Vastaavasti Function[{x1,x2,...},lauseke] on puhdas funktio, jossa on muodolliset parametrit x1, x2, ....

Function[x, x^2]

%[a]

Puhdas funktio voidaan muodostaa myös ilman, että nimetään argumenttia. Argumenttina käytetään tällöin risuaitaa # tai jos argumentteja on useampi #1, #2, .... Funktion lauseke kirjoitetaan risuaitojen avulla ja loppuun kirjoitetaan &. Kun funktiota kutsutaan, risuaita korvautuu funktion argumentilla.

#^3 &;

%[x]

#1^2 + #2 &;

%[2, x]

Muunnossäännön käyttäminen

Lausekkeessa esiintyvälle muuttujalle voidaan antaa arvo ns. muunnossäännön avulla. Muunnossääntö, jossa lausekkeen muuttuja korvataan jollakin arvolla, on muotoa muuttuja -> arvo. Nuoli koostuu tavuviivasta ja suurempi kuin -merkistä. Paletissa on myös nuolimerkki ->, jota voidaan käyttää. Korvausoperaattorin /. (kauttaviiva ja piste) avulla lausekkeelle voidaan sijoittaa muunnossääntö.

lauseke = x^2 + 2;

lauseke  /.  x -> 1

Muuttujalle x sijoitettiin arvo 1 vain korvauskäskyssä, joten muuttujan lauseke arvo pysyi ennallaan.

lauseke

Samassa lausekkeessa voidaan korvata useita muuttujia samalla kertaa kirjoittamalla muunnossäännöt listaksi.

lauseke = x^2 + y^2;

lauseke  /.  {x -> 1, y -> 2}

Mathematica antaa suuren osan tuloksista muunnossääntöinä. Korvausoperaattorilla tulos voidaan sijoittaa jonkin muuttujan arvoksi.

ratkaisu = Solve[x^2 - 2 == 0, x]

arvo = x /. First[ratkaisu]

Lausekkeen sieventäminen ja muokkaaminen

Yleiset sievennyskomennot

Mathematica yhdistää samannimiset termit automaattisesti. 
Komento Simplify sieventää argumenttina annettua lauseketta käyttäen erilaisia algebrallisia muunnoksia. FullSimplify käyttää suurempaa valikoimaa algebrallisia muunnoksia ja tekee siten enemmän sievennyksiä. Se sieventää myös erikoisfunktioita sisältäviä lausekkeita. FullSimplify on kuitenkin suurien lausekkeiden käsittelyssä varsin hidas.

(x - 1) (x + 1) // Simplify

Simplify[Cos[x]^2 + Sin[x]^2]

Simplify[Sqrt[2  Sqrt[2] + 3]]

FullSimplify[Sqrt[2  Sqrt[2] + 3]]

Lausekkeen muokkaaminen: peruskomentoja

Yleisten sievennyskomentojen Simplify ja FullSimplify lisäksi on lausekkeen muokkaamista varten olemassa joukko muitakin komentoja: 
({{Expand[lauseke], \(kerrotaan\ auki\ tulot\ ja\ positiiviset

              kokonaislukupotenssit\ 

              \((murtolausekkeissa\ vain\ osoittajasta)\)\)}, {ExpandAll[lauseke], \(kerrotaan\ auki\ kaikki\ tulot\ ja\ 

              kokonaislukupotenssit\)}, {Factor[lauseke], \(\(jaetaan\)\(\ \)\(lauseke\)\(\ \)\(tekijöihin\)\(\ \)\)}, {Collect[lauseke,x], kirjoitetaan lauseke muuttujan 
x potenssien mukaan}, {FactorTerms[lauseke,x], jaetaan lauseke tekijöihin niin,  
                että 
toisessa tekijässä ei ole muuttujaa x}})

Expand[(x + 2)^4]

Factor[%]

Expand[(2  x + y)^2 (1 + 2  y)^2]

Collect[%, x]

FactorTerms[%, x]

Lausekkeen osien poimiminen

Lausekkeesta voidaan poimia osia jatkokäsittelyä varten. Osoittajan ja nimittäjän poimiminen käsitellään murtolausekkeiden yhteydessä.

({{Coefficient[lauseke,x], muuttujan x kerroin}, {lauseke[[n]], lausekkeen n. termi}})

lauseke = x^2 + 3  y x + 5  x

Coefficient[lauseke, x]

lauseke[[3]]

Murtolausekkeet

Murtolausekkeen osoittajaan viitataan komennolla Numerator[lauseke] ja nimittäjään komennolla Denominator[lauseke]. Näiden komentojen avulla murtolausekkeen osoittajaa ja nimittäjää voidaan muokata millä tahansa lausekkeen muokkauskomennolla. 
Seuraavassa on joitakin erityisesti murtolausekkeiden käsitelyyn tarkoitettuja komentoja. Katso myös komennot Factor, Expand ja ExpandAll.
({{ExpandNumerator[lauseke], \(\(kerrotaan\ osoittajasta\ auki\)\(\ \)\(
\)
              \(tulot\ ja\ positiiviset\)\(\ \)\(
\)
              \(kokonaislukupotenssit\)\(\ \)\)}, {ExpandDenominator[lauseke], \(\(kerrotaan\ nimittäjästä\ auki\)\(
\)
              \(tulot\ ja\ positiiviset\)\(\ \)\(
\)
              \(kokonaislukupotenssit\)\(\ \)\)}, {Together[lauseke], \(lavennetaan\ murtolausekkeet\ 

              samannimisiksi\ ja\ lasketaan

              yhteen\)}, {Cancel[lauseke], \(supistetaan\ osoittajan\ ja\ 

              
              nimittäjän\ yhteiset\ tekijät\)}, {Apart[lauseke]
Apart[lauseke, muuttuja], \(kirjoitetaan\ lausekkeen\ 

              
              osamurtokehitelmä\ \((toisena\ 

                    argumenttina\ annetun\ muuttujan\ 
suhteen)\)\)}})

Together[
      3/(x - 1) + (1 + 2 x)/(x^2 - x + 3)]

ExpandDenominator[%]

Apart[%]

Cancel[(x + 1)/(x^2 - 1)]

Mutkikkaampien lausekkeiden muokkaus

Erilaisia lausekkeiden sieventämiseen ja muokkaamiseen liittyviä komentoja voidaan käyttää myös mm. trigonometrisia lausekkeita käsiteltäessä.  Näille lausekkeille on kuitenkin myös muita sievennyskäskyjä.
({{TrigExpand, \(poistetaan\ trigonometrisen\ funktioiden\ argumentteina

              olevat\ summat\ ja\ kulmien\ monikerrat\)}, {TrigFactor, \(kirjoitetaan\ trigonometriset\ lausekkeet\ tulomuotoon\)}, {TrigReduce, \(kirjoitetaan\ trigonometrinen\ lauseke\ ilman\ tuloja\ ja\ 

              potensseja\)}, {TrigToExp, \(kirjoitetaan\ trigonometriset\ \ funktiot\ kompleksisten

              eksponenttien\ avulla\)}, {ExpToTrig, \(kirjoitetaan\ kompleksiset\ eksponentit\ trigonometristen

              funktioiden\ avulla\)}, {ComplexExpand, \(kirjoitetaan\ lauseke\ auki\ oletuksella, \ 
              että\ kaikki

              muuttujat\ ovat\ reaalisia\)}, {PowerExpand, \(muunnetaan\ potenssi - \ 
                ja\ logaritmilausekkeita\ 

              yksinkertaisempaan\ muotoon\ oletuksella, \ että

              tarvittavat\ oletukset\ ovat\ voimassa . \ Komennon

              
              käytössä\ pitää\ olla\ \(varovainen!\)\)}})
Esimerkkejä komennon ComplexExpand käytöstä: kompleksiluvut

TrigExpand[Sin[2  x]]

TrigFactor[Cos[x]^2 - Sin[x]^2]

TrigReduce[Cos[x]^2 - Sin[x]^2]

TrigToExp[Sin[x]]

ExpToTrig[5  Exp[3  I x] ]

Mitä oletuksia muuttujista x ja y on tehtävä, jotta seuraavat ovat voimassa?

Sqrt[x^2] // PowerExpand

PowerExpand[Log[x y]]

Kompleksiluvut

Kompleksiluvut voidaan  Mathematicassa esittää joko suorakulmaisten koordinaattien x ja y avulla muodossa x + y i tai napakoordinaattien r ja γ avulla muodossa r (e^(i γ)). Peruslaskutoimitukset pätevät myös kompleksiluvuille ja suurin osa matemaattisista funktioistakin on määritelty kompleksialueella. 
Imaginaariyksikkö on I (paletista i).
({{Re[z], reaaliosa}, {Im[z], imaginaariosa}, {Conjugate[z], kompleksikonjugaatti}, {Abs[z], itseisarvo eli moduli}, {Arg[z], argumentti}})

(3 + 5  I)/(2 + 4  I)

ArcSin[2] // N

Lauseketta voidaan sieventää komennolla ComplexExpand, joka olettaa, että kaikki lausekkeen muuttujat ovat reaalisia.

ComplexExpand[E^(I x)]

ComplexExpand[(-1)^(1/3)]

Katso: komennot TrigToExp ja ExpToTrig.

Ratkaistaan esimerkkinä yhtälö (z^6) = 1 ja piirretään ratkaisut kompleksitasoon.

ratk = Solve[z^8 == 1, z]

pisteet = {Re[z], Im[z]}  /.  ratk

ListPlot[pisteet, PlotStyle -> AbsolutePointSize[4], 
        AspectRatio -> Automatic];

Yhtälön ratkaiseminen

Yhtälö muodostetaan Mathematicassa aina kahdella yhtäsuuruusmerkillä == (paletissa ==). Yhtälö on siten muotoa vasenp == oikeap.

Algebrallinen ratkaiseminen

Mathematica ratkaisee algebrallisesti kaikki korkeintaan 4. astetta olevat polynomiyhtälöt. Myös osa korkeamman asteen yhtälöistä ratkeaa. Tällöin ratkaisu saattaa kuitenkin olla Root-objektin avulla esitetty ja siten hankalasti tulkittavissa.
Yhtälöt ratkaistaan algebrallisesti Solve-komennolla. Komennossa ensimmäiseksi argumentiksi annetaan ratkaistava yhtälö ja toiseksi argumentiksi muuttuja, jonka suhteen yhtälö halutaan ratkaista.
Solve[yhtälö, muuttuja]
Jos yhtälössä esiintyy vain yksi muuttuja, niin yhtälö ratkaistaan automaattisesti tämän suhteen. Tällöin ei ole välttämätöntä kirjoittaa Solve-komentoon toista argumenttia.
Yhtälön ratkaisu saadaan muunnossääntönä  muuttuja -> arvo. Jos ratkaisuja on useita, ne annetaan listana. Yksittäisiin ratkaisuihin voidaan tällöin viitata kuten listan alkioihin. Katso: listan alkioon viittaaminen

ratkaisu = Solve[-x^2 + 2  x + 3 == 0, x]

Ratkaisut saadaan listana seuraavasti.

juuret = x /.  ratkaisu

Yksittäiseen ratkaisuun voidaan viitata usealla tavalla:

First[juuret]

x /. First[ratkaisu]

Polynomiyhtälöiden lisäksi joitakin muita yhtälöitä voidaan ratkaista Mathematicalla algebrallisesti. Käyttäjälle annetaan varoitus, jos osa ratkaisuista saattaa jäädä löytymättä. Seuraavassa esimerkissä Mathematica ei anna ratkaisun 2  π-monikertoja. Vaikeammat transkendenttiyhtälöt ratkaistaan yleensä numeerisesti.

Solve[Cos[x] == 1/Sqrt[2], x]

Seuraavassa on esimerkki Root-objektin avulla saadusta ratkaisusta. Ratkaisun numeeriset arvot saadaan N-komennolla tai käyttämällä Solve-komennon sijaan NSolve-komentoa.

Solve[x^6 + 3  x^5 + 7 == 0, x]

% // N

Numeerinen ratkaiseminen

NSolve-komennolla ratkaistaan polynomiyhtälöitä numeerisesti.
NSolve[yhtälö, muuttuja]

NSolve[x^6 + 3  x^5 + 7 == 0, x]

Muut yhtälöt ratkaistaan numeerisesti käyttäen FindRoot-komentoa. Se etsii yhtälön ratkaisun Newtonin iteraatiolla. Komennossa annetaan ensimmäisenä argumenttina ratkaistava yhtälö, toisena lista, jonka alkioina ovat muuttuja, jonka suhteen yhtälö ratkaistaan, sekä muuttujalle annettava alkuarvo. Sopiva alkuarvo etsitään esimerkiksi kuvaajan avulla.
FindRoot[yhtälö,{muuttuja, alkuarvo}]

Plot[{Cos[x], x}, {x, 0, 1.5}];

FindRoot[Cos[x] == x, {x, 0.7}]

\[MathematicaIcon] Mathematica Book
Lisää FindRoot-komennosta: luku 3.9.6

Yhtälöryhmät

Yhtälöryhmiä ratkaistaan algebrallisesti Solve-komennolla ja numeerisesti NSolve- ja FindRoot-komennoilla. Ratkaistavat yhtälöt ja muuttujat kirjoitetaan listoiksi. Lineaarinen yhtälöryhmä voidaan ratkaista myös komennolla LinearSolve.
Solve[yhtälöt,muuttujat]
NSolve[yhtälöt,muuttujat]
FindRoot[{yhtälö1,yhtälö2,...}, {muuttuja1,alkuarvo1}, {muuttuja2,alkuarvo2},...]

Solve[{x + y == 1, 2 x - 3 y == 8}, {x, y}]

NSolve[{x^2 - y == 1, x + y == 2}, {x, y}]

FindRoot[{x^3 + y^3 - 3*x*y == 0, x^2 + y == 0}, {x, 
        1}, {y, -2}]

Algebrallinen ratkaisu saattaa olla  Root-objektin avulla esitettynä.

Eliminate ja Reduce

Komennolla Eliminate voidaan yhtälöryhmästä eliminoida halutut muuttujat.

Eliminate[{x + y == 1, x*y == 1}, y]

Solve-komento ei ota huomioon yhtälössä esiintyvien parametrien kaikkia mahdollisia arvoja. Jos ne on huomioitava, käytetään komentoa Reduce.

Solve[a*x + b == 0, x]

Reduce[a*x + b == 0, x]

Tasografiikkaa

Reaalifunktion kuvaajan piirtäminen

Plot-komennolla voidaan piirtää reaalifunktioiden kuvaajia. Komennossa ensimmäisenä argumenttina annetaan piirrettävän funktion lauseke tai piirrettävien funktioiden lausekkeet ja toisena lista, jonka alkioina ovat funktion/funktioiden muuttuja ja piirrettävän välin alku- ja loppupiste. 
Plot[lauseke,{x,xmin,xmax}]
Plot[{lauseke1,lauseke2,...},{x,xmin,xmax}]
Katso: tasografiikkaan liittyviä optioita

Plot[x*Sin[x], {x, -4 Pi,  4  Pi}]

Edellinen rivi -Graphics- jää tulostumatta, kun syötteen perään lisätään puolipiste. Katso: PlotStyle-option käyttö

\(\(Plot[{Sin[x], Sin[2*x]}, {x, 0, 4  Pi}, 
        PlotStyle -> {{}, 
			AbsoluteDashing[{3}]}];\)\)

Kuvien yhdistäminen samaan kuvaan

Kuvat voidaan piirtää erikseen ja yhdistää samaan kuvaan jälkeenpäin Show-komennolla. Option DisplayFunction arvolla Identity kuvaa ei näytetä ja arvolla $DisplayFunction kuva näytetään. Oletusarvona on aina $DisplayFunction.

kuva1 = 
        Plot[3  x^2 + 2  x, {x, -1.5, 1}, 
          DisplayFunction -> Identity];

kuva2 = 
        Plot[x^3 + x^2, {x, -1.5, 1}, 
          DisplayFunction -> Identity];

Show[kuva1, kuva2, 
        DisplayFunction -> $DisplayFunction];

Tasografiikkaan liittyviä optioita

Kuvien ulkoasua voidaan muokata lukuisilla optioilla. Seuraavassa joitakin usein tarvittavia optioita.

AspectRatio

Mathematicassa oletusarvoisesti kuvan mittasuhteet (korkeuden suhde leveyteen) noudattavat kultaisen leikkauksen suhdetta. Tällöin x- ja y-akselin yksiköt ovat yleensä eripituisia. Jos yksiköt halutaan samanpituisiksi, annetaan optio AspectRatio->Automatic. 
AspectRatio määrää kuvan korkeuden ja leveyden suhteen. Sille voidaan antaa myös numeroarvoja, kuten AspectRatio->2.

Plot[x^2, {x, -2, 2}, AspectRatio -> Automatic];

PlotRange

Varsin käyttökelpoinen optio on PlotRange, jolla voidaan määrätä osa, joka kuvaajasta halutaan näkyviin. Esimerkiksi PlotRange->{-10,10} rajoittaa y-suunnassa kuvan välille [–10,10].
Toisinaan Mathematica leikkaa itse osan kuvasta pois. Tällöin koko kuvaaja saadaan näkyviin kirjoittamalla optio PlotRange->All.

Plot[Cos[3*x]*Exp[x], {x, 0, 6}];

Plot[Cos[3*x]*Exp[x], {x, 0, 6}, PlotRange -> All];

PlotStyle

PlotStyle-optiolla voidaan muuttaa käyrien piirustustyyliä.
Käyrän väri voidaan määritellä monella tavalla: GrayLevel[g], RGBColor[r,g,b] ja Hue[h]. Värin määrityksessä kaikki argumentit  ovat välillä [0,1]. 
Absolute-alkuisissa paksuus yms. määritetään 1/72 tuuman monikertoina. Muissa se määritetetään suhteena kuvan leveyteen. 
({{AbsoluteThickness[r]
Thickness[r], \(käyrän\ paksuus\)}, {AbsoluteDashing[{r1,(Subscript[r2, ,...])}]
Dashing[{r1,(Subscript[r2, ,...])}], katkoviivoitus}, {AbsolutePointSize[r]
PointSize[r], pisteen koko}}) 
Käyrien oletustyyli on AbsoluteThickness[0.5], AbsoluteDashing[{0}] ja GrayLevel[0]. 
Esimerkki  katkoviivoituksen käytöstä ja esimerkki pistekoon muuttamisesta.
Piirretään esimerkkinä funktioiden y = cos x ja y = sin x kuvaajat samaan kuvaan. Säilytetään kosinifunktion kuvaajan tyylinä oletustyyli (tätä merkitään tyhjällä listalla {}) ja piirretään sinifunktion kuvaaja harmaalla ja hieman oletusarvoa paksummalla.

Plot[{Cos[x], Sin[x]}, {x, -Pi, 2*Pi}, 
        PlotStyle -> {{}, {AbsoluteThickness[3], 
              GrayLevel[0.5]}}];

\[MathematicaIcon] Mathematica Book:
Lisää PlotStyle-optiosta: luku 2.9.3

Muita optioita

Kuvaan voidaan lisätä tekstiä, kuvan taustalle voidaan asettaa ruudukko ja kuvan ympärille kehykset jne.

\[MathematicaIcon] Mathematica Book:
Tasografiikkaan liittyvät optiot: luku 1.9.3

Parametrimuotoisen tasokäyrän piirtäminen

ParametricPlot-komennolla voidaan piirtää parametrimuodossa esitettyjä tasokäyriä. Komennossa annetaan ensimmäiseksi argumentiksi piirrettävän käyrän parametriesitys {x(t), y(t)} ja toiseksi argumentiksi lista, jonka alkioina ovat käyrän parametri ja sen alku- ja loppupiste.
ParametricPlot[{x(t),y(t)},{t,tmin,tmax}]
Piirretään asteroidi x(t) = (cos^3) t ja y(t) = (sin^3) t.

ParametricPlot[{Cos[t]^3, Sin[t]^3}, {t, 0, 2  Pi}, 
        AspectRatio -> Automatic];

Implisiittisessä muodossa esitetyn tasokäyrän piirtäminen

Pakettiin Graphics`ImplicitPlot` sisältyy komento ImplicitPlot, jolla voidaan piirtää implisiittisessä muodossa annettujen käyrien kuvaajia. Katso: pakettien lataaminen. 
Vaihtoehtoisesti voidaan käyttää myös ContourPlot-komentoa.
Piirretään lemniskaatta, jonka yhtälö on (y^2) = (x^2) - (x^4).

Needs["Graphics`ImplicitPlot`"]

ImplicitPlot[y^2 == x^2 - x^4, {x, -1, 1}, 
        AspectRatio -> Automatic];

Avaruusgrafiikkaa

Kahden muuttujan funktion kuvaajan piirtäminen

Plot3D-komennolla voidaan piirtää muotoa z = f(x, y) olevia pintoja kolmiulotteiseen avaruuteen. 
Plot3D[f(x,y),{x,xmin,xmax},{y,ymin,ymax}]
Piirretään satulapinnan z = (x^2) - (y^2) kuvaaja origon ympäristössä.

Plot3D[x^2 - y^2, {x, -1, 1}, {y, -1, 1}];

Avaruusgrafiikassa voidaan käyttää monia tasografiikkaan liittyviä optioita.  Kuville voidaan kirjoittaa otsikoita, akseleille nimiä jne. Avaruusgrafiikassa on myös monia omia optioita. Muutetaan esimerkkinä muutaman option arvoa: poistetaan varjostus ja kasvatetaan piirtoverkon tiheyttä.

Plot3D[x^2 - y^2, {x, -1, 1}, {y, -1, 1}, Shading -> False, 
        PlotPoints -> 30];

\[MathematicaIcon] Mathematica Book
Lisää avaruusgrafiikkaan liittyviä optioita: luku 1.9.7

Pintojen korkeuskäyrät

Pinnoille z = f(x, y) voidaan piirtää korkeuskäyriä ContourPlot- komennolla. Oletuarvona on, että piirretään 10 korkeuskäyrää tasavälein funktion minimi- ja maksimiarvon väliltä. Käyrien väliin jäävät alueet varjostetaan eri sävyillä. Tummilla alueilla funktio saa pienempiä arvoja kuin vaaleilla alueilla.
ContourPlot[f(x,y),{x,xmin,xmax},{y,ymin,ymax}]

Piirretään satulapinnan z = (x^2) - (y^2) korkeuskäyriä.

ContourPlot[
        x^2 - y^2, {x, -1, 1}, {y, -1, 1}];

Optiolla Contours voidaan muuttaa piirrettävien korkeuskäyrien määrää, esimerkiksi  Contours->30. Halutut korkeuskäyrät voidaan myös luetella listana, esimerkiksi Contours->{-1,0,1,2}. Valitsemalla sopivasti vain yksi korkeuskäyrä, ContourPlot-komentoa voidaan käyttää implisiittisessä muodossa esitettyjen käyrien kuvaamiseen. Käyrien väliin jäävien alueiden väritys saadaan poistettua optiolla ContourShading->False.
Piirretään esimerkkinä Cartesiuksen lehti (x^3) + (y^3)=3xy.Laskettavien pisteiden määrää voidaan lisätä optiolla PlotPoints.

ContourPlot[x^3 + y^3 - 3  x y, {x, -3, 3}, {y, -3, 3}, 
        Contours -> {0},  ContourShading -> False,  
        PlotPoints -> 60];

\[MathematicaIcon] Mathematica Book
Lisää ContourPlot-komennosta: luku 1.9.6

Avaruuskäyrän ja -pinnan piirtäminen

Komennolla ParametricPlot3D piirretään parametrimuodossa esitettyjä käyriä ja pintoja kolmiulotteiseen avaruuteen.
Piirrettäessä avaruuskäyrää annetaan ensimmäiseksi argumentiksi käyrän parametriesitys {x(t), y(t), z(t)} ja toiseksi argumentiksi lista, jonka alkioina ovat käyrän parametri ja sen alku- ja loppupiste.
ParametricPlot3D[{x(t),y(t),z(t)},{t,tmin,tmax}]
Piirrettäessä avaruuspintaa annetaan vastaavasti ensimmäisenä argumenttina pinnan parametriesitys  {x(t, u), y(t, u), z(t, u)} ja toisena ja kolmantena argumenttina listat, joiden alkioina ovat parametrit alku- ja loppupisteineen.
ParametricPlot3D[{x(t,u),y(t,u),z(t,u)}, {t,tmin,tmax},{u,umin,umax}]

Piirretään ruuviviiva, jonka parametriesitys on muotoa x(t) = cos(t), y(t) = sin(t) ja z(t) = t/4.

ParametricPlot3D[{Cos[t], Sin[t], t/4}, {t, 0, 
          5  Pi}];

Piirretään toisena esimerkkinä yksikköpallon kuori käyttäen pallokoordinaatteja. Poistetaan myös akselit ja laatikko pallon ympäriltä.

ParametricPlot3D[{Cos[th] Cos[fii], Cos[th] Sin[fii], 
          Sin[th]}, {th, -Pi/2, Pi/2}, {fii, -Pi, Pi}, 
        Boxed -> False, Axes -> None];

\[MathematicaIcon] Mathematica Book
Lisää ParametricPlot3D-komennosta: luku 1.9.10
Avaruusgrafiikkaan liittyviä optioita: luku 1.9.7

Datan havainnollistaminen

Komennolla ListPlot voidaan havainnollistaa listana esitettyä dataa pisteinä. 
ListPlot[data]
Data voi olla muotoa {(Subscript[y, 1]),  
        (Subscript[y, 2, ]) (Subscript[y, 3]),  ... } tai  {{(Subscript[x, 1]), (Subscript[y, 1])},  {(Subscript[x, 2]), (Subscript[y, 2])},  {(Subscript[x, 3]), 
          (Subscript[y, 3])},  ... }. Ensimmäisessä tapauksessa piirretään pisteet  {1, (Subscript[y, 1])}, {2, (Subscript[y, 2])}, {3, (Subscript[y, 3])}, ...  ja toisessa tapauksessa pisteet {(Subscript[x, 1]), (Subscript[y, 1])}, {(Subscript[x, 2]), (Subscript[y, 2])}, {(Subscript[x, 3]), (Subscript[y, 3])}, ...
 Optiolla PlotJoined->True yhdistetään pisteet jananpätkillä. Pisteet saadaan tarvittaessa suuremmiksi lisäämällä optio PlotStyle->AbsolutePointSize[3]. Komennossa voidaan käyttää monia tasografiikkaan liittyvistä optioista.

vakiluku = {{1990, 4.998}, {1991, 5.029}, {1992, 5.055}, {1993, 
            5.078}, {1994, 5.099}, {1995, 5.117}, {1996, 5.132}, {1997, 
            5.147}, {1998, 5.160}};

ListPlot[vakiluku,  
        PlotStyle -> AbsolutePointSize[3]];

ListPlot[vakiluku, PlotJoined -> True, 
        AxesLabel -> {"vuosi", "väkiluku \n milj."}, 
        PlotLabel -> "Suomen väkiluku 1990-luvulla"];

Paketissa Graphics`Graphics` on runsaasti erilaisia datan käsittelyyn sopivia komentoja mm. histogrammien ja piirakkadiagrammien piirtämiskomennot.

Raja-arvot

Lausekkeen raja-arvo, kun x lähestyy lukua (Subscript[x, 0]), lasketaan komennolla Limit. 
Limit[lauseke,x->x0]

Limit[Sin[x]/x, x -> 0]

Toispuoliset raja-arvot voidaan laskea antamalla komennolle Limit optio Direction. Jos option arvo on 1, niin kyseessä on vasemmanpuolinen raja-arvo ja jos option arvo on -1, niin kyseessä on oikeanpuolinen raja-arvo.

f[x_] := Abs[4  x]/x

Limit[f[x], x -> 0, Direction -> 1]

Derivointi

Jos derivoitava lauseke on määritelty funktioksi, saadaan derivaatat tavanomaisilla merkinnöillä.

f[x_] := 3  x^2 - 2  x + 7

f'[x]

f''[x]

Derivaatat voidaan laskea myös komennolla D. Tällä komennolla on laskettava osittaisderivaatat.
({{\(syöte

              
              näppäimistöltä\), \(syöte\ 

              paletista\), operaatio}, {D[f,x], (∂_x) f, lausekkeen f osittaisderivaatta 
muuttujan x suhteen}, {D[f,{x,n}], ei, lausekkeen f  n. osittaisderivaatta 
muuttujan x suhteen}, {D[f,x1,x2], (∂_(x1, x2))f, lasketaan lausekkeen f 
osittaisderivaatta ensin muuttujan x1 
suhteen, sitten muuttujan x2 suhteen}})

D[3  x^2 - 2  x + 7, x]

D[3  x^2 - 2  x + 7, {x, 2}]

lauseke = 3  x y + x^2;

D[lauseke, x]

D[lauseke, x, y]

Funktioita voidaan derivoida myös symbolisessa muodossa. Symbolisessa muodossa esitettyjen usean muuttujan funktioiden derivaatat Mathematica merkitsee yläindekseillä.

D[g[x]^2, x]

D[g[x, y], y]

D[g[x, y], x, y, y]

Integrointi

Symbolinen integrointi

({{\(syöte\ näppäimistöltä\), syöte paletista, operaatio}, {Integrate[f,x], ∫f dx, funktion f  integraalifunktio 
muuttujan x suhteen }, {Integrate[f,{x,a,b}], (∫_a^b) 
              f dx, funktion f määrätty
integraali a:sta b:hen}, {Integrate[f,{x,a,b},
{y,c,d}], (∫_a^b)(∫_c^d) 
                f dx dy, kaksinkertainen integraali}})

f[x_] := 5  x + Exp[-x]

Integrate[f[x], x]

Integrate[f[x], {x, 1, 3}]

Määrätyt integraalit voivat olla myös rajoittamattomia.

Integrate[1/x^2, {x, 1, Infinity}]

Integroitava lauseke voi sisältää myös parametreja. Integroitaessa tällaisia lausekkeita on huomattava, että Mathematica ei kiinnitä huomiota parametrin erikoisarvoihin. Ne jäävät käyttäjän huolehdittaviksi.

Integrate[x^n, x]

Tämä ei luonnollisestikaan päde, kun n = -1. Tällöin integroitava lauseke on muotoa (1/x), jonka integraali on ln x.

Numeerinen integrointi

Mathematica ei pysty laskemaan kaikkia määrättyjä integraaleja symbolisesti. Tällöin voidaan hakea määrätylle integraalille numeerista arvoa komennolla NIntegrate.
NIntegrate[f,{x,a,b}]

Integrate[Cos[Exp[x^2]], {x, 0, 1}]

NIntegrate[Cos[Exp[x^2]], {x, 0, 1}]

Myös rajoittamattomia määrättyjä integraaleja voidaan integroida numeerisesti.

Taylorin sarja

Astetta n oleva Taylorin sarja lausekkeelle f muuttujan x suhteen kohdassa (Subscript[x, 0]) saadaan komennolla
Series[f,{x,x0,n}]

Series[Exp[x], {x, 0, 5}]

Jäännöstermiä merkitään O[ ]\(TraditionalForm\`\^\(n + 1\)\). Komennolla Normal saadaan jäännöstermi tarvittaessa poistettua.
Jos sarjakehitelmä tehdään tuntemattomalle lausekkeelle, sarjakehitelmä tulostuu symbolisessa muodossa.

Series[g[x], {x, 1, 4}] // Normal

Tavalliset differentiaaliyhtälöt

Differentiaaliyhtälön kirjoittaminen

Differentiaaliyhtälössä tuntematon funktio kirjoitetaan argumenttinsa kanssa. Derivaatat kirjoitetaan tavallisesti pilkkua käyttäen. Yhtäsuuruutta merkitään kahdella yhtäsuuruusmerkillä. Kirjoitetaan esimerkkinä differentiaaliyhtälö y'' (x) - 2  y' (x) + 3  y(x) - 
          2  x = 0 Mathematican  haluamaan muotoon.

y''[x] - 2  y'[x] + 3  y[x] - 2  x == 0;

Analyyttinen ratkaiseminen

Differentiaaliyhtälöitä ratkaistaan analyyttisesti DSolve-komennolla. Ensimmäisenä argumenttina annetaan differentiaaliyhtälö, toisena tuntematon funktio ja kolmantena funktion argumentti.
DSolve[yhtälö,y[x],x]
Vastaus saadaan muunnossääntönä ja yleisen ratkaisun mielivaltaiset vakiot on merkitty symboleilla C[1], C[2] jne...

DSolve[y''[x] == 2  y[x], y[x], x]

Alkuarvo- tai reuna-arvotehtävässä DSolve-komennon ensimmäinen argumentti on lista, jossa on alkioina differentiaaliyhtälö ja alku- tai reunaehdot yhtälöiksi kirjoitettuina.
DSolve[{yhtälö1,yhtälö2,...},y[x],x]

ratkaisu = 
      DSolve[{y''[x] == 2  y[x], y[0] == 1, y'[0] == 0}, y[x], 
        x]

y1[x_] = y[x] /. Flatten[ratkaisu]

y1[3]

Differentiaaliyhtälöryhmä ratkaistaan samaan tapaan kuin yksittäinen differentiaaliyhtälö. Alku- ja reuna-arvot kirjoitetaan yhtälölistaan samaan tapaan kuin edellä.
DSolve[{yhtälö1,yhtälö2,...},{y1[x],y2[x],...}, x]

DSolve[{y'[x] == z[x], z'[x] == -y[x]}, {y[x], z[x]}, 
      x]

DSolve[{y'[x] == z[x], z'[x] == -y[x], y[0] == 1, 
        z[0] == 0}, {y[x], z[x]}, x]

\[MathematicaIcon] Mathematica Book
Lisää DSolve-komennosta: luku 3.5.10

Numeerinen ratkaiseminen

Alkuarvotehtävän numeerinen ratkaisu tietyllä välillä saadaan NDSolve-komennolla. Ratkaisu saadaan muunnossääntönä, jossa ratkaisufunktio on paloittain kolmannen asteen interpolaatiopolynomi. 
NDSolve-komennon ensimmäisenä argumenttina annetaan lista, joka koostuu differentiaaliyhtälöstä ja alkuehdoista yhtälöiksi kirjoitettuina. Toisena argumenttina on ratkaistava funktio ja kolmantena funktion argumentti.
NDSolve[{yhtälö1, yhtälö2,...}, y[x], {x,xmin,xmax}]

ratkaisu = 
      NDSolve[{y'[x] == x + y[x], y[0] == 1}, 
        y[x],  {x, 0, 1}]

Interpolaatiopolynomi voidaan piirtää ja sille voidaan laskea yksittäisiä arvoja.

y1[x_] = y[x]  /. First[ratkaisu]

y1[0.2]

Plot[y1[x], {x, 0, 1}];

Differentiaaliyhtälöryhmä ratkaistaan numeerisesti NDSolve-komennolla samaan tapaan kuin yksittäinen differentiaaliyhtälö.
NDSolve[{yhtälö1,yhtälö2,...},{y1,y2,...},{x,xmin,xmax}]

\[MathematicaIcon] Mathematica Book
Lisää NDSolve-komennosta: luku 3.9.7
Lisää InterpolatingFunction-objektista: luku 3.8.2

Suuntakenttä

Ensimmäisen kertaluvun differentiaaliyhtälön suuntakenttä voidaan piirtää Graphics`PlotField`-pakettiin sisältyvällä PlotVectorField-komennolla.  Katso: paketin lataaminen 
Piirretään esimerkkinä differentiaaliyhtälön y' (x) = (e^(-x)) + y(x) suuntakenttä.  Optiolla ScaleFunction piirretään suuntakentän nuolet yhtäpitkiksi.

Needs["Graphics`PlotField`"]

PlotVectorField[{1, Exp[-x] + y}, {x, -3, 3}, {y, -3, 3}, 
        Axes -> True, Frame -> True, 
        ScaleFunction -> (1 &)];

Vektorit ja matriisit

Vektorit ja matriisit esitetään listoina. Vektoreille ja matriiseille kohdistetut operaatiot suoritetaan automaattisesti alkioittain.

a = {1, 3, 5};

{5  a, a^2, 1/a, Sqrt[a]}

Matriisit voidaan esittää matriisimuodossa MatrixForm-komennolla. Palettien BasicInput ja BasicCalculations avulla matriisi voidaan kirjoittaa myös suoraan matriisimuotoon.

matriisi = {{1, 3, 5}, {7, 11, 13}};

MatrixForm[matriisi]

Seuraavassa on muutamia vektoreihin ja matriiseihin liittyviä komentoja.

({{a.b (tavallinen piste), pistetulo,a·b}, {Cross[a,b], ristitulo, a×b}})

({{IdentityMatrix[n], n×n yksikkömatriisi}, {Inverse[matriisi], käänteismatriisi}, {Det[matriisi], determinantti}, {Transpose[matriisi], matriisin transpoosi}, {DiagonalMatrix[lista], \(diagonaalimatriisi, \ jonka\ 

            
            lävistäjällä\ listan\ alkiot\)}, {Dimensions[lista], listan dimensio}, {Eigenvalues[matriisi], ominaisarvot}, {Eigenvectors[matriisi], ominaisvektorit}, {LinearSolve[a, b], ratkaisee yhtälöstä a.x=b vektorin b}})

a = {1, 2, -1};  b = {-2, -4, 3};

a . b

Cross[a, b]

Dimensions[matriisi]

DiagonalMatrix[{1, 3, 5, 7}] // MatrixForm

Ratkaistaan lineaarinen yhtälöryhmä 
	({{x + y + 2  z = -1}, {x - 2  y + z = -5}, {3  x + y + z = 3. }})
LinearSolve-  ja Solve-komennoilla

a = {{1, 1, 2}, {1, -2, 1}, {3, 1, 1}};

b = {-1, -5, 3};

LinearSolve[a, b]

Solve[a . {x, y, z} == b, {x, y, z}]

Optiot

Komentoihin ja funktioihin liittyy usein lisäargumentteja, joilla voidaan eri tavoin vaikuttaa komennon/funktion lopputulokseen. Näitä lisäargumentteja sanotaan optioiksi. Optioilla on tietyt oletusarvot ja käyttäjä voi  tarvittaessa muuttaa niiden arvoja muunnossäännön avulla. Optiot sijoitetaan komennon/funktion loppuun ennen hakasuljetta.
Kuhunkin funktioon ja komentoon liittyvät optiot oletusarvoineen saadaan komennolla
Options[komento]
Esimerkkinä Newtonin iteraatiossa käytettävän FindRoot-komennon optiot oletusarvoineen. Jos käyttäjä ei muuta minkään FindRoot-komentoon liittyvän option arvoa, komento suoritetaan optioiden oletusarvoilla.

Options[FindRoot]

Kysymysmerkillä voidaan kysyä lisätietoa esimerkiksi optiosta AccuracyGoal. Muutetaan esimerkkinä tämän option  arvoa.

?WorkingPrecision

FindRoot[Cos[x] == x, {x, 0.5}, WorkingPrecision -> 20]

Pakettien lataaminen

Lisäpaketteja ladataan komennoilla
<<paketti  tai   Needs["paketti"]
Needs-komento ei yritä ladata pakettia uudelleen, jos paketti on jo ladattu.
Kun paketti on ladattu, näyttää komento ?paketti*, mitä uusia komentoja on saatu käyttöön. 
Ongelmia syntyy, kun yritetään käyttää jonkin paketin komentoja, ennen kuin tätä pakettia on ladattu. Jos näin on tapahtunut, on Global`-kontekstiin syntynyt komennon kanssa samanniminen muuttuja. Tämä on poistettava komennolla
Remove[muuttuja]

Kontekstit

Mathematica sijoittaa muuttujat eri konteksteihin. Komennolla $ContextPath nähdään kulloinkin käytössä olevat kontekstit. Tavallisesti käytössä on kaksi kontekstia.

System`, jossa on Mathematicaan sisäänrakennetut nimet

Global`, jossa on kaikki käyttäjän määrittelemät nimet

Jokaisella lisäpaketilla on oma kontekstinsa. Ladattaessa lisäpaketteja tulee siis lisää konteksteja. Lisäpakettien komentojen nimet kuuluvat luonnollisesti näiden lisäpakettien konteksteihin. 
Kontekstiin liittyvät muuttujien nimet nähdään Names-komennolla. Esimerkiksi käyttäjän luomat nimet nähdään komennolla Names[Global`].
Kun Mathematicalle annetaan komento, se etsii ensin tämän komennon nimeä Global`-kontekstista ja vasta sen jälkeen muista konteksteista. Toisin sanoen käyttäjän määrittelemät nimet ovat ykkössijalla. Tästä seuraa ongelmia yritettäessä käyttää jonkin paketin komentoa, ennen kuin pakettia on ladattu. Tällöin syntyy samanniminen muuttuja Global`-kontekstiin. Vaikka paketti ladataan jälkeenpäin, samanniminen muuttuja on jo olemassa Global`-kontekstissa. Mathematica tyytyy siihen eikä etsi muista konteksteista. Tällaisessa tapauksessa itse luotu nimi on poistettava komennolla Remove[nimi].
Kontekstin tunnuksena käytetään laskevaa aksenttia `.

Ohjelmointi

Mathematican oma ohjelmointikieli antaa mahdollisuudet varsin monipuoliseen ohjelmointiin. Yksinkertaisissa ohjelmissa komentoja vain suoritetaan järjestyksessä. Lisäksi saatetaan käyttää mm. Table-komentoa ja määritellä omia funktioita. Toisinaan peräkkäin suoritettavat komennot kannattaa kirjoittaa tiedostoon jollakin tekstieditorilla. Tiedosto tallennetaan m-tiedostoksi eli esimerkiksi tiedosto.m. Tiedosto ajetaan antamalla Mathematicassa komento
<<tiedosto.m
Seuraavassa esitellään lyhyesti tavallisimmat ohjelmoinnin ohjausrakenteet: For, Do, While ja If. Lisäksi tutustutaan mutkikkaammissa ohjelmissa varsin hyödylliseen Module-komentoon.

\[MathematicaIcon] Mathematica Book
Muita ohjausrakenteita: luku 2.5.9

For

For-lauseen syntaksi on seuraavanlainen:

For[alkuehto,ehtolauseke,lisäys,toistolauseke]

For-lauseessa suoritetaan ensin alkuehto, jonka jälkeen suoritetaan toistuvasti toistolauseke ja lisäys, kunnes ehtolauseke ei ole enää voimassa.
Jos alkuehto, ehtolauseke, lisäys tai toistolauseke koostuu useista käskyistä, ne erotetaan toisistaan puolipisteellä.

For[i = 1, i < 4, i = i + 1, Print[i]]

For[i = 1; j = 1, i <= 10, i = i + 1, j = j + i];  j

Do

({{Do[toistolauseke,{n}], suorittaa toistolauseketta n kertaa}, {Do[toistolauseke,
{i,imin,imax}], suorittaa toistolauseketta, kun i käy 
arvosta imin arvoon imax}, {Do[toistolauseke,
{i,imin,imax,di}], suorittaa toistolauseketta, kun i käy 
arvosta imin arvoon imax di:n välein}})
Jos toistolauseke koostuu useista käskyistä, ne erotetaan toisistaan puolipisteellä. Vertaa: Table-komento

s = 0; Do[s = s + x^i, {i, 1, 4}]; s

t  = Sqrt[2];  Do[t  =  1/(1 + t),  {3}];  t

While

While[ehtolauseke, toistolauseke] tarkistaa ensin, onko ehtolauseke tosi ja toistaa sitten toistolauseketta, niin kauan kuin ehtolauseke on tosi. Jos toistolauseke koostuu useista käskyistä, ne erotetaan toisistaan puolipisteellä.
Ehtolauseke muodostetaan vertailuoperaatioiden ja loogisten operaatioiden avulla.

a = 25;  While[a >= 0, a = a - 4; Print[a]]

If

If-lauseella on useita eri muotoja. Siihen liittyvä ehtolauseke muodostetaan vertailuoperaatioiden ja loogisten operaatioiden avulla.

If[ehtolauseke, lauseke]
Jos ehtolauseke on tosi, niin suoritetaan lauseke.

If[7 < 8, Print["tosi on"]]

If[ehtolauseke, lauseke1, lauseke2]
Jos ehtolauseke on tosi, niin suoritetaan lauseke1 ja jos se on epätosi suoritetaan lauseke2. Määritellään esimerkkinä Heavisiden funktio f(x)={({{1,  kun x > 0}, {0,  kun x <= 0}}).

f[x_] := If[x > 0, 1, 0]

{f[2], f[0], f[-2]}

Module

Module-komennolla voidaan ohjelmoida omia komentoja ja funktioita. Sen sisällä määritellyt muuttujat ovat lokaaleja, eivätkä viittaa mihinkään Module-komennon ulkopuolella määriteltyyn muuttujaan. Tämä mahdollistaa samannimisten muuttujien käytön Module-komennon sisä- ja ulkopuolella.
Module[{x,y,...},lauseke]
Lokaalit muuttujat erotetaan toisistaan pilkulla ja niille voidaan antaa myös alkuarvot, esimerkiksi {x=x0, y=y0, ...}
Lausekeosassa komennot erotetaan toisistaan puolipisteellä. Lausekeosan viimeisen komennon tulos tulostuu automaattisesti.

a = 5;
Module[{a}, a = 2; a]

a

Ohjelmat rakennetaan usein funktioiksi. Ohjelma voidaan siten suorittaa funktiolle annetun argumentin arvolla.

f[a_, n_] := Module[{b}, b = (a + 1)^n; Expand[ b]]

f[2 + x + y, 3]

Joskus on tarpeen sallia viittaukset komennon ulkopuolelle globaaleihin muuttujiin. Tällöin käytetään Module-komennon sijasta Block-komentoa. Block-komennossa muuttujille luodaan lokaalit alkuarvot, mutta muuttujien nimet voivat olla globaaleja.

\[MathematicaIcon] Mathematica Book
Lisää Module- ja Block-komennoista: luku 2.6

Kirjallisuutta

Maeder, Roman. Prgramming in Mathematica. 3rd ed. Addision-Wesley. USA 1997, 366 s.
Ruskeepää, Heikki. Mathematica-opas. Versio 4. University of Turku. Institute for Applied Mathematics. Manuals D1. June 1999, 127 s.
Wolfram, Stephen. The Mathematica Book, 3rd ed., Mathematica Version 3. Wolfram Media. Cambridge University Press. USA 1996, 1403 s.
Wolfram Research. Mathematica 3.0 Standard Add-on Packages. Wolfram Media. Cambridge University Press. USA 1996, 516 s.