Mathematica kasutamine

1. Sissejuhatus

Programmi Mathematica avanemisel pole programmi tuum - Kernel - vaikimisi käivitatud. Kernel on programmi see osa, mis tegelikult teostab arvutusi. Mathematica abil võib mitte ainult arvutada, vaid ka kujundada dokumente. Peale selle, programmi tuum võib töötada hoopis teises arvutis, mis asub samas arvutivõrgus. Seda kõike on võimalik konfigureerida, vaikimisi käivitatakse tuum siiski samas arvutis esimese arvutuse käivitamisel.
Arvutuse teostamiseks tuleb pärast arvutuse sisestamist vajutada Shift+Enter. Näiteks:
2+4 Shift+Enter.
Ekraanile ilmub:

2 + 4

In ja Out näitavad, mitmenda arvutusega on tegemist, antud juhul on esimene sisestus 2 + 4 ja esimene väljund 6. Edasistes arvutustes saab viidata tagasi eelmistele sisestustele ja väljunditele ning neid arvutustes kasutada. Seda vaatame hiljem. Arvutustes saab kasutada nii tekstipõhist arvutust  - kõik tehted trükitakse sisse käsitsi, ei mingit hiirega edasi-tagasi sõelumist. (kes on proovinud hiire abil Wordis valemeid sisestada, teab, kui aega nõudev see on). Mathematica 4 ja 5 versioonides saab kasutada ka graafilist kasutajaliidest. Shift-Enteri asemel võib vajutada ka Enter-klahvi, mis asetseb klaviatuuri paremas servas.
	Vihje: tihedalt valemeid täis tekstis kasutatakse TeX-i - tulemus on ilusam, valemite sisestamine 
	võtab tunduvalt vähem aega. Teisalt - TeX-i õppimine võtab natuke aega, kuid kes teadusega 
	tahab tegelda, selle jaoks on see enam-vähem kohustuslik. Matemaatika ja füüsika ajakirjad 
	võtavad vastu üldjuhul vaid TeX-s või LaTeX-s esitatud tekste), kuigi viimastel aastatel siiski ka 
	näiteks MS Wordis kirjutatut.

2. Aritmeetika, algebra.

2.1. Aritmeetika. Täpsed ja ligikaudsed tehted.

Tavalistes arvutustes kasutatavad tehted:

x+y+z		    liitmine
		-x	                                    lahutamine, miinus, neg .  arv 
		x y z või x*y*z	 korrutamine, \(korrutusmärk\ või\ tühik\ selle\ asemel\)
		x/y                                           jagamine
		x^y ehk  (x^y)                             astendamine

ASCII koodis on astendamismärk 94, selle saab kätte kui vajutada Alt+94 (94 klaviatuuri paremalt poolelt).
Näited:

2.3 + 5.6*2

2 4 6

(2.4^32)

Viimane avaldis on antud juba nn teaduslikus tähistuses (scientific notation). Samamoodi saab arve ka sisestada. Kolm järgmist kirjutist on samaväärsed:

3.5 (10^34)

3.5 10^34

3.5*^34

Kuigi Mathematica võib leida väga pikki arvutustulemusi täpselt, on tavaliselt soovitav need esitada siiski nö ümmardatud kujul, kümne astmete kaudu. Kümne astmete kaudu (ligikaudsel kujul) saab arve esitada kasutades funktsiooni N[  ]:

(3^32)

(3^32)  // N

N[(3^32)]

N[(2^40)]

Mathematica  eristab täisarve ning reaalarve. Kui sisestate arvutuses kõik arvud täisarvudena, siis antakse ka lõpptulemus täisarvude kaudu. Näiteks 34 on antud programmi jaoks täisarv, 34.0 ehk ka 34. reaalarv.

1/2 + 4/7

452/62

452.0/62

1.0 + 452/62

Seega, kui arvutuses on antud vähemalt üks reaalarv, antakse vastus reaalarvuna.

Mõned matemaatilised funktsioonid.

Sqrt[x] ehk  (Sqrt[x])				ruutjuur x-st
Sqrt[x,n]  ehk  (x^(1/n))			n-s juur x-st
Log[x]					naturaallogaritm - ln x
Log[a,x]					logaritm alusel a - (Subscript[log, a]) x
Sin[x], Cos[x], Tan[x], Cot[x]			trigonomeetrilised funktsioonid, argument on radiaanides!
ArcSin[x], ArcCos[x], ArcTan[x], ArcCot[x]	trigonomeetrilised pöördfunktsioonid (arkusfunktsioonid),
 						annavad vastuse radiaanides
n!						faktoriaal
Abs[x]						absoluutväärtus
Round[x]					ümmardamine
Mod[n,m]					jääk, mis saadakse jagamisel (n/m)
Quotient[n,m]					jagatise (n/m) täisosa
Random[]					pseudojuhuslik arv 0 ja 1 vahel
Max[x,y,...], Min[x,y,...]			arvude (avaldiste) x,y,... maksimum, miinimum
FactorInteger[n]				täisarvu n lahutamine algarvude korrutiseks
avaldis // N   ehk   N[avaldis]		avaldise ligikaudne väärtus; esitaminekümne astmete kaudu
N[avaldis,n]					avaldise väärtus n numbrikoha (mitte komakoha!) täpsusega

NB! Mathematica's on kõigi funktsioonide argumendid antud alati kandilistes sulgudes. Funktsioonide ja protseduuride nimed algavad alati suure tähega. Seetõttu on mõistlik enda defineeritud suurused ja funktsioonid anda väikeste algustähtedega.

Konstandid.

Pi   või   π					π ≈ 3,14159
E  või    e					e ≈ 2,71828
Degree   või   °				nurgakraadi tähis
I   või   i					immaginaarühik,  i = (Sqrt[-1])
Infinity    või   ∞				      lõpmatus

π ja e võetakse arvuti poolt vaikimisi samuti kui täpsed arvud. Seetõttu ei anna arvuti selliste avaldiste ligikaudseid väärtusi. Mõned näited:

π/4

Pi/4.

Sin[20  °]  //  N

(E^20.)

Ilma ligikaudset vastust nõudva funktsioonita  N antakse vatuseks lihtsalt Sin[20°], mis ongi täpne vastus.

Kompleksarvud.

x + I y						kompleksarv kujul  x+i y
Re[z]						kompleksarvu reaalosa  - x
Im[z]						kompleksarvu immaginaarosa  - y
Abs[z] 					absoluutväärus   |z|
Arg[z]						kompleksarvu |z|(e^i)φ argument φ
Conjugate[z]					arvu z kaaskompleks \(TraditionalForm\`z\&_\) ehk \(TraditionalForm\`\(z\^*\)\)

Näited:

(3 + 2  I) (7 - I)

((3 + 2  I)/(7 - I)) // N

Exp[2.0 - 7  I]

2.2. Algebralised teisendused

Mathematica võimaldab ka tehteid suure arvu muutujate ja arvudega, sisaldab erinevaid teisendusreegleid, võimaldab taandada ja murdudes koondada, tuua mingeid liikmeid sulgude ette jne. Üht omapära tuleb küll enne mainida. 
Ülalpool on öeldud, et korrutusmärgina võib kasutada ka tühikut. Kuid näiteks juhul 2(x-3) pole tühikut vaja. Samuti 2x on sama, mis 2*x; kuid x2 on uus muutuja, mida võiks tähistada ka x2. Seega - arvu korrutamisel muutujaga, kui arv asub  eespool, pole tühikut või korrutusmärki vaja. Kuid muutuja korrutamisel arvuga (muutuja on enne arvu), peab see olemas olema - x*2. Ka xy tähendab lihtsalt üht uut muutujat, mitte x ja y korrutist.

Expand[avaldis]				korrutab lahti kõik korrutised ja astmed 
						kirjutades saadud tulemuse summana
ExpandAll[avaldis]				rakendab Expand'i kõikjal (võtab kauem aega)
PowerExpand[avaldis]			kirjutab lahti ka astmete korrutised ja jagatised (näiteks ruutjuur ruudust)
Factor[avaldis]				kirjutab avaldise vähima arvu tegurite korrutisena
Simplify[avaldis]				üritab leida avaldise lihtsaimat kuju kasutades 
						erinevaid algebralisi teisendusi
FullSimplify[avaldis]				üritab leida avaldise lihtsaimat kuju kasutades 
						erinevaid algebralisi teisendusi, võimaldab rohkem aega kulutada, 
						resultaat võib väga pikkade avaldiste korral olla lühem
Together[avaldis]				viib murdude summa kõik liikmed ühisele nimetajale
Apart[avaldis]				kirjutab murru lahti, tulemuseks on murrud, millede nimetajad
						on võimalikult lihtsamal kujul
Cancel[avaldis]				taandab murru nimetaja ja lugeja ühised tegurid
Collect[avaldis,x]				rühmitab avaldise liidetavad x astmete järgi
FactorTerms[avaldis,x]			toob sulgude ette liikmed, mis ei sõltu x-st

$Line = 0;

Näited:

f = (((((x - 1))^2) (2 + x))/((1 + x) (((x - 3))^2)))

Expand[f]

s = ExpandAll[f]

Together[s]

Apart[%]

Factor[%]

Simplify[%]

St, Factor käsuga leitud avaldis ongi juba lihtsaimal kujul

v = (((3 + 2  x))^2) (((x + 2  y))^2)

Expand[v]

Collect[v, x]

FactorTerms[v, y]

TrigExpand[avaldis]			korrutab trigonomeetrilised avaldised summana lahti
TrigFactor[avaldis]			kirjutab trigonomeetrilise avaldise lahti tegurite korrutisena
TrigReduce[avaldis]			teisendab, koondab ja taandab avaldise kasutades nurkade 
					trigonomeetriliste funktsioonide vahelisi seoseid
TrigToExp[avaldis]			teisendab trigonomeetrilised funktsioonid eksponentideks
ExpToTrig[avaldis]			teisendab eksponendid trigonomeetrilisteks avaldisteks
FunctionExpand[avaldis]		korrutab (eraldab välja) spetsiaalfunktsioonid
ComplexExpand[avaldis]		korrutab kompleksarvudega avaldised lahti

2.3. Muutujatele, avaldistele väärtuse omistamine, 
tehted eelnevate arvutustulemustega

x = väärtus					x-le antakse mingi väärtus, see võib olla arvuline väärtus, 
					algebraline avaldis või mingi pikem funktsioon, arvutus, võrrand jne
x = .  või   Clear[x]			x-i väärtus tühistatakse
x := väärtus					x-le antakse mingi väärtus, sarnane esimese omistamisega
avaldis /. x-> väärtus		annab avaldises x-le väärtuse
avaldis /. {x -> (Subscript[x, v])äärt, y -> (Subscript[y, v])äärt}	avaldises antakse väärtused nii x-le kui ka y-le

Defineerime  avaldise s järgmiselt:

s = (x^2) + 4.5  x - y

Järgnevalt näitame mitmeid erinevaid võimalusi avaldises s sisalduvatele muutujatele väärtuste omistamiseks.

s /.  x -> 4

s /. {x -> 2.3,  y -> 3}

s /. {x -> y,  y -> t}

s /. {x -> (x^2), y -> (y^3)}

Viimane on nn  rekursiivne väärtustamine  Mathematica's ja peaks väga tuttav olema neile, kes on programmeerimisega kokku puutunud. /.  abil väärtuste omistamine ja arvutus toimib järgmiselt: esmalt teostatakse arvutus avaldises olevate muutujatega, seejärel omistatakse muutujatele uus väärtus ning antakse lõplik arvutustulemus. Seda demonstreerib ka järgmine näide.

(s^2) + 3  /.  x -> 2

Expand[%]

Viimases arvutuses rakendati protseduuri Expand eelmisele (eelviimasele).
Teine võimalus avaldises või arvutuses olevatele muutujatele väärtuse omistamine on toodud järgnevas näites.

a = 3. ;
b = 2.5;
c = x - y;
(a^2) + (b^3) - (c/2.)

Viimases näites oleme enne arvutust omistanud väärtused muutujatele a, b, c. Semikoolon rea lõpus eristab erinevaid sisestusi; semikooloniga lõppeva rea arvutuse tulemust ei kuvata ekraanile (ka lihtne väärtuse omistamine a=3. on siin mõistetud arvutusena), samas on iga sellise arvutuse tulemus ikkagi hiljem kasutatav. Semikoolonit on vahel mõtekas kasutada ka siis, kui on tegemist pikkade arvutustega ning mingi vahetulemus on väga pikk, sel juhul võib kasutada pidevalt viimast arvutust (vahepeal lihtsustades ning taandades/koondades erinevaid liikmeid) iga kord semikooloniga sisestuse lõpus ning alles viimase sisestus on ilma semikoolonita. Semikooloni kasutamine on mõistlik ka arvutimälu säästmise seisukohalt. 
Veel üks omapära on toodud järgmises näites:

23  x  +  14  y - 23  x*y
2  (y^2) - 11  x

Esimeses sisestuses on teisele reale mindud üle reavahetuse klahvi abil. Nagu näha on arvuti eeldanud, et tegemist on kahe erineva sisestusega, mitte ühe ja sama avaldisega. Juhul, kui avaldis ei mahu ühte ritta ära ja peaks ilmtingimata just korrutusmärgi koha pealt avaldist tüheldama, peaks esimese rea lõppu kirjutama korrutusmärgi:

23  x + 14  y - 23  x*y*
2  (y^2) - 11  x

Mathematica vanemad versioonid eeldavad vaikimisi siiski, et tegemist oli korrutamisega. 
Nagu mainitud, on antud programmis mitmeid võimalusi eelmistele väljunditele.

%						eelmise arvutuse väljund (resultaat)
%%						üle-eelmise arvutuse väljund
%n						n-nda arvutuse väljund
Out[n]						n-nda arvutuse väljund

Veel mõned näited. Pidage silmas, et kui teie sisestate avaldised täpselt nii nagu alltoodud näites, võite saada täiesti erineva tulemuse, kui teie arvutuste numeratsioon erineb antud näidete omast:

%(14^2)

Expand[%14 - (y^2)]

Out[16] - Out[17]

Expand[%]

Simplify[%]

2.4.Avaldiste lühendamine, avaldise
osade eraldamine, avaldise lihtsustamine eeldustel

Esmalt vaatame mõningaid lihtsustamisi lisaeeldustel. Näiteks

$Line = 0;
Clear[s, a, b, c];

Simplify[(Sqrt[(x^2)])]

Selline on vastus tänu sellele, et (Sqrt[(x^2)]) = x vaid siis, kui x>0. Kui eeldame, et see tingimus on täidetud, peaksime kirjutama:

Simplify[(Sqrt[(x^2)]), x > 0]

St lihtsustamine toimub eeldusel, mis on avaldisest eraldatud komaga.
Veel üks näide sellisest eeldusest on juhul, kui eeldame, et mingi suurus kuulub kindlasse hulka. Eeldame, et n∈N, st n on täisarv.

Simplify[Sin[x + 2  π n], Element[n, Integers]]

Simplify[avaldis, eeldus]				lihtsustab avaldist antud eeldusel
Simplify[avaldis, {(Subscript[eeldus, 1]),  (Subscript[eeldus, 2])}]			lihtsustab avaldist antud eeldustel (mis ei tohi olla 
							üksteisega vastuolus
Element[x, hulk]					defineerib x kui hulga liikme
Element[{(Subscript[x, 1]),  (Subscript[x, 2]),  
          (Subscript[x, 3]) ... }, hulk]			defineerib kõik (Subscript[x, i])hulga liikmetena
Reals							reaalarvud
Integers						täisarvud
Complexes						kompleksarvud
Primes							algarvud

Hulga võib ka ise defineerida ja siis lihtsustada tingimusel, et mingi suurus kuulub defineeritud hulka
Algebralisetest avaldistest võib kätte saada ka vaid nende osasid, vastavad käsud on järgmised:

Coefficient[avaldis, vorm]				annab avaldise vorm'i kordaja
Exponent[avaldis, vorm]				annab vormi maksimaalse astme
Part[avaldis] või avaldis[[n]]			annab avaldise n-nda liikme
Numenator[avaldis]					annab murdavaldise lugeja
Denominator[avaldis]					annab murdavaldise nimetaja

3. Sümbolarvutus. Tuletised, 
integraalid. Funktsioonid.

3.1. Tuletis, diferentsiaal, integraal, 
piirväärtus, summa.

Clear[f]; $Line = 0;

D[f,x]  või   (∂_x) f				(osa)tuletis funktsioonist f x järgi: (df/dx)ehk ∂(f/∂)x
D[f,x,y,...]  või   (∂_(x, y, z,  ... ))f			mitmekordne (osa)tuletis funktsioonist või avaldisest f:  \(TraditionalForm\`∂\^3 f\/\(∂x ∂y ∂z\)\).
D[f,{x,n}]					n-kordne tuletis avaldisest f x järgi: (((d^n) f)/(dx^n))
Limit[f, x -> (Subscript[x, 0])]				piirväärtus (lim_(x -> (Subscript[x, 0]))) f
Dt[f]						täisdiferentsiaal
Dt[f,x]						täistuletisavaldisest f muutuja x järgi
∫f dx  või  Integrate[f,x]			määramata integraal
(∫_a^b) f(x) dx  või Integrate[f,{x,a,b}]		määratud integraal
∫∫f(x, 
              y) dx dy  või Integrate[f,x,y]	mitmekordne määramata integraal muutujate x  ja y järgi
(∫_a^b)(∫_c^d) f(x, 
              y) dx dy	või 			mitmekordne määratud integraal
Integrate[f,{x,a,b},{y,c,d}]
Series[f, {x, (Subscript[x, 0]), järk}]			Taylori astmerida funktsioonist (avaldisest) f punkti x = (Subscript[x, 0]) juures
Normal[rida]					juhul, kui  rida on Taylori astemrida, siis see protseduur annab
						tulemuseks Taylori rea ilma viimase liikmeta
(∑_(i = (Subscript[i, min]))^((Subscript[i, max])))f  või  Sum[f, {i, (Subscript[i, min]), (Subscript[i, max])}]	summa
Sum[
        f, {i,  (Subscript[i, min]),  (Subscript[i, max])}, {j, (Subscript[j, min]), (Subscript[j, max])}]	mitmekordne summa
(∏_(i = (Subscript[i, min]))^((Subscript[i, max])))f  ehk  Product[f, {i, (Subscript[i, min]), (Subscript[i, max])}]	korrutis

Tuletised, diferentsiaalid

(∂_x) (x^3)

D[(x^n), x]

D[(x^n), n]

(∂_x) (x^2)  Log[x + a]

Esimene avaldis on tavaline tuletis. Teine näitab, et kui tuletist võetakse x järgi, on n lihtsalt konstant (tegemist on osatuletisega x järgi).. Kolmandas arvutuses oleme leidnud osatuletise muutuja n järgi, Ka viimases arvutuses leitakse osatuletis x järgi võttes a konstandiks.

(∂_(x, y))(3 (x^2) (y^5))

(∂_(x, y)) 3  (x^2) (y^5)

Eelviimane avaldis näitab, kuidas käib mitmekordse osatuletise leidmine. Sellise kirjutusviisi korral peab avaldis paiknema kindlasti ümarsulgudes. Vastasel juhul leitakse tuletis vaid avaldise esimesest tegurist, mida näitab viimane näide, kus tuletis on leitud arvust 3 (mis on loomulikult 0). Samast avaldisest võime leida ka kahekordse tuletise muutuja x järgi:

(∂_(x, x))(3  (x^2) (y^5))

D[3  (x^2) (y^5), {x, 2}]

Tuletise võime leida ka tundmatul kujul antud funktsioonist, kus on näidatud, et see funktsioon sõltub muutujast x:

(∂_x) (3 f[x])

D[Sin[x] f[3  x], x]

Niinimetatud täistuletise Dt[f,x] korral eeldatakse, et kõik muutujad (st mitte-arvud) sõltuvad muutujast x.

Dt[n Sin[x], x]

Seega, viimases avaldises tähendab Dt[n,x] tuletist n-st muutuja x järgi.

Integreerimine.

∫((3  y)/((x^2) + (y^2))) \[DifferentialD]x

Antud integraali leidmisel arvestati loomulikult, et y ei sõltu x-st, y on konstant.Koolimatemaatikast on meil teada, et määramata integraali leidmisel liidetakse alati otsa konstant. Antud programm jätab selle kasutajate hooleks.

(∫_0^5) 2  (x^3) \[DifferentialD]x

Integrate[((2  y)/((x^2) + (y^2))), x, y]

Järgmisena vaatame kahekordset määratud integraali, kus integreerimispiirkond on näidatud allpool toodud joonisel. See tähendab, et võime integreerida funktsiooni f(x,y) esmalt y järgi 0-st kuni ((2  x)/3)-ni ja siis x järgi 0-st 3-ni:

(∫_0^3)(∫_0^(((2  x)/3)))((x^2) + 
              (y^2)) \[DifferentialD]y \[DifferentialD]x

Sama integraal teiste tähistustega:

Integrate[(x^2) + (y^2), {x, 0, 3}, {y, 0, ((2  x)/3)}]

Viimasest arvutusest on näha, et sellisel juhul integreeritakse esimesena viimasena antud muutuja järgi erinevalt tavapärasest esitusviisist, kus esmalt leitakse sisemine integraal.

Piirväärtused. Taylori rida.

Taylori rida on astmerida kujul:

\(TraditionalForm\`f(
          x) = \(\(f(x\_0) + 
            f' \((x)\)\)\( | \_\(x = x\_0\)\)\(\ \)\(\((x - 
                x\_0)\)\  + \(1\/2\) 
              f'' \((x)\)\)\( | \_\(x = 
                x\_0\)\)\(\ \)\(\(\(\((x - 
                      x\_0)\)\^2\)\(+\)\)\  ... \)\(\ \)\)\)
\(TraditionalForm\`\(+\ \(1\/\(n!\)\)\) \(\(f\^\((n)\)\)(
            x)\)\( | \_\(x = 
              x\_0\)\)\ \(\(\((x - x\_0)\)\^n\)\(+\)\)\  ... \)
Järgmises näites arendame Taylori ritta funktsiooni f(x) = (e^x)(1 + x) punkti (Subscript[x, 0]) = 0 juures.

Series[(E^x) (1 + x), {x, 0, 4}]

Viimane liige - O[x]^5 võtab kokku kõik liikmed, milles x aste on 5 või sellest suurem. Et sellest vabaneda, tuleks kasutada käsku Normal:

Normal[%]

Järgmised paar näidet on piirväärtuste kohta. Esmalt defineerime avaldise, siis leiame piirväärtuse ning vaatama ka seda, kuidas Mathematica otsese arvutusega üritab avaldise väärtust leida.

s = Sin[x]/x

Limit[s, x -> 0]

s /. x -> 0

Seega, avaldisel leidus lõplik piirväärtus - 1, kuid otsesel arvutusel oleks tulnud jagada nulliga ning tulemus jäänud leidmata.

t = (((9 - (x^2)) 2  (x^3))/((3  x - 9)))

Limit[t, x -> 3]

t /. x -> 3

Veel mõned näited:

Limit[(E^(-x)) - 1, x -> ∞]

Limit[Tan[x], x -> (π/2)]

Summad ja korrutised.

(∑_(i = 0)^5) ((2^i)/(i!))

N[%]

(∑_(i = 1)^∞) (1/(i^2))

(∑_(i = 1)^∞) (1/(i! + (2  i)!))

N[%]

(∑_(i = 1)^3)(∑_(j = 1)^i) (x^i) (y^j)

Product[x + i, {i, 1, 5}]

3.2. Funktsioonide defineerimine.

Clear[s, f];
$Line = 0;

Lisaks Mathematica's defineeritud funktsioonidele ja protseduuridele võib neid ka ise teha. Defineerime järgmise ruutfunktsiooni:

f[x_] := 3  (x^2) + 2  x + 1

Siin alakriips ('blank') tähendab, et see funktsioon ehk reegel antud funktsiooni leidmiseks kehtib ka siis, kui me edaspidi asendama muutuja x muutujaga y:

f[y]

f[2.5]

Võrdluseks mõned vastupidised näited:

g[x] := 3  (x^2) + 2  x + 1

g[y]

g[3]

St, antud reegel (g[x]) ei ütle midagi selle kohta, kui x asemel on y. Me saame küll leida mõningate avaldiste väärtusi, kuid enamus võimalusi jääb kasutamata.

g[x] /. x -> y

g[x] /. x -> 3

Seega, sellisel, ilma alakriipusta definitsioonil 'kui funktsioon x-st' puudub mõte. Selliselt võime määrata ka lihtsa avaldisena (vähem vaeva edasistes arvutustes). Esmalt tühistame g[x] definitsiooni:

Clear[g]

g := 3  (x^2) + 2  x + 1

g /. x -> 4

Analoogiliselt võib defineerida ka mitme muutuja funktsioone. Allpool toome näitena füüsikast tuntud avaldise teepikkuse määramiseks mingil ajahetkel kui funktsiooni ajast t, algkiirusest (Subscript[v, 0]) ja kiirendusest a.
Märkus: alaindeksite kasutamine arvutustes ei ole alati väga hea idee!

Clear[s]

s[t_, v0_, a_] := v0*t + (1/2) a*(t^2)

s[4, 0.5, 1]

s[4, 1, 0.5]

Funktsioone saab defineerida ka kui mingit funktsioonide jada - protseduuri:

avald[n_] := Expand[(∏_(i = 1)^n)(x + i)]

avald[4]

Siin defineerisime funktsiooni (x+1)(x+2)(x+3)...(x+n), mis korrutab selle avaldise ka lahti (vaikimisi Mathematica seda ei tee).

ava[x_, n_] := 
      Expand[(∏_(i = 1)^n)(x + (i^2))]

ava[3, 4]

Mis juhtub, kui n asemele sisetada negatiivne arv või mitte-täisarv?

f[x_] := (x^3)				funktsiooni f(x) defineerimine
f[x_, y_] := (x^3) + Sin[2  x + 3]		mitme muutuja funktsiooni defineerimine
Clear[f]				funktsiooni f definitsiooni tühistamine
?f					funktsiooni f kuju näitamine (kehtib ka arvuti 
					poolt defineeritud 
					funktsioonide ja protseduuride kohta
??f					kogu funktsiooni või protseduuri f kohta käiva 
					info näitamine
f[x] = (x^3)				avaldise (ja mitte funktsiooni) f defineerimine

3.3. Võrrandid.

Alapunktis 2.3 näitasime, kuidas omistada väärtusi muutujatele. Näiteks x = y on lihtsalt muutujale x muutuja y väärtuse omistamine. Selline omistamine deklareerib mõlemad suurused võrdseks, kuid ühe täpsustusega. Kui anname y-le mingi väärtuse, saab ka muutuja x automaatselt sama väärtuse, kuid muutujale x väärtuse omistamisega, jääb y väärtus muutumatuks ning sellest hetkest alates ei olen enam x y-ga võrdne. x == y aga kontrollib, kas x on y-ga võrdne. Kahte võrdusmärki kasutatakse ka võrrandite lahendamisel (võrrandite defineerimisel samuti).

x = y

x == y

2 + 4 == 6

2*5 == 11

x =.

Viimase võrdusega tühistasime x väärtuse.

x == 5

Kuivõrd x-l väärtus puudub, ei oska ka programm öelda, kas võrdus on tõene või väär. 
Avaldis x==5 on tegelikult juba võrrand (mille lahendiks on ilmselt x=5), sest x väärtus on defineerimata.
Programmis Mathematica (ja ka näiteks Maple's) on tihti tavaks anda mingile avaldisele väärtuseks võrrand ise.

eq = (x^2) - 4  x - 7 == 0

x = y 					omistab x-le väärtuse y
x == y 					kontrollib, kas x ja y on võrdsed
x != y					kontrollib, kas x ei võrdu y-ga (kui x ja y ei ole võrdsed, 
					on vastus True)
x > y					kontrollib, kas x on suurem, kui y
x < y					kontrollib, kas x on väiksem kui y
x <= y					väiksem või võrdne
x >= y					suurem või võrdne
x == y == z				kas kõik on omavahel võrdsed
x != y != z				kas kõik on omavahel mittevõrdsed

Ülaltoodud avaldisi saab eriti hästi kasutada keerulisemata ülesannet lahendamisel, näiteks programmeerimisel Mathematicas, kasutades laused While-, Do, For, If.

Võrrandite lahendamine.

Solve[vasak pool == parem pool, x]	võrrandi lahendamine x suhtes, tulemuseks on 
						on reegilite hulk (list)
x /. lahend					reeglite listi kasutatakse x väärtuste saamiseks
avaldis /. lahend				reeglite listi kasutatakse avaldisele väärtuse andmiseks

Solve abil saab lahendada algebralisi võrrandeid, milles muutuja aste on maksimaalselt 4. Kui kõrgeim aste on üle nelja, ei pruugi täpset lahendit antud protseduur leida.

Solve[eq, x]

Kuivõrd võrrandis olid kõik arvud täisarvud, siis antakse tulemus täpselt. Ligikaudse lahendi saamiseks oleks kordajatest vähemalt üks tulnud ette anda reaalarvuna (nt 7.0) või teha nii nagu järgnevas näites:

N[%]

Viimane avaldis on reeglite hulk (list). Ainult arvude hulga saame järgmiselt:

lahendid = x  /.  %28

Kui nüüd soovime omistada esimese väärtuse (Subscript[x, 0])-le, teise (Subscript[x, 1])-le, tuleks teha järgmiselt:

(Subscript[x, 0]) = lahendid[[1]]

(Subscript[x, 1]) = lahendid[[2]]

(Sqrt[x])  /.  %28

Kuivõrd Out[9] oli meil list, milles x-l oli kaks väärtust, siis ka (Sqrt[x]) protseduuri rakendamine andis tulemuseks listi, milles on kaks liiget. Ja kuivõrd esimene väärtus oli negatiivne, siis sellest ruutjuure võtmisel saame tulemuseks loomulikult kompleksarvu.

Solve[(x^5) - 4  (x^4) + 9 == 0, x]

Nagu nähe, ei suutnud antud juhul Solve-protseduur anda täpset lahendit. Küll saame ligikaudse:

Solve[(x^5) - 4  (x^4) + 9.0 == 0, x]

Solve[Sin[x] == a, x]

Antud juhul kasutatakse siinuse pöördfunktsiooni arcsin, seetõttu on siin ka hoiatus,et et mõned lahendid võivad jääda leidmata. Antud võrrandil on tegelikult lõpmata hulk lahendeid, mis erinevad üksteisest 2 π n võrra, n on siin täisarv.

Solve[Sin[x] == x, x]

See tähendab, et ülaltoodud võrrand sisaldab transendentseid funktsioone ning algebraliselt on seda võrrandit võimatu lahendada. Selliste transendetnsete võrrandeid lahendatakse numbriliselt ning nende  lahendamiseks on funktsioon FindRoot, mida käsitleme hiljem.

Solve[{(Subscript[vp, 1]) == (Subscript[pp, 1]), 
          (Subscript[vp, 2]) == (Subscript[pp, 2]),  ... }, {(Subscript[x, 1]), (Subscript[x, 2]),   ... }]		võrrandisüsteemi 
								lahendamine (Subscript[x, 1]), (Subscript[x, 2]), ..suhtes
NSolve[{(Subscript[vp, 1]) == (Subscript[pp, 1]),  
          (Subscript[vp, 2]) == (Subscript[pp, 2]),   ... }, {(Subscript[x, 1]), (Subscript[x, 2]),   ... }] 		võrrandisüsteemi numbriline 	
								lahendamine (Subscript[x, 1]), (Subscript[x, 2]) ..suhtes
Eliminate[{(Subscript[vp, 1]) == (Subscript[pp, 1]),  
          (Subscript[vp, 2]) == (Subscript[pp, 2]),   ... }, {(Subscript[x, 1]), 
          (Subscript[x, 2]),   ... }]  	võrrandisüsteemist muutujate (Subscript[x, 1]), (Subscript[x, 2]) 
								ellimineerimine
Reduce[{{(Subscript[vp, 1]) == (Subscript[pp, 1]),  
        (Subscript[vp, 2]) == (Subscript[pp, 2]),   ... }, {(Subscript[x, 1]), (Subscript[x, 2]),   ... }] 	annab lihtsustatud võrrandite süsteemi koos
								võimalike lahendustega
FindRoot[vp == pp,  {x, (Subscript[x, 0])}]					leiab numbriliselt lahendi võrrandile, alustades (Subscript[x, 0])-st

Solve[{2  x - 4  y + 3  z == 0, x - 3  y - z == 0, 
        x - 3  z == -9}, {x, y, z}]

NSolve[{2  x - 4  y + 3  z == 0, x - 3  y - z == 0, 
        x - 3  z == -9}, {x, y, z}]

Eliminate[{2  x + 4  y + 3  z == 0, x - 3  y == z - 2}, 
      z]

Reduce[{2  x + 4  y + 3  z == 0, x - 3  y == z - 2}, {x, 
        y}]

Eliminate käsuga saime kahest kolme muutujaga võrrandist ühe kahe muutujaga võrrandi. Reduce abiga antud juhul saime kaks võimalikku uut võrrandit - esimesel juhul elimineerisime y, teisel juhul x. 
Kuigi NSolve leiab võrrandite lahendeid numbriliselt, sobib see protseduur siiski vaid võrrandite jaoks, kus muutujad on mingites astmetes (polünoomvõrrandid). Vastasel juhul tuleb kasutada ikkagi protseduuri FindRoot, mis leiab nullkohad Newtoni iteratsioonimeetodil, kuid selleks tuleb anda piisavalt hea lähtepunkt, st ligikaudne nullkoht. Viimast on üsna hea leida joonise abil.
Järgnevas näites defineerime uue funktsiooni, teeme selle kohta joonise ja siis leiame nullkohad.

Clear[f, g];

g[x_] := 2  x*(E^(0.1  x)) - (x^2)

Plot[g[x], {x, -2, 4}]

Jooniselt on näha, et üks nullkoht on umbes kohal 0, teine kohal 2,5. Tuleb kasutada kaks korda protseduuri FindRoot

FindRoot[g[x] == 0, {x, 0}]

FindRoot[g[x] == 0, {x, 2.5}]

Seega on kaks nullkohta: (Subscript[x, 1]) = 0,  (Subscript[x, 2]) ≈ 2, 59.

4. Joonised

4.1. Joonised tasandil

Plot[f, {x, (Subscript[x, min]),  (Subscript[x, max])}]			joonistab funktsiooni f graafiku (Subscript[x, min])-st 
						kuni (Subscript[x, max])-ni
Plot[{f, g,  ... }, {x, (Subscript[x, min]),  (Subscript[x, max])}]		joonistab mitme funktsiooni graafikud
Show[joonis1, joonis2]				joonistab erinevad joonised ühele kokku

$Line = 0;

Plot[(E^(-0.5 x)) Sin[x], {x, 0, 2  π}]

Plot[{2  (x^2) - 4  x, 2  x}, {x, -2, 4}, 
      AxesLabel -> {x, y}]

Show[%1, %2]

Nagu teisest arvutusest näha, võib Plot-protseduurile anda erinevaid lisavõimalusi. Täieliku info võimalustest saab Help-st või kasutades Help-käsku (kehtib kõigi Mathematica funktsioonide ja protseduuride kohta).

Mõned näited erinevate võimaluste kasutamise kohta.

Plot[{(E^x), x, Log[x]}, {x, -3, 3}, 
      PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0.5, 0.5, 0], 
          RGBColor[0, 0.5, 1]}, AxesLabel -> {"x", "y"}, 
      PlotRange -> {{-3, 3}, {-3, 4}}, 
      AspectRatio -> Automatic]

Nagu näha, andis programm ka teada, et funktsiooni ln(x) (Log[x]) ei saa negatiivsete väärtuste ja nulli kohal leida. Kuivõrd tegemist on kolme funktsiooni graafikuga, siis on ka PlotStyle-s iga funktsiooni jaoks värv ära määratud, st PlotStyle's on tegemist listiga.

funkt[x_] := 2*Sin[2  x]

Plot[funkt[x], {x, 0, 12}, 
      TextStyle -> {FontSlant -> "Italic",  
          FontSize -> 
            12}, 
Ticks -> {{{1.5, "a"}, {3, "2a\
"}, 8}, Automatic}, 
      Epilog -> {Text["Sin(2x)", {8.7, 0.8}, {0, 0}]}]

valik			vaikväärtus
Axes			Automatic 	kas teljed lisada, ntx Axes->No (Yes)
AxesLabel		None		millised tähised telgede juurde panna, nt
					AxesLabel->{"a","b/s"}
AxesOrigin		Automatic	millises punktis asub telgede ristumiskoht (nullpunkt)
					nt AxesOrigin->{2,0}
Frame			False		kas tõmmata kast ümber joonise True või False 
					nt Frame->True
GridLines		None		abijooned. Automatic lisab iga olulisema väärtuse kohale joone
PlotRange		Automatic	milline vahemik joonisele pannakse. Tihti joonistab programm
					"kõige huvitavama" piirkonna, mitte kõike, vastupidine oleks
					PlotRange->All

Kõikvõimalikke valikuid saab leida nn 'help-käsu abil:

?? Plot

Jooniste kujundamisel on abiks veel lisapaketid (vt Help-menüüst Add-ons, Standard Packages, Graphics).

4.2. Joonised ruumis.

Plot3D[
        f, {x, (Subscript[x, min]), (Subscript[x, max])}, {y, (Subscript[y, min]), (Subscript[y, max])}]	teeb kolmemõõtmelise joonise kui funktsiooni kahest 
						muutujast x ja y

Plot3D[(x^2) + 2  (y^2), {x, -2, 2}, {y, -2, 2}]

Plot3D[2  y Sin[x y], {x, -1, π}, {y, -1, 2}, 
      AxesLabel -> {x, y, 
          z}, 
ViewPoint -> {1.6, -1.5, 2}, 
      Mesh -> False, PlotPoints -> 25, 
      PlotLabel -> "z(x,y) = 2y sin(x*y)"]

Ka antud leiab kogu võimalike valikute hulga käsu ??Plot3D abil, soovi korral koos näidetega.

4.3. Parameetrilised joonised.

ParametricPlot[{x(t),  y(t)}, {t, (Subscript[t, 1]), (Subscript[t, 2])}]	parameetrilise joonise tegemine
ParametricPlot[{{(Subscript[x, 1])(t),  (Subscript[y, 1])(
              t)}, {(Subscript[x, 2])(t), (Subscript[y, 2])(t)},  ... }, {t, (Subscript[t, 1]), 
          (Subscript[t, 2])}] 	
						mitme parameetrilise joonise tegemine
ParametricPlot[{x(t),  y(t)}, {t, (Subscript[t, 1]), (Subscript[t, 2])}, 
        AspectRatio -> Automatic ]	
						parameetriline joonis, selline, et ka joonise õige kuju säiliks
ParametricPlot3D[{x(t), y(t), z(t)}, {t, (Subscript[t, 1]), 
          (Subscript[t, 2])}]		
						parameetriline joon 3-mõõtmelises ruumis

ParametricPlot[{Sin[t],  Cos[t]}, {t, 0, 2  π}, 
      AspectRatio -> Automatic]

Järgnevalt veel mõned näited nn Lissajoux' kujunditest (eelmine on kõige lihtsam).

ParametricPlot[{{Sin[2  t], Sin[5  t]}, {Sin[2  t], Cos[3  t]}}, {t, 0, 
        2 π}, 
PlotStyle -> {RGBColor[1, 0.5, 
            0.8], Hue[0.6]}]

ParametricPlot3D[{Sin[t], Cos[t], 0.1  t}, {t, 0, 25}]

5. Diferentsiaalvõrrandite lahendamine.
Integraalide ja diferentsiaalvõrrandite
numbriline lahendamine.

DSolve[{(Subscript[vor1, vas]) == (Subscript[vor1, par]),  
          (Subscript[vor2, vas]) == (Subscript[vor2, par]),  ... },  {(Subscript[f, 1])[x], (Subscript[f, 2])[x],  ... }, 
        x] 
				diferentsiaalvõrrandite süsteemi lahendamine
NDSolve[{(Subscript[vor1, vas]) == (Subscript[vor1, par]),  
          (Subscript[vor2, vas]) == (Subscript[vor2, par]),  ... },  {(Subscript[f, 1]), (Subscript[f, 2]),  ... }, {x, 
          (Subscript[x, 1]), (Subscript[x, 2])}] 
				diferentsiaalvõrrandite süsteemi numbriline lahendamine lõigus [(Subscript[x, 1]), (Subscript[x, 2])]
NIntegrate[f[x], {x, (Subscript[x, 1]), (Subscript[x, 2])}] 		numbriline integreerimine

Vaatame näitena järgmist diferentsiaalvõrrandit: (((d^2) y(x))/(dx^2)) = a y(x) + 1, mis on teist järku diferentsiaalvõrrand. Selle lahendamine:

DSolve[(∂_x) y[x] == a*y[x] + 1, y[x], x]

Selle tähistusviisiga analoogiline on järgmine:

DSolve[y'[x] == a*y[x] + 1, y[x], x]

Nagu näha, on siin sees ka kaks konstanti, mis määratakse lisatingimustest. 
Anname ette ka lisatingimused ning vaatame, milline näeb välja lahendi graafik.

lahend = 
      DSolve[{(∂_x) y[x] == a*y[x] + 1, y[1] == (2/a)}, y[x], 
        x]

lahend[[1]][[1]][[2]]

Plot[lahend[[1]][[1]][[2]]  /. 
        a -> 3, {x, -1, 2}]

Ülaltoodud tähistus lahend[[1]][[1]][[2]] annab parasjagu kahekordsetes loogelistes sulgudes oleva avaldise teise liikme, st funktsiooni. (Proovige järgi, mis on lahend[[1]], lahend[[1]][[1]] ja lahend[[1]][[1]][[1]] ).
Loomulikult oleksime võinud lihtsalt defineerida uue funktsiooni (cut-paste abil) ning siis selle graafiku üles joonistada juhul, kui a=5 näiteks:

u[x_] := (((E^(-a)) (-(E^a) + 3 (E^(a x))))/a)

Plot[u[x] /. a -> 5, {x, -2, 1}, 
      PlotRange -> All]

Teise näitena vaatame sumbuvat võnkumist kirjeldavat võrrandit koos algtingimustega. See on teist järku lineaarne konstantsete kordajatega diferentsiaalvõrrand:
y''(x)+0.01y'(x)+4y(x)==0.2 cos (3x), y'(0)=2, y(0)=10

lahendus = 
      DSolve[{y''[x] + 0.15  y'[x] + 4  y[x] == 
            5  Cos[3  x], 
y'[0] == 2, 
          y[0] == 10}, y[x], x]

Plot[lahendus[[1]][[1]][[2]], {x, 0, 70}, 
      PlotPoints -> 100, PlotRange -> All]

Kuigi lahendis on kompleksarvud sees, on lahend tegelikult reaalne. I ees olevad kordajad on arvutustäpsuse piiril. Nagu oli näha, arvestas programm seda funktsiooni graafiku joonistamisel. Kuid selleks, et antud juhul neist neist lahti saada, võib kasutada funktsiooni Chop:

lahend = Chop[%20]

Chop[avaldis]				viskab ära liikmed, mis on väiksemad kui (10^(-10))
Chop[avaldis, dx]			viskab ära liikmed, mis on väiksemad kui dx

Plot[lahend[[1]][[1]][[2]], {x, 0, 70}, 
      PlotPoints -> 100, PlotRange -> All]

Clear[x, u, t, y]

Tihti pole võimalik leida diferentsiaalvõrrandi või võrrandite süsteemi lahendit analüütiliselt. Sel juhul 
tuleb alati ette anda ka algtingimused. Tulemuseks saame funktsiooni, mis on esitatud interpoleeritud funktsioonina. Viimast saame omakorda lähemalt uurida graafiku abil.

funkt = 
      NDSolve[{u'[t] == 2 - (((u[t]))^2) + Sin[t], 
          u[0] == 2}, u, {t, 0, 15}]

Plot[
      Evaluate[u[t] /. funkt[[1]][[1]]], {t, 0, 15}]

Ülaltoodud protseduuris Evaluate[u[t]/.funkt[[1]][[1]]] ongi käsklus, mille kohaselt programm võtab funktsiooni u[t] väärtuse nii nagu diferensiaalvõrrandi lahendamisel leitud.

Evaluate[u[3] /. funkt[[1]][[1]] ]

2*Sin[4]*Evaluate[u[4] /. funkt[[1]][[1]] ]

Võime lahendada ka mitmest diferentsiaalvõrrandist koosneva süsteemi.

sol = 
      NDSolve[{x'[t] == 
            2 (((x[t]))^2) - 0.1 (((y[t]))^2), 
y'[
              t] == -x[t] + y[t], x[0] == -2, 
          y[0] == 1}, {x, y}, {t, 0, 10}]

sol[[1]][[1]]

Plot[
      Evaluate[x[t] /. sol[[1]][[1]] ], {t, 0, 10}]

Plot[
      Evaluate[y[t] /. sol[[1]][[2]] ], {t, 0, 10}]

Mõned näited integraali numbrilise arvutuse kohta. Esmalt - kuidas oleks tulemus tavakujul ja NIntegrate abil.

(∫_1^3) (E^((x^2)))/(x^3) \[DifferentialD]x

N[%33]

NIntegrate[(E^((x^2)))/(x^3), {x, 1, 3}]

6. Vektorid, maatriksid, listid.

6.1. Tehteid listidega

$Line = 0;

Listiks võiks nimetada igasugust tüüpi avaldis, mis avaldatakse loogeliste sulgude vahel ning avaldise liikmed on omavahel eraldatud komadega. Mõned näited:

v = {2, 3, 4}

Toodud üherealist listi võime nimetada ka vektoriks. Allpool vataleme ka pikemalt, kuidas vektoritega tehteid teha. Mõned lihtsamad aga siin.

Sqrt[v]

N[%]

v + 2

v*a

(x^v)

D[((x )^v), x]

(∫_0^3) (x^v) \[DifferentialD]x

(∫_0^3) (v^x) \[DifferentialD]x

N[%]

Seega võib antud juhul vaadata listi kui mingit andmetekogumit. Kasutades listi mingites algebralistes operatsioonides, rakendatakse neid operatsioone kõigile listi liikmetele. Mingi algoritmi järgi saab listi genereerida kasutades käsku Table.

li = Table[(i^2), {i, 5}]

li2 = Table[i - 3, {i, 5}]

li + li2

Table[Sin[n/5], {n, -2, 4}]

maat = Table[(x^i) + (y^j), {i, 3}, {j, 2}]

TableForm[%]

Table[Random[],  {4}]

Table[f, {imax}]			genereeritakse list, milles on imax liiget, antakse funktsiooni f abil
Table{f,{i, imax}]			genereeritakse list, mille liikmed antakse f abil 1-st kuni imax-ni
Table[f, {i, imin, imax}]		genereeritakse list, mille liikmed antakse f abil imin-st kuni imax-ni
Table{f, {i, imin, imax, di}]		genereeritakse list, mille liikmed antakse f abil 1-st kuni imax-ni sammuga di
Table[f, {i,imin,imax},{j,jmin,jmax}] 	genereeritakse tabel (või maatriks) funktsiooni f abil
TableForm[list]			list kuvatakse tabeli kujul

Listidest ja maatriksitest saab välja eraldada mõningaid liikmeid, teha tehteid nendega ning koostada neist uusi liste.

maks = maat[[3]]

li3 = li2[[2]]

li2[[{3, 4, 5}]]

li3*maks

t[[i]] või Part[t,i]			annab listi t alamlisti i (vt maks) või ühe elemendi (vt li3)
					alamlistiks võib olla ka vaid üks listi liige
t[[{(Subscript[i, 1]),  (Subscript[i, 2]),   ... ,  (Subscript[i, n])}]]  			genereeritakse uus n liikmeline list vanast listist t
t[[i,j,...]] ehk Part[t,i,j,...]		antakse listi t osa i-nda osa j-s osa

t = {{2, 3}, {a + z, g}, {d, (Sqrt[3 + 5])}}

t[[2]]

t[[2, 1]]

t[[2]][[1]]

t[[2]][[1]][[1]]

t[[2, 1, 1]]

Nagu ülaltoodud näidetest näha võib sel moel tuua ka pikast avaldisest välja erinevaid osi, antud juhul listi ühe osa üht liidetavatest. Mõned sarnased näited veel, kus saab mingist pikemast avaldisest osa liikmeid välja tuua.

vorrandilahend = 
      Solve[{x + 2  y - 3.0  z == 2, y - z == 0.5, 
          x + 2  y - 6  z == 4}, {x, y, z}]

iks = vorrandilahend[[1]][[1]]

ks = vorrandilahend[[1]][[1]][[2]]

Siin kasutasime asjaolu, et võrrandi lahend antakse listina - see on antud loogeliste sulgude vahel. Sel listil on omakorda 3 liiget (x->0.333333, y->0.166667, z->0.666667), mis koosnevad kahest liikmest.

ig = vorrandilahend[[1]][[2]][[2]]

ze = vorrandilahend[[1]][[3]][[2]]

Clear[x, t]

difvor = 
      DSolve[{2.0  x''[t] + 0.5  x'[t] + 5  x[t] == 
            2.5 Sin[5  t], x'[0] == 2, x[0] == -1}, 
        x[t], t]

Chop[%]

Allpool defineerime suuruse fun listi abil.

fun := difvor[[1]][[1]][[2]]

Plot[fun, {t, 0, 50}, PlotRange -> All]

6.2. Vektorid ja maatriksid.

Vektor on samasugustest elementidest koosnev üherealine list (üherealine maatriks). Maatriksil võib mõõtmeid olla tunduvalt rohkem, kuigi enamkasutatav on kahemõõtmeline maatriks.

{a, b, c}					vektor (a,b,c) ehk ühemõõtmeline 1x3 maatriks
{{a,b},{c,d}}					kahemõõtmeline 2x2 maatriks (({{a, b}, {c, d}})) 
{{{(Subscript[a, 1]),  (Subscript[a, 2]),  (Subscript[a, 3])}, {(Subscript[b, 1]), (Subscript[b, 2]), (Subscript[b, 3])}}, {{(Subscript[c, 1]),  (Subscript[c, 2]), (Subscript[c, 3])},  {(Subscript[d, 1]),  (Subscript[d, 2]),  
            (Subscript[d, 3])}}} 
						kolmemõõtmeline 2x2x3-maatriks
c v						vektori korrutamine skalaariga
a.b						vektorite skalaarkorrutis
Cross[a,b]					vektorite vektorkorrutis

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

a . b

Cross[a, b]

Juhul, kui nii a kui ka b on mõlemad samade mõõtmetega vektorid, tähendab a b uut vektorit, mille komponentideks on vastavate komponentide korrutised.

a b

Clear[a, b, c, v]

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

MatrixForm[a]

MatrixForm[b]

a . b

b . a

Tehted vektoritega:

Table[f, {i,n}]				n-mõõtmelise vektori loomine funktsiooni f abil, i=1,2,...,n
Array[a,n]				n-mõõtmelise vektori loomine kujul {a[1], a[2], ..., a[n]}
Range[n]				listi {1,2,...,n} loomine
Range[(Subscript[n, 1,]) (Subscript[n, 2])]				listi {(Subscript[n, 1, ]) (Subscript[n, 1]) + 
          1,   ... ,  (Subscript[n, 2]) - 1,  (Subscript[n, 2])} loomine
Range[(Subscript[n, 1]),  (Subscript[n, 2]),  dn]			listi {(Subscript[n, 1]),  (Subscript[n, 1]) + dn,   ... ,  (Subscript[n, 2]) - dn,  
        (Subscript[n, 2])}  loomine
list[[i]] ehk Part[list, i]			annab listi i-nda elemendi
Length[list]				annab listis olevate elementide arvu
ColumnForm[list]			näitab vektorit ekraanil ühes veerus

Tehted maatriksitega:

Table[f, {i,n},{j,n}]			m × n maatriksi loomine funktsiooni f abil
Array[a,{m,n}]			m × n maatriksi loomine, kus maatriksi i-nda rea j-nda veeru element
					antakse kujul a[i,j]
IdentityMatrix[n]			n × n ühikmaatriksi loomine
DiagonalMatrix[list]			luuakse ruutmaatriks, mille diagonaalil on listi elemendid
list[[i]]	ehk Part[list,i]			antakse maatriksi list i-rida
list[[i,j]] ehk Part[list,i,j]		antakse listi i-nda rea j-nda veeru element
Dimensions[list]			annab listi dimensioonid
MatrixForm[list]			maatriks kuvatakse ekraanile maatriksina
c m					maatriksi m korrutamine skalaariga c 
a.b 					maatriksite korrutamine
Inverse[m]				pöördmaatriksi leidmine
MatrixPower[m,n]			maatriksi m n-s aste
Det[m]					determinant
Tr[m]					maatriksi jälg
Transpose[m]				transponeeritud maatriksi leidmine
Eigenvalues[m]			maatriksi omaväärtuste leidmine
Eigenvectors[				omavektorite leidmine
Eigenvalues[N[m]], Eigenvectors[N[m]]	numbrilised omaväärtused ja omavektorid

mx = Table[(s^(i - j)), {i, 3}, {j, 4}]

MatrixForm[mx]

sx = Table[i - j, {i, 4}, {j, 3}]

MatrixForm[sx]

mx . sx

MatrixForm[%]

MatrixForm[2 sx]

Det[mx . sx]

Tr[mx . sx]

Eigenvectors[mx . sx]

Eigenvalues[mx . sx]

ahaa = {{2, 3}, {1, 7}}

Eigenvalues[N[ahaa]]

Eigenvectors[N[ahaa]]

Seega saame maatriksi ahaa avaldada omaväärtuste ja omavektorite abil järgmiselt:
(({{2, 3}, {1, 7}}))(({{-0.4761}, {-0.8794}}))=7.54138(({{-0.4761}, {-0.8794}}))  ning
(({{2, 3}, {1, 7}}))(({{-0.9841}, {-0.1776}}))=1.45862(({{-0.9841}, {-0.1776}}))

Ülal on toodud kaks erinevat võimalust maatriksite defineerimiseks - Array ning Table abil. 
Table abil on mugavam luua maatriksit mingi algoritmi järgi. Array-ga loodud maatriksis on maatriksi elementide muutmine mõneti lihtsam (sarnane erinevates programmeerimiskeeltega). Seetõttu on ka Array kasutamine programmeerimisel üsna loomulik.

Clear[s, v, a, b]

s = Table[i*j, {i, 3}, {j, 3}]

s[[2]]

s[[2]][[3]]

s[[2]][[3]] = 2

Nagu näha, keelatakse selline omistamine ära.

a = Array[v, {3, 3}]

v[1, 1] = 2

For[i = 1, i ≤ 3, 
      i = i + 1, 
For[j = 1, j ≤ 3, 
        j = j + 1, 
v[i, j] = 
          i*j
]
]

a

a[[2]]

v[2, 3]

Selliselt oli ka käsu Array korral maatriksile a võimalik omistada samasuguseid väärtusi nagu maatriksis s. Erinevalt Table-käsu kasutamisest, saab maatriksi elementide väärtusi pärast maatriksi loomist muuta.

6.3. Protseduure (ja tehteid) maatriksite ja listide osadega.

First[list]				listi esimene liige
Last[list]			 	listi viimane liige
Part[list,n] ehk list[[n]]		listi n-s liige
Part[list,-n] ehk list[[-n]]		listi tagantpoolt lugedes n-s liige
Part[list, {(Subscript[n, 1]),  (Subscript[n, 2]),   ... }]		uus list, mille elementideks on vana listi elemendid
					positsioonidel (Subscript[n, 1]),  (Subscript[n, 2,]) ... 
Take[list,n]				listi n esimest liiget
Take[list,-n]				listi n viimast liiget
Take[list,{m,n}]			listi liikmed alates m-ndast kuni n-ndani (kaasa arvatud)
Take[list,{m,n,step}]			listi liikmed alates m-nast kuni n-ndani sammuga s
Rest[list]				list ilma esimese liikmeta
Drop[list,n]				list ilma esimese n liikmeta
Drop[list,-n]				list ilma viimase n liikmeta
Drop[list,{m,n}]			list, millest elemendid m-ndast kuni n-ndani on ära jäetud
Drop[list,{m,n,s}]			list, millest on välja jäetud elemendid m-ndast kuni n-ndani
					sammuga s

$Line = 0;

Clear[a, b, c, d, e, f, g, h, t]

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

Last[t]

Leiame listi t 3.nda elemendi

t[[3]]

t[[{2, 5}]]

Take[t, -2]

Teeme uue listi, milles on kõik listi t liikmed, välja arvatud 4.s

Drop[t, {4, 4}]

Part[list,i,j,...] ehk list[[i]][[j]][[...]] ehk list[[i,j,...]]	
			listi i-nda liikme j-nda alamlisti ... (jne)
Part[
        list, {(Subscript[i, 1]),  (Subscript[i, 2]),   ... }, {(Subscript[j, 1]), 
          (Subscript[j, 2]),   ... },  ... ]  või list[[{(Subscript[i, 1]), (Subscript[i, 2]),   ... }, {(Subscript[j, 1]), 
            (Subscript[j, 2]),  ... },  ... ]] 
			uus list vana listi elemendidest
Part[list,...,All,...] ehk list[[...,All,...]]
			list elementidest, milles on kõik antud tasandi elemendid sees
Part[list,All,i] ehk	list[[All,i]]
			listi i-s veerg

Clear[t]

t = {{a, b, c}, {d, e, f}}

t[[2]]

t[[2, 3]]

t[[2]][[3]]

t[[{2, 2, 1, 1}]]

See andis uue listi, milles on kaks korda esitatud vana listi teine rida, kaks korda esimene rida.

t[[{2, 2, 1, 1}, {2, 3}]]

Eelnevast näitest võeti kõigist ridadest vaid 2. ja 3. element.

t[[All, 1]]

Leidsime listi (maatriksi) esimese veeru.

t[[1]]

Selliselt leidi maatriksi esimene rida.

(Subscript[si, 1]) = {{(Subscript[a, 1]), (Subscript[a, 2])}, {(Subscript[a, 3]), (Subscript[a, 4])}};
(Subscript[si, 2]) = {{(Subscript[b, 1]), (Subscript[b, 2])}, {(Subscript[b, 3]), (Subscript[b, 4])}};
(Subscript[si, 3]) = {{(Subscript[c, 1]), (Subscript[c, 2])}, {(Subscript[c, 3]), (Subscript[c, 4])}};
(Subscript[si, 4]) = {{(Subscript[d, 1]), (Subscript[d, 2])}, {(Subscript[d, 3]), (Subscript[d, 4])}};

s = {{(Subscript[si, 1]), (Subscript[si, 2])}, {(Subscript[si, 3]), (Subscript[si, 4])}}

MatrixForm[s]

Part[s, 2]

MatrixForm[%]

Part[s, 2, 1]

Part[s, 2, 1, 1]

Part[s, 2, 2, 1, 1]

Part[s, 2, All, 2]

Part[s, All, 2]

MatrixForm[%]

6.4. Listi ja maatriksi elementide otsimine, testimine, 
asendamine, kustutamine.

Position[list, form]			positsioonid, milles form listis esineb
Count[list,form]			mitu korda form listis esineb
MemberQ[list,form]			testi, kas form on üks listi elementidest
FreeQ[list,form]			testi, kas form ei ole üks listi elementidest (ei leidu mitte kusagil)

Nagu kusagil üleval juba mainitud, kehtivad paljud listide kohta käivad protseduurid ka algebraliste avaldiste kohta või muude Mathematica konstruktsioonide kohta.

$Line = 0;

Clear[s, t]

t = {a, b, c, d, a, d, f, e, e, a}

Count[t, a]

Position[t, a]

MemberQ[t, f]

FreeQ[t, 0]

u = 2 + b + v + m + j*(2/w)

MemberQ[u, v]

Take[u, {2, 3}]

Take[u, {3, 5}]

u[[5]]

u[[5, 1]]

Ülaltoodud näited algebralistest avaldistest mõnede liikmete eraldamise kohta on üsnagi lihtsad. Kui avaldis (näiteks mõne arvutuse tulemus) on mitmeid lehekülgi pikk, ei või väga kindel olla, et programm eraldab sealt tõesti just sellise osa, mida eeldaks. Peale selle - ülaltoodud u avaldises paistab ka välja, et kusagil on j-le omistatud väärtus (For-lauses vist) - veel üks probleem, mis võib tekkida pika Mathematica dokumendi loomisel, arvutuste tegemisel.

Prepend[list,element]			lisab elemendi listi algusesse
Append[list,element]			lisab elemendi listi lõppu
Insert[list, element, i]			lisab elemendi listi i-ndale positsioonile
Insert[list, element, -i]			lisab elemendi listi lõpust lugedes i-ndale positsioonile
Insert[list,element,{i,j,...}]		lisab elemendi listi mitmetesse kohtadesse
Delete[list,i]				kustutab listi i-nda elemendi
Delete[list, {{(Subscript[i, 1]),(Subscript[j, 1])},{(Subscript[i, 2]), (Subscript[j, 2])},...}]	kustutab mitmeid listi elemente
ReplacePart[list,uus,i]			asendab listis i-ndal kohal oleva elemendi uue-ga
ReplacePart[list,uus,-i]		asendab listis tagantpoolt i-ndal kohal oleva elemendi uue-ga
ReplacePart[list,uus,{i,j,...}]		asendab listis i-ndal, j-ndal ... kohal olevad elemendid uue-ga

Prepend[{a, b, c}, x]

Append[%, y]

Insert[%, h, 3]

Insert[%, hg, -3]

Delete[%30, {{3}, {2}}]

uus = {x, a, h, b, hg, c, y};

ReplacePart[uus, 2  x, {{2}, {4}}]

m = {{1, 0, 0}, {0, 0, 2}, {3, 2, 1}}

m = ReplacePart[m, {r, q}, {2, 2}]

MatrixForm[m]

Join[(Subscript[list, 1]),  (Subscript[list, 2]),   ... ]			listide üheks liitmine
Union[(Subscript[list, 1]),  (Subscript[list, 2]),   ... ]			listide liitmine, kusjuures korduvad elemendid eemaldatakse 
					ja järgi jäänud eemaldatakse
Sort[list]				listi elementide sorteerimine kasvavas järjekorras
Reverse[list]				listi elementide järjekorra pööramine
RotateLeft[list]			listi liikmete asukoha nihutamine ühe koha võrra vasakule
RotateLeft[list,n]			listi liikmete asukoha nihutamine n kohta vasakule
RotateRight[list]			listi liikmete asukoha nihutamine ühe koha võrra paremale
RotateRight[list,n]			listi liikmete asukoha nihutamine n kohta paremale
Partition[list,n]				listi lõhkumine n-elemendilisteks tükkideks
Partition[list, n, d]			listi lõhkumine n-elemendilisteks tükkideks sammuga d
Apply[Plus, list]			listi kõigi liikmete summa
Apply[Times, list]			listi kõigi liikmete korrutamine
Flatten[list]				listi silumine üheks 'vektoriks'
Flatten[list,n]				ülemisel n astmel olevate listi liikmete silumine üheks
FlattenAt[list,i]				listi i-ndal positsioonil oleva alamlisti silumine üheks

Join[m, uus]

Flatten[%]