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

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, toimib ka Alt+Ä).
Näited:

2.3 + 5.6*2

2 4 6

(2.4^32)

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)]

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

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.

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.

%						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:

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)

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

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]

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]

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

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

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]

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]

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.

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:

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)"]

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.