Matemātiskās un statistiskās datorprogrammupaketes (1.daļa)

H.Kalis

Rīga 2007

0

ANOTĀCIJA

Seminārā matemātiskās modelēšanas, matemātiskās un skaitliskās analīzes dažādas problēmas tiek apskatītas no vienota matemātisko datorprogrammu (DP) lietošanas viedokļa. Seminārā paredzēts iepazīstināt studentus ar DP elementiem,operatoriem un komandām, skaitlisko un simbolisko rezultātu vizualēšanu, grafisko rezultātu interpretācijām, matemātiskās analīzes un algebras galveno operatoru modelēšanu, diferenciālvienādojumu simbolisko un skaitlisko risināšanu, skaitlisko metožu algoritmiem un programmēšanas elementiem.

Kursā paredzēts ar DP Mathematica, Matlab un Maple palīdzību praktiskajos darbos risināt konkrētus uzdevumus. Studenti spēs patstāvīgi analizēt un lietot dažādas skaitliskās metodes problēmu risināšanā.

DP iegāde Latvijas Universitātē ir saistīta ar ESF projekta Nr. 2006/0254/VPD1/ESF/PIAA/06/APK/3.2.3.2./0093/0063 „Datoru matemātisko sistēmu ieviešana mācību procesā augstskolā„ īstenošanu 2006-2007.g., bet DP ieviešana mācību procesā ir saistīta ar ESF projekta ???2006/0254/VPD1/ESF/PIAA/06/APK/3.2.3.2./0093/0063 „Datoru matemātisko sistēmu ieviešana mācību procesā augstskolā„ īstenošanu 2007.gadā.

1

SATURS

Anotācija …………………………………………………………………………….1 1. Datorprogammu (DP) elementu apraksts un lietošana………………………… ... .4 1.1 MATLAB elementu apraksts un lietošana………………………………………4 1.1.1 MATLAB darba vide ………………………………………………………..5 1.1.2 Vienkāršākie aritmētiskie izskaitļojumi ar MATLAB……………………….6 1.1.3 MATLAB failu veidošana……………………………………………………8 1.2 MAPLE elementu apraksts un lietošana………………………………………...10 1.2.1 Vienkāršākie aritmētiskie izskaitļojumi ar MAPLE………………………...11 1.2.2 Galvenie operatori un komandas……………………………………………12 1.2.3 Funkciju veidošana undarbības ar tām……………………………………....15 1.2.4 Izteiksmju vienkāršošana…………………………………………………....17 1.3 MATHEMATICA elementu apraksts un lietošana……………………………...19 1.3.1 Vienkāršākie aritmētiskie izskaitļojumi ar MATHEMATICA……………...19 1.3.2 Funkciju veidošana…………………………………………………………..212. Skaitlisko un simbolisko rezultātu vizualizēšana, grafisko rezultātu interpretācija……………………………………………………………………….22 2.1 MATLAB grafiki………………………………………………………………..22 2.1.1 Vektoru datu interpretācija ar MATLAB..…………………………………..22 2.1.2 Matricu datu interpretācija ar MATLAB…………………………………....23 2.1.3 Viena argumenta funkciju grafiki ar MATLAB…………………………….23 2.1.4 Divu argumentu funkciju grafiki ar MATLAB……………………………...29 2.1.5 MATLAB grafiskie objekti………………………………………………….34 2.1.6 MATLAB 7 iespējas………………………………………………………...36 2.2 MAPLE grafiki…………………………………………………………………..37 2.2.1 MAPLE grafiskie instrumenti……………………………………………….37 2.2.2 MAPLE 2-dimensiju grafiki un to lietošana funkciju pētīšanā……………...39 2.2.3 MAPLE 3-dimensiju grafiki un to lietošana………………………………...43 2.3 MATHEMATICA grafiki……………………………………………………….45 2.3.1 MATHEMATICA 2-dimensiju grafiki un to lietošana………………………45 2.3.2 MATHEMATICA 3-dimensiju grafiki un to lietošana………………………483. Matemātiskās analīzes galveno operatoru modelēšana……………………………50 3.1 MATLAB lietojumi matemātiskajā analīzē…………………………………….50 3.2 Matemātiskās analīzes elementi ar MAPLE……………………………………55 3.2.1 Skaitļu virknes, rindas un funkciju robežas ar MAPLE……………………..55 3.2.2 Funkciju atvasināšana un diferencēšana ar MAPLE………………………...57 3.2.3 Integrēšana, MAPLE pakete „student”.…………………………………….58 3.2.4 Funkciju rindas, MAPLE pakete „powseries”………………………………62 3.3 Matemātiskās analīzes elementi ar MATHEMATICA………………………….644. Algebras galveno operāciju modelēšana ………………………………………….66 4.1 Algebras operācijas ar MATLAB………………………………………………66 4.1.1 MATLAB darbības ar masīviem-vektoriem………………………………...66 4.1.2 MATLAB darbības ar masīviem-matricām…………………….…………...68 4.1.3 Lineāra algebra ar MATLAB………………………………………………..71 4.2 Algebras operācijas ar MAPLE………………………………………………….74 4.2.1 MAPLE darbības ar veseliem skaitļiem……………………………………..74 4.2.2 Parastie daļskaitļi un racionālas izteiksmes ar MAPLE……………………..76 4.2.3 MAPLE darbības ar reāliem skaitļiem un izteiksmēm………………………77

2

4.2.4 Kompleksie skaitļi ar MAPLE………………………………………………78 4.2.5 MAPLE darbības ar polinomiem……………………………………………..79 4.2.6 Vienādojumi un nevienādības ar MAPLE…………………………………….81 4.2.7 Matricas, vektori un MAPLE, algebras pakete „linalg”……………………...83 4.3 Algebras operācijas ar MATHEMATICA………………………………………86 4.3.1 Aritmētiskie un algebriskie pārveidojumi ar MATHEMATICA…………….86 4.3.2 Vienādojumi un vienādojumu sistēmu risināšana ar MATHEMATICA…….87 4.3.3 Lineāras vienādojumu sistēmas ar MATHEMATICA……………………….885. Diferenciālvienādojumu simboliskā un skaitliskā atrisināšana……………………89 5.1 Diferenciālvienādojumi ar MATLAB…………………………………………..89 5.1.1 Košī problēma……………………………………………………………….89 5.1.2 Robežproblēma……………………………………………………………....93 5.2 Diferenciālvienādojumi ar MAPLE...……………………………………….......95 5.2.1 Košī problēma……………………………………………………………….95 5.2.2 Robežproblēma………………………………………………………………97 5.3 Diferenciālvienādojumi ar MATHEMATICA...………………………………...996. Skaitlisko metožu algoritmi………………………………………………….......103 6.1 Skaitliskās metodes ar MATLAB……………………………………………..103 6.2 Skaitliskās metodes ar MAPLE…………………………………………….….105 6.3 Skaitliskās metodes ar MATHEMATICA………………………………….…1077. Programmēšana ar DP……………………………………………………………108 7.1 Programmēšana ar MATLAB…………………………………………………108 7.2 Programmēšana ar MAPLE…………………………………………………...109 7.3 Programmēšana ar MATHEMATICA………………………………………...1118. Konkrētu matemātikas problēmu modelēšana ar DP…………………………….112 8.1 Modelēšana ar MATLAB……………………………………………………...112 8.2 Modelēšana ar MAPLE………………………………………………………..119 8.3 Modelēšana ar MATHEMATICA……………………………………………..122 8.4 Uzdevumi……………………………………………………………………...124Literatūra……………………………………………………………………………125

3

1. Datorprogammu (DP) elementu apraksts un lietošana

No plaši pazīstamām DP MAPLE, MATHEMATICA, MATLAB, MATHCAD galvenokārt apskatīsim pirmās trīs.

Akadēmiķis V.V.Djakonovs grāmatā “Kompjūteru matemātika” (kr. val.) 2001.g. Smoļenskā ir devis pārskatu par šo jauno zinātnisko un lietiško virzienu - Datoru matemātiskās sistēmas (DMS), kas radies matemātikas un informātikas saskarē.

Tādas DMS kā EXCEL, DERIVE, MUPAD, MATHCAD, MATHEMATICA, MAPLE un MATLAB ir šī virziena pamatā.

BIBLIOTEKA Šo datorprogrammu struktūra ir: KODOLS INTERFEIS HELP (palīgs) PAKETES KODOLS--- iepriekš kompilētas funkcijas un procedūras, kas nepārtraukti uzlabojas,

INTERFEIS--- pamatā WINDOWS operatorsistēma ar visām interpretācijas iespējām,BIBLIOTEKA un PAKETES--- palīgprogrammas un algoritmi.

DMS risina elementārās un augstākās matemātikas – aritmētikas, algebras, ģeometrijas, matemātiskās analīzes, statistikas un diferenciālvienādojumu uzdevumus.

Darbs ar DMS aizrauj studējošos, samazina barjeru, kas rodas mācoties grūtas matemātikas nodaļas, savieno patīkamo ar vajadzīgo, mācoties matemātikas pamatus un apgūstot datorus. DMS ir instruments pedagogu, studentu, inženieru un zinātnieku rokās, to tikai vajag pareizi lietot.

Dažas interneta adreses, kur izstrādā DP jaunākās versijas :1) www. mathsoft.com ( Anglijā izstrādātā sistēma MATHCAD),2) www.wolfram.com (Amerikā profesoru izstrādātā sistēma MATHEMATICA),3) www.maplesoft.com (Kanādā studentu izstrādātā sistēma MAPLE), 4) www. mathworks.com (ASV izstrādātā sistēma MATLAB un c.).

1.1 MATLAB elementu apraksts un lietošana

Izskaitļojumos DMS līderis ir MATLAB (matricu laboratorija), bet simboliskos pārveidojumos MATHEMATICA un MAPLE (MATLAB-ā ir atsevišķa pakete “Symbolic” , kuras pamatā ir Maple).

„MATLAB ir pasakaina sistēma, kas no nožēlojama pīlēna ir kļuvusi par gulbi.” (V.Djakonovs). To lieto praktiski visos pasaules zinātniskajos centros un universitātēs. Tā ir interaktīva sistēma inženieru un zinātnisko aprēķinu veikšanai. Pasaulē ir izdotas vairāk kā 600 monogrāfijas un rakstu par MATLAB (krievu valodā ap 35). Galvenais objekts sistēmā ir taisnstūra veida skaitliskais masīvs un tā ievads, nenorādot izmērus. Ar tiem aprēķini ir veicami ātrāk nekā ar Fortran, Basic, Pascal u.c. programmēšanas valodām. MATLAB lieto vairāk kā 100 pasaules universitātēs un zinātniskās iestādēs (sevišķi ASV).

MATLAB izstrādā ASV 1984. G. Klīvs Moulers uz Fortran bāzes. Pašlaik ir

4

vairākas MATLAB versijas, kuras izstrādā firma MATHWORKS. Mēs apskatīsim jaunāko MATLAB 7.2 versiju.

Tā ir interaktīva sistēma inženieru un zinātnisko aprēķinu veikšanai. Sistēma veic operācijas ar vektoriem, matricām, masīviem, polinomiem, vienādojumiem un vienādojumu sistēmām u.t.t. Matlab lieto vairāk kā 100 pasaules universitātēs unZinātniskās iestādēs (sevišķi ASV).

Aprēķinus veido kā “skriptus” vai “proceduras-funkcijas” t.s. m-failos.Apskatīsim dažus Matlab operatorus , kas atšķiras no Maple operatoriem:1) Matricu A,B elementu operācijas, kas atbilst lineārās algebras likumiem (+ - * ^ )un operatori ar masīviem ( .* --- reizināšana pa elementiem a(i,j)*b(i,j); .\--- inversā dalīšana pa elementiem b(i,j)/a(i,j); ./--- dalīšana pa elementiem a(i,j)/b(i,j); .^ --- kāpināšana pa elementiem a(i,j)^b(i,j) ),2) ciklu operators ( for i=1:d:n ----- (cikla kodols)------- end), kur d --- solis, n --- skaits,3) speciālu veidu matricas ( zeros --- nulles matrica; ones --- vieninieku matrica; eye --- vienības matrica),4) lineāra 1D masīva (vektors-rindiņa) formēšana ( x=linspace(a,b,n) vai x=a:h:b) ,5) 2D vektoru x,y masīva formēšana ( [X,Y]=meshgrid(x,y) ),6) masīvu formēšana , piem. for j=1:n A(8:n,j)=A(7,j) end pārsūta matricas A 7. rindiņu, sākot no 8. līdz n-tai (pēdējai); v=0:h:n --- izveido vektoru-rindiņa [0 h 2h ……n]; A=A(i1:i2,j1:j2) --- izdala matricas bloku; A(:,j), A(i,:) --- fiksē matricas j-to kolonu un i-to rindiņu,7) algebrisku vienādojumu sistēmu risināšana (AX=B X=B\A, XA=B X=B/A ), 8) pseido inversās matricas formēšana ( P=pinv(A) ar īpašībām APA=A, PAP=P),9) matricas A īpašvērtību (diagonālmatricā D) un īpašvektoru (matricas R kolonās ) aprēķināšana ( [R,D]=eig(A) no AR=RD),10) matricas-funkcijas izskaitļošana, piemēram, eksponentmatricas aprēķināšana --- Y=expm(A) vai Y=R*diag(exp(diag(D))) / R; matricas-funkcijas cos(A) aprēķināšana --- Y=funm(A,’cos’),11) datu apstrāde, piemēram, Y=sort(X) --- sakārto vektora X (matricas X kolonas) elementus augošā secībā; Y=max(X) --- sameklē vektora X (matricas X kolonas) maksimālo elementu; y0=max(max(X)) --- sameklē matricas X lielāko elementu, 12) grafiku veidošana, piemēram, quiver(X,Y,u,v,0.5), hold on --- zīmē vektoru u,v lauku; C=contour(X,Y, , 10); clabel(C) --- zīmē funkcijai 10 līmeņlīnijas ar to vērtībām; plot (XM,YM,’*’), hold off --- piezīmē klāt * masīvu (XM,YM) koordinātes.

Šī nodaļa ir veltīta MATLAB darba vides aprakstam un aprēķinu veikšanai, lietojot iebūvētās matemātiskās funkcijas. Tā kā datorprogrammas komandas nav garas, tad vienkāršības labad strādāsim tikai ar Command Window t.i. komandu logu.

1.1.1 MATLAB darba videIelādējot MATLAB displejā parādās Command Window. Simbols “>>” ir

komandas rindiņas pazīme un tas parādās automātiski pēc Enter ar ko ir jābeidz komandas vai izteiksmes ievads. Ar pārbīdes taustiņiem (vertikāli) var atkārtoti iegūt tekošā komandas rindiņā iepriekš atlikto komandu, labot to un palaist ar Enter. Ja komandas izpildes rezultātu negrib redzēt uz ekrāna, tad komandas beigās liek semikolu “ ;”.

Jaunākā MATLAB-7 versija, kura parādījās 2004.g. jūnijā, dod papildus iespējas interfeisa lietošanā. Pēc noklusēšanas palaižot datorprogrammu uz

5

displeja parādās kombinēts logs, kas satur 4 svarīgākos paneļus. Bez Comand Window (CW- komandu logs) vēl ir logs Command History (CH- komandu vēsture), Workspace (W-darba lauks) un Current Directory (CD – pašreizējais katalogs). Pēdējie divi paneļi atrodas viens uz otra, un lai tos atdalītu vajag ieklikšķināt attiecīgā rāmī. Katru no logiem var nofiksēt displejā autonomi, lietojot pogas Undock (augšējā labējā loga stūrī ♂ ). Laukus aizvērt var arī ar menjū Desktop (darba galds) komandām. Jaunums ir masīvu redaktors Array Editor(AE), ar kuru var labot masīvu elementus. MATLAB-7 izvēles (menjū) rindā ir 2 jauni rīki – Desktop un Debug (skaņošana). Uzlabotais darba lauks atļauj ērti vadīt logus. No galvenā MATLAB-7 menjū ir pazudis View (skats), kura komandas ir Desktop menjū.

Apskatot galvenā menjū komandas, jāatzīmē sekojošais: 1) File satur komandas Save Workspace As (saglabāt darba lauku kā), Import

Data (importēt datus), Set Path (uzdodot ceļu var mainīt katalogu kārtību), Preferences (pieņēmumi, ar kuriem var mainīt sistēmas parametrus),

2) Edit satur komandas Clear Command Window (attīrīt komandu logu), Clear Command History (attīrīt komandu vēstures logu), Clear Workspace (attīrīt darba lauka mainīgos),

3) Desktop satur komandas Undock Command Window (neaktivizējot komandu logus, atdala savienotos logus, atļaujot Command Window logam pārvietoties patstāvīgi), Desktop Layout (atzīmējot darba galdu, nosaka aktīvo paneļu skaitu un sekojošu novietojumu : Default --pēc noklusēšanas atstājot displejā 3 logus, Command Window Only – atstājot tikai komandu logu, History and Command Window – atstājot 2 logus, All Tabbed – fiksē displejā visus logus ar ieliktņiem apakšā, atvērtu turot tikai komandu logu), Save Layout (saglabāt darba galdu), Command Window, Command History, Current Dictionary, Workspace, Help, Profiler – ar „v” atzīmētās fiksē atvērtos logus displejā, Toolbar (vada paneļu rīku redzamību), Titles (vada logu virsrakstu, nosaukumu redzamību), Shortcuts Toolbar (uzdod vajadzīgos paneļu rīkus).

Izsaucot komandu Preferences parādās dialoga logs, kurā var izdalīt rindu Command Window un ievietot atbilstošus skaitlisko rezultātu izvada formātus - short, long, short e, long e u. c.

Šajā versijā ir paātrināti izskaitļojumu ar dubulto precizitāti ātrums un uzticamība, piem. jaunie FFT (ātrā Furjē transformācija) algoritmi strādā apmēram par 20% ātrāk. Uzlabotais kompilators dod iespēju saistīt MATLAB lietojumus ar EXCEL, C, C++ un COM. Automatizēta m-failu noformēšana HTML, Word un LaTeX dokumentu formā. Radīta iespēja lietot iekļautas funkcijas, kas vienkāršo m-failu formēšanu. Ir radīta funkcija linsolve, kas atļauj ātri risināt lineāras vienādojumu sistēmas.

1.1.2 Vienkāršākie aritmētiskie izskaitļojumi ar MATLABKomandas, kas veic izteiksmju izskaitļojumus, atbilst visām augsta līmeņa

programmēšanas valodām. Tiek šķiroti lielie un mazie alfabēta burti. Visas komandas sākās ar mazajiem burtiem. Izskaitļojumi tiek veikti ar dubulto precizitāti neatkarīgi no skaitļu izvada formāta, lietojot peldošo komatu. Iebūvēto matemātisko funkciju argumenti tiek uzdoti parastajās apaļajās iekavās. Rezultāts tiek izdots komandu logā bez simbola ”>>”.

DP var lietot iebūvētās funkcijas: trigonometriskās (sin, cos, tan, cot, sec, csc), inversās trigonometriskās (asin, acos, atan, acot, asec, acsc), hiperboliskās (sinh, cosh, tanh, coth, sech, csch), inversās hiperboliskās (asinh, acosh, atanh,

6

acoth, asech, acsch), eksponenciālo (exp), logaritmiskās (log, log10, log2), pakāpju (pow2, sqrt, nexpow2), noapaļošanas (fix, floor, ceil, round), atlikuma (mod, rem, sign) un funkcijas darbībām ar kompleksiem skaitļiem (abs, angle, complex, conj, imag, real). MATLAB arī izskaitļo dažādas speciālās funkcijas (besselh, besselj, bessely, besseli, besselk, beta, ellipj, ellipke, erf, gamma, legendre un citas).

Kalendāru ar nedēļas dienām un datumiem (6 x 7 matrica) veido komanda “calendar(g,m)”, kur “g” ir gadu skaitlis, “m”--- mēnesis; šīs nedēļas datus iegūst ar “calendar”. Šodienas datumu iegūst ar “date” formā 30-Okt-2007. Pulksteni nosaka operators “clock”, kas atgriež vektoru ar 6 elementiem: gads, mēnesis, diena, stunda, minūtes, sekundes (ja rezultātu grib redzēt veselos skaitļos, tad jālieto “fix(clock)”).

Procesora laiku sekundēs nosaka ar “cputime”(atgriež procesora laiku tekošā momentā) vai ar “tic”(palaiž taimeri) un “toc”(izdod laiku, kas pagājis pēc taimera palaišanas).

Mainīgajiem piešķir vērtības ar vienādības zīmi “=”. Aritmētiskās operācijas (+, , *, ^ ) tiek izpildītas parastā kārtībā. Dalot ar nulli, var tikt izdots rezultāts “Inf” vai “NaN”. Darbībās ar kompleksiem skaitļiem, liekot tos iekavās, lieto imagināro vienību i vai j .

Ja izteiksmi nevar sarakstīt vienā rindā, tad tās beigās lieto 3 punktus “…”. Skaitli veido ar “pi”.

Ar “factor(n)” var skaitlim “n” iegūt pirmskaitļus-reizinātājus, bet “primes(n)” atgriež pirmskaitļu sarakstu (vektoru-rindu), kas nepārsniedz skaitli “n”.

Daži vienkāršākie piemēri:1) saskaitot divus skaitļus, tos atliek un nospiež ENTER

>> 1+2ans = 3 (rezultāts ir ierakstīts speciālā mainīgā “ans”, ar kuru var darboties tālāk, piem.,>> ans/4.5 ans = 0.6667 : īsuma labad rakstīsim operāciju ar “ans” tajā pašā rindiņā),

2) skaitļu formātu var izvēleties no FILE punkta PREFERENCES (iepriekšējais formāts bija SHORT, kas izdod tikai 4 ciparus aiz decimāla punkta, ar LONG var iegūt 14 ciparus aiz decimālā punkta),3) formātu var atlikt arī komandu logā, piem.,

>> format long>> 3 / 4 .5 ans = 0.66666666666667

4) pēdējo rezultātu izdot citā formātā var ar “ans” un ENTER, piem.,>> format short ans= 0.6667

5) izskaitļojot kompleksi saistītos skaitļus lieto apostrofu “ ’ ”, piem.,>> (2-3i)’ ans = 2.0000 + 3.0000i

6) izskaitļot pakāpi, kurā jākāpina 2, lai iegūtu tuvāko skaitlim 1000 >>nextpow2(1000) ans = 107) veidot kompleksu skaitli 2+3i no reālas un imaginārās daļas

>> complex(2,3) ans =2.0000 + 3.0000i8) noapaļot skaitļus 1.8 un –1.8 līdz tuvākiem veseliem attālumā no 0

>> fix(1.8) ans = 1 >>fix(-1.8) ans =-1

9) divu izteiksmju dalījuma vērtība>> x=sin(1.3*pi)/log(3.4); y=sqrt(tan(2.75)/tanh(2.75));

7

>> z=(x+y)/(x-y) z=0.0243 – 0.9997i

10) iepriekšējais rezultāts bez mainīgo x,y,z lietošanas>>(sin(1.3*pi)/log(3.4)+sqrt(tan(2.75)/tanh(2.75)))/(sin(1.3*pi)/…log(3.4)- sqrt(tan(2.75)/tanh(2.75))) ans = 0.0243 –0.9997i

11) funkciju vērtības var iegūt arī no masīva-vektora, piem., >>cos([0 : pi]) ans = 1.0000 0.5403 –0.4161 -0.9900

12) mazākais pozitīvais skaitlis, kas maina 1.0 vērtību >> eps ans = 2.2204e-016

13) dalot ar 0, iegūst bezgalību “Inf”, ja dala 0 ar 0 , tad iegūst “ NaN”,piem. >> 4/0 ans = Inf >>0/0 ans=NaN

14) ar “realmax” un “realmin” var iegūt lielāko un mazāko pozitīvo reālo sk. >> n=realmax , m=realmin n=1.7977e+308, m=2.2251e-308

15) nosakot procesora laiku pīķveida virsmas zīmēšanai ar operatoru “surf(peaks(50))” var rīkoties divējādi:

>>t1=cputime; W=surf(peaks(50)); cputime –t1 ans = 0.5600 >>tic, surf(peaks(50)); toc elapsed_time = 0.5500

16) nosakot visus pirmskaitļus, kas nepārsniedz 25 >> p = primes(25) p= 2 3 5 7 11 13 17 19 23

17) lietojot funkcijas “ atan(x)” segmentā [-/2, /2] un “ atan(y,x)” segmentā [-, ] (kvadrantu nosaka sign(y) un sign(x), bet vērtība ir atan(y/x))

>>atan(1) ans = 0.7854 >>atan2(1,2) ans = 0.463618) aprēķinot inversās hiperboliskās funkcijas iegūstam

>>asinh(2.456) ans = 1.6308 >>atanh([0.84 0.16 1.39]) ans = 1.2212 0.1614 0.9065 +1.5708i

19) aprēķinot speciālo funkciju “erf(x)”(kļūdas funkcija) >>erf([0.2, -0.3]) ans = 0.2227 -0.3286

1.1.3 MATLAB m-failu veidošana

Ja lieto daudz komandu, tad darbs ar Command Window vidi kļūst sarežģīts. Ar M-failu redaktoru var veidot arī funkciju vai programmu blokus, kurus var izsaukt (palaist) no komandu loga.

Atverot MATLAB galvenā logā File un punktā New izvēlas apakšpunktu M-File. Jaunais M-fails ir bez nosaukuma (Untitled). Tas jāsaglabā ar konkrētu nosaukumu “fails.m” MATLAB-a apakškatalogā BIN vai WORK, izvēloties punktu Save As no File (iespējams saglabāt arī citā katalogā). Lai palaistu šo programmu, izvēlas Run no Tools rīkiem. M-failu redaktorā ir iespēja viegli palaist arī tikai daļu operatoru no programmas, piem., ar peli vai taustiņiem <shift> un <> aizzīmējot programmas operatorus un izpilda tās ar Evaluate Selection (vai <F9>).

M-failos var ievietot arī komentārus(aprakstus ar % zīmi sākumā), kuri tiek izlaisti izpildot komandas. M-failu redaktorā var vienlaicīgi atvērt vairākus failus, kuru nosaukumi parādās redaktora apakšā (viegli ar peli pāriet no viena M-faila uz otru). Atvērt saglabātos M-failus var no komandu loga izvēles Open vai no M-failu redaktora.

8

Izškir 2 veidu M-failus: faili-programmas un faili-funkcijas.Palaist komandas faila-programmā var divos veidos:1) no M-failu redaktora (kā iepriekš),2) no MATLAB komandu loga vai cita M-faila programmas, lietojot M-faila

nosaukumu, piem., ja komandu rindā atliek >>fails (konkrēts nosaukums), tad pēc Enter tas tiek izpildīts.

Apskatīt un mainīt pašreiz aktivizēto katalogu MATLAB-ā var izvēloties Set Path no FILE komandu darba laukā. Tad parādās logs Path Browser un ievada laukā Current Directory tiek definēts pašreiz lietotais katalogs.

Faili-programmas ir MATLAB komandu virknes bez ievada un izvada argumentiem. Skaitliskajā analīzē nepieciešami sastādīt failus-funkcijas, kurās notiek nepieciešamās darbības ar ieejas argumentiem un tiek izdoti rezultāti izejas parametros. Faili-funkcijas tāpat kā faili-programmas tiek veidoti M-failu redaktorā. Faila-funkcijas augšgalā (1.operatoram) jābūt rindai:

function [p1, p2, …] = nos(a1,a2,…)kur “p1,p2,…” ir izejas parametri, kuru vērtības ir aprēķinātas un piešķirtas M-faila ar nosaukumu “nos” labajā pusē, “a1,a2,…” ir faila-funkcijas argumenti vai ieejas formālie parametri. Atbilstoši MATLAB komandu rindā, griežoties pie faila-funkcijas, jābūt komandai:

>> [P1, P2,…] = nos(A1,A2,…)kur “A1,A2,…” ir faktiskie argumenti, “P1,P2,…” izvada argumenti, kurus var izmantot tālāk un kuros atrodas “p1, p2,…” vērtības.

Piemēri:1) aprēķināsim viena argumenta funkcijas vērtību, sastādot failu-funkciju

“myfun.m” formā:

function f = myfun(x)f = exp(-x)*sqrt((x^2+1)/(x^4+0.1));

tad komandu rindā jāraksta konkrēts arguments x, lai iegūtu funkcijas vērtību y >> y = myfun(1.3) y= 0.2600

(semikols M-failā aizliedz lieku izvadu uz ekrāna),

2) lai izdotu funkcijas vairākas vērtības ir jāmaina M-faila kodola komandaf = exp(-x).*sqrt((x.^2 + 1)./(x.^4 + 1));tad komandu rindā var rakstīt>> x = [1.3 7.2] ; y = myfun(x) y = 0.2600 0.0001

3) aprēķina trīs argumentu funkcijas vērtību, ja x=y=z=1, sastādot failu-funkciju “mzfun.m” formā:

function g = mzfun(x, y, z) g = sqrt(x.^2 + y.^2 + z .^2);

tad komandu rindā jāraksta >> R = mzfun(1, 1, 1) R = 1.732

4) radot vektora-funkciju no 3 izejas parametriem, pārveido doto laiku sekundēs par st., min. un sek. ar M-faila funkcijas “hms” palīdzību:

9

function [st, min, sek] = hms(sec)st=floor(sec/3600); min=floor((sec-st*3600)/60); sek=sec-st*3600-min*60;

tad komandu rindā var veikt konkrētu aprēķinu >> [ST, M, S] = hms(1000) ST = 2 M = 46 S = 40

1.2 MAPLE elementu apraksts un lietošana

Lai gan galvenokārt MAPLE ir veltīta simboliskiem aprēķiniem, tomēr skaitliskajā analīzē tai ir liela nozīme un to plaši var lietot skaitlisko metožu kursā. Ar to iespējams risināt algebriskus un transcendentus vienādojumus un vienādojumu sistēmas, skaitliski diferencēt un integrēt, veikt funkciju interpolāciju un aproksimāciju, kā arī plaši risināt diferenciālvienādojumus (to skaitliskai atrisināšanai ir iespējams lietot vairāk kā 25 dažādas metodes). Konkrēti apskatīsim Maple 10 versiju.

MAPLE satur vairāk kā 2500 komandas, kuru nosaukumi sākās parasti ar mazo alfabēta burtu. Komandas parametri ir ieslēgti vienmēr parastās iekavās ( … ), kuras var saturēt arī papildus parametrus – opcijas, kas dod plašas iespējas komandu funkcionālai darbībai. Ielādējot datorprogrammu, automātiski atmiņā tiek izsauktas ardaļa komandas. Citas komandas, kuras atrodas bibliotēkā, ielādē atmiņā ar operatoru readlib ( … ), bet komandas no attiecīgās paketes pak, izsauc ar operatoru with (pak). Galvenās paketes datorprogrammā ir linalg, geometry, numapprox, orthopoly, plots, powseries, inttrans, student, DEtools un citas.

Vieglāk iemācīties strādāt ar MAPLE ir interaktīvā (komandu rindiņu) režīmā. Ievadot datorprogrammu novieto peles kursoru uz MAPLE ikonas (kļavas lapa) un izpilda dubultklikšķi. Tad uz monitora ekrāna parādās programmas titullapa, kuru pēc īsa brīža nomaina programmas darba logs (darba burtnīca), kurā parādās komandas ievada zīme ">". Darba loga augšējā daļā ir redzama izvēlņu josla, bet zem tās darba rīku josla. Katrai izvēlnei ir pakārtots lodziņš ar komandkarti, kuru var ieraudzīt pēc peles klikšķa uz attiecīgās izvēlnes.

Datorprogramma atļauj vienlaicīgi strādāt ar vairākiem darba logiem.Atkarībā no tā, uz kāda objekta darba logā atrodas kursors (ievada, izvada vai teksta režīmā), mainās izvēlņu joslas un darba rīku joslas veids un atbilstošo pogu saturs. Lai komandu (ievada) rindiņu pārveidotu par teksta rindiņu, jāiedarbojas ar peli uz pogu "I", vai jāaktivizē komanda "Text input" izvēlņu joslā "Insert".Lai teksta rindiņu vai izvada rindiņu darba logā pārveidotu par komandu, jāiedarbojas uz pogu " " vai jāaktivizē izvēlņu joslā "Insert" komanda "Maple input". Komandu rindiņā pēc ">" zīmes var ierakstīt jebkuru algebrisku izteiksmi, kas satur mainīgos, simbolus, skaitļus un funkcijas. Katra tāda izteiksme, kas satur operatorus un kura beidzas ar semikolu ";" (izpildes rezultāts parādās uz monitora ekrāna) vai kolu ":" (rezultāts neparādās uz displeja) ir MAPLE komanda vai operators.

Konkrētās komandas izpilda ar "Enter" taustiņa palīdzību.

1.2.1 Vienkāršākie aritmētiskie izskaitļojumi ar MAPLEGalvenās iebūvētās funkcijas ir:

10

log(x) vai ln(x), log[10](x) – naturālais ln(x) un decimālais lg(x) logaritmi,exp(x) – eksponentfunkcija ex, sin(x), cos(x), tan(x), cot(x) – trigonometriskās funkcijas, arcsin(x), arccos(x), arctan(x), arccot(x) – inversās trigonometriskās funkcijas, sinh(x), cosh(x), tanh(x), coth(x) – hiperboliskās funkcijas,signum(x) – zīmju funkcija sign(x), max (x1,x2, …) – maksimālā vērtība,min (x1,x2, …) – minimālā vērtība, sqrt(x) – kvadrātsakne, abs(x) – absolūtā vērtība.

DP satur globālos mainīgos, kuru vērtības palaišanas (starta) momentā ir fiksētas, piemēram,Digits:= k – lietojamo zīmju ciparu skaits (parasti pēc noklusēšanas k = 10),Order:= k – aproksimācijas kļūdas kārta funkcijas izvirzīšanai rindā (parasti k = 6).Pēdiņas (") lieto iepriekšējā rezultāta izmantošanai. Rezultātu vienkāršošanai lieto operatorus simplify(…), convert(…), combine(…), piemēram,combine (sin(x)^4 – cos(x)^4); => – cos(2x) (zīmi => lietosim rezultāta izdošanai).

Vienādojuma vdj labo vai kreiso pusi izdala ar operatoriem rhs(vdj) vai lhs(vdj).

Vienkāršākie MAPLE objekti ir simboli, konstantes, mainīgie, skaitļi un vārdi. Simboli sastāv no latīņu alfabēta 26 mazajiem un 26 lielajiem burtiem, 10 skaitļiem un vēl 32 speciāliem simboliem. Vārds, ko piešķir izteiksmēm, var sastāvēt no burtu simboliem (a–z, A–Z), skaitļiem (0–9) un pasvītrošanas simbola ( _ ).Ir iespējams veikt darbības ar šādiem skaitļu tipiem: veselie, racionālie, reālie ar peldošu komatu-punktu (. ) un kompleksie, piem., 3, 3/10, 0.3, 0.3*10^(–30), 0.1+0.2*I;

=> 3, 3/10, 0.3, ×3000000000 10–30, 0.1+0.2i (komplekss skaitlis, i= ) (pēc noklusēšanas tiek izdoti 10 zīmīgi cipari).

Simbols punkts ( . ) tiek lietots galvenokārt kā decimālais punkts skaitļos ar peldošo komatu. Dažos gadījumos to lieto kā konkatenācijas operatoru, radot sanumurējamus vārdus, piem.,

seq(a.i, i=1..5); => a1, a2, a3, a4, a5 (izveido virknes simbolus).Tiklīdz skaitļa pierakstā lieto decimālpunktu, tā tas tiek interpretēts kā

tuvināts, piem., 12/1000 nav tas pats, kas 0.123 (pirmais 123/1000 ir precīzs skaitlis, bet otrs tuvināts decimāldaļskaitlis). Jāņem vērā, ka skaitļi 234/100, sqrt(2), kā arī konstante Pi (π), ir precīzi skaitļi, tāpēc vērtības sin(234/100), sqrt(2) netiek aprēķinātas, bet sin(0.234), sqrt(2.) MAPLE precīzi aprēķina uzreiz tuvināti ar 10 zīmīgiem cipariem. Lai iegūtu rezultātus ar k zīmīgiem cipariem, lieto izteiksmes izt aprēķināšanai operatoru evalf(izt,k). Var lietot arī izskaitļojumu sākumā komandu Digits:=k.

Simbols – divkāršās pēdiņas (") tiek izmantotas galvenokārt iepriekšējās komandas izpildes rezultāta izsaukšanai, analogi lieto (" ") un (" " "). Jaunākajām MAPLE versijām iepriekšējās komandas izpildes rezultāta izsaukšanai lieto simbolu (%), atkārtojot tālāk minētos piemērus, to vajadzētu ņemt vērā.

Ar simbolu – vienkāršās pēdiņas (') iezīmē literārus (vārdus), piem., x:='x' (atjauno mainīgo x), sum('i^2','i'=1..6) (aprēķina summu 12+22+ … + 62).

Simbolu – inversās pēdiņas, apostrofu (`) lieto teikuma–rindiņas atzīmēšanai, piem.,`ta ir rindina`; => ta ir rindina.Aritmētisko operāciju izpildes kārtība ir parastā, ieskaitot iekavu ((...)) lietošanu.

Atzīmēsim vēl virkni galveno MAPLE simbolus: ! faktoriāla aprēķināšanai, @ saliktas funkcijas veidošanai, @@ funkciju atvasinājuma kārtai, = vienādības zīmei, >, <, <=, >=, <> nevienādībām,

11

:= mainīgā vērtību piešķiršanai, # komentāriem, & matricu un vektoru reizināšanai, [...] masīvu un sarakstu indeksu ieslēgšanai, $ atkārtošanai, {...} sakārtojumiem un sarakstiem, do...end do ciklu veidošanai programmās (NB! vecākās versijās end do vietā od), if... end if loģiskā nosacījuma veidošanai (vecākās versijās end if vietā if), D, diff diferencēšanai, with pakešu izsaukšanai, Re kompleksa skaitļa reālai daļai, Im kompleksa skaitļa imaginārai daļai, abs absolūtā vērtība.

MAPLE satur šādas matemātiskās konstantes: Pi, pi – skaitļa π = 3.1415926535... apzīmēšanai, I – kompleksa skaitļa imaginārā vienība, infinity – bezgalības (∞) apzīmēšanai, –infinity – bezgalības (– ∞) apzīmēšanai, gamma – Eilera konstante γ=0.5772156649..., Catalan – Katalana konstante C=0.9159655942..., true, false – Bula funkcijas vērtība – patiess vai nepatiess, exp(1) – naturālā logaritma bāze.

Datorprogrammā tiek rezervēti vārdi (tos nevar citur izmantot): and, else, if, mod, or, stop, by, end, in, not, proc, then, do, intersect, quit, to, done, for, local, global, option, read, union, elif, from, minus, options, save, while.

MAPLE satur arī globālos mainīgos, kuru vērtības starta momentā (pēc komandas restart izpildes) ir fiksētas:Digits – zīmīgo ciparu skaita fiksēšanai reālos skaitļos ar peldošo komatu (pēc noklusēšanas 10), Order - aproksimācijas kārtas fiksēšanai rindās, constants - konstanšu definēšanai, libname - standartbibliotēkas vārdam, printlevel - informācijas izdošanas līmeņa fiksēšanai uz ekrāna, lasterror - pēdējās kļūdas fiksēšanai, status - sistēmas mainīgo statusam.

1.2.2 Gavenie operatori un komandasKomandu nosaukumi var būt:

1) saīsinājumi angļu valodā no to funkcionālām iespējām, piem., intparts – parciālā integrēšana,2) sastāvoši no viena burta, piem., D – diferencēšana,3) saīsinājumi, kas sākas ar lielo vai mazo alfabēta burtu (to nozīme ir dažāda), piem.,diff un Diff ir dažādi operatori.

Komandu un operatoru parametri (argumenti) vienmēr ir ieslēgti parastās iekavās. Parametru skaits var mainīties: bez minimāli nepieciešamiem var būt arī papildus parametri (opcijas), kas dod plašas iespējas komandu funkcionālai darbībai. Daļa komandu, kuras pastāvīgi atrodas galvenajā bibliotēkā, jāielādē atmiņā ar operatora readlib palīdzību, pēc kura to var izpildīt, piem., readlib(ifactors) – ielādē atmiņā komandu, kas naturālu skaitli sadala reizinātājos–pirmskaitļos,ifactors(120); =>[1, [[2,3], [3,1], [5,1]]], t.i., parāda, ka 120 = 1.23.31.51.Izsaucot komandu no attiecīgā MAPLE paketes, vispirms jāizsauc pakete ar operatoru with un tikai pēc tam var izpildīt komandu, ko satur šī pakete, piem.,with(stats): =>tiek izsaukta statistikas pakete, describe[mean] ([1,2,3,4,5,6]); =>7/2 (aprēķina skaitļu vidējo vērtību). Šo operāciju var veikt arī īsāk, neizsaucot visu paketi uzreiz, bet gan tikai atbilstošo komandu no šīs paketes, piem., with(stats) [describe]: un pēc tam izpilda komandu mean.

Apskatīsim dažus galvenos operatorus un komandas, kuras automātiski tiek ielādētas atmiņā un kuras lieto biežāk:1) evalf (izt,k) – izskaitļojot izt rezultātu, izdod decimāldaļskaitļa formā ar k

cipariem, piem.,

12

evalf (Pi,25); =>3.141592653589793238462643 (izdod skaitli π ar 25 zīmīgiem cipariem),

2) expand (izt) – atver iekavas, pārveido un izskaitļo izt, piem., expand((x–2)*(x+5)); => x2+3x–1,3) simplify (izt) – izt vienkāršošanai, piem.,

simplify(cosh(x)^2–sinh(x)^2); => 1 (identitāte hiperboliskajām funkcijām),4) convert (izt,f) – pārveido izt, lietojot funkciju f, piem.,

convert(arcsinh(x),ln); =>ln(x+ ) (inversā hiperboliskā sinusa funkcija logaritmiskā formā),

5) combine (izt) – pārveido izteiksmi izt dažādās formās, piem., combine (2*sin(x)*cos(x)); => sin(2x),

6) evalc (izt) – izskaitļo kompleksu izteiksmi, atdalot tai reālo un imagināro daļu, piem., evalc (ln(1+2*I)); => ln(5)/2+I arctan(2),

7) factor (izt) – sadala izt reizinātājos, piem., factor (x^2–x–2); => (x+1)(x–2),8) normal (izt) – veido vienkāršotu racionālas izt formu, piem.,

normal ((x^2+3*x+2) / (x^2+5*x+6));

, 9) solve (vdj,x) – atrisina vienādojumu vdj pret mainīgo x, piem., solve (x^2+2*x–

3=0, {x}); => {x= –3}, {x=1} (izdod kvadrātvienādojuma atrisinājumu figūriekavās),

10) fsolve (vdj,x) – atrisina vienādojumu skaitliski, piem.,fsolve(45*x^6–2*x^5–45*x^4+10*x^2–121+1,x); => -1.310320243, 1.333379948(izdod polinoma visas reālās saknes; pievienojot opciju complex ir iespējams iegūt visas saknes, arī kompleksās), 11) isolve (vdj) – atrisina vienādojumu veselos skaitļos, piem., isolve (2*x+3*y=7); => {x=2–3_Z1, y=1+2_Z1} (šeit _Z1 ir patvaļīgs vesels skaitlis),12) msolve (vdj,m) – atrisina vienādojumu vai vienādojumu sistēmu vdj pēc moduļa m, piem., msolve({2*x–3*y=5,x+y=–3},6); => {y=5, x=4},13) map (f,[a,b]) – saraksta [f(a),f(b)] veidošanai, piem., d:=distance ([x,y],[2,5]) = distance ([x,y],[8,12]): f:=x->x^2: map (f,d); => (x–2)2+(y–5)2 = (x–8)2+(y–12)2 (meklējot punktu ģeometrisko vietu (x,y), kuri atrodas vienādā attālumā no 2 punktiem (2,5) un (8,12), lieto operatoru distance;)sastādītam vienādojumam d ceļ abas puses kvadrātā to vienkāršojot:expand (rhs(")–lhs(")); =>–12x+179–14y=0 (punktu ģeometriskā vieta ir taisne),14) plot (f(x),x=a..b) – zīmē funkcijas vai izteiksmes f(x) grafiku, segmentā [a,b]; ja nav norādīts segments, tad a= –10,b=10, piem.,plot ({3*x–11,–3*x+11},x); => zīmē 2 krustiskas taisnes segmentā [–10,10],15) restart – nostāda MAPLE starta pozīcijā, attīrot darba lauku,16) subs (x=x0,izt) – ievieto izteiksmes izt mainīgā x vietā x0, piem.,subs (x=4/3, x^2+3); => 43/9,17) trunc (q) – aprēķina skaitļa q veselo daļu, piem., trunc (1.5); =>1,18) assign – piešķir mainīgiem skaitliskas vērtības, piem.,solve ({x–y–z=1,x+y–z=4, x+y+z=6}, {x,y,z}); => {z=1, y=3/2, x=7/2},assign ("); x,y,z; => 7/2, 3/2, 1 ,19) taylor (f(x), x=x0,n) – Teilora rindas izvirzījums x0 apkārtnē ar kārtu n , piem.,

13

taylor (sin(x), x,6);

,

20) sum (f(i),i=1..n) – aprēķina summu, piem.,sum ((–1)^i*1.0/i!, i=1..20); => –0.6321205588 ,21) seq (f(i), i=1..n) – veido virkni f(1),f(2),...,f(n), piem.,

seq (i!/i^2, i=1..6); ,22) diff (izt,x) – atvasina izt pēc x, piem., diff (3*x^2+2*x–6,x); => 6x+2,23) int (izt,x) vai integrate (izt,x) – integrē izt pēc x, piem.,

int (x,x); (iegūst nenoteikto integrāli),24) allvalues – izskaitļo polinoma (vienādojuma) visas saknes pēc ziņojuma RootOf, piem., vdj:= {x^2+y^2=1; sqrt (x+y) = x^2–y^2 };(uzdod 2 nelineāru vienādojumu sistēmu), main:= {x,y}; (fiksē 2 mainīgos x,y), atr:= solve (vdj, main); (atrisina vienādojumu sistēmu, izdodot figūriekavās atrisinājumu pārus {x=..., y=...}, starp kuriem ir arī ziņojums RootOf),atr [1]; => { y=RootOf (2_Z2–1), x= –RootOf (2_Z2–1)} (izdod pirmo atrisinājumu pāri, kurš satur ziņojumu RootOf),

allvalues(atr[1]); (izskaitļo atrisinājumu), 25) limit (f(x),x=x0) – izskaitļo robežu funkcijai f(x), x x0, piem.,limit (sin(x)/x, x=0); =>1,26) assume (nos) – fiksē nosacījumu nos, piem., assume (x>0); x; => tālākos aprēķinos mainīgais x būs pozitīvs, kurš tiek iezīmēts ar vilnīti ( ~ ),27) product (f(i), i=1..n) – aprēķina reizinājumu, piem., product (i^2, i=1..4); => 576,28) unapply (izt,x) – pārvērš izteiksmi izt par funkciju no x, piem.,izt:=x^2: f:=unapply (izt,x); => f:=x x^2,29) series (f(x), x=x0,n) – līdzīgi Teilora rindas izvirzījumam, piem.,series (1/(1–x^2), x=0,5); => 1+x2+x4+0(x),30) array ([saraksts]) – vektora vai matricas veidošanai no datiem saraksts, piem., v:= array ([a,b,c,]); => v:= [a,b,c] (izveido 3.kārtas vektoru),m:= array ([[ cos (alpha), –sin (alpha)], [sin (alpha), cos (alpha) ]]);

izveido 2. kārtas matricu m:= ,31) lenght(sk) – nosaka naturālā skaitļa sk garumu (ciparu skaitu), piem.,length (10^29 –10^14 –1); => 29,10^29–10^14 –1; => 99999999999999899999999999999,32) time( ) – fiksē pašreizējo laika momentu, lieto mašīnlaika aprēķināšanai, kas ir nepieciešams, izpildot noteiktas komandas, piem.,

14

to:=time( ): (fiksē starta laiku pirms attiecīgo komandu operatoru izpildes),ifactors (10^29–10^14–1); => (61) (223) (13166701) (97660768252549) (5717)(sadala skaitli pirmskaitļu reizinātājos);t:= (time( )–to)*sek; => t:= 3.600 sek (izdod mašīnlaiku, kurš ir atkarīgs no konkrēta datora lietošanas),33) type (izt, opc) – pārbauda izt tipu, kurš ir uzdots ar opc, piem.,type (x^2+x+1, polynom); => true,type (x+1, `+`); => true,type (0.5, integer); => false,34) print(izt) vai lprint (izt) – izdod izt uz datora ekrāna, piem.,a:=2: atr:= solve (a*x^2+b*x+c=0, x): print (atr);

, ,35) vector ([saraksts]) – veido vektoru no saraksts, piem.,v:= vector([1,3,5]);=> v:= [1,3,5] (veido 3.kārtas vektoru),v1:=vector(3, i->2*i–1); => v1:= [1,3,5] (veido to pašu vektoru ar funkcijas palīdzību, kur i=1,2,3),matrix ([[1,2], [3,5]]); 36) matrix ([saraksts]) – veido matricu no saraksts, piem.,(veido 2.kārtas matricu)

, matrix (2,2, (i,j) ->(i*j)^2); (veido 2.kārtas matricu ar funkcijas palīdzību, kur i=1,2 (rindiņas numurs), j=1,2 (kolonas numurs),

1.2.3 Funkciju veidošana un darbības ar tāmPatvaļīgas funkcijas y = f(x) definīcijai lieto komandu f:= xizt, kur izt ir

izteiksme, kas satur argumentu x. Ar operatoru f:= izt var zīmēt grafiku, bet nevar izskaitļot f(x) vērtības. Lai pārtaisītu izteiksmi izt, kura ir atkarīga no x par funkciju f(x), lieto komandu f:=unapply (izt,x).

Ar komandu f:='f' dzēš funkcijas f iepriekšējo definīciju, t.i., atjauno identifikatoru.

Funkciju vērtību izskaitļošanai ar peldošo komatu lieto komandu evalf (f(x),k), kur k – zīmīgo ciparu skaits – precizitāte (pēc noklusēšanas k=10 un tad šo komandu raksta šādi evalf (f(x))).

Ja atvasina f(x), tad var lietot operatoru D(f)(x) vai diff (f(x),x).Ja funkcija f(x) ir gluda, tad var tās grafika punktā (a,f(a)) izskaitļot pieskares vienādojumu y = D (f)(a)*(x–a)+f(a).

Gabaliem nepārtrauktas funkcijas aprakstam lieto komandupiecewise (nos1,f1,nos2,f2,...,nosn,fn,cit), kur fi – atsevišķu formulu izteiksmes, kuras tiek izpildītas, ja nosacījumi (Bula izteiksmes) nosi ir true, i=1,…,n; to izpildes kārtība: if nos1 is true then f1 else if nos2 is true then f2 utt., cit ir noslēguma izteiksme (pēc noklusēšanas 0);nosi var saturēt loģiskos operatorus and, or, not un attiecību operatorus <, <=, >, >+, =, < >.

15

Piemēram, assume (a<b, b<c); => pieņem, ka a<b<c, piecewise (x>a and x<b, 1, x>b and x<c, 2): convert (",piecewise,x); => izdod 1, ja x (a,b); 2, ja x(b,c) un 0 citos gadījumos.

Izvērst funkciju definīcijas var ar komandām simplify un convert. Funkciju izskaitļot pie nosacījuma var ar operatoru assume, piem., assume (x>0) – tālāk izskaitļo funkciju tikai pozitīviem argumentiem.

Funkciju f(x) var izdalīt arī no vienādojuma, ja lieto operatoru isolate, piem.,vdj:= x^2+3 = 3*f(x): isolate (", f(x)); => f(x) = x2/3+1.

Var veidot arī aritmētiskas operācijas ar funkcijām, piem.,f:= x izt1: g:=xizt2: (f+g)(x), (f–g)(x), (f/g)(x); => izdod funkciju summu, starpību, dalījumu, plot ({f(x), g(x), (f+g)(x)}, x=a..b);=> zīmē 2 funkciju un to summas grafiku.

Saliktu funkciju f(g(x)) vai funkciju kompozīciju veido ar komandu (f@g)(x).Piemēram, f:= x->x^3: g:= x->3*x–2: (f@g)(u); =>(3u–2)3 (veido saliktu funkciju f(g(u))), (g@f)(u); => 3u3–2 (veido saliktu funkciju g(f(u))),(f@f)(u); => u9 (veido funkciju f(f(u))), (g@g)(u); => 9u–8 (veido funkciju g(g(u))), (f@g)(a+b); => (3a+3b–2)3 (veido funkciju f(g(a+b))).

Lai pārbaudītu, vai funkcija f(x) ir pāra vai nepāra funkcija, var rīkoties šādi:f:= x izt: (definē funkciju), f(x) = f(–x);=> izdod 2 izteiksmes ar = zīmi; ja tās abas sakrīt, tad funkcija ir pāru,f(x) = –f(–x); => analogi iepriekšējam, ja abas izteiksmes sakrīt, tad tā ir nepāra funkcija.

Konstantu funkciju definē šādi f:=x->const: f(a), f(b), f(1000);=> const, const, const.

Funkciju veidošanai var lietot loģisko izvēles operatoru virkni if, then, else, end if. Lai realizētu 2 nosacījumus, veido šādu loģisko operatoru virkniif, then, elif, then, ..., else, end if.

Var veidot funkcijas arī no diviem un vairāk argumentiem, piem., operatorsf:= (x,y)izt veido funkciju f(x,y) no 2 argumentiem, kur izteiksme izt ir atkarīga no x,y.

Daži piemēri funkciju veidošanai un izskaitļošanai:1) g:= n->expand (product (x+i, i=1..n)): g(2); =>2+3x+x2 (aprēķina sarežģītas

funkcijas g(n), atkarīgu no parametra x vērtības),2) f:=x->sum(n*sin(n*x),n=1..2): f(x); => sinx+2sin(2x), f(3.); =>–0.4177109883, 3) g:=x->if x<=0 then 2*x+1 else x^2+1 end if: g(–2); => -3, g(5); => 26

(definē funkciju ar 2 formulām un aprēķina tās vērtības),4) h:= xif x< –2 then x+3 elif x<=2 then 5–x^2 else 3–x end if: h(–3); =>0, h(0); => 5, h(3); => 0 (definē funkciju ar 3 formulām un aprēķina tās vērtības),5) f:= (x,y) x^2+y^2–3: f(2,5); => 26 (aprēķina 2 argumentu funkcijas vērtību),6) izt:= x^2+3*x–18: f:=xx^2+3*x–18: subs (x=2,izt); =>–8 (izskaitļo izteiksmes vērtību), f (2); =>–8 (izskaitļo funkcijas vērtību), factor (izt); =>(x+6)(x–3) (sadala izteiksmi reizinātājos), factor (f(x)); =>(x+6)(x–3) (sadala funkciju reizinātājos),subs (x=a+h,izt) – subs (x=a,izt) / h; f(a+h)–f(a)) / h; (veido vienādas izteiksmes)

y:= f(x); => y:= x2+3x–18 (pārvērš funkciju par izteiksmi),g:= unapply (izt, x); => g:= xx2+3x-18 (pārvērš izteiksmi par funkciju),g(x); => x2+3x–18,

16

7) f:=xx^2+3*x^4+1: f(x) = f(–x); => x2+3x4+1 = x2+3x4+1 (f(x) ir pāra funkcija),8) f:= x x^3+3*x: f(x) = –f(–x); => x3+3x = x3+3x (f(x) ir nepāra funkcija),9) f:= xx^3+3*x^2: f(x) = f(–x); f(x) = –f(–x); => x3+3x2 = –x3+3x2

x3+3x2 = x3–3x2 (funkcija f(x) nav ne pāra, ne nepāra),10) f:= x^2: f(2); =>x(2)2 (kļūda, jo f nav funkcija, bet izteiksme),subs (x=2, f); => 4,

Funkciju pētīšanai var sekmīgi izmantot MAPLE, piemēram,1) f:= xx^3–2*x: diff (f(x),x); => 3x2–2 (atrod funkcijas pirmos atvasinājumus),solve (">0,x); (izskaitļo nevienādību, atrodot funkcijas augšanas intervālus)

,solve (" "<0,x); (izskaitļo nevienādību, atrodot funkcijas dilšanas intervālus)

,diff (f(x), x$2); => 6x (atrod funkcijas otro atvasinājumu),solve (">0); => {0<x} (intervāls, kurā funkcija ir izliekta uzleju),solve (" "<0); => {x<0} (intervāls, kurā funkcija ir izliekta uz augšu),2) f:= x x^3–7*x: diff (f(x),x); => 3x2–7 (funkcijas pirmais atvasinājums),

s:= solve (",x); s:= (funkcijas atvasinājuma nulles, ekstrēmi),

f (s[1]); (funkcijas vērtība pirmā ekstrēma punktā),

f (s[2]); (funkcijas vērtība otrā ekstrēma punktā),

diff (f(x), x$2);=> 6x (funkcijas otrais atvasinājums), subs (x=s[1],"); (1.ekstrēma punkts ir minimuma punkts),

subs(x=s[2],"); – (2.punkts ir maksimuma punkts).

1.2.4 Izteiksmju vienkāršošanaOperatorus expand, combine, simplify, convert, trigsubs plaši lieto

izteiksmju vienkāršošanai, piemēram,1) cos(2*x): "=expand ("); => cos(2x) = 2cos(x)2–1,2) cos(x+y): "=expand ("); => cos(x+y) = cos(x)cos(y) – sin(x)sin(y),3) cosh(5*x): "=expand ("); =>cosh(5x) = 16cosh(x)5 – 20cosh(x)3 + 5cosh(x),4) ln(x*y): "=expand ("); => ln(xy) = ln(x)+ln(y),5) x^(y+z): "=expand ("); => x(y+z) = xyxz,6) šeit var rasties arī daži paradoksi, piem.,(x*y)^z: "=expand ("); => (xy)z = xzyz,subs ({x=–1, y=–1, z=1/2},"); => 1= –1 (jo izvirzījumi nav spēkā visiem reāliem skaitļiem),7) (n+1)!: "=expand ("); => (n+1)! = n!(n+1),8) sin(x)*sin(y): "=combine ("); => sin(x)sin(y) = (cos(x-y) –cos(x+y))/2,9) 2*sin(x)*cos(x): "=combine ("); => 2sin(x)cos(x) = sin(2x),10) sinh(x)sinh(y): "=combine ("); => sinh(x)sinh(y) = (cosh(x+y)

–cosh(x-y))/2,

17

11) sqrt (cosh(x)^2–1)*sqrt (cosh(x)^2+1): "=combine (", `trig`);

(pārveido izteiksmi ar opcijas `trig` palīdzību).12) yln(x): "=combine ("); => ylnx = ln(xy),13) ln(x)+ln(y): "=combine (");=>ln(x) + ln(y) = ln(xy),14) (x^y)*(x^z): "=combine (",`power`); => xyxz = x(y+z),15) sqrt(x)*sqrt(y): "=combine (")

· ,subs ({x= –1, y= –1},"); => –1 = 1 (izveidojas paradokss, jo izvirzījums nav spēkā visiem reāliem skaitļiem),16) arctan(1/2)+arctan(1/3): "=combine ("); => arctan ½ + arctan 1/3 = ¼ π17) sin(x)^2: "=simplify ("); => sin(x)2 = 1 – cos(x)2,18) cosh(x)^2–sinh(x)^2: "=simplify ("); => cosh(x)2 – sinh(x)2 =1,19) exp(x)*exp(y): "=simplify ("); => exey = e(x+y), expand (rhs(")); => exey (iegūst sākotnējo izteiksmi),20) cos(x): "=convert (",exp);

cos(x) = (kompleksa izteiksme),

map (convert,",`trig`);

cos(x) = simplify ("); => cos(x) = cos(x),21) izt:= exp(x+I*y): convert (izt,`trig`); => (cosh(x)+sinh(x)) (cos(y)+Isin(y)),evalc (izt); => excos(y)+Iexsin(y) (operators evalc izskaitļo komplekso izteiksmi).

22) arcsin(x): "=convert (",ln); => arcsin(x) = –I ln( +Ix),

23) arcsinh(x): "=convert (",ln); => arcsinh(x) = ln(x+ ),

24) arccosh(x): "=convert (",ln); => arccosh(x) = ln(x+ ).25) sin(x)/cos(x): "=convert (",tan); => sin(x)/cos(x) = tan(x),26) tan(x): "=convert (",`expsincos`); => tan(x) =sin(x)/cos(x),27) readlib (trigsubs): trigsubs (sin(x)+sin(y));

.28) simplify ((–1)^(1/3), assume=real);

(tātad rezultāts var būt arī komplekss skaitlis, jo pieņēmums real iedarbojas tikai uz atbilstošo funkcijas argumentu).

1.3 MATHEMATICA elementu apraksts un lietošana

18

MATHEMATICA ir pilnīgākā mūsdienās datoru algebras (computer algebra) integrētā sistēma, DP parādījās 1988.g. un to radīja Wolfram Research firma. Tās pirmie lietotāji bija inženieri, fiziķi un matemātiķi. Tagad to izmanto arī biologi, sociologi, studenti un skolnieki. DP nepārtraukti attīstās. Jaunajā versijā MATHEMATICA 5.2 , salīdzinot ar vecajām 2.2, 4.0, 4.2, ir optimizētas lineārās algebras operācijas, ievesta komanda LinearSolveFunction lineāru vienādojumu sistēmu aprēķināšanai, paplašināts komandas NDSolve lietošanas iespējas, risinot arī parciālos diferenciālvienādojumus, ievesta komanda RSolve rekurenču sakarību aprēķināšanai u.t.t.

1.3.1 Vienkāršākie aritmētiskie izskaitļojumi ar MATHEMATICA

DP var lietot arī kā kalkulatoru, atliekot darba laukā atbilstošu komandu un izpildot to ar Shift + Enter. Komanda tiek ievadīta, parādoties simbolam In[k] (k --- komandas numurs). Tiek izdots rezultāts uz displeja ar Out[k], ja aiz komandas nav pieturzīmes (ja komandas beigās ir semikols (; ) izskaitļošana notiek, bet rezultāts uz displeja neparādās). Visu iebūvēto funkciju un komandu vārdi sākas ar lielo burtu, bet argumenti tiek ieslēgti kvadrātiekavās. DP apskata sarakstus, objektu kopu, kuri ir ieslēgti figūriekavās un atdalīti viens no otra ar komatiem.

Galvenie simboli un konstantes:1) @ --- funkcijas f[x] identiskam pierakstam f@x,2) ! --- faktoriālam, 3! =6,3) = = --- vienādības zīme, Solve[2 x +1 ==3,x] => 1,4) = --- mainīgo piešķiršanas zīme, a=3 => a=3,5) =. --- mainīgo dzēšanai , a=. ,6) # --- viena mainīgā fiksēšanai „tīrajā” (pure) funkcijā, #^2&[a] => a2 ,7)& --- zīmes # iedarbības nobeigumam, #1^2 + #2^2 & [x,y] => x2+y2,8) [[ ]] --- saraksta (list) elementu norādei, v[[2]] => vektora v elements v2,9) { } --- 1D saraksta (list) vektora fiksēšanai, v ={2,3,4},10) {{ }} --- 2D saraksta (list) matricas fiksēšanai, m={{1,2}{3,4}},11) % --- iepriekšējā rezultāta izmantošanai,12) // --- izteiksmju izskaitļošanai, Pi// N => 3.14159,13) := --- izteiksmes (likuma) definēšanai , a=3; b:=1+a => neizskaitļo, b =>4,14) /; --- nosacījuma realizēšanai, f[x_ /; x>1]:= x^2; f[x_ /; x<1]:=x; {f[-2], f[2]}=>{-2,4},15) /. --- nosacījuma ievietošana izteiksmē, izt /. c 2 => ievieto izteiksmē izt c=2,16) --- aizvietošanas likuma realizēšanai,17) * * --- komentāriem,18) $ --- DP sistēmas iespēju norādei, $ MachinePrecision => 16,19) E --- Eilera skaitlis e= 2.71828,20) Infinity --- bezgalības apzīmēšanai,21) I --- imaginārās vienības apzīmēšanai, a+ b I => kompleks skaitlis,

22) D --- izteiksmes diferencēšanai, D[f,x] => ,

23) Pi --- skaitļa π apzīmēšanai (izskaitļošana notiek ar N[Pi], Pi //N vai N[Pi,k]),24) Degree --- skaitļa π/180 apzīmēšanai,25) GoldenRatio --- zelta griezumam (1+ )/2 = 1.61805…

19

Lietojot MATHEMATICA rezultātu interpretācijai lieto operatorus:1) N [izt,k] – izdod skaitlisko rezultātus izteiksmē izt ar k zīmīgiem decimālcipariem , N[izt] --- izdod rezultātu ar 6 zīmīgiem decimālcipariem (izskaitļošanā parasti piedalās 16 decimālcipari, tos var uzzināt, lietojot komandu $MachinePrecision),2) Chop [izt] – pārvērš izteiksmē izt visus skaitļus mazākus par 10–10 par nullēm,3) Chop [izt, dx] – pārvērš par nullēm izteiksmē izt visus tos skaitļus, kuru modulis nepārsniedz pozitīvu skaitli dx.Piemēri:1) 10! => 3628800 (izskaitļojot 100! iegūst lielu vairāk kā ar100 cipariem skaitli),2) N[E^Pi –Pi^E] => 0.6815349144 (redzam, ka patstāv nevienādība e π > πe ),3) (-1)^ (1/2) => i (imaginārā vienība),4) N[Log[10,E], 15] => 0.434294481903252 ( tiek izskaitļots ar 15 zīmīgiem cipariem pārejas modulis no naturāliem logaritmiem uz decimāliem),5) N[Sin[Pi/180], 11] => 0.017452406437 (tiek izskaitļots ar 11 zīmīgiem cipariem sin (10) ),6) 22/7 => 22/7, 22/7. => 3.14286, N[22/7] => 3.14286 (primārā ir simboliskā izskaitļošana), 7) Expand[(a+b+c)^5] => izdod izvērstu izteiksmi, Simplify[%] =>(a+b+c)^5,8) Factor [a10+b10] =>(a2+b2) (a8-a6b2 +a4b4-a2b6+b8) – sadala reizinātājos,9) Re[3+4 I] => 3, Re[a+b I] => -Im(b) +Re(a)--- kompleksa skaitļa reālā daļa,10) Im[3+4 I] => 4, Im[a+b I] =>Im(a) +Re(b)--- kompleksa skaitļa imaginārā daļa,11) {Arg[1], Arg[I], Arg[-1]} => (0, π/2, π) --- kompleksu skaitļu argumenti,12) PreviousPrime[1000] => 997 (ātri izskaitļo iepriekšējo pirmsskaitli: lai uzzinātu mašīnlaiku aiz komandas jāraksta // Timing ,13) NextPrime[1000] => 1009 (ātri izskaitļo iepriekšējo pirmsskaitli),14) GCD[36,45] => 9, GCD[2200+3, 3300 + 80] =>349 (lielākais kopīgais dalītājs),15) LCM[2,3,5] => 30 (mazākais kopīgais dalāmais),16) Quotient[16,5] => 3 (divu skaitļu dalījums, veseliem skaitļiem ekvivalents operators Floor[16/5]),17) Mod[3^10,5] =>4 (divu skaitļu dalījuma atlikums),18) Random [ ] => pseidogadījumu skaitlis starp 0 un 1.

Rezultātu uz displeja izdod ar operatoru Print, grafikus zīmē ar operatoru Plot. Galvenās iebūvētās funkcijas ir:Log [x] – naturālais logaritms ln(x), Exp [x] – eksponentfunkcija ex,Sin [x], Cos [x], Tan [x], Cot [x] – trigonometriskās funkcijas sin(x), cos(x), tg(x), ctg(x), ArcSin [x], ArcCos [x], ArcTan [x], ArcCot [x] – inversās trigonometriskās funkcijas arcsin(x), arccos(x), arctg(x), arcctg(x),Sinh [x], Cosh [x], Tanh [x], Cot [x] – hiperboliskās funkcijas sh(x), ch(x), th(x), cth(x), Sign [x] – zīmju funkcija sign(x), Max [x1,x2, …] – maksimālā vērtība,Min [x1,x2, …] – minimālā vērtība, Sqrt [x] – kvadrātsakne .

Piemēri. 1.) a=1470./180*N[Pi]; Series [Sin[x], {x,0,160}]; p:= Normal [%];N [p/.xa] => –6.87538, aprēķina sin (14700) pēc izvirzījuma pakāpju rindā ar 160 saskaitāmajiem,Series [Sin[x], {x,0,161}]; p1:= Normal [%]; N[p1/.xa] => –6.87538, aprēķina sin (14700) ar 161 saskaitāmiem pakāpju rindā,Series [Sin[x], {x,0,166}]; p2:= Normal [%]; N[p2/.xa]=> –6.87538, aprēķina sin (14700) ar 166 saskaitāmiem pakāpju rindā; izskaitļojumi

20

rāda, ka alternējošā rindā noapaļošanas kļūdas var uzkrāties tādā mērā, ka rezultāti kļūst absurdi,2.) NSum [1/n, {n,1, 100000000}, Working Precision 3] => 19.0, aprēķina harmoniskās rindas nogriezni ar 100 miljonu saskaitāmiem,NSum [1/n, {n,1, 200000000}, Working Precision 3]=> 19.7, aprēķina harmoniskās rindas nogriezni ar 200 miljonu saskaitāmiem,t.i., ar doto precizitāti harmoniskā rinda konverģē, kas nav iespējams teorētiski,3.) NIntegrate [x^10*Exp [x], {x,0,1}]/Exp [1.]

=> 0.0838771, izdod integrāļa precīzo vērtību,For [y0=1.–Exp[–1.]; k=1, k<11, k++, y0=1.–k*y0, Working Precision 3];Print [y0] => –437.0, izdod vērtību aprēķinātu pēc nestabilas rekurences sakarībasIk = 1 – kIk–1, k =1,…,10, I0 = 1 – e–1;

4.) Plot [Sin [x], {x,0,2Pi}] => izdod funkcijas y = sin(x) grafiku segmentā [0, 2π];

5.) f [x_]:= Exp [x] – x – 2; Plot [f [x], {x, –3, 3}]=> zīmē funkcijas f(x) = ex –x –2 grafiku segmentā [–3, 3], no kura redzams, ka 2 reālās saknes funkcijai atrodas apakšsegmentos [–2, –1] un [1,2].

1.3.2 Funkciju veidošana Ar DP var definēt funkcijas f(x) un f(x,y) šādi:

1) f [x_]:= izt; f [x_, y_]:= izt;2) f [x_] = izt; f [x_, y_] = izt,kur f ir funkcijas identifikators–vārds, izt ir izteiksme, kas satur argumentus x vai x,y.Ar zīmi = izsauc funkcijas definīcijā tūlītēju labās puses novērtēšanu, bet ar zīmi := labā puse tiek novērtēta tikai tad, kad tiek lietots kreisās puses simbols (ar nokavēšanos). Funkcijas var definēt arī kā "tīro" (pure) funkciju formāFunction [x, izt] vai #izt& (#izt nozīmē, ka arguments x ir aizstāts ar #).

Vairāku argumentu gadījumā i–tā argumenta aizstāšanai jālieto #i, piemēram,Function [{x,y}, x*log[y]] [2,3] vai #1 log [#2] & [2,3] => 2 log3.Efektīva ir funkcijas definīcija ar operatoru f = Compile [{x1,x2, …}, izt], kur x1,x2, … ir argumenti. Šādu funkciju izskaitļošana notiek apmēram 10 reizes ātrāk nekā ar iepriekšējām definīcijām, piemēram, salīdzinot mašīnlaikus operatoriemfc = Compile [x, 1+x+3*x^2 + 4*x^3]; f [x_]:= 1+x+ 3*x^2 + 4*x^3;x list = Range [0,1, 0.001] iegūst Timing [f / @ x list;] => 2.4 sec, Timing [fc / @ x list;] => 0.23 sec.

DP ir definēti ortogonālie polinomi, speciālās funkcijas, sadalījuma funkcijas, eliptiskie integrāļi un funkcijas, u.c., piem. Chebyshev T[n,x] => 2. veida Čebiševa polinoms Tn(x).

21

2. Skaitlisko un simbolisko rezultātu vizualēšana, grafiskā rezultāta interpretācija

Šajā nodaļā apskata augsta līmeņa grafikus, attēlojot ar DP divu un trīs mainīgo funkcijas, vektoru un matricu datus. 2.1 MATLAB grafiki

Vienkāršības labad apskatīsim tikai Command Window vidi, t.i., komandu logu. Funkcijas grafika veidošanai lieto operatoru plot(x,y), bet simboliskās izteiksmes izdod ezplot . Tad ekrānā parādās atsevišķs logs Figure No. 1 ar funkcijas grafiku, piemēram, tabula ar soli 0.01un funkcijas grafiks:

>> x = [0:0.01:1]; y = exp(-x) .* sin(10*x); plot(x,y)

(zīmē funkcijas grafiku, sastāvošu no maziem nogriežņiem, kas savieno mezglu punktus). 2.1.1 Vektoru datu interpretācija ar MATLAB

Vektoru data var interpretēt ar stabiņu diagrammu, lietojot MATLAB operatoru bar(data). Tad ekrānā parādās grafiskais logs, kur uz horizontālās ass ir vektora elementu kārtas numuri, bet uz vertikālās – elementu vērtības. Ja vektors data ir atkarīgs no cita vektora, piem., time, tad lieto operatoru bar(time, data) un uz horizontālās ass ir vektora time elementu vērtības. Operatori barh un bar3 zīmē horizontālo un telpisko stabiņu grafikus. Vektora riņķa diagrammas konstruēšanai lieto operatoru pie(data), kur katra sektora laukums atbilst vektora elementa procentuālajai vērtībai pret visu elementu vērtību summu, t.i., MATLAB normē vērtības, izskaitļojot data/sum(data). Lai atdalītu riņķa diagrammas sektoru, kas atbilst fiksētai vektora data elementa vērtībai, operatorā pie lieto otru argumentu-vektoru, kurš sastāv no 0 un 1 (vieninieks ir tajā pozicijā, kura atbilst izdalāmās vērtības numuram). Telpiskās riņķa diagrammas attēlo ar pie3. Lai uzzinātu kā dati sablīvējas dotos intervālos lieto vektoru histogrammas ar operatoru hist, piem.

>> data = randn(100000,1); hist(data)

22

-5 0 50

0.5

1

1.5

2

2.5

3

3.5x 10

4

0 0.2 0.4 0.6 0.8 1-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

parāda, kā gadījuma vektora elementi ir sakārtoti 10 intervālos pēc normālā sadalījuma,

>> data =[24.1 17.4 10.9]; parts = [1 0 0]; pie3(data, parts)

izdod 3D riņķa diagrammu ar atdalītu sektoru 1. vektora elementa vērtībai un uzrakstiem 46%, 33% un 21%.

2.1.2 Matricu datu interpretācija ar MATLABAr operatoru bar(DATA) var zīmēt stabiņu diagrammu n x m matricas DATA

elementiem, kuru vērtības tiek grupētas skaitā m grupās pa n stabiņiem. Analogi vektoriem lieto operatorus barh un bar3. Piemēram.>> DATA = [1.2 1.4 1.1; 3.7 3.5 3.1; 2.0 2.8 2.2; 4.2 4.7 4.1]; bar(DATA) diagrammā ir novietotas 4 datu grupas, katra no kurām satur 3 stabiņus atbilstoši matricas rindu elementiem.

2.1.3 Viena argumenta funkciju grafiki ar MATLABMATLAB-ā ir plašas iespējas funkciju vizualizēšanai ar augstu kvalitāti.

Vienā logā var ievietot vairākus grafikus. Piemēram, zīmējot divus grafikus kopīgā logā funkcijām f(x)=exp(-0.1 x) sin(2x), g(x)=exp(-0.2 x)sin(2x) segmentā [-2, 2], lietojam operatorus:

>> x = [-2*pi : pi/20 : 2*pi] ; f=exp(-0.1*x) .* sin(2*x); >> g=exp(-0.2*x) .*sin(2*x); plot(x, f, x, g)

23

33%

21%

46%

-8 -6 -4 -2 0 2 4 6 8-3

-2

-1

0

1

2

3

4

Analogi, lietojot plot komandā aiz komata abcisu vektoru un ordinātu vektoru, var zīmēt patvaļīga skaita funkciju grafikus. Ja funkciju vērtības stipri atšķiras, tad ar operatoru plotyy var veidot grafiku ar 2 vertikālām (ordinātu) asīm. Grafikus logaritmiskā mērogā izdod ar operatoriem loglog(logaritmiskais mērogs uz abām asīm), semilogx vai semilogy (logaritmiskais mērogs uz x vai y ass). Ja plot arguments ir matrica, tad vienā logā tiek zīmēti matricas kolonu grafiki.

Grafiku īpašības var mainīt, lietojot markerus, mainīt līniju krāsu un veidu (nepārtrauktās, punktētās, svītrotās u.t.t), lietojot plot komandā papildus argumentus apostrofos: 1)līniju krāsai --- ‘y’(dzeltena), ‘m’(rozā), ‘c’(gaiši zila), r’(sarkana),‘g’(zaļa), b’(zila), ‘w’(balta), ‘k’(melna),2)markeru tipam --- ‘.’(punkts), ‘’ (riņķis), ‘x’(krustiņš), ‘+’(plus), ‘*’(zvaigznīte), ‘’(kvadrāts), ‘d’(rombs), ‘v’(trīstūris ar virsotni lejā), ‘^’(trīstūris ar virsotni aukšā), ‘<’(trīstūris ar virsotni pa kreisi), ‘>’(trīstūris ar virsotni pa labi), ‘h’(sešstūru zvaigzne),3)līniju tips --- ‘’(nepārtraukta), ‘…‘(punktēta), ‘- .’(svītr-punktēta), ‘- -‘(svītrota vai pārtraukta).

Noformējot grafikus lieto koordinātu režģi (operators grid on), uzrakstus uz asīm (operatori xlabel un ylabel), virsrakstu (operators title) un „leģendu” (operators legend). Pievienojot legend jāievēro, lai argumentu skaits apostrofos sakristu ar līniju skaitu grafikā. Operatorā legend ar pēdējo papildargumentu var regulēt „leģendas” stāvokli grafiskajā laukā: “-1”--- ārpus grafika loga augšējā labajā stūrī, “ 0” --- izvēlas labāko vietu grafika robežās, lai pēc iespējas mazāk pārklātu grafiku, “1” --- grafika augšējā labajā stūrī (šis stāvoklis ir arī pēc noklusēšanas ), “ 2” --- augšējā kreisajā grafika stūrī, “3” --- apakšējā kreisajā grafika stūrī, “ 4” --- apakšējā labajā grafikas stūrī („leģendas” stāvokli var regulēt arī ar peli). Ja vēlas pielikt grafikas līknei uzrakstu, tad aiz plot lieto komandu gtext(‘uzraksts’), kuru pēc izpildes ar peli var nolikt vajadzīgā vietā.

Simbolisko funkciju grafikus zīmē ar operatoru “ezplot”, piem.,>> f = sym(‘x^2 *sin(x)’); ezplot(f)

izdod grafiku kopā ar virsrakstu “x^2 sin(x)” segmentā [ -2 , 2 ]. Ja grib izdot grafiku segmentā [-3, 2], tad lieto komandu “ezplot (f, [ -3 2])”. Var zīmēt arī 2 argumentu simbolisko funkciju, piem.,

>>z = sym (‘x^2+y^3’); ezplot(z, [-2 1 –3 4]) t.i., x mainās no –2 līdz 1, bet y no –3 līdz 4.

Paketē “ToolBox Symbolic Math” ir vesela rinda simbolisko funkciju, kas zīmē grafikus: “ezmesh, ezmeshc, ezplot, ezplot3, ezpolar, ezsurf, ezsurfc”, piem., >> ezsurf(’asin(x*y)’, [0 6 -7 7]) zīmē 2D grafiku.

MATLAB izdod dažus īpašus grafikus: trepveida grafiku iegūst ar stairs(x,y), grafiku ar kļūdu zonām --- errorbar(x,y,e), kur “e“ ir kļūda, grafiku ar diskrētām

24

-6 -4 -2 0 2 4 6

-25

-20

-15

-10

-5

0

5

10

15

20

25

x

x̂ 2 *sin(x)

funkciju vērtībām--- stem(x,y). Polārās koordinātēs funkcijas r() grafiku veido operators polar (fi, r(fi)).

Funkciju var uzdot arī parametriski x=x(t), y=y(t), vispirms ģenerējot parametra t vērtības. Zīmē arī gabaliem definētu funkciju grafikus.

Vizualizējot vektoru laukus ar bultiņām, lieto quiver (x,y,ux,uy,k), kur “ux, uy” ir ātruma vektora koordinātes, “k”(0,1)---bultiņu garums.

Piemēri:1) salīdzinot 2 funkciju grafikus, kuru vērtības stipri atšķirās:

>> x= [0.5 : 0.01 : 3]; f = x .^ -3; F = 1000*(x+0.5) .^ -4;>> plotyy(x, f, x, F)

izdod 2 vertikālas asis ar atbilstošām krāsām,2) noformējot grafiku dienas temperaturas izmaiņām:

>> time = [0 4 7 9 10 11 12]; T1 = [14 15 14 16 18 17 20];>> T2 = [12 13 13 14 16 16 18]; >> plot(time, T1, ‘ro-‘, time, T2, ‘ko-‘)>> grid on, title ( ‘Dienas temperatura’)>> xlabel (‘laiks (st.) ‘), ylabel (‘Temperatura (C)’)>>legend (’10. maijs’, ‘11. maijs ‘)

zīmē grafiku ar „leģendu” aukšējā labajā stūrī, 1. grafiks sarkans ar riņķiem, 2. grafiks melns ar riņķiem,3) zīmējot grafiku parametriskā veidā:

>> t = [0:0.01:2*pi]; x = 0.5* sin (t); y = 0.7*cos(t); plot(x, y)iegūstam elipsi,

25

0.5 1 1.5 2 2.5 30

5

10

0.5 1 1.5 2 2.5 30

500

1000

0 2 4 6 8 10 1212

13

14

15

16

17

18

19

20Dienas temperatura

laiks(st.)

Tem

pera

tura

(C)

10.maijs11. maijs

4) zīmējot funkcijas grafiku, kurš definēts ar gabaliem:>> x1 = [-2*pi:0.01:-pi]; y1 = pi*sin(x1); x2 = [-pi:0.01:pi];>> y2 = pi - abs(x2); x3 = [pi:0.01:2*pi]; y3 = pi*sin(x3) .^3;>> x = [x1 x2 x3]; y = [y1 y2 y3]; plot(x, y)

iegūstam grafiku

5) var iepriekšējo grafiku iegūt arī šādi:>> plot(x1, y1, x2, y2, x3, y3)

tad iegūst analogu grafiku, tikai krāsa nebūs viendabīga (zils, zaļš, sarkans),6) zīmējot ķermeņa ar masu “m”, kurš ir sviests pret horizontu no koordināšu sākuma punkta ar sākumu ātrumu (ux0, uy0), trajektorijux = ux0 t, y = uy0 t – g t^2/ (2m) kopā ar ātruma vektoru (ux=ux0, uy =uy0-g t/m) (g--- brīvās krišanas paātrinājums), un izvēloties parametrus tā lai lidojuma ilgums būtu 2 sek. ar sākuma ātrumu (0.5, 0.8):

>> t = 0:0.2:2; x = 0.5*t; y = 0.8*t .*(1-0.5*t); ux(1:length(x))=0.5; >> uy =0.8*(1-t); quiver(x, y, ux, uy, 0.5)

iegūst vektora lauku

7) daži speciāli grafiki:>> x= 0:0.25:10; stairs(x, x.^2) %izdod trepveida grafiku

>> x = -2:0.1:2; y = erf(x); e =rand(size(x))/10; errorbar(x,y,e) izdod grafiku ar kļūdas zonām

26

-0.5 0 0.5-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

-8 -6 -4 -2 0 2 4 6 8-0.5

0

0.5

1

1.5

2

2.5

3

3.5

0 0.2 0.4 0.6 0.8 1 1.2 1.4-0.2

-0.1

0

0.1

0.2

0.3

0.4

0.5

0 2 4 6 8 100

10

20

30

40

50

60

70

80

90

100

>> x = 0:0.1:4; y = sin(x .^2) .* exp(-x); stem(x,y) % diskrēts grafiks

8) zīmējot 5-staru rozi ar operatoru polar:>> t = 0:pi/50:2*pi; polar(t, sin(5*t))

Grafikus var veidot arī ar M-failu palīdzību. Sastādīsim nelielu programmu, kas zīmē 2 funkciju grafikus vienā logā:

x = [0:0.1:7]; f = exp(-x); subplot (1, 2, 1), plot(x, f)g = sin(x); subplot(1, 2, 2), plot(x, g)

Saglabājam jauno M-failu ar nosaukumu “fgraf .m” MATLAB-a apakškatalogā BIN vai WORK. Ja komandu rindā atliek >>fgraf tad pēc ENTER parādās grafiskais logs “Figure No 1”, kas satur abu funkciju grafikus. Ja vēlās programmā kaut ko mainīt, piem., operatoru “g=sin(x)” ar “g=cos(x)”, tad to var viegli izdarīt un palaist programmu no jauna.

Apskatīsim dažus piemērus, lietojot simbolisko funkciju ezplot.1) Sastādīsim grafikus 4 elementārām funkcijām:

>>syms x, subplot(2,2,1), ezplot(x^2,[-5 5]), xlabel (‘’), grid on>>subplot(2,2,2), ezplot(exp(x),[-2 2]), xlabel (‘’), grid on>>subplot(2,2,3), ezplot(log(x),[0 5]), grid on>>subplot(2,2,4), ezplot(sqrt(x),[0 10]), grid on

27

-3 -2 -1 0 1 2 3-1.5

-1

-0.5

0

0.5

1

1.5

0 0.5 1 1.5 2 2.5 3 3.5 4-0.15

-0.1

-0.05

0

0.05

0.1

0.15

0.2

0.25

0.3

0.35

0.2

0.4

0.6

0.8

1

30

210

60

240

90

270

120

300

150

330

180 0

-5 0 50

10

20

x 2̂

-2 0 20

2

4

6

exp(x)

0 2 4

-2

-1

0

1

x

log(x)

0 5 100

1

2

3

x

x (̂1/2)

2) Sastādīsim grafikus 4 trigonometriskām funkcijām: >>syms x, subplot(2,2,1), ezplot(sin(x),[-5 5]), xlabel (‘’), grid on

>>subplot(2,2,2), ezplot(tan(x),[-5 5]), xlabel (‘’), grid on>>subplot(2,2,3), ezplot(asin(x),[-1 1]), grid on>>subplot(2,2,4), ezplot(atan(x),[-5 5]), grid on

3) Sastādīsim grafikus 4 hiperboliskām funkcijām:>>syms x, subplot(2,2,1), ezplot(sinh(x),[-4 4]), xlabel (‘’), grid on>>subplot(2,2,2), ezplot(cosh(x),[-4 4]), xlabel (‘’), grid on>>subplot(2,2,3), ezplot(tanh(x),[-4 4]), grid on>>subplot(2,2,4), ezplot(sech(x),[-4 4]), grid on

4) Sastādīsim grafikus 4 inversām hiperboliskām funkcijām: >>syms x, subplot(2,2,1), ezplot(asinh(x),[-4 4]), xlabel (‘’), grid on

>>subplot(2,2,2), ezplot(acosh(x),[0 4]), xlabel (‘’), grid on>>subplot(2,2,3), ezplot(atanh(x),[-1 1]), grid on>>subplot(2,2,4), ezplot(asech(x),[0 1]), grid on

28

-5 0 5

-1

-0.5

0

0.5

1

sin(x)

-5 0 5

-5

0

5

tan(x)

-1 0 1

-1

0

1

x

asin(x)

-5 0 5

-1

0

1

x

atan(x)

-4 -2 0 2 4

-20-10

01020

sinh(x)

-4 -2 0 2 40

10

20

cosh(x)

-4 -2 0 2 4

-1

-0.5

0

0.5

1

x

tanh(x)

-4 -2 0 2 40

0.5

1

x

sech(x)

-4 -2 0 2 4

-2

-1

0

1

2

asinh(x)

0 2 40

0.5

1

1.5

2

acosh(x)

-1 0 1

-2-1012

x

atanh(x)

0 0.5 10

1

2

3

4

x

asech(x)

5) Sastādīsim 4 grafikus funkcijām, kas modulē dažādus signālus:>>x=-10:0.01:10;subplot(2,2,1), plot(x, 0.8*sign(sin(x)))

>>xlabel (‘0.8*sgn(sin(x))’)>>subplot(2,2,2), plot(x, atan(tan(x/2))), xlabel (‘atan(tan(x/2))’)>>subplot(2,2,3), plot(x, sin(x). ^3), xlabel (‘sin(x) ^3’)>>subplot(2,2,4), plot(x, tan(cos(x))), xlabel (‘tan(cos(x))’)

2.1.4 Divu argumentu funkciju grafiki ar MATLABMATLAB dod iespēju zīmēt dažāda veida 2 argumentu funkciju grafikus: 3D

grafiki, līmeņlīnijas, parametriskās līnijas un virsmas. 3D grafikus iegūst ar operatoriem mesh(X,Y,Z) vai surf(X,Y,Z), kur koordināšu mezglus [X, Y] definē ar operatoru meshgrid, Z ir atbilstošā funkcijas z=f(x,y) vertību matrica mezglu punktos. Ar komandu colorbar var blakus grafikam izdot stabiņu, kas izdod atbilstību starp krāsas toņiem un funkcijas vērtībām. Komandas meshc vai surfc izdod papildus plaknē (x,y) funkcijas līmeņlīnijas. Funkcijas 3D līmeņlīnijas var veidot ar operatoru contour3(X,Y,Z,levels), kurā kā ceturto argumentu var uzdot līmeņlīniju skaitu vai vektoru “levels “, kura elementu vērtības sakrīt ar funkcijas vērtībām, kurām jāzīmē līmeņi. Ja šo argumentu neuzdod, tad līmeņlīniju skaits tik uzdots automātiski. 2D kontūrlīnijas vai līmeņlīnijas zīmē ar operatoriem contour(X,Y,Z) vai contourf(X,Y,Z) (ar mainīgu krāsu spektru, aiz šī operatora var lietot colorbar). Katru līmeņlīniju var atzīmēt ar atbilstošo funkcijas vērtību, lietojot MATLAB funkciju clabel ar 2 argumentiem: informācijas matrica par līmeņiem un grafikas pazīme.

Grafika krāsu izmaiņu uzdod ar colormap(krāsa), kur par “krāsa” var būt: bone(gaiši pelēka), flag(cikliski mainās sarkanā, baltā, zilā un melnā krāsas), gray(pelēka), winter(zilās un zaļās kombinācija), jet (pakāpeniski mainās zila, gaiši zila, zaļa, dzeltena un sarkana krāsas), hot (pakāpeniski mainās melna, sarkana, oranža , dzeltena un balta krāsas), copper(vara iekrāsa), pink(līdzīgi “gray” ar brūnu iekrāsu) u. c.

Vertikālās ass apzīmēšanai lieto komandu zlabel. Formulas virsrakstā uzdod ar TEX formatu, lietojot “\” zīmi (grieķu alfabeta burti ir jāuzdod ar “\alpha, \beta, \gamma, \delta, \epsilon, \eta, \theta, kappa, \lambda, \mu, \nu, \xi, \rho, \sigma, \tau, \phi, \chi, \psi, \omega, \Gamma, \Delta, \Theta, \Lambda, \Phi” ).

Dažu simbolu pieraksts: “ \leq”( <=), “ \geq”( =>), “\pm” (), “\partial”( ), “\rightarrow”(-->), “\downarrow”(), “\uparrow”(), “\propto”(), “\leftarrow”(<--), “\leftrightarraw”(<-->), “\pi”( ), “\it” (slīpie burti- italic).

MATLAB zīmē 3D līnijas parametriskā veidā x=x(t), y=y(t), z=z(t), t[a,b], kā arī virsmu x=x(u,v), y=y(u,v), z=z(u,v), u [a,b], v [c,d] grafikus, lietojot operatorus plot3,surf un mesh. Ar surfl var iegūt apgaismotas virsmas, ja krāsu palitrus copper, bone, gray, pink uzdod ar komandu colormap.

29

-10 0 10-1

-0.5

0

0.5

1

0.8*sgn(sin(x))-10 0 10

-2

-1

0

1

2

atan(tan(x/2))

-10 0 10-1

-0.5

0

0.5

1

sin(x) 3-10 0 10

-2

-1

0

1

2

tan(cos(x))

Aizkrāsotus daudzstūrus iegūst ar patch(x,y,[k1 k2 k3]), kur vektori-rindas “x, y” uzdod daudzstūru virsotnes, [k1 k2 k3] ir krāsu palete (k1=1---sarkana, k2=1---zaļa, k3=1---zila)’. Konstruējot cilindra grafiku lieto komandu [X, Y, Z] = cylinder(R,N), kur tiek radīti masīvi X,Y,Z, kas apraksta cilindrisku virsmu ar radiusu R, ar N mezglu punktiem; sfēras grafiku veido ar komandu [X, Y, Z] = sphere(N), kas ģenerē matricas X,Y un Z ar izmēriem (N+1) x (N +1).

Piemēri:1) 3D funkcijas grafiks-virsma:

>> [X,Y] = meshgrid(-1:0.05:1, 0:0.05:1); Z = sin(pi*X).*cos(pi*Y);>> mesh(X, Y, Z) %zīmē karkasa virsmu

iepriekšējā virsma ar krāsām: >> surf(X, Y, Z)virsma kopā ar vertikālo krāsas stabiņu: >> surf(X, Y, Z), colorbarkrāsaina virsma ar līmeņlīnijām (x,y) plaknē kopā ar krāsas stabiņu:>> surfc(X, Y, Z), colorbar

2) grafiks kopā ar telpiskiem uzdotiem līmeņiem:>> levels = [0:0.02:0.5]; contour3(X, Y, Z, levels), colorbar

3) grafiks ar līmeņlīnijām: >> contour(X, Y, Z)

4) grafiks ar atzīmētām līmeņlīniju vērtībām un režģi:

30

-1-0.5

00.5

1

0

0.5

10

0.1

0.2

0.3

0.4

0.5

0

0.05

0.1

0.15

0.2

0.25

0.3

0.35

0.4

0.45

0.5

-1 -0.5 0 0.5 10

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

>> [M,h] = contour (X, Y, Z); clabel(M,h), grid on

5) grafiks ar ietonētām skaitā fiksētām līmeņlīnijām:>> contourf(X, Y, Z, 20), colorbar

6) virsmas grafika noformēšana:>> surfc(X, Y, Z), colorbar, colormap(gray), title(‘Grafiks z(x,y)’)>> xlabel(‘x’), ylabel(‘y’), zlabel(‘z’)

7) parametriski uzdotas telpas līnijas grafiks (spirālveidīgs):>> t = [0:0.1:100]; x = exp(abs(t-50)/50) .* sin(t);>> y = exp(abs(t-50)/50) .* cos(t); z = t; plot3(x,y,z) >> grid on

31

-1 -0.5 0 0.5 10

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

-0.2 0 0

0

0

0.4

-1 -0.5 0 0.5 10

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

-4-2

02

4

-4-2

02

40

20

40

60

80

100

8) parametriski uzdotas virsmas grafiks x=0.3ucos(v), y=0.3usin(v), z = 0.6u, u,v[-2,2]:

>> u = [-2*pi:0.1*pi:2*pi]’; v = [-2*pi:0.1:2*pi]; X = 0.3*u*cos(v);>> Y = 0.3*u*sin(v); Z = 0.6*u*ones(size(v)); surf(X, Y, Z)>> colorbar, xlabel (‘x=0.3 u cos v ‘), ylabel (‘y=0.3 u sin v’)>> zlabel (‘z=0.6 u’)

9) elipsoida grafiks:>> u=[-pi:0.1*pi:pi]; v=[-pi:0.1*pi:pi]; X = cos(u)*cos(v); >> Y = 0.9*cos(u)*sin(v); Z = 0.8*sin(u)*ones(size(v)); >> mesh(X, Y, Z) hidden off %novērš neredzamo daļu,

10) aizkrāsota (sarkana) 4-stūra grafiks: >> X =[1 2 3 2 1]; Y =[1 2 0 5 1]; patch(X, Y, [1 0 0])

11) cilindra grafiks: >> [X, Y, Z] = cylinder (10, 30); surf(X, Y, Z)

12) sfēras grafiks: >> [X, Y, Z] = sphere(30); surfl(X, Y, Z)

32

1 1.5 2 2.5 30

0.5

1

1.5

2

2.5

3

3.5

4

4.5

5

-10-5

05

10

-10-5

05

100

0.2

0.4

0.6

0.8

1

13) pīķveida iebūvētās funkcijas “peaks” grafiks:>> peaks %izdod grafiku un sekojošu formuluz = 3*(1-x).^2.*exp(-(x.^2)-(y+1).^2)-10*(x./5-x.^3-y.^5)… .*exp(-x.^2-y.^2)-1/3*exp(-(x+1).^2-y.^2)

Nosakot punkta kustību plaknē vai telpā, var konstruēt grafiku animāciju, lietojot operatorus comet vai comet3. Piemēram, zīmējot punkta kustības trajektoriju plaknē pēc likumsakarības x(t)=sin(t)/(t+1), y(t) = cos(t)/(t+1) 10 sek. laikā:

>> t = [0:0.001:10]; x = sin(t) ./ (t+1); y = cos(t) ./ (t+1); comet(x,y)Analogi zīmē punkta kustības trajektoriju telpā, lietojot operatoru comet3(x,y,z).

Lai iegūtu vairākus grafiku logus, lieto komandu figure, piem.,>> [X,Y] = meshgrid(-1:0.05:1, 0:0.05:1); Z = sin(X .*Y); figure mesh(X,Y,Z), figure, surfl (X,Y,Z) => izdod 2 grafiskos logus: “Figure No 1”, kas satur karkasa virsmu, un “ Figure No 2” ar apgaimotu virsmu. Logs “Figure No 2” ir pašreiz aktivizēts (grafikam var uzrakstīt virsrakstu), lai aktivizētu “Figure No 1”, vajag uz to iedarboties ar peli un tad atgriezties MATLAB darba vidē, lai to noformētu. Ērtāk ir lietot “figure” ar nosaukumu, piem.,

>> gm = figure; gs = figure; [X,Y] = meshgrid(-1:0.05:1, 0:0.05:1);>> Z = sin(X.*Y); figure(gm)>> mesh(X,Y,Z), figure(gs), surfl(X,Y,Z), figure (gm)>> title(‘Karkasa virsma‘), figure (gs), title(‘Apgaismota virsma’)

Lai atbilstošu grafikas logu attīrītu lieto “ clf(gs)” vai “clf(gm)”.Lai iegūtu vairākus grafikus vienā logā tos apvienojot, lieto komandu hold

on. Piem., šķeļot konusu ar plakni lieto komandas>> u = [-2*pi:0.1*pi:2*pi]’ ; v = [-2*pi:0.1*pi:2*pi]; X=0.3*u*cos(v);>> Y = 0.3*u*sin(v); Z = 0.6*u*ones(size(v)); surf(X, Y, Z)>> [X,Y] = meshgrid(-2:0.1:2); Z = 0.5*X+0.4*Y; hold on>> mesh(X, Y, Z), hidden off %lai parādītu, ka daļa konusa atrodas virs

plaknes

33

Operatora plot(x, f, x, g) darbība divu funkciju f(x), g(x) grafikam ir ekvivalenta 3 operatoru plot(x,f), hold on un plot(x,g) darbībai.

Grafikus var sadalīt par apakšgrafikiem logā, lietojot komandu subplot(i,j,n), kur i un j ir apakšgrafiku skaits vertikālā un horizontālā virzienā, bet n ir apakšgrafika numurs pēc kārtas, sākot no kreisā aukšējā stūra pa rindām. Piem., novietosim 6 dažādus virsmas grafikus ar uzrakstiem vienā logā 2 rindās un 3 kolonās: >> [X, Y]=meshgrid(-1:0.05:1,0:0.5:1); Z=sin(2*pi*X).*cos(3*pi*Y);>> subplot (3, 2,1), mesh(X, Y, Z), title(‘mesh’), subplot(3, 2, 2), surf(X, Y, Z), title(‘surf’), subplot(3, 2, 3), meshc(X, Y, Z), title(‘meshc’), subplot(3, 2, 4), surfc(X, Y, Z), title(‘surfc’), subplot(3, 2, 5), contour3(X, Y, Z), title (‘contour3’), subplot(3, 2, 6), surfl(X, Y, Z), title (‘surfl’), colormap(gray)

Lai grafikus novietotu jaunos logos, lieto komandu hold off,

2.1.5 MATLAB grafiskie objektiVisi grafikas elementi (asis, līnijas, virsmas, teksti) ir MATLAB objekti ar

savām īpašībām. Katrā grafiskā logā var būt vairāki grafiki ar savām asīm, dažādām līnijām, virsmām un tekstiem. Manipulācijas ar grafisko objektu īpašībām veic ar operatoriem get un set. Ja ir atvērts grafiskais logs, tad 3 standarta funkcijas ir šo operatoru argumenti: 1) “gcf”--- aktivizētajam grafiskajam logam,2) “gca” --- aktivizētajām asīm,3) “gco” --- aktivizētajam grafiskajam objektam.

Lai iegūtu asu īpašības jāizpilda komanda >> get(gca), tad komandu logā parādās tabula ar daudzām grafika asu īpašībām un to vērtībām.

Ar komandu >>set (gca, īpašība, vērtība) var piešķirt katrai asu īpašībai pieļaujamo vērtību, piem. >> set(gca, ‘LineWidth’, 2).

34

Piemērs: pārveidosim funkcijas sin(x) grafiku, ko iegūst ar komandām >> x = [0:0.1:10]; y = sin(x); plot(x, y, ‘k –‘)

Šim grafikam ir 3 objekti: grafiskais logs “Figure No. 1”, asis un līnija. Grafika uzlabošanai lietosim komandas: >> set(gca, ‘LineWidth’, 2), set(gca, ‘Ytick’, [-1 0 1]) >> set(gca, ‘YtickLabel’, (‘y=-1’; ‘y=0’; ‘y=1’)) >> set(gca, ‘Xgrid’,’on’), set(gca, ‘GridLines’, ‘- ‘) (iegūsim grafikā vertikālas līnijas ar uzrakstiem uz ordinātu ass)

Papildus ieejas argumentus, lai noformētu grafikus, var uzdot arī tiešioperatorā plot formā “…,īpašība, vērtība, …”, piemēram: >>t = [0:0.1:7]; x =sin(t); y = cos(t); axes( ‘XGrid’ , ‘on’) >>hold on, plot(t, x, ‘LineWidth’, 3) >>plot(t, y, “Marker’, ‘o’, ‘MarkerFaceColor’, ‘w ‘)

Grafisko objektu var izvadīt ar image(C) vai imagesc(C), kur C ir matrica, piem. >>image(magic(10)) % izdod maģiskās 10 x 10 matricas krāsainu attēlu

>> imagesc(peaks) % izdod pīķveida krāsainu grafiku.

35

0 2 4 6 8 10-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

0 2 4 6 8 10y=-1

y=0

y=1

0 1 2 3 4 5 6 7-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

1 2 3 4 5 6 7 8 9 10

1

2

3

4

5

6

7

8

9

10

2.1.6 MATLAB 7 iespējasIzdodot funkcijas grafikus, var izmantot grafiskā loga paneļu rīkus un menjū.

Grafikas logs ir MATLAB objekta tips Figure. Ar grafikas loga menjū var:1) saglabāt šo logu failā ar paplašinājumu fig,2) izmantot labi izstrādātu grafisko objektu īpašību redaktoru3) pāriet MATLAB vidē un izpildīt jebkuras darbības komandu logā.

Apskatot grafikas loga menjū komandas, jāatzīmē sekojošais: 1) File satur komandas Save As (eksportēt- saglabāt grafiku failā ar paplašinājumu eps, jpg, bmp u. c.), Generate M-File ( ģenerē m-failu funkciju grafikas veidošanai), Export Setup (eksporta parametri, ar ko izsauc dialoga logu, kurā var mainīt grafiku izmērus (Size), vizualizāciju veidu (Rendering), fontu (Font) un līniju vedu (Lines)), Page Setup (lappuses parametri, kas izsauc dialogu logu ar vairākiem paneļa rīkiem, kurā var mainīt grafika izmērus un poziciju (Size and Position), ja ieslēgts režīms Use manual size and position: Top (augšā), Left (pa kreisi), Width (platums), Height (augstums), Units (mēra vienības); ja ieslēgts režīms Use screen size, centered on page , tad automātiski grafiks būs lappuses vidū); ar rīku Paper var izvēlēties papīra formātu un tā orientāciju Portrait vai Landscape ; ar rīku Axes and Figure var izmainīt grafika asu stāvokļus), 2) Edit satur komandas Figure Properties (izsauc logu Property Editor- Figure, kurš pievienojas grafikas logam apakšā un atļauj izmainīt grafika īpašības: Figure Name (nosaukumu), Colormap (grafika krāsa), Figure Color (grafika lauka krāsa), Show Figure Number (grafika numura iekļaušana), Inspector (izsauc Property Inspector, kurā redzamas visas grafika īpašības un kuras arī var izmainīt), Export Setup (eksporta parametri)), Axes Properties (izsauc logu Property Editor- Axes , kurš pievienojas grafikas logam apakšā un atļauj izmainīt grafika asu īpašības: Title (virsrakstu zem grafikas lauka), Colors (krāsas), Grid (režģis), Box (grafika rāmis), X Label, Y Label, Z Label (asu nosaukumi),X Limits, Y Limits, Z Limits ( minimālās un maksimālās robežas), X Scale, Y Scale, Z Scale (mērogi), Reverse (asu virzienu maiņa uz pretējo), Ticks ( izsauc dialoga logu Edit Axes Ticks , kurā var formēt grafika iedaļas automātiski vai tās uzdot vienmērīgi ar soli vai tabulas veidā), Inspector (izsauc Property Inspector, kurā var redzēt visas izmainītas īpašības) ),Property Editors (izsauc Property Editor –Lineseries, kurš pievienojas grafikas logam apakšā un atļauj izmainīt grafika līniju īpašības: X/Y/Z Label Data Source (vektoru x, y un z vērtību maiņa, pēc katras maiņas nospiežot pogu Refresh Data ), Plot Type (var izvēlēties vienu no 5 funkcijas grafiku veidiem (Line, Bar, Area, Stars, Stem) ), Marker (sarakstā var izvēlēties mārkeri)), Find Files (palīdz atrast failus),3) View satur komandas, ar kurām var atvērt (ja tās ir atzīmētas) Figure Toolbar (grafiskā lauka paneļa rīkus), Camera Toolbar (kameras vadības paneļa rīkus), Plot Editor Toolbar (grafika redakcijas paneļa rīkus), Figure Palette (grafiskā lauka redaktoru), Plot Browser (grafisko objektu apskata rīkus), Property Editor (grafisko objektu īpašību redaktoru),4) Insert satur komandu virkni dažādu grafikas elementu noformēšanai:Legend (leģendām), Colorbar (dažādu krāsu stabiņam), Line (līnijām), Arrow, Double Arrow, Text Arrow (dažādām bultiņām), Text Box (paskaidrojošiem pierakstiem), Rectangle (taisnstūriem), Ellipse (elipsēm),5) Tools (serviss) satur komandas Edit Plot (veikt grafika redakciju), Zoom In (palielināt mērogu), Zoom Out (samazināt mērogu), Pan (paņemt), Rotate 3D (3D rotācija), Data Cursor (dati zem kursora), Reset View (atjauno skatu pēc izmaiņas

36

ar Pan ), Options (atver komandu sarakstu: Unconstrained Zoom, Unconstrained Pan – dabīgs mērogs visām koordinātēm vai grafika pārvietošana pa peles trajektoriju, Horizontal Zoom, Horizontal Pan – mērogs un pārvietošana pa horizontāli, HVertical Zoom, Vertical Pan – mērogs un pārvietošana pa vertikāli, Display Cursor as Datatip – punkta koordināte zem kursora, Display Cursor in Window – punkta koordināte zem grafikas lauka) u.c.

2.2 MAPLE grafiki

Ar DP MAPLE var zīmēt dažāda veida grafikus. Uzzīmētos grafikus var apstrādāt ar dažādu rīku palīdzību.

Viena no spilgtākām MAPLE īpašībām ir labi attīstīta rezultātu grafiskā interpretācija. Datorprogramma satur virkni funkciju un opcijas 2–dimensionālo (2–D) un 3–dimensionālo (3–D) objektu grafiskai attēlošanai. Bez standarta operatoriem plot, plot3d MAPLE satur arī specializētas paketes pak, kuras izsauc ar komandu with (pak):1) grafiku attēlošanas pakete "plots", kas satur ap 50 dažādas komandas grafiku veidošanai,2) zīmēšanas pakete "plottools", ar kuru var radīt ap 30 dažādus 2–D un 3–D primitīvos grafikus,3) ģeometrijas pakete "geometry", kur ar komandas draw palīdzību var zīmēt dažādas ģeometriskas konstrukcijas (punktus, taisnes, riņķus, trijstūrus utt.).

MAPLE satur arī 45 koordinātu sistēmas, kuras koordinātu līnijas var zīmēt un komandas changecoords un addcoords, kuras dod iespēju pāriet no vienas koordinātu sistēmas uz otru, kā arī veidot jaunas koordinātu sistēmas.

2.2.1 MAPLE grafiskie instrumenti.1) 2-dimensiju grafika instrumentu paneļa rīki:

1 – peles kursora koordinātes; 2 – nepārtraukta līknes grafika veidošana;3 – punktveida grafika veidošana;4 – grafiks ar režģa līnijām;5 – blīvs grafiks;6 – grafiks rāmī ar asīm;7 – grafiks ar asīm kreisajā apakšējā stūrī;8 – grafiks ar asīm centrā;9 – grafiks bez asīm;10 – mēroga izmaiņa.

37

2) 3-dimensiju grafika instrumentu paneļa rīki:

1,2 – figūras apskata leņķi;3 – līnijas un pildījums;4 – pildījums bez līnijām;5 – līmeņlīnijas ar pildījumu;6 – tikai līnijas;7 – līmeņlīnijas bez pildījuma;8 – visas līnijas bez pildījuma;9 – punktveida figūra;10 – grafiks "kastē";11,12 – grafiks ar koordināšu asīm;13 – grafiks bez koordināšu asīm;14 – mēroga izmaiņa;15 – grafika pārzīmēšana. Veicot vairāku grafikas pārbīdi – animāciju (animation), grafikas logā,

uzklikšķinot ar peli, parādās papildus rīki : Text, Math, Drawing, Plot, Animation. Izvēloties Animation, var lietot rindu pogu: Stop (kvadrāts – animācijas pauze), Start (trijstūris—animācijas palaišanai), Next frame un Previous frame (trijstūri ar taisnstūri – kārtējai grafikas fiksētai līknei), Animation Speed (logs, kurā var fiksēt līkņu kustības ātrumu no 1līdz 100), Current frame (logs ar animācijas numuru) un pogas, ar kurām var mainīt animācijas (kustības) virzienus ( uz priekšu, atpakaļ un cikliski).

Apskatīsim dažas grafisko datu struktūras un opcijas, ko lieto komandās plot un plot3d:1) teksta veidošanai ir operators TEXT({x,y], `teksts`, hor, ver), kur hor satur vienu no atslēgas vārdiem ALIGNLEFT (tekstu novieto pa kreisi no [x,y] ) vai ALIGNRIGHT (tekstu novieto pa labi no [x,y] ); analogi ver satur vienu no vārdiem ALIGNABOVE (tekstu novieto virs [x,y] ) vai ALIGNBELOW (tekstu novieto zem [x,y] ); ja hor vai/un ver iztrūkst, tad teksts tiek centrēts ap [x,y] (iespējams operatorus rakstīt arī ar mazajiem latīņu burtiem),2) stila opcijai STYLE var būt 4 dažādas vērtības: POINT (punkts), LINE (līnija), PATCH (raustīta līnija), PATCHNOGRID (režģis), piem. style=POINT,3) opciju THICKNESS=n lieto zīmēto līniju biezumu fiksēšanai (n=0;1;2;3;4); pēc noklusēšanas n=0,4) opcijai SYMBOL var būt vērtības: BOX, CROSS, CIRCLE, POINT, DIAMOND (dažāda veida simboli), piem. symbol=BOX,5) ar opciju LINESTYLE veido līnijas stilu (nepārtrauktu, raustītu, pārtrauktu),6) ar opciju COLOUR (kura var atkārtoties plot komandā) veido dažādu krāsu grafikus, lietojot specifikācijas RGB, HUE, HSV, piem.COLOUR (HUE,0.1) vai COLOUR (RGB, 1.0,0.0,0.0) sarkanai krāsai),7) ar opciju TITLE (uzr) var veidot grafikiem virsrakstus uzr,8) opciju AXES lieto grafika koordinātu asu stilu noformēšanai ar 5 iespējām: BOX (veido kastītē noformētu grafiku), FRAME (daļējā kastīte), NORMAL (asis ir taisnes ar iezīmētu nulles pozīciju), NONE (asis iztrūkst), DEFAULT (pēc noklusēšanas – speciāls veids),

38

9) opciju AXESTICKS lieto koordinātu asu iezīmju veidošanai,10) opciju AXESLABELS lieto koordinātu asu uzrakstu veidošanai.

Opcijas var ieslēgt paketē ar komandām plots[setoptions] (opc), plots [setoptions3d] (opc), kur argumenti opc ir formāopt1=izt1,..., optn=iztn, piem. with (plots): setoptions (tittle=`grafiki`, axes=BOXED);plot ({seq (cos((x^2+(0.4*i)^2)/4)/(x^2+(0.4*i)^2+Pi),i=1..10)}, x= –3..10);zīmē grafiku virkni.

Opcijā color=c var uzdot definētas krāsas ar RGB vai HUE, kā arī atsevišķu krāsu nosaukumus angļu valodā, kur par parametru c var būt aquamarine, black, blue, navy, coral, cyan, brown, gold, green, gray, grey, khaki, magenta, maroon, orange, pink, plum, red, sienna, tan, turquoise, violet, wheat, white, yellow.

2.2.2 MAPLE 2- dimensiju grafiki un to lietojumi funkciju pētīšanāZīmējot funkcijas y=f(x) grafikus, kura definēta ar izteiksmi y:=f(x), var

rīkoties šādi (opc – opcijas):1) plot (y,x,opc) – zīmē grafiku segmentā [–10,10], mērogs pa Oy asi atbilst funkcijas vērtībām,2) plot (y, 'x'=a..b, 'y'=c..d, opc) – zīmē grafiku x (a,b), y (c,d) ar uzrakstiem uz asīm.

Ja funkcijas definīcija ir formā f:=xizt, tad var zīmēt grafiku šādi:1) plot (f(x), x=a..b, opc) – zīmē grafiku x (a,b),2) plot (f, a..b, c..d, opc) – zīmē grafiku x (a,b), y (c,d),3) plot (f, opc) – zīmē grafiku intervālā x (–10,10).

Var veidot arī aritmētiskas operācijas ar funkcijām un zīmēt to grafikus,piem. f:= xizt1: g:=xizt2: (f+g)(x), (f–g)(x), (f/g)(x);=> izdod funkciju summu, starpību, dalījumu,plot ({f(x), g(x), (f+g)(x)}, x=a..b);=> zīmē 2 funkciju un to summas grafiku.

Ar MAPLE var pētīt funkcijas definīcijas apgabalu, izdarot virkni darbību, piem. f:= x sqrt (2–x–x^2): f(x);

,"^2; => 2–x–x2 (funkcijas kvadrāts),factor (");=> –(x+2)(x–1) (sadalīšana reizinātājos),plot (", x= –3..3);=> grafikā redzam, ka definīcijas apgabals atrodas starp 2 funkcijas nullēm, t.i., x [–2,1].

Pētot funkcijas vai izteiksmes izt grafikus ar operatoriem D(f)(x),diff (f(x),x) nosaka ekstrēmu punktus (f '(x)=0) (lokālos maksimumus un minimumus) un pārliekuma punktus (f "(x)=0). To var realizēt šādi:plot (izt,x); y1:= diff (izt,x): y2:= diff (y1,x):x1:= fsolve (y1=0, x, x=a..b); x2:= fsolve (y2=0, x, x=c..d):subs (x=x1,izt); subs (x=x2,izt);t.i. izskaitļo ekstrēmu un pārliekuma punktu koordinātes x1,x2 un izteiksmes vērtības y1,y2 šajos punktos.

39

Piemēri:1) h:=x (x^3–6*x^2–12*x+49) / ((x–2)*(x–7)):plot (h,numpoints=100);=> izdod grafiku intervālā (–10,10) ar 2 izteiktiem pīķiem punktu x=2 un x=7 apkārtnē,limit (h(x), x=2, left); => (robeža no kreisās puses),limit (h(x), x=2, right); => (robeža no labās puses),formula:= h(x): solve (denm (formula)=0,x); => 2, 7 (izdod racionālās funkcijas saucēja nulles),plot (h(x), x= –10..20, y= –20..50);=> tiek precizēts grafiks apkārtnē, kurā pēta doto funkciju; redzams, ka ekstrēma punkti ir 5 un 9 apkārtnē, pie kam pirmais ir lokālā maksimuma, bet otrs lokālā minimuma punkti,diff (formula,x): first:=normal(");

(izdod funkcijas h pirmo atvasinājumu),krpunkti:= {fsolve (numer (first)=0,x};=> krpunkti:= {5.440990751, 8.640175839}(izdod kritiskos (ekstrēma) punktus),plot (signum (first),x = –10..20, –2..2, discont=true);=> izdod 1.atvasinājuma zīmju funkciju, no kuras var spriest, ka intervālā (2, 5.4410) funkcija h ir augoša, bet intervālos (5.4410, 7) un (7, 8.6402) dilstoša,second:= normal (diff (first,x));

(izdod funkcijas h otro atvasinājumu),fsolve (numer (second)=0,x); => –29.51084117 (izdod pārliekuma punktu),plot (h, –1000..1000, –1000..1000);=> izdod funkcijas h globālo grafiku, uz kura nav redzami singulārie punkti,

2) g:=x ln (x^2+7): plot (g(x),x);=> zīmē logaritmiskās funkcijas grafiku intervālā (–10, 10),g1:=xlimit ((g(x+h)–g(x)) / h, h=0);

=> g1:= (atvasinājums pēc definīcijas),plot (g1(x),x);=>zīmē atvasinājuma grafiku intervālā (–10, 10), uz kura redzams, ka tas ir negatīvs, ja x<0, pozitīvs, ja x>0 un nulle, ja x=0,

3) f:= x x^5+9*x^4–19*x^3–241*x^2–150*x+200:plot (f, –9..6, –300..300);=> redzams saraustīts funkcijas grafiks,plot (f);=>intervālā (–10, 10) redzamas 5 reālās polinoma f(x) saknes,f1:= D(f);=>f1:= x5x4+36x3–57x2–482x–150

40

(funkcijas atvasinājums f'(x)=f1(x)),To:=xf1(1.)*(x–1)+f(1.): f(1);=> definē funkcijas f(x) grafikam pieskari punktā (1,f(1)) un aprēķina f(1)= –200,plot ({f,To}, –1..3, –300..50);=>zīmē funkcijas grafiku kopā ar pieskari,x1:= fsolve (To(x)=0,x);=>x1:= 0.6913580247 (atrod pieskares krustpunktu ar Ox asi),y1:= f(x1);=> y1:= –22.9604001 (aprēķina funkcijas vērtību krustpunktā, t.i. iegūstam labāku tuvinājumu x1 funkcijas saknei apkārtnē (0,1) nekā x=1,T1:= xf1 (x1)*(x–x1) + y1: plot ({f,T1}, 0.5..0.75, –25..2);=>procesu turpinot, zīmē funkcijas grafiku kopā ar pieskares grafiku punktā (x1,y1), redzam, ka abi grafiki gandrīz sakrīt,x2:= fsolve (T1(x)=0,x);=> x2:= 0.6452009558 (atrod jaunās pieskares krustpunktu ar Ox asi),y2:= f(x2);=>y2:= –0.5363646 (aprēķina funkcijas vērtību krustpunktā, tā jau ir tuvāk nullei),T2:= xf1 (x2)*(x–x2)+y2: T2(x);=>–474.1794689x + 305.4046820 (jaunās pieskares vienādojums),x3:= fsolve (T2(x)=0,x); y3:= f(x3); T3:= xf1 (x3)*(x–x3)+y3: T3(x);=>x3:= 0.6440698133 y3:= –0.0003232 –473.6079582x + 305.0362660(iterācijas process (Ņūtona metode) tiek turpināts),x4:= fsolve (T3(x)=0,x); y4:= f (x4); => x4:= 0.6440691308y4:= 0.1 10–6

(iegūta funkcijas f(x) saknes tuvinātā vērtība; šo procesu var realizēt ciklā ar operatoru for, from, by, to, do, od palīdzību),

4) f:= xpiecewise (x>3, x^2, x–5);

=> f:=x ,f(2); f(5);=> –3 25, plot (f); => izdod funkcijas grafiku,

5) plot (trunc(x), x=0..5, style=LINE); =>zīmē kāpņveida funkciju,

6) plot (abs(x^3–3*x), x= –2..2); => zīmē izteiksmes absolūtās vērtības grafiku,

7) r1:= (x+5) / (x+1) > (x+2) / (x–2): lhs(r1) – lhs(r1):plot(",x= –10..10, y= –20..20);=> pēc grafikas var spriest (funkcijas pozitīvās daļas) par nevienādības atrisinājumu,

8) f:= x^2: f(2); => x(2)2 (kļūda, jo f nav funkcija, bet izteiksme),subs (x=2, f); => 4,plot (f(x), x=0..2); =>zīmē grafiku,

9) f:= xx^2: g:=xx^4: with (plots): p1:= plot(f, –5..5, color=blue):p2:= plot(g, –5..5, color=red): display ({ p1,p2 });=> izdod 2 krāsainus grafikus,

41

10) f:= 2*x^3 -5*x^2 +x+2: x:=6: f; => 260 (aprēķina izteiksmes vērtību),subs (x=6, f); =>260 (aprēķina izteiksmes vērtību),plot (f, x= –2..3); => zīmē grafiku,

11) f:= x x^3 – x^2 + 4*x+4: plot (f, –infinity..infinity);=> zīmē grafiku uz visas reālās taisnes,

12) f:= x2*x^2–4*x+9: plot ({f(x), 3*f(x)}, x= –10..10);=> zīmē 2 funkciju grafikus: f(x) un 3 f(x),

13) f:= xx^(1/3): f1:= f(x): f2:= f(f1): f3:=f(f2);=> f3:= x1/27 (izveido funkciju iterācijas),plot (f(x),x); plot (f1,x); plot (f2,x); plot (f3,x); with (plots):display ([seq (plot ((f@@n) (x),x=0..20), n=1..10)],insequence=true);=> izdod funkciju grafikus un veido "kustīgus" grafikus (grafiku animācija),

14) f:= x3*cos(2*x): plot (f(x), x= –4*Pi..4*Pi);f(0), f(Pi/2), f(Pi);=> 3, –3, 3 (zīmē funkcijas grafiku un konstatē, ka funkcijas periods ir π, bet amplitūda 3),

15) with(plots): animate( plot, [A*x^2,x=-4..4], A=-3..3 ); => veido kustīgas parabolas grafiku,

16) > with(plots):animate( plot, [A*x^2,x=-4..4], A=-3..3, trace=5, frames=50 );

17) plot([(t^2-1)/(t^2+1), 2*t/(t^2+1), t=-infinity..infinity]); => zīmē līkni parametriskā veidā,

18) with(plots):pointplot({seq([k,sin(k/10)],k=0..30)}); => zīmē punktveida grafiku.

19) > with(plots):implicitplot({x^2-y^2=1, y=exp(x)}, x=-Pi..Pi,y=-Pi..Pi); => izdod 3 līknes

42

2.2.3 MAPLE 3- dimensiju grafiki un to lietojumiLietojot zīmēšanas paketi plots, var veidot dazādus grafikus. No

paketes atsevišķu komandu izsauc ar plots [komanda] vai with (plots, komanda). Visas paketes komandas “ielādē” kompjūterā ar komandu with (plots). Plots komandas ir:animate, animate3d, changecoords, complexplot, complexplot3d, conformal, contourplot, contourplot3d, coordplot, coordplot3d, cylinderplot, densityplot, display, display3d, fieldplot, fieldplot3d, gradplot, gradplot3d, implicitplot, implicitplot3d, inequal, listcontplot, listcontplot3d, listdensityplot, listplot, listplot3d, loglogplot, logplot, matrixplot, odeplot, pareto, pointplot, pointplot3d, polarplot, polygonplot, polygonplot3d, polyhedraplot, replot, rootlocus, semilogplot, setoptions, setoptions3d, spacecurve, sparsematrixplot, sphereplot, surfdata, textplot, textplot3d, tubeplot.

Divu argumentu funkcijas z=f(x,y) vai izteiksmju grafikam, kas satur 2 argumentus, kuri pieder taisnstūrim [xmin, xmax],[ymin, ymax] lieto komanduplot3d (z(x,y), x=xmin..xmax, y=ymin..ymax, opc),kur opciju (opc) sarakstā ir, piemēram,1) orientation = […,…]- pagriešanas leņķu fiksēšana, lai labāk varētu redzēt grafiku;2) view=az..bz vai view=[ax..bx, ay..by, az..bz] - redzes punkta izvēlei,3) projection = n, kur n ir starp 0 un 1 – projekcijas fiksēšanai,4) style = (POINT, LINE, HIDDEN, PATCH, WIREFRAME, CONTOUR, PATCHNOGRID, PATCHCONTOUR) - grafikas stila noteikšanai,5) shading = (Z, XY, XYZ, Z_GREYSCALE, Z_HUE, NONE) - veido grafika ēnojamību,6) grid = [n1,n2] - grafika režģa nofiksēšanai (pēc noklusēšanas (25;25),7) contours = n - precizē kontūrlīniju skaitu (pēc noklusēšanas n=10), 8) gridstyle = triangular - trijstūra režģa veidošanai (pēc noklusēšanas:rectangular),9) tickmarks = [nx,ny,nz] - iezīmju skaita fiksēšanai pa koordinātu asīm,10) labels = [litx, lity,litz] - veido uzrakstus (pazīmes) uz koordinātu asīm kā vārdus,11) font = [opc1,opc2,n] kur opc1 = (TIMES, COURIER, HELVETICA), opc2 = (ROMAN, BOLD, ITALIC, BOLDITALIC), n - fontu izmērs.

43

Ar komandu plot3d (z(x,y), x=min..xmax, ymin..ymax, zmin..zmax, opc); uzdod arī vertikālos izmērus pa z asi.

Piemēri:1) plot3d (f, xmin..xmax, ymin..ymax);=> zīmē grafiku 2 argumentu funkcijai,

2) with (plots): implicitplot (x^2+y^2 = 1, x= –1..1, y= –1..1);=> izsauc paketi "plots" un zīmē funkcijas grafiku aizklātā veidā (riņķa līniju),

3) f:= (x,y)x*y^2 + 2*x*y +5: f(0,0);=> 5,plot3d (f(x,y), x= –2..2, y= -2..2); => zīmē funkcijas grafiku,

4) with (plots): implicitplot ((x/4)^2+(y/2)^2=1, x= –4..4, y= –2..2, scaling=CONSTRAINED); => zīmē elipsi.

5) with (plots): implicitplot ((x/4)^2–(y/2)^2=1, x= –10..10, y= –10..10); => grafiks ir hiperbola,

6) plot ([ 1,1,3,4,5,5,5,6 ]); => no zīmētā grafika redzams, ka sakarība nedefinē funkciju, jo pēdējie 2 punkti ir savienoti savā starpā ar vertikālu līniju,

7) with(plots): contourplot(sin(x*y),x=-3..3,y=-3..3); => zīmē pēc noklusēšanas 8 kontūras, contourplot(sin(x*y),x=-3..3,y=-3..3,contours=3); => zīmē 3 kontūrus, contourplot(sin(x*y),x=-3..3,y=-3..3,grid=[15,15],contours=[-1/2,1/4,1/2,3/4]); => zīmē noteiktu kontūru skaitu,

8) with(plots): implicitplot3d(x^3+y^3+z^3+1=(x+y+z+1)^3, x=-2..2, y=-2..2, z=-2..2, grid=[13,13,13]); => zīmē aizklātas funkcijas virsmas grafiku,

9) plot3d(sin(x+y), x=-1..1, y=-1..1); => zīmē virsmas z=sin(x+y) grafiku,

10) with(plots):spacecurve([cos(t),sin(t),t],t=0..4*Pi); => zīmē telpiskas līknes grafiku,

11) with(plots):animate( plot3d, [A*(x^2+y^2),x=-3..3,y=-3..3], A=-2..2, style=patchcontour ); => izveido kustīgu virsmu,

12) with(plots): fieldplot3d([2*x,2*y,1],x=-1..1,y=-1..1,z=-1..1,grid=[5,5,5]);=> izveido vektoru lauku,

13) with(plots): p:= dsolve({D(y)(x) = y(x), y(0)=1}, type=numeric, range=-5..2): odeplot(p); => zīmē Košī problēmas y’(x) =y(x), y(0)=1 atrisinājumu segmentā [-5,2],

14) with(plots): pointplot3d({[0,1,1],[1,-1,2],[3,0,5]},axes=normal,symbol=box); => zīmē telpā 3 punktus,

15) with(plots):with(LinearAlgebra): A:= HilbertMatrix(8): matrixplot(A); => zīmē Hilberta matricas grafiku

44

2.3 MATHEMATICA grafiki

DP ir plašas iespējas datu un skaitlisko rezultātu grafiskai interpretācijai.

2.3.1 MATHEMATICA 2- dimensiju grafiki un to lietojumiFunkcijas y=f(x) grafika zīmēšanai segmentā [a,b] lieto komandu Plot[f[x],

{x,a,b},opc], kur opc ir neobligāti parametri, ar kuriem var ietekmēt grafika izskatu, piemēram,PlotRange {{xa,xb},{ya,yb}} (fiksē grafika izmērus), AxesLabel {‘x’, ‘y’}(asu uzrakstiem), PlotLabel {‘y=f(x)’} (līkņu pierakstiem), PlotPoint n (punktu skaits zīmēšanai, pēc noklusēšanas n=25), AspectRatio Automatic (fiksē vienādus grafika izmērus pa asīm), Thickness[k] (līniju biezumam, k<1), PlotStyle PointSize[k] ( punktu biezumam).

Vairāku funkciju grafiku zīmēšanai segmentā [a,b] lieto komandu Plot[{f1[x],f2[x],…},{x,a,b},opc].

Parametriskā veidā uzdotas funkcijas grafiku zīmē ar ParametricPlot[{x[t],y[t]}{t,ta,tb},opc], piem., ParametricPlot[{Sin[t],Cos[t]}{t,0,2 Pi}] => izdod elipsi, lai iegūtu riņķa līniju jāpievieno opcija AspectRatio Automatic. To var izdarīt nemainot iepriekšējo komandu ar komandu Show[%,AspectRatio Automatic].

Ja dati ir uzdoti saraksta (list) veidā, tad tos attēlo ar komandu ListPlot[{{x1,y1},{x2,y2},…}, opc]. Ja punkti nav redzami, tad jālieto opcija PlotStyle PointSize[k], kur 0<k<1, piemēram, T=Table[i^3,{i,10}] => izveido tabulu {1,8,…,1000}, ListPlot[T] => zīmē punktveida grafiku, ListPlot[T,PlotJoined True] => izdod nepārtrauktu grafiku, punktus savienojot ar taisnēm.

Veidojot grafikus no elementiem, lieto operatoru gr=Graphics[elementi,opc], kuru palaiž ar komandu Show[gr,opc].Par grafikas elementiem var būt:1)Point[{x0,y0}] --- fiksēts punkts plaknē,2) Line[{{x1,y1}, {x2,y2},…}]--- lauzta līnija plaknē caur fiksētiem punktiem,3) Rectangle [{xa,ya},{xb,yb}] --- piepildīts taisnstūris,4) Polygon[{{x1,y1},{x2,y2},…}] --- piepildīts poligons,5) Circle [{x0,y0},R] --- piepildīts riņķis ar rādiusu R un centru(x0,y0),

45

6) Circle [{x0,y0},{Rx,Ry}] --- elipse ar pusasīm Rx,Ry,7) Text [izt,{x,y}] --- tekstam „izt” centrētam punktā (x,y).

Gafiku formēšanai ir virkne paketes , kuru izsaukums ir formā << Graphics`nos`, kur par nos var būt:1) ImplicitPlot --- aizklāto funkciju grafikiem,2) InequalityGraphics --- nevienādību atrisinājumiem,3) Animation --- funkciju animācijai,4) PlotField --- vektoru lauka zīmēšanai,5) Spline --- splainu ilustrēšanai ,6) Graphics --- grafiku noformēšanai, u.c.(skat. Help).

Piemēri:1) g=Graphics [{Line[{{{-1,-1},{1,1}}],Line[{{-1,1},{1,-1}}]}]; Show[g] =>zīmē divas taisnes, Show [g, Axes Automatic] => taisnes kopā ar asīm,

2) Plot[BesselJ[0,x],{x,0,15}, AxesLabel{x,BesselJ[0,x]}]; => zīmē Besseļa funkcijas grafiku

3) values=BesselJ[0,Range[20]] => izdod Besseļa funkcijas tabulu{BesselJ[0,1],BesselJ[0,2],BesselJ[0,3],BesselJ[0,4],BesselJ[0,5],BesselJ[0,6],BesselJ[0,7],BesselJ[0,8],BesselJ[0,9],BesselJ[0,10],BesselJ[0,11],BesselJ[0,12],BesselJ[0,13],BesselJ[0,14],BesselJ[0,15],BesselJ[0,16],BesselJ[0,17],BesselJ[0,18],BesselJ[0,19],BesselJ[0,20]}

ListPlot[values,PlotStylePointSize[0.02]]; => zīmē punktveida grafiku

5 10 15 20

-0.4

-0.2

0.2

0.4

0.6

2 4 6 8 10 12 14x

-0.4

-0.2

0.2

0.4

0.6

0.8

1BesselJ[0,x]

46

4) ParametricPlot[{Cos[5t],Sin[3t]},{t,0,2Pi},AspectRatioAutomatic]; =>zīmē sarežģītu līkni plaknē

-1 -0.5 0.5 1

-1

-0.5

0.5

1

5) << Graphics`ImplicitPlot`ImplicitPlot[Sin[2 x] + Cos[3 y] == 1, {x, 0, 2 Pi},{y, 0, 2 Pi}, PlotPoints30]=> izsauc paketi un zīmē aizklātās funkcijas y=f(x) grafiku (līknes )

0 1 2 3 4 5 60

1

2

3

4

5

6

ContourGraphics

6) <<Graphics`InequalityGraphics`InequalityPlot[ Abs[ Abs[x] - Abs[y]] 1, {x, -2, 2}, {y, -2, 2}] => zīmē nevienādības atrisinājuma apgabalu

-2 -1 1 2

-2

-1

1

2

-2 -1 1 2

-2

-1

1

2

Graphics

7) <<Graphics`Spline`pts = {{0, 0}, {1, 2}, {2, 3}, {3, 1}, {4, 0}}; Show[ Graphics[{Hue[0], Line[pts], GrayLevel[0], Spline[pts, Cubic]}], PlotRange -> All] => zīmē kubiskā un lineārā splainu grafikus

47

Graphics

2.3.2 MATHEMATICA 3- dimensiju grafiki un to lietojumiDivu argumentu funkcijas z=f(x,y) grafikas zīmēšanai taisnstūrī ([xa,xb],

[ya,yb]) lieto komandu Plot3D[f[x,y], {x,xa,xb}.{y,ya,yb},opc],kur opciju saraksts ir vēl plašāks.

Parametriskās līnijas un virsmas var zīmēt ar ParametricPlot3D[{x[t],y[t],z[t]},{t,ta,tb},opc]; ParametricPlot3D[{x[u,v],y[u,v],z[u,v]},{u,ua,ub}, {v,va,vb},opc].

Ja dati ir doti 2D tabulas (matricas, list) veidā, tad tos var attēlot ar ListPlot3D[list,opc].

Kontūru (līmeņlīniju) grafikus izdod ar ContourPlot[f[x,y],{x,xa,xb}, {y,ya,yb},opc].

Funkciju sablīvējuma attēlošanai lieto DensityPlot[f[x,y],{x,xa,xb}, {y,ya,yb},opc]. Analogi var lietot ListDensityPlot[list,opc].

Veidojot grafikus no elementiem, lieto operatoru gr=Graphics3D[elementi,opc], kuru palaiž ar komandu Show[gr,opc].Par grafikas elementiem var būt:1)Point[{x0,y0,z0}] --- fiksēts punkts telpā,2) Line[{{x1,y1,z1}, {x2,y2,z2},…}]--- lauzta līnija telpā caur fiksētiem punktiem,3) Cuboid [{xa,ya,za},{xb,yb,zb}] --- piepildīts paralelskaldnis,4) Polygon[{{x1,y1,z1},{x2,y2,z2},…}] --- piepildīts paralelskaldnis ,5) Text [izt,{x,y,z}] --- tekstam „izt” centrētam punktā (x,y,z).

Gafiku formēšanai ir virkne paketes , kuru izsaukums ir formā << Graphics3D`nos`, kur par nos var būt:1) ImplicitPlot --- aizklāto funkciju grafikiem,2) ParametricPlot3D --- parametriskām līnijām un virsmām,3) Animation --- funkciju animācijai,4) PlotField3D --- vektoru lauka zīmēšanai,5) ContourPlot3D --- kontūru ilustrēšanai,6) Graphics3D --- grafiku noformēšanai, u.c.(skat. Help).

Piemēri:1) ParametricPlot3D[{Sin[t],Cos[t],t/3}, {t,0,15}] => zīmē spirāli telpā,2) ParametricPlot3D[{t,u,Sin[ t u]}, {t,0,3},{u,0,3}] => zīmē virsmu telpā,3) ContourPlot[Exp[1-Abs[x]-0.2*y^2]*Sin[y], {x,-10,10},{y,-10,10}],4) d=DensityPlot[Exp[1-Abs[x]-0.2*y^2]*Sin[y], {x,-10,10},{y,-10,10}], lai iegūtu labu izšķiršanas spēju, ālieto opcijas PlotPoint 100, Mesh False, t. i. Show[d, PlotPoint 100, Mesh False]

5) <<Graphics`PlotField3D`

48

PlotVectorField3D[{y , -x, 0}/z , {x, -1, 1}, {y, -1, 1}, {z, 1, 3}] => zīmē vektoru lauku

Graphics3D6) <<Graphics`ContourPlot3D`ContourPlot3D[Cos[ x^3 + y^2 + z^3 ], {x,-1,1}, {y,-1,1}, {z,-1,1}] => zīmē kontūras

Graphics3D

7) Plot3D[Sin[x y],{x,0,4},{y,0,4}];=> zīmē viļņotu grafiku

01

23

4 0

1

2

3

4

-1-0.5

00.51

01

23

4

9) ParametricPlot3D[{Cos[5t],Sin[3t],Sin[t]},{t,0,2 Pi}]; => līkne telpā

49

-1-0.5

00.5

1

-1-0.5

00.5

1

-1

-0.5

0

0.5

1

-1-0.5

00.5

1

-1-0.5

00.5

1

3. Matemātiskās analīzes galveno operatoru modelēšana

Apskatīsim DP lietošanu matemātiskās analīzes problēmu risināšanā. Simboliskos pārveidojumos šeit prioritāte ir MAPLE un MATHEMATICA versijām.

3.1 MATLAB lietojumi matemātiskajā analīzē

Tā kā MATLAB operē galvenokārt ar reāliem skaitļiem, tad simboliskajos aprēķinos DP loma ir mazāka. Neskatoties uz to MATLAB sastāvā ieiet simboliskā matemātiskā pakete (ToolBox) ar kuru var atrast analitiskos atrisinājumus, integrēt, diferencēt un veidot dažādu izteiksmu pārveidojumus. Šajā paketē ir datorprogrammas MAPLE kodols.

Simboliskie mainīgie un funkcijas ir no “ sym object “ klases, pretēji skaitļiem, kuri ir no “ double array” klases. Simbolisko objektu rada ar funkciju “syms”, piem., komanda >> syms x a b veido 3 simboliskos mainīgos “ x a b”. Aritmētiskās darbības tiek izpildītas kā parasti, piem.,

>> f =(sin(x) +a)^2* (cos(x) +b)^2/ sqrt(abs(a +b))izdod to pašu izteiksmi vienā rindā. Ja izteiksmi vajag izdod uzskatāmākā formā (kā daļu), lieto komandu logā funkciju “pretty(f)”. Simbolisku funkciju var radīt bez “syms”, ja ieejas argumentus ievieto apostrofos, piem.,

>> z = sym(‘c/(d+1)’) => z = c/(d+1)>> pretty(z) c

------ d+1

Funkciju “sym” var lietot simbolisko mainīgo definēšanai, piem., komanda “syms a, b, c” ir ekvivalenta komandu virknei “ a= sym(‘a’); b= sym(‘b‘); c = sym(‘c‘)”.

Simboliskie mainīgie var būt matricu un vektoru elementi. Matricas rindas elementi tiek ievadīti ar komatiem vai tukšām vietām, bet kolonas elementi ar semikolu (kā parasti). Rezultātā veidojas simboliskie vektori un matricas, kurām var pielietot parastās operācijas, piem.

>> syms a b c d e f g h ; A = [a b; c d]; B = [e, f, g, h];>> C = A*B C=a*e +b*g a*f + b*h

c*e +d*g c*f + d*hFunkcija “sym” realizē skaitļu pārvaidošanu par simboliskajiem, piem.,

>>A = [ 1.3 -2.1 4.9 ; 6.9 3.7 8.5 ]; B = sym(A)

50

B = 13/10 -21/10 49/ 10 69/10 37/10 17/2Pārveidojot simboliskos mainīgos rezultātā veidojas racionālas daļas, piem.

>>c = [ 3.2; 0.4; -2.1); d = sym(c); e = B*d e = -697/100 571/100Lietojot racionālas daļas, simboliskie aprēķini ir precīzi bez noapaļošanas kļūdām. Lai izskaitļotu simboliskās izteiksmes lieto funkciju “ vpa”, piem.,

>> c = sym(‘sqrt(2)’); cn = vpa (c) cn = 1.41421356237309504…pēc noklusēšanas tiek izdoti 32 cipari; var izdot arī vairāk vai mazāk ciparu,ja lieto komandu “ cn = vpa( c, N)”, kur “N “ ir ciparu skaits;

Vispārīgāk var lietot operatoru “digits(N)”, kura nostiprina ciparu skaitu visa seansa laikā. Lai pārveidotu simboliskos mainīgos skaitļos ar dubultprecizitāti lieto funkciju “ double”, piem.,

>> cnun = double(cn) cnun = 1.41421356237310

Operācijās ar polinomiem realizē 4 funkcijas : “collect” (izskaitļo polinoma koefficientus pie pakāpēm), “expand”( izvērš polinomu pēc tā pakāpēm), “horner” (lieto Hornera shēmu), “ factor” (sadala polinomu reizinātajos).

Lai izteiksmes vienkāršotu lieto funkcijas “simple” un “simplify”. Ar funkciju “subs” ar 3 ieejas argumentiem ( simboliskās funkcijas vārds, mainīgais, kas jāmaina un izteiksme, kas jāliek mainīgā vietā) var realizēt transformāciju.

Piemēri:1) lietojot funkciju “collect” iegūstam:

>> p = sym(‘(x+a)^3 + (x-a)^2 – a*x +x –3); pc = collect(p);>> pretty (pc)

izdod polinomu sakārtotu pēc mainīgā “x” pakāpēm (pēc noklusēšanas), ja grib polinomu veidot pēc masinīgā “a” pakāpēm, tad jālieto komanda“ >> pca = collect(p, ‘a’); pretty(pca)2) lietojot funkciju “ expand” iegūstam:

>>pe = expand(p); pretty(pe)izdod izvērstu polinomu pēc mainīgo “x” un “a”pakāpēm; par “expand” argumentu var būt ne tikai polinomi, bet arī simboliskas izteiksmes, kas satur trigonometriskas, eksponenciālas un logaritmiskas funkcijas, piem.,

>> f = sym(‘sin(arccos(3*x))+exp(2*log(x))’); fe = expand(f);>>pretty(fe) (1 – 9x ^2)^1/2 +x^2

3) lietojot funkciju “ factor” iegūstam:>>p= sym(‘x^5+13*x^4+215/4*x^3+275/4*x^2-27/2*x-18’);>>pf = factor(p); pretty(pf) ¼(2x+1) (2x-1) (x+6) (x+4) (x+3)

izdod polinomu sadalītu reizinātajos; ar “ factor” var arī skaitli sadalīt pirmskaitļu reizinājumā, piem.

>>syms a; a= sym (‘230010’); s= factor(a); s = (2)*(3)*(5)*(11)*(17)*(41)

vai>>s1 = factor(230010) s1 = 2 3 5 11 17 41

iegūst analogu rezultātu, bet “s” ir simboliskais mainīgais un “s1” reāls,4) lietojot funkciju “ subs” iegūstam:

>>f = sym(‘exp(x^3 + x^2 + x+ 5)’); q = subs(f, ‘x’, 1.1) q=1.8977e+004

51

iegūstam skaitlisku vērtību, bet var iegūt arī simbolisku, ja lieto komandu>> q = subs(f, ‘x ‘, ‘1.1’) q = exp(1.1^3+2*1.1^2+1.1+5)

bet ar “vpa”>> vpa(q,33) ans = 18977.3226391838022895228444721396 Ar ToolBox Symbolic Math. var risināt lineārus un nelineārus vienādojumus,

atrast robežas un atvasinājumus, aprēķināt noteiktos un nenoteiktos integrāļus, meklēt analitiskos atrisinājumus diferenciālvienādojumiem un to sistēmām.

Risinot lineārās algebras uzdevumus var lietot visus vektoru un matricu operācijas, piem.,

>> A=sym(‘[a b c; d e f; g h j]’); D=det(A) D = j*a*e - a*f*h - j*d*b + d*c*h + g*b*f - g*c*eAlgebriskie vienādojumi līdz 4. kārtai tiek risināti precīzi ar “solve”, piem.,

>> syms x ; f=sym(‘x^3-x^2-5*x+1’); r=solve(f,x); pretty(r)izdod sarežģītu formulu, kas satur 3 polinoma saknes simboliskā masīvā r(varēja lietot arī tieši komandu “ pretty(solve(f,x)) “),pārbaudot sakņu pareizību, izskaitļosim funkcijas “f” vērtību no pirmās saknes (lieto “simplify” rezultātu vienkārsošanai)

>>simplify(subs(f, ‘x’, r(1)) ans= 0Augstākas kārtas algebriskie vienādojumi un trancendenti vienādojumi tiek risināti tuvināti. Analogi tiek risinātas lineāras un nelineāras vienādojumu sistēmas, piem., divu vienādojumu f1(x1,x2)=0, f2(x1,x2)=0 sistēma, lietojot operatorus “ >>syms x1 x2 ; [x1,x2]=solve(‘f1(x1,x2)=0’, ‘f2(x1,x2)=0’)”.

Izvirzot funkcijas Teilora rindā, lieto operatoru “ taylor”, piem.,>> f=sym(‘1/(1+x)’); tf=taylor(f); pretty(tf)iegūst Teilora rindas nogriezni ar 6 saskaitāmiem, ja funkcija “f” ir akarīga no parametra “p”, tad var lietot komandu “tf= taylor(f,n,x)”, kur n ir izvirzījuma locekļu skaits.

Summējot simboliskas izteiksmes, lieto funkciju “symsum(s(k),k,k0,kn)”, kur “s(k)” --- summējamā izteiksme, “k” ---indeks, “k0” ---indeka apakšējā robeža, “kn” ---augšējā robeža, piem.,

>> syms k; s= symsum(‘(-1)^k/k^2’, k, 1, Inf) s=-1/12*pi^2var arī summēt izteiksmes atkarīgas no parametra, piem.,

>>syms k x ; s=symsum((-1)^(k)*x^(2*k+1)/ sym(‘(2*k+1)!’),k,0,Inf) s = sin(x) (faktoriāla dēļ jālieto “sym”)

Risinot matemātiskās analīzes uzdevumus, lieto operatorus “limit (izt, main, punkts)”,“diff(izt, main, kārta)”,“int(f,x)” un “int(f,x,a,b)”, kur “ izt” ---simboliskā izteiksme, “ main”--- mainīgais, funkcijas “f” arguments x [a,b]. Lai aprēķinātu vienpusīgās robežas operatorā “limit” lieto ceturto argumentu ‘right’ vai ‘left’.

Piemēri:1) aprēķinot robežu izteiksmei, ja x tiecas uz bezgalību:

>>syms a x ; limit((1+1/x)^(x*a), x, Inf) ans= exp(a)

2) atvasinājumu pēc definīcijas var iegūt arī ar operatoru “limit”:>> syms h x ; L=limit((atan(x+h)-atan(x))/h,h,0); pretty(L) 1/(1+x^2)

3) aprēķinot atvasinājumu tieši ar operatoru “diff”: >>p=diff(‘atan(x)’, ‘x‘,1); pretty(p) 1/(1+x^2)

4) sastāda M-failu funkciju “tangent(fstr, X0)”, kas zīmē noteiktā punktā “X0” funkcijas “fstr “ grafikam pieskari:

52

function tangent (fstr, X0)f=sym(fstr);Y0=subs(f,’x’,X0); A=X0-1; B=X0+1;% rada segmentu graf.X=A : (B-A)/100 : B; F=subs(f, ‘x’,X); Hline = plot(X,F); set(Hline, ‘LineWidth’, 2) % izdod grafiku ar biezāku līnijuk=diff(f,x,1); K=subs(k, ‘x‘,X0); yt=sym(‘y0+k*(x-x0)’); % simb. vdj.-syt=subs(yt, ‘k’, K); yt=subs(yt, ‘x0’, X0); yt=subs(yt, ‘y0’, Y0); hold onezplot(yt,[A B]) % ievieto pieskares vienād. reālos param. un zīmē toplot(X0, Y0, ‘o’) % pieskares punkts tiek atzīmēts ar riņķigrid on hold off

5) aprēķina nenoteikto integrāli un pārbaudīsim to ar diferencēšanu: >> syms =x; f=sym(‘x^3*exp(x)’); I=int(f,x) I=x^3*exp(x)-3*x^2*exp(x)+6*x*exp(x)-6*exp(x)>> diff(I,x,1) ans = x^3*exp(x)

6) aprēķina noteikto integrāli ar operatoru “ int(f,x,a,b)”: >>syms x a b ; f=sym(‘(x^3+1)/(x-1)’); I=int(f,x,a,b)I= 1/3*b^3+1/2*b^2+b +2*log(b-1)-1/3*a^3-1/2*a^2-a-2*log(a-1)

7) divkāršo integŗāli aprēķina 2 reizes apgabalā [a,b,c, d] lietojot “int”: >>syms a b c d x y; f=sym(‘y*sin(x)’); Ix=int(f,x,a,b)Ix = -y* cos(b) + y* cos(a)>> Iy=int(Ix, y, c, d) Iy = ½*(-cos(b)+cos(a))*(d^2-c^2)

8) divu funkciju f(x)= x+sin(x), g(x)= x sin(x) segmentā [-10, 10] grafiks vienā logā ar uzrakstiem uz līknēm, ar leģendu apakšējā labajā stūrī, ar nepārtrauktām un pārtrauktām līnijām un ar sarkanām un zilām krāsām: >>x=[-10:0.01:10]; f=x+sin(x); g=x*sin(x); plot(x,f, ‘r –‘, x, g, ‘b- -‘) >> grid on, title(‘Divu funkciju grafiks’), xlabel(‘x’), ylabel(‘y‘) >> legend (‘f(x)=x+sin(x)’,‘g(x)=x sin(x)’,4), gtext(‘f(x)’),gtext(‘g(x)’)(ar peli var pēc kārtas uzvilkt uzrakstus “f(x)” un “g(x)” uz attiecīgajiem grafikiem),

9) izskaitļojot robežas:>>syms x, limit(x/sin(x),x,0) ans = 1>>limit(sqrt(x +sqrt(x +sqrt(x)))/sqrt(x+1),x,inf) ans = 1>>limit(exp(1/x),x,0,’right’) ans = inf >>limit(exp(1/x),x,0,’left’) ans = 0>>limit(exp(1/x),x,0) ans = NaN

10) atvasinot izteiksmes:>> diff( x^x, x,1) ans = x^x *(log(x) +1)

>> diff( x^x, x,2) ans = x^x*(log(x)+1)^2+x^x/x

11) zīmējot funkcijas f(x)=2x/(x*x +1) un tās 2. kārtas atvasinājuma grafiku segmentā [-2 2]:

>>f=sym(2*x/(x^2+1)); g=diff(f,x,2); ezplot(f,[-2 2]), hold on >> ezplot(g,[-2 2])

12) integrējot izteiksmes:

53

>>int(1/(1+cos(x)),x) ans = tan(1/2*x)>>int(1/(1+cos(x)),x,0,pi/2) ans = 1

13) pārbaudot Ņūtona-Leibnīca formulu:>>f=sym(sin(x)-sin(2*x)-sin(3*x)); F=int(f,x)

F=-1/16*cos(4*x) –1/8*cos(2*x) +1/24*cos(6*x)>> int(f,x,0,pi/2), subs(F,’x’, pi/2) –subs(F, ‘x’, 0) ans = 1/6, 0.1667

14) izskaitļojot summas un rindas:>> syms x k, symsum(x^k/‘k !’, k, 0, inf) ans = exp(x)>> symsum(1^k/‘k !’, k, 0, inf) ans = exp(1)>> exp(1) ans = 2.7183>> symsum(1^k/‘k !’, k, 0, 5) ans = 2.71666666…>> symsum(1^k/‘k !’, k, 0, 10) ans = 2.71828180…

15) lietojot Teilora rindu:>> syms x, taylor(cos(x)) ans = 1 -1/2*x^2 +1/24*x^4>> taylor(cos(x),4,pi/2) ans = -x +1/2*pi +1/6*(x-1/2*pi)^3-

1/120*(x-1/2*pi)

16) zīmējot Teilora rindas tuvinājumus:>> syms x, f1=taylor(sin(x),x,0,5); f2=taylor(sin(x),x,0,7);>> f3=taylor(sin(x),x,0,9), ezplot(f1), hold on, ezplot(f2),hold on>> ezplot(f3),hold on, ezplot(‘sin(x)’)

17) aprēķinot singulārus integrāļus:>> syms t x, F= int(exp(-t^2),t,0,x), int(exp(-t^2),t,0,inf)

F = ½*sqrt(pi)*erf(x) ans = ½*sqrt(pi)>> diff(F,x,1), subs(F,x,1), subs(F,x,3), subs(F,x,inf)

exp(-x^2), 0.7468, 0.8862, 0.8862

18) izvirzot pārtrauktu funkciju f(x)= 1, ja |x|</2, f(x)=0, ja |x|>/2 segmentā [-, ] Furjē rindā a0/2 + (ak cos(kx) + bk sin(kx)), kur ak=1/ f(x) cos(kx) dx, bk=1/ f(x) sin(kx) dx, lai novērotu Hibsa efektu:

>>syms x k, ak=int(cos(k*x),-pi/2,pi/2)/pi; >>bk=int(sin(k*x),-pi/2,pi/2)/pi; F1=symsum(bk*cos(k*x), k,1,5);

>> F2=symsum(bk*cos(k*x), k,1,25); ezplot(F1,[-4 4]), hold on>> ezplot(F2,[-4 4]) % (jo ak =0)

19) divu argumentu funkciju diferencēšana:>> syms x y, f = sym(sin(x + sin(y))); fx = diff(f,x,1), fy=diff(f,y,1)

fx = cos(x+sin(y)), fy =cos(x + sin(y))*cos(y)>> fxy=diff(fx,y,1), fyx = diff(fy,x,1), fxx=diff(fx,x,1), f2=diff(f,x,2)

fxy=-sin(x+sin(y))*cos(y)),fyx=-sin(x+sin(y))*cos(y)), fxx=-sin(x+sin(y)),f2= -sin(x+sin(y)

3.2 Matemātiskās analīzes elementi ar MAPLE

54

Ar MAPLE var veikt rindu matemātiskās analīzes operāciju: skaitļu virkņu, rindu un funkciju robežu aprēķināšanu, funkciju atvasināšanu un integrēšanu u.c.operācijas.

3.2.1 Skaitļu virknes, rindas un funkciju robežas ar MAPLE Skaitļu virknes {an} var veidot ar komandu seq (a(n), n=nmin..nmax),

kur naturālā argumenta funkciju a(n) definē ar operatoru a:=nizt (izt – izteiksme atkarīga no n), nmin,nmax – mazākā un lielākā vērtība argumenta n izmaiņām.

Virkņu robežas aprēķina ar komandu limit (a(n), n=infinity), piem., a:=n®1/n^2:limit (a(n), n=infinity); => 0.

Rindas konverģences pētīšanai lieto Dalambēra, Košī un integrālo kritērijus:

, , .Rindas parciālās summas aprēķina ar operatora sum (a(n), n=1..k) palīdzību.Pakete "student" satur šī operatora inerto formu Sum.

Izsaucot paketi "student" ar komandu with (student) iespējams lietot robežu aprēķināšanai arī operatoru Limit. Tad virknes robeža netiek izskaitļota, bet var viegli apskatīt visas robežu īpašības, lietojot operatoru expand:

1) Limit (c*a(n), n=infinity): "=expand(");

2) Limit (a(n)+b(n), n=infinity): "=expand (");

,3)Limit (a(n)+b(n), n=infinity): "=expand(");

, 4) Limit (a(n)^b(n), n=infinity): "=expand(");

.Funkciju f(x) robežu, kad x x0 aprēķina analogi ar operatoru limit (f(x),

x=x0), kur funkcija f(x) ir definēta ar operatoru f:=x izt.Ja funkcijas vērtība f(x) ir izskaitļojama, tad var lietot operatoru

f0:=subs (x=x0,f).Nenoteiktības gadījumos ar operatoru subs iegūst ziņojumu, ka funkcijas vērtība f(x0) nav aprēķināma un tad lieto operatoru limit (f(x), x=x0).

Vienpusīgo robežu izskaitļošanai lieto komandas limit (f(x), x=x0, right); limit (f(x), x=x0, left) .

Lietojot komandu Limit (f(x), x=x0) no paketes "student" robežvērtība netiek izskaitļota. Lai to iegūtu, jālieto operatori combine, expand, simplify vai value. Šajā paketē ir operators shangevar, ar kuru var mainīt argumentus.

Kompleksa robežas gadījumā lieto operatoru limit (f(x), x=x0, complex).

Piemēri:1) f:=x(x–4)/(sqrt (x)–2): limit (f(x), x=4); => 4,

55

plot (f, 0..5); => zīmē grafiku,2) a:=n2^(3*n)/(2*n+1)!: Limit (a(n+1)/(a(n), n=infinity): value(");=> 0 (rindakonverģē pēc Dalambera kritērija),Limit (a(n)^(1/n), n=infinity): value(");=>0 (rinda konverģē pēc Košī kritērija),3) a:=nln(n)/n^2: int (a(n), n=1..infinity): value(");=>1 (rinda konverģē pēc integrālā kritērija),4) g:=xsqrt (x^2–4*x)–x: limit (g(x), x=infinity);=> –2,5) f:=xpiecewise(x<=0, x–1, x^2): simplify(f(x)): limit (f(x), x=0,left);=>–1,limit (f(x), x=0, right); =>0,limit (f(x), x=0); => ziņo, ka robeža neeksistē,6) limit (tan(x), x=Pi/2, complex); => infinity,7) with (student): Limit (f(x)*g(x), x=x0):"=expand (");

,8) limit ((sin(5*x)–sin(3*x))/sin(x), x=0); =>2,9)limit (x^x, x=0); =>1, plot (x^x, x=0..1); => zīmē grafiku,10) e1:=(x^3+2*x–6)/(x–3): subs (x=3,e1); => error, division by zero(izdod ziņojumu par to, ka saucējs ir nulle), limit (e1,x=3); =>11,normal (e1); => x2+2,with (student): Limit (e1,x=3): value(");=> 11,

11) Sum ((1/2)^n, n=1..k); value(");

, ,Limit (",k=infinity): "=value(");

,12) ln (x)–ln (x+exp (–x)): Limit (",x=infinity ): "=value (");

,13) f:= n(1+1/n)^n: n:= 'n': sum (f(n), n=1); =>2,evalf (sum (f(n), n=10)); =>2.593742460,evalf (sum (f(n), n=100)); =>2.704813829,evalf (sum (f(n), n=1000)); => 2.716923932,limit (f(n), n=infinity); =>e (parāda kā mainās virknes an vispārīgais loceklis un, ka robeža ir e = 2.7182828183 ...),14) a:=3: q:=2: solve(a*q^n=384,n): evalf(");=>7.000000000,sum (a*q^n, n=1..7); =>762 (nosaka ģeometriskas progresijas locekļu skaitu un summu).

3.2.2 Funkciju atvasinājumi un diferencēšana ar MAPLE

56

Funkcijas f(x) atvasināšanai lieto diferencēšanas operatoru D(f), piem.D (sin) =>cos, t.i .iespējams atvasināt funkcijas simbolu (identifikatoru).Vispārīgākas operatoru formas ir D(f)(x) un diff (f(x),x).

Augstākas k–kārtas atvasinājumu izskaitļo ar operatoru diff (f(x),x$k) vai (D@@k) (f)(x).Divu argumentu funkcijas f(x,y) parciālos pirmās kārtas atvasinājumus var aprēķināt šādi: diff (f(x,y),x), diff (f(x,y),y).Operatoram diff ir atbilstošā inertā forma Diff, kad izskaitļošana nenotiek.

Ja mainīgo a definē kā konstanti ar komandu assume (a,constant), tad automātiski D(a)=0.Jāievēro, ka D[ ](f)=f, D(f+g)=D(f)+D(g), D(f*g)=D (g*f)=D(f)*g+D(g)*f,D (f@g)=D (f)@g*D(g), kur f@g ir funkciju f un g kompozīcija – salikta funkcija f(g).

Ja funkcija f(x) ir gluda, tad var tās grafika punktā (a,f(a)) izskaitļot pieskares vienādojumu y = D (f)(a)*(x–a)+f(a).

Ar operatoru convert (izt,diff,x) var pārveidot (konvertēt) diferenciālizteiksmi izt ar operatoru D(f)(x) par izteiksmi ar operatoru diff (f(x),x)).Ar komandu implicitplot (vdj,x=a..b, y=c..d), kura atrodas paketē "plots", var zīmēt līknes grafiku, kuru raksturo vienādojums vdj aizklātā formā f(x,y)=0. Diferencējot vdj abas puses pēc x un atrisinot ar operatoru solve pret atvasinājumu y' (x) var iegūt atklātu izteiksmi šim atvasinājumam, piem.,vdj:=3*x*y=x^3+y^3:subs (y=y(x),"); => ievieto vienādojumā y vietā y(x),diff (",x);

,solve(",diff(y(x),x)); => atvasinājuma y' (x) izteiksme,

,subs (y(x)=y,"): Dy:=simplify ("); => izdod galīgo atvasinājuma izteiksmi (-y+ x2)/(x-y2).

Ar paketi "student" var izsaukt komandu slope (A,B), kas aprēķina virziena koeficientu starp 2 plaknes punktiem A=[a,f(a)], B=[b,f(b)] pēc formulas (f(b)–f(a))/(b–a). Ar komandu showtangent (f(x),x0, x=a..b, y=c..d) var zīmēt pieskari funkcijas y=f(x) grafikam punktā x=x0.

Meklējot funkcijas globālo maksimumu un minimumu, izsauc paketi readlib (minimize): piemēram, minimize (cos(x),x);=> –1, maximize (cosx,x); =>1.

Lokālos ekstrēmus funkcijai f(x) atrod ar standarta funkcijas pētīšanas metodēm, lietojot operatorus diff, D, solve, fsolve, subs u.c. Pētot funkcijas vai izteiksmes izt grafikus ar operatoriem D(f)(x), diff (f(x),x) nosaka ekstrēmu punktus (f '(x)=0) (lokālos maksimumus un minimumus) un pārliekuma punktus (f "(x)=0). To var realizēt šādi:plot (izt,x); y1:= diff (izt,x): y2:= diff (y1,x):x1:= fsolve (y1=0, x, x=a..b); x2:= fsolve (y2=0, x, x=c..d):subs (x=x1,izt); subs (x=x2,izt);=> izskaitļo ekstrēmu un pārliekuma punktu koordinātes x1,x2 un izteiksmes vērtības y1,y2 šajos punktos.

57

Zinot funkcijas augstākas kārtas atvasinājumus, var veidot Teilora rindu

punkta x=x0 apkārtnē. Šajā nolūkā lieto komandu taylor (f(x), x=x0,k), kur k – rindas saskaitāmo skaits (pēc noklusēšanas k=6).

Lai atmestu atlikuma locekli 0(x–x0)k, lieto operatoru convert (",polynom).

Piemēri:1) D(ln)(x)=diff (ln(x),x); => 1/x,2) (D@@2)(f); =>(D(2))(f),3) f:=xx^2: D(f); =>2x,4) f:=(x,y)exp (x*y): diff (f(x,y),x); => y exp(xy), diff (f(x,y),y); => x exp(xy),5) D(f)(x)–diff(f(x),x); => 0,6) diff (sin(x),x); diff (cos(x),x); diff (tan (x),x);=> cos(x) –sin(x) 1+tan(x)2,7) diff (sin(x),x$3);=> – cos(x),8) f:=xx^3–8*x: diff (f(x),x); =>3x2–8,Limit ((f(x+h)–f(x))/h, h=0); Df:=value (");=>Df:=3x2–8x (aprēķina atvasinājumu pēc tā definīcijas),9) Newt:=xevalf (x–f(x)/D(f)(x); => definē iteratīvo funkciju Newt(x)=x–f(x)/f '(x) Ņūtona iterācijas procesā, aprēķinot vienādojuma f(x)=0 saknes, t.i., uzdodot sākuma tuvinājumu x=x0, aprēķina Newt(x0), Newt("), utt, kamēr rezultāts nemainās (piem., var uzdot f(x)=x3+x–2 un x0=0),10) f:=x(x–1)*x–2)*x: a:=1/5: m:=subs(x=a,diff (f(x),x)); =>m:=23/25,y–f(a)=m*(x–a); => pieskares vienādojums,with (student): showtangent (f(x), x=1/5, x:= –1..1, y= –1..1);=> zīmē funkcijas grafiku kopā ar pieskari,11) f:=x(x–1)*(x–2)*(x–3)*(x–4): D(f);=>x(x–2)(x–3)(x–4)+(x–1)(x–3)(x–4)+(x–1)(x–2)(x–4)+(x–1)(x–2)(x–3),plot ({f,D(f)}, –1..5, –5..5); =>zīmē funkcijas un atvasinājuma grafikus,12) f:=xa^x:eval (f); =>xax, D (f); => x axlna,13) taylor (sin(x),x,10); => x

,p1:=convert (",polynom); => p1:=x

,plot ({sinx,p1}, x= –5..5, y= –2..2);=> zīmē 2 grafikus, kur redzama Teilora rindas tuvinājuma precizitāte,14) y:= xexp (sin(x)): diff (y(x),x); => cos(x) esin(x) (aprēķina atvasinājumu).

3.2.3 Integrēšana, MAPLE pakete "student"Ar MAPLE var atrast nenoteikto un noteikto integrāļu simboliskās izteiksmes,

kā arī to skaitliskās vērtības. Šajā nolūkā lieto operatorus int, Int, value, changevar, subs, intparts, convert, parfrac u.c. Daļa no šiem operatoriem ir paketē "student".Nenoteikto integrāli no f(x) aprēķina ar komandu int (f(x),x), bet noteikto segmentā [a,b] ar komandu int (f(x), x=a..b). Operators int ir saīsinājums no integrate.

58

Operators Int ir operatora int inertā forma, t.i., nenotiek izskaitļošana, bet tiek fiksēts tikai integrāļa simbolisks pieraksts. Lai integrāli izskaitļotu, jālieto operators value.

Racionālu daļveida funkciju f(x) = Q(x)/R(x), kur R(x), Q(x) ir polinomi, integrēšanai var lietot izvirzījumu elementārajās parciālās daļās ar komanduconvert (f(x),parfrac,x).

Operatora int (f(x),x) integrēšanas rezultātu var pārbaudīt ar atvasināšanu, lietojot komandu diff (",x) kopā ar simplify (").

Paketē "student" iespējams integrāļus integrēt parciāli, lietot substitūcijas, izskaitļot tos tuvināti, parādot to grafiski. To realizē operatori intparts, changevar, powsubs, leftbox, rightbox, leftsun, rightsum, middlebox, midlesum, trapezoid, simpson, value u.c.

Definējot integrāli kā funkciju no augšējās robežas, piem., g:=xint (f(t),

t=a..x): var viegli pārbaudīt sakarību , lietojot operatoru combine.

Divkāršo integrāli taisnstūrī aprēķina šādi: int (f(x,y), x=a..b, y=b..c).Skaitliskai integrēšanai lieto operatoru evalf, kuru izpilda pēc operatora int vai

Int, ja zemintegrāļa funkcija f(x) nepieļauj analītisku integrēšanu. Šo komandu var lietot arī tieši: evalf (int(f(x), x=a..b)); evalf (Int(f(x), x=a..b)).

Izsaucot paketi "student" ar komandu with (student) var lietot komandas (daļa no tām zīmē arī grafikas):1) leftbox (f(x), x=a..b,n); =>integrāli sadala no kreisās puses n daļās (kreisā taisnstūra formula),2) rightbox (f(x), x=a..b,n); => integrāli sadala no labās puses n daļās (labējā taisnstūra formula),3) leftsum (f(x), x=a..b,n); => aprēķina tuvināti integrāli pēc kreisās taisnstūra formulas,4) rightsum (f(x), x=a..b,n); =>aprēķina tuvināti integrāli pēc labējās taisnstūra formulas.5) middlebox (f(x), x=a..b,n); =>integrāli sadala viduspunktos n daļās (vidējā taisnstūra formula),6) middlesum (f(x), x=a..b,n); => aprēķina integrāli tuvināti pēc vidējās taisnstūra formulas,7) trapezoid (f(x), x=a..b,n); => integrāli sadala n daļās un tuvinātā aprēķinā lieto trapecas formulu,8) simpson (f(x), x=a..b,n); => integrāļa tuvinātam aprēķinam lieto Simpsona formulu.Ar komandu evalf (Int(f(x), x=a..b,k); var aprēķināt integrāli ar precizitāti k–zīmīgie cipari. Var izveidot arī apakšprogrammas funkcijas–procedūras skaitliskai integrēšanai, piem. lietojot salikto trapeces formulu. Ja h=f(g(x)) ir salikta funkcija, ko definē ar operatoru h:=f@g: D(h)(x);=> D(f)(g(x))D(g)(x) (saliktas funkcijas atvasinājums), Int(",x)=h(x): changevar (g(x)=u,",u); => iegūstam pareizu sakarību.

Trigonometrisku funkciju integrēšanai ērti ir lietot operatoru expand (",trig).Izteiksmi izt, kura atkarīga no mainīgā x, sadala parciālās daļās ar operatoru

convert (izt,parfrac,x).Pārbaudot nenoteikto integrāli, rezultātu atvasina un vienkāršošanai lieto

komandu normal (",`expanded`).

59

Piemēri:1) int (x^3*cos(x),x); =>x3sinx+3x2cosx–6cosx–6xsins,2) int ((x^3)*sqrt (x^2–a^2), x=a..2*a); =>14/5a231/2,3) f:=1/sqrt (2*t^4–3*t^2–2): with (student): Int (f,t=sqrt(2)..2)=int (f,t=sqrt(2)..5);

(integrālis tiek aprēķināts simboliski ar speciālas eliptiskas funkcijas palīdzību),evalf (");=> 0.5993068720,4) i0:=int (x^2+1,x); => i0:=x+x^3/3, i1:=int (x^2+1, x=0..3); =>12,subs (x=3,i0) – subs (x=0,i0); => 12 (pārbauda Ņūtona–Leibnica formulu),5) with (student): Int (x*sin(x),x): intparts (",x); => lieto parciālo integrēšanas formulu (u=x, dv=sinx dx)

, value (");=> –xcos(x)+sinx,

6) A:=Int ((cos(x)+1)^3*sin(x),x): changevar (cos(x)+1=u,A,u);

,A1:=value (");=>A1:= –u4/4, A2:=subs (u=cos(x)+1,A1);

,diff (A2,x); => (cosx+1)3sinx (sākotnējā zemintegrāļa izteiksme),7) izt:=(x^2–3*x+1)/(x^3+x^2–2*x): convert (izt,parfrac,x);=> izteiksmi izt sadala parciālajās daļās, int (",x);

,8) int (sin (x/2.) – 1./x^2, x=1.5 ..3); =>0.9885700007 (laukums starp līknēm, ko veido funkciju f(x) = sin(x/2) un g(x) =1/ x2 grafiki segmentā[1.5,3]),9) int (exp (x^3), x=1..2): evalf (");=> 275.5109838,10) ssin:=xint (sin(sin(t)), t=0..x); => definē integrāli ar mainīgu augšējo robežu kā funkciju no x, evalf (ssin(1)); => 0.4306061031, plot (ssin, –3*Pi..3*Pi);=>izdod jaunās funkcijas grafiku,11) f:=xarcsin(x)^2: with (student): g:=Int (f(x),x=1/2..1): g1:=evalf (g);=> g1:= 0.4234235793,g2:=trapezoid (f(x), x=1/2..1,10): g3:=evalf (value(g2));=>g3:= 0.4330866500,g4:=simpson (f(x), x=1/2..1,10): g5:=evalf (value (g4));=> g5:= 0.4274530821,abs (g1–g3), abs (g1–g5); => 0.009663, 0.0040295 ( Simpsona formula ir precīzāka),12) f:=arcsin(x): g:=1–ln(x): plot ({f,g}, x=0..1); => zīmē funkciju grafikus,x0:=fsolve (f=g,x); =>x0:= 0.8957436147 (atrisina vienādojumu, x0 ir abu grafiku krustpunkta abscisa),tilp:=Pi*Int (g^2–f^2, x=0..x0): value (tilp): evalf (tilp);=>14.40316195 (aprēķina rotācijas figūras ap x asi, ko veido 2 līknes f(x), g(x),

60

tilpumu),13) f:=10–x^2: leftbox (f,x=1..sqrt (10),8);=>zīmē 8 taisnstūrus no kreisās puses, kas sadala attiecīgi laukumu zem funkcijas f,g1:=leftsum (f,x=1..sqrt (10),n): g2:=value (g1);

,g3:=limit (g2, n=infinity);

,expand (g3);

,evalf (g3); => 11.41518440,int (f(x), x=1..sqrt (10.)); => 11.41518440,

14) f:=4+x*y: Int (Int (f,x=0..2), y= –1..1) = int (int (f,x=0..2), y= –1..1);

(aprēķina divkāršo integrāli).15) y:= x®(2*x+8)/(18*x^2+52*x–6): convert (y(x), parfrac,x);

,int (",x);

16) y:= x–1/3*x^2–4*x+9: with (student): trapezoid (y(x), x= –13..1,20);

,evalf ("); => 217.3966667 (aprēķina tuvināti laukumu segmentā [–13,1], lietojot trapecas formulu), simpson (y(x), x= –13..1,20);

,evalf (");=>217.7777778 (aprēķina tuvināti laukumu ar Simpsona formulu),int (y(x), x= –13..1): evalf (");=> 217.7777778 (laukuma precīzā vērtība). 3.2.4 Funkciju rindas, MAPLE pakete "powseries"

61

Iepriekš jau mēs apskatījām summu un dažu skaitlisko rindu aprēķināšanas piemērus, lietojot operatoru sum. Summējot funkcijas f(x) pakāpju rindu, lieto komandu series (f(x), x=x0,x).kur x0 ir punkts, kura apkārtnē funkciju f(x) izvirza pakāpju rindā izdodot tās nogriezni formā

.Ja komandas 2.argumenta x=x0 vietā ir x, tad pakāpju rinda tiek formēta 0–punkta apkārtnē (tā ir Teilora rindas Maklorena rinda). Pēc noklusēšanas, ja 3.arguments k nav norādīts, tad tiek pieņemts, ka k=6 (ja grib mainīt aproksimācijas kārtu k, tad to var definēt arī ar operatoru Order:=k pirms operatora sum izpildīšanas).Ar operatoru convert pakāpju rindas nogriezni (polinomu) var arī pārveidot par racionālu daļu (opcija ratpoly) vai nepārtraukto ķēdes daļu (opcija confrac)Ja x0 ir infinity (bezgalība), tad tiek izdots izvirzījums pēc x negatīvām pakāpēm (asimptotiskā rinda). Ar operatoru convert (S,polynom) ir iespējams pakāpju rindu S konvertēt (pārveidot) par polinomu, atmetot atlikuma locekli 0((x–x0)k).Ar operatoru type (s,series) var pārbaudīt vai izteiksme s ir pakāpju rinda (tiek izdoti ziņojumi true vai false). Izvirzot funkciju f(x) Teilora rindā, lieto komandutaylor (f(x), x=x0,x), kura darbojas analogi komandai series (...).

Ar pakāpju rindām var veikt dažādas operācijas (aritmētiskās, kā arī diferencēšanu un integrēšanu). Piemēri:1) series (x/(1–x–x^2),x); => x+x2+2x3+3x4+5x5+0(x6),convert (",polynom); =>x+x2+2x3+3x4+5x5,2) series (x+1/x, x=1,3); => 2+(x–1)2+0(x–1)3,3) series (x^3/(x^4+4*x–5), x=infinity);

,4) taylor (sin(x), x=0,6); p:=convert (",polynom);

, ,ss:=series (sin(x), x=0,6): diff (ss,x);

,integrate (ss,x);

,solve (y=ss,x);

,convert (ss,ratpoly); => racionāla daļveida funkcija

62

,convert (ss,ratpoly,1,2); =>racionāla daļveida funkcija ar 1.pakāpes polinomu skaitītājā un 2.pakāpes – saucējā

,convert (ss,'confrac'); => nepārtrauktā vai ķēdes daļa)

.Izsaucot paketi "powseries" ar komandu with (powseries),

iespējams veikt dažādas manipulācijas un pārveidojumus ar pakāpju rindām.Apskatīsim dažas šīs paketes komandas:1) evalpow (izt) – izskaitļo izteiksmi izt kā pakāpju rindu,2) inverse (s) – izskaitļo pakāpju rindas s inverso,3) multconst (s,izt) – katru pakāpju rindas s saskaitāmo reizina ar izt,4) multiply (s1,s2) – sareizina divas pakāpju rindas,5) powadd (s1,...,sn) – saskaita pakāpju rindas s1,...,sn,6) powint (s) – veido pakāpju rindu, integrējot s,7) powdiff (s) – veido pakāpju rindas s atvasināto,8) powexp (s), powlog (s), powsin (s), powcos (s), powsqrt (s) – veido pakāpju rindas no s , pielietojot funkcijas exp, log, sin, cos, sqrt,9) quotient (s1,s2) – dala pakāpju rindu s1 ar s2,10) substract (s1,s2) – veido pakāpju rindu s1 vai s2 starpību,11) tpsform (s,main,posint) – transformē pakāpju rindu s par pakāpju rindu ar mainīgo main un kārtu posint,12) powpoly (pol,main) – veido pakāpju rindu no polinoma pol ar mainīgiem main.

Piemēri (iepriekš izpildot komandu with(powseries)):1) tpsform (powdiff (powsin(x)),x,6);

,2) s1:=powadd (powpoly (1+x^2+x,x), powlog (1+x)):tpsform (s1,x,6);

,3) s:=evalpow (tan(x)): tpsform (",x,5);

,4) s:=series (exp(–x), x=0,6): inverse (s):subs (x=s,");

63

x+0(x6) (pārbauda inverso pakāpju rindu),5) s1:=series (sin(x),x);

s1 ,

s2:=series (cos(x),x);

s2: ,

s3:=series (exp(x),x);

s3: ,powadd (s1,s2);

.

3.3 Matemātiskās analīzes elementi ar MATHEMATICA

Aprēķinot funkcijas f(x) vētību y0 punktā x0, lieto operatoru y0=f[x]/.xx0.Nenoteiksmes gadījumā lieto Limit[f[x], xx0].

Funkciju virknes veido ar Array[f,n] => {f[1], f[2],…}, NestList[f,x,n] =>{x,f[x], f[f[x]],…}, kur n ir locekļu skaits.

Vienpusīgo robežu operatori ir Limit[f[x],xx0,Direction 1] (robeža no kreisās puses vai uz priekšu), Limit[f[x],xx0,Direction -1] (robeža no labās puses vai atpakaļ).

Funkciju f(x) atvasināšanai lieto operatorus D[f,x] => fx , D[f,x1,x2,…] =>fx1,x2,…, D[f,{x,n}] =>fxxx…(n-tās kārtas atvasinājums), f’[x], f’’[x], …Atvasinājumus var definēt šādi: f’[x]: = izt vai Derivative[n][f][x]:=izt (n-tās kārtas atvasinājums). Var transformēt diferencēšanas simbolu D par citu, piem. atv=D[#,x]& , tad atv[Sqrt[x]] => ½ Sqrt[x].

Nenoteikto integrāli aprēķina ar Integrate[f[x],x], bet noteikto integrāli segmentā [a,b] aprēķina ar Integrate[f[x],{x,a,b}]. Lietojot Integrate[f[x],x],rezultātu var pārbaudīt ar D[%,x], sarežģītas izteiksmes vienkāršojot ar Simplify[%].

Divkāršo integrāli taisnstūrī aprēķina šādi: Integrate[f[x,y],{x,xa,xb},{y,ya,yb}].

Skaitliskai integrēšanai lieto operatoru NIntegrate[f[x],{x,a,b}]. Rezultātu var izdot ar jebkuru precizitāti, ja lieto N[Integrate[f[x],{x,a,b}],k], kur k ir ciparu skaits.Ja vispirms aprēķina analītiski integrāli ar mainīgo augšējo robežu, t.i., Integrate[f[x],{x,a,t}], pēc tam transformē ar %/. b , izskaitļo ar N[%], tad iegūst to pašu rezultātu kā ar NIntegrate[f[x],{x,a,b}]. Skaitliskos aprēķinos b var būt arī bezgalība (Infinity), piem. NIntegrate[Exp[-x^3],{x,0,Infinity}]=> 0.89298.

Ar simbolu :: var izvēlēties citu integrēšanas operatoru, piemēram, int::=Integrate.

Aprēķinot integrāli no parametra c, definē funkciju g[c_]: =Integrate[f[x,c],{x,a,b}], tad g[c] izskaitļo integrāli. Tomēr šāda pieeja var būt neērta, jo D[g[c],c] izdod korektu rezultātu, bet D[g[x],x] =>0. Tāpēc labāk definēt funkciju—procedūru ar lokālo mainīgo x

64

g[c_]: = Module[{x},Integrate[f[x,c],{x,a,b}]], tad D[g[x],x] izdod korektu rezultātu.Šai funkcijai var zīmēt grafiku ar Plot[g[c],{c,cmin,cmax}].

Aprēķinot simboliski galīgas summas, lieto operatoru Sum[f[i],{i,imin,imax,di}] , kur f(i) summējamā funkcija, di --- summēšanas solis, imin, imax --- summēšanas robežas, i --- summēšanas indeks(ja di=1,imin=1, tad tos var nerakstīt).Ja imin = - Infinity vai imax = Infinity, tad tiek summētas rindas,kuras aprēķina skaitliski.

Simboliskai summu aprēķināšanai var izsaukt paketi <<Algebra` SymbolicSum` un lietot komandu SymbolicSum[f[i],{i,n}].

Var aprēķināt arī vairākkārtīgas summas, piem. Sum[x^i*y^j, {i,1,3},{j,1,i}]=> xy+x2y +x3y+x2y2+x3y2+x3y3.

Reizinājuma aprēķināšanai lieto Product[f[i],{i,imin,imax,di}]. Skaitliskos aprēķinos lieto NSum, NProduct.

Rindu skaitliskai summēšanai var definēt arī funkcijas, piem.r[b_]:= NSum[(-1)^(n+1)/(1+n^2 b^2), {n,1. Infinity}]; r[10.] => 0.00813094.

Summējot pakāpju rindas, lieto operatorus Series[f[x],{x,x0,n}] vai f[x]+O[x]^(n+1) , kuri izvirza funkciju f(x) pakāpju rindā punkta x0 apkārtnē, izdalot (n+1) saskaitāmos kopā ar simbolu O[x]. Ar Normal[%] saskaitāmo O[x] var atmest.

Var meklēt izvirzījumus arī pēc x negatīvām pakāpēm, a x0=Infinity, piem.Series[Exp{1/x], {x,Ininity,2}] => 1+1/x +1/(2x2) O(1/x)3.

Pakāpju rindu var izdot ar tās koeficientu sarakstu, piem.Cos[x] +O[x]^5 => 1- x2/2 +x4/24 +O[x]5, InputForm[%] => SeriesData[x,0,{1,0-1/2,0,1/24},0,5,1]

Ar rindām var veikt dažādas operācijas: aritmētiskās, kompozīciju, inversiju, diferencēšanu u.c. Divu rindu (r1,r2) kompozīciju realizē ar r1 /.x r2. Rindas r1 inverso atrod ar operatoru InverseSeries[r1].

MATHEMATICA 5.2 jaunā versija satur arī sistēmas WORD elementus, kas atļauj rakstīt formulas dabīgā veidā (aritmētiskas izteiksmes, integrāļus utt.).

Piemēri:1) t=Sin[x] /x; t/. x0=> (nevar izskaitļot), Limit[t, x 0]=> 1,2) Limit[1/x, x0, Direction -1] => Infinity,3) h[x_]:=x^4; D[h[x],x] => 4x3, h’[x]=>4x3, h’’[x]=> 12x2,4) D[f[x]^2,x] =>2f[x] f’[x], D[f[x,y],y] =>f(0,1)[x,y],5) Integrate[x^2+1, {x,0,3}]=> 12,6) Integrate[1/x,{x,1,3}]=> -Log[3]; %//N => -1.09861,7) Integrate[1/(x^4-1),x] => izdod rezultātu; D[%,x]; Simplify[%]=>1/(-1+x4),8) Integrate[Cos[x]/(x+Sin[x]),{x,1,2}]=> neintegrē analītiski, NIntegrate[Cos[x]/(x+Sin[x]),{x,1,2}]=>0.0432618,9) f[x_]:=NIntegrate[Exp[-(u-v-x)^2] Sin[2 (u-v-x)^2], {u,0,1},{v,0,1}];=> definīcija, f[2.0] // Timing => aprēķina un izdod mašīnlaiku,10) sar=((-1)^(#+1)/N[#]^2)&/@Range[1,30]; FoldList[Plus,0,sar] =>izdod visas 30 parciālsummas, pēdējā ir 0.82193(šeit lieto operatorus Plus un FoldList),

ListPlot[%]=> zīmē parciālsummu grafiku (rindas summa ir π2/12),

11) Series[Exp[-x],{x,0,5}]; InverseSeries[%]; % /.x %%=> x+ O[x6],12) Series[1+f[t],{t,0,2}]=>1+f[0]+f’[0]t + ½ f’’[0] t2 +O[t3], Normal[%]=>1+f[0]+f’[0]t + ½ f’’[0] t2

65

13) sinseries=Series[Sin[x],{x,0,7}] =>

cosseries=Series[x Cos[x],{x,0,7}] =>

4. Algebras galveno operāciju modelēšana

Apskatīsim DP lietošanu algebras problēmu risināšanā.

4.1. Algebras operācijas ar MATLAB

MATLAB izdalās starp citām DP ar oriģinālu darbību veidu ar realiem skaitļiem, vektoriem un matricām. Šajā DP ir izveidoti speciāli algoritmi lielu lineāru algebrisku vienādojumu sistēmu ar retinātām matricām atrisināšanai.

4.1.1 MATLAB darbības ar masīviem—vektoriemVisi dati MATLAB-ā tiek uzdoti masīvu veidā (skaitļi—1 x 1 masīvs, vektori-

kolonas---n x 1 masīvs, vektori-rindas---1 x n masīvs, matricas--- m x n masīvs utt.). Masīva elementus raksta ar indekiem, kurus norāda apaļās iekavās. Ievadot

vektora-kolonas elementus, tos raksta kvadrātiekavās un atdala ar semikolonu. Vektora-rindas elementus atdala vienu no otra ar tukšumiem vai komatiem. Divu vektoru “a” un “b” skalāro un vektoriālo reizinājumus veido ar operatoriem “sum(a.*b)” un “cross(a,b)”.

Funkcija “ linspace(a, b, n)” ģenerē “n” punktus (vektoru-rindu) vienmērīgi sadalītus starp “a” un “b”, bet “linspace(a,b)” atgriež lineāru masīvu ar 100 punktiem.

Lai iegūtu viena argumenta funkcijas y=f(x) tabulu, vajag radīt vektoru-rindu x, pēc tam izskaitļot funkciju f(x) no katra vektora argumenta (elementa) un iegūtās vērtības ierakstīt vektorā-rindā y. Aprēķinot funkciju, jālieto masīvu aritmētiskās operācijas ar punktu ( “ . “) . Ja mezglu punkti tabulai ir novietoti vienmērīgi ar soli h, tad nosacīti var lietot operatoru x=[ xa:h:xb], kur xa, xb ir argumenta x sākuma un beigu vērtība (vektors-rinda tiks noformēts līdz elementam, kurš nepārsniedz xb). Ja h=1, tad to var operatorā izlaist. Lai iegūtu vektoru-kolonu, vektors-rinda ir jātransponē, lietojot operāciju “ ‘ “ (apostrofs). Matemātiskās funkcijas var lietot masīvu elementiem kā to argumentiem, iegūstot jaunus masīvus. Masīvu blokus veido ar kola zīmi “ : ”, bet to garumus ar operatoru “length”. Masīva elementus sareizina ar “prod”, summē ar “sum”,

xx36

x5120

x75040

O x 8

xx32

x524

x7720

O x 8

66

aritmētisko vidējo aprēķina ar “mean”, maksimālo un minimālo elementu atrod ar “max” un “min”, sakārto augošā secībā ar “sort” ( dilstošo secību iegūst ar “–sort”), transponē ar operāciju “ ‘ “ (apostrofs, komplekso masīvu var transponēt bez kompleksi-saistītās darbības ar operāciju “ . ‘ “).

Divus masīvu elementus atbilstoši saskaita ar operāciju “ .+ “, sareizina ar “.*“, atbilstoši kāpina ar “ . ^ “ un dala ar “. / “ ( apgriezto dalīšanu realizē ar “. \“). Pa elementiem tiek veiktas arī masīva aritmētiskās operācijas ar skaitli. Lielāko kopīgo dalītāju (operators “ gcd”) un mazāko kopīgo dalāmo (operators “lcm”) var noteikt arī vektoriem. Vektora “v” normas diskrētajā telpā L_p aprēķina ar komandu “norm(v,p)”, kura ir ekvivalenta “sum(abs(v).^p)^(1/p)” (ja p=2, tad var rakstīt “norm(v)”), ja p= , tad lieto “norm(v,inf)” (ekvivalents “max(abs(v))” un ja p=- , tad lieto “norm(v,-inf)” (ekvivalents “ min(abs(v))”).

Simboliskie mainīgie var būt matricu un vektoru elementi. Matricas rindas elementi tiek ievadīti ar komatiem vai tukšām vietām, bet kolonas elementi ar semikolu (kā parasti). Rezultātā veidojas simboliskie vektori un matricas, kurām var pielietot parastās operācijas, piem.,

>> syms a b c d e f g h ; A = [a b; c d]; B = [e, f, g, h];>> C = A*B C=a*e +b*g a*f + b*h

c*e +d*g c*f + d*hFunkcija “sym” realizē skaitļu pārvaidošanu par simboliskajiem, piem.,

>>A = [ 1.3 -2.1 4.9 ; 6.9 3.7 8.5 ]; B = sym(A) B = 13/10 -21/10 49/ 10 69/10 37/10 17/2kur B ir taisnstūra matrica.Piemēri:1) vektors-kolona “c” (garums 3) ar elementiem 8.4, 8.9,15.1 un tā normas:

>>c=[8.4; 8.9; 15.1], norm(c,1), norm(c,2), norm(c,10), norm(c,inf)c = 8.4000 8.9000 15.1000, 32.4000, 19.4366, 15.1119, 15.1000

2) vektors-rinda “c1” ar elementiem 8.4, 8.9,15.1:>> c1 =[ 8.4 8.9 15.1] c1 = 8.4000 8.9000 15.1000

3) funkcijas “sin” izskaitļošana no vektora “c1”:>> d1 = sin(c1) d1 = 0.8546 0.5010 0.5712

4) vektora elementa 0.5010 izdalīšana:>> d1(2) ans = 0.5010

5) vektora elementa “d1(2)” maiņa ar 0.8:>> d1(2) = 0.8 d1 = 0.8546 0.800 0.5712

6) vektora “d2”ar garumu 2 izdalīšana, lietojot indeku kopu “ind”:>> ind = [1 3]; d2 = d1(ind) d2 = 0.8546 0.5712

7) vektora “d2” garuma noteikšana:>> length(d2) ans = 2

8) jauna vektora veidošana no citiem: >>v1 = [1 2]; v2 = [3 4 5]; v = [v1 v2]v = 1 2 3 4 5

9) vektora bloka veidošana ar kolu “ : “ : >> v3 = v(2:4) v3 = 2 3 4

10) divu vektoru “v2” un “v3” reizināšana pa elementiem: >> u = v2 . * v3 u = 6 12 20

11) atbilstošā dalīšana pa elementiem: >> d = v2 . / v3 d = 1.5000 1.3333 1.2500

67

12) atbilstošā apgrieztā dalīšana: >> d1 = v2 .\ v3 d1 = 0.6667 0.7500 0.8000 (d .*d1 ir vienības vektors), 13) vektora “v” saskaitīšana ar skaitli 6:>> s = v + 6 s = 7 8 9 10 11 (analogi pārējās aritmētiskās operācijas),14) skaitļa 60 dalīšana ar vektoru “v”:>> s1 = 60 . / v s1 = 60 30 20 15 12 (analogi citas aritmētiskās operācijas),15) kompleksa vektora transponēšana:>> p = [2 + 3i; 1-2i; 3+2i]; p1 = p’ p1 = 2.0000 – 3.0000i 1.0000 + 2.0000i 3.0000 –2.0000i >> p2 = p . ‘ p2 = 2.0000 – 3.0000i 1.0000 + 2.0000i 3.0000 –2.0000i16) vektora elementu sareizināšana un vidējā kvadrātiskā aprēķināšana:

>> z = [3; 2; 1; 4; 6; 5]; p = prod(z) p = 720>> pm = prod(z)^(1/length(z)) pm = 2.9938

17) vidējās aritmētiskās vērtības aprēķināšana (divējādi):>> sum(z)/length(z) ans = 3.5000>> mean(z) ans = 3.5000

18) maksimumu un minimumu aprēķināšana:>> M = max(z) M = 6>> m = min(z) m = 1

19) minimālā elementa indeka noteikšana:>> [m,k] = min(z) m=1 k=3

20) elementu sakārtošana augošā secībā (bez un ar indekiem) :>> Z = sort(z’) Z = 1 2 3 4 5 6 >>[Z, ind] = sort(z’) Z = 1 2 3 4 5 6 ind = 3 2 1 4 6 5

21) divu vektoru “Z” un “z’ ” skalāro reizinājumu veidošana:>> z1 = sum(Z .* z’) z1 = 86

22) divu vektoru reizināšana:>> a = [1 2 3]; b = [4; 5; 6]; a*b ans = 32>> dot(a,b) ans = 32>> a .* b’ ans = 4 10 18>> A= b*a (matrica) 4 8 12 A= 5 10 15 6 12 18

23) lielākais kopīgais dalītājs un mazākais kopīgais dalāmais vektoriem: >> A=[2 6 9]; B=[2 3 3]; gcd(A,B) ans = 2 3 3 >> lcm(A,B) ans = 2 6 9

24) divu vektoru vektoriālais reizinājums: >>a=[6 5 3]; b=[1 7 6]; c=cross(a,b) c= 9 -33 37

25) izdodot displejā garu (x,y) tabulu, ērtāk ir lietot komandu “ >> [x’ y’] ”, kas rezultātu izdod kolonas veidā:

>> x = 0:0.05:1; y=exp(-x) .* sin(10*x); [x’ y’]

26) tabulas sastādīšana:>> x = [ 0.2 0.3 0.5 2.5] x = 0.2000 0.3000 0.5000 2.5000>> y = sin(x) .^2 ./(1+cos(x)) + exp(-x) .* log(x)y = -1.2978 -0.8473 -0.2980 1.8764

4.1.2 MATLAB darbības ar masīviem—matricāmMatricas ir 2D masīvi, ar tām var veikt aritmētiskas darbības un citas

matemātiskas operācijas: matricas formēšanu, atdalot rindiņas vienu no otras ar

68

semikolu (ievadot tās atdala ar ENTER); atsevišķu matricas A elementa i-tā rindā un j-tā kolonā izdalīšana, lietojot operatoru “A(i,j)”; matricu saskaitīšana (+), atņemšana(-), reizināšana(*), transponēšana(‘) un kāpināšana(^); matricu reizināšana (.*), dalīšana (./) un kāpināšana (.^) pa elementiem; atsevišķu matricas bloku izdalīšanu, lietojot kolu “:“; rindiņu un kolonu izmešana; matricu funkciju izskaitļošana; matricas “A” pēdas aprēķināšana “trace(A)”; determinanta aprēķināšana “det(A)”; apakšējās trīsstūra matricas kopā ar diagonāli izdalīšana “tril(A)”; augšējās trīsstūra matricas kopā ar diagonāli izdalīšana “ triu(A)”; matricas pagriešana par 90◦ “rot90(A,k)”(ja k=1, tad “rot90(A)”); trīsstūra matricas izdošana pēc Gausa izslēgšanas metodes ar galveno elementu “rref(A)” (ja šo procedūru grib izdot pa soļiem, tad lieto “rrefmovie(A)”) un citas.

Datu apstrādes funkciju lietošana matricām: operators “sum(A)” vai “sum(A,1)” veido vektoru-rindu, summējot matricas A elementus pa kolonām, “sum(A,2)” veido vektoru-kolonu, summējot matricas A elementus pa rindām, “cumsum(A)” veido jaunu matricu, summējot matricas A elementus pa kolonām un attiecīgi uzkrājot summas jaunās matricas rindiņās ( 1. rindiņa sakritīs ar matricas A 1. rindiņu), atbilstoši strādā reizināšanas operators “prod“ un sakārtošanas operators “sort“, atbilstoši “max(A)” vai “min(A)” izskaitļo vektoru-rindu, kura satur maksimālo vai minimālo elementus atbilstošās matricas A kolonās, dažādu matricas A normu izskaitļošana;1) ”max(sum(abs(A))) “maksimums no matricas elementu absolūto vērtību summām pa kolonām vai operators “ norm(A,1)”, 2) “max(sum(abs(A),2)) “vai “ q=max(sum(abs(A’))) “ maksimums nomatricas elementu absolūto vērtību summām pa rindām vai “norm(A,inf)”, 3) “sqrt(sum(sum(abs(A).^ 2)))” kvadrātsakne no visu matricas elementukvadrātu summas vai operators “norm(A,2)” (arī “norm(A)”),4) “sqrt(sum(diag(A’A)))” Frobēniusa norma vai operators “norm(A,’fro’)”,5) “s=sum(sum(abs(A)))” visu matricas elementu moduļu summa.Atbilstošie nosacītības skaitļi ir nosakāmi ar operatoru “cond(A,p)”, kur “p”var piņemt vērtības: 1, 2, inf, ‘fro’.

Speciālu matricu veidošana: taisnstūra m x n nulles matrica “A=zeros(m,n)” vai kvadratiska n x n nulles matrica “A=zeros(n)”, n x n vienības matrica “A=eye(n)”, taisnstūra m x n vienenieku matrica “A=ones(m,n)”, gadījumu skaitļu matricu “ A=rand(m,n)”(gadījuma skaitļi sadalīti starp 0 un 1) vai “A=randn(m,n)” (normālais sadalījums), matricas A diagonāles izdalīšana vektorā-kolonā“ d=diag(A)”, diagonālmatricas D formēšana no vektora-kolonas d “D=diag(d)”, augšējās blakus diagonālmatricas D1 formēšana “D1=diag(d,1)”, apakšējās blakus diagonālmatricas D2 formēšana “D2=diag(d,-1)” un citas. Var formēt dažādas testēšanas matricas lietojot komandu “[A,B,…]=gallery(‘tmat’, P1,P2,…)“, kur “tmat” ir testa matricas vārds (funkcija “gallery” satur vairāk kā 50 dažādas matricas), “P1, P2,…” ieejas parametri, “A, B,…” izejas parametri.

Skaitlisko metožu aprobācijai var veidot šādas kvadrātiskās n-kārtas matricas: Adamāra matricu “H=hadamard(n)” (sastāv no 1 un –1 ar ortogonālām kolonām), Hilberta matricu “H=hilb(n)” (slikti nosacīta ar elementiem H(i,j)=1/(i+j-1)), Paskāla matricu “pascal(n)” (simetriska pozitivi definita ar veseliem elementiem no Paskāla trijstūra), Vilkinsona matricu “wilkinson(n)” (simetriska 3-diagonālmatrica ar pa pāriem tuvām īpašvērtībām),

69

Maģiskā kvadrāta matricu “magic(n)” (veseli skaitļi no 1 līdz n*n, kurā elementu summa pa rindām, kolonnām un diagonālēm ir vienāda ar vienu un to pašu skaitli) u.c.

Datora atmiņā m x n matricas A elementi glabājas kā vektors ar garumu mn, kurā matricas elementi ir novietoti pa rindiņām viens aiz otra, t.i., ” [ A(1,1) A(1,2) . . . A(1,n) . . . A(m,1) A(m,2) . . . A(m,n) ]”. Līdz ar to matricas elementus var uzdot ar vienu indeksu, kurš ir matricas vektora elementu kārtas skaitlis.

Retinātas (ar daudz nullēm) m x n matricas var uzdot tikai ar nenulles elementiem, lietojot komandu “A = sparse(irow, jcol, nzer, m, n)”, kur “irow”, “jcol”--- rindiņu un kolonu numuru vektori, kurās atrodas nenulles elementi, “nzer”--- nenulļu elementu vektors, t.i., A(irow(k),jcol(k))=nzer(k), kur k ir kārtas numurs. MATLAB automātiski sameklē matricas elementa A(i,j) vērtību ieskaitot arī nulles. Aritmētiskās operācijas ar retinātām matricām, ko iegūst ar “sparse”, notiek tāpat kā ar parastajām matricām. Ar operatoru “full(A)” var iegūt pilno matricu ar nullēm. Ar “spy(A)” var zīmēt retinātās matricas A šablonu.

Piemēri:1) summu izskaitļošana: >> A =[1 –2 –4; 3 –6 4; 2 –2 0] ; s1 =sum(A) s1 = 6 –10 0

>> s2 = sum (A,2) izdod vektoru-kolonu s2 ar koordinātēm –5 1 0 2) reizinājumu aprēķināšana:

>> p1 = prod(A) p1 = 6 -24 0 >> p2 = prod(A,2) vektors-kolona p2 ar koordinātēm 8 –72 03) minimālo un maksimālo vērtību aprēķināšana:

>> mx = max(A) mx = 3 -2 4>> mn = min (A) mn = 1 -6 -4

4) analogi ar izdalītiem indekiem: >>[mx,k] = max(A) mx = 3 -2 4 k = 2 1 2>>[mn,n] = min (A) mn = 1 -6 -4 n = 1 2 1

5) matricas A otrās rindas izdalīšana: >> v1= A(2 , :) v1 = 3 -6 4

6) otrās kolonas izdalīšana:>> v2 =A(: ,2) v2 = -2 -6 -2

7) no matricas A 2.kārtas matricas A1 (bloka), sākot no 2. rindas un kolonas izdalīšana:

>> A1 = A(2:3,2:3) A1 = -6 4 -2 0

8) 7.kārtas 3-diagonālmatricas M, kur galvenā diagonālē atrodas skaitļi 2, bet blakus diagonālēs skaitļi 1 ievadīšana:

>> M =2*eye(7)+diag(ones(1,6),1)+diag(ones(1,6),-1)8) iepriekšējās matricas M vizualizēšana, izdodot nenulles elementu skaitu:

>> spy(M) % izdod kvadrātu ar punktiem 9) 2.kārtas matricas iegūšana, aprēķinot matricu funkciju eksponenti

>>B=expm(A1) B= -0.0987 0.2340 -0.1170 0.2524

10) 4.kārtas maģiskās matricas veidošana un operatoru “sum” un “cumsum” lietošana:

>> A=magic(4) A = 16 2 3 13 5 11 10 8 9 7 6 12 4 14 15 1

70

>> B=sum(A) B = 34 34 34 34 >> C= cumsum(A) C = 16 2 3 13 21 13 13 21 30 20 19 33

34 34 34 34

4.1.3 Lineārā algebra ar MATLABMATLAB-ā ir plašas iespējas lineārās algebras uzdevumu risināšanā:

izskaitļot matricu un vektoru normas, determinantu (operators “det”), rangu (“rank”), nosacītības skaitli (“cond”), inversās matricas (“inv”) un pseidoinversās matricas (“pinv”), risināt lineāru vienādojumu sistēmas, reducēt matricas trīsstūra formā, lietojot Gausa izslēgšanas metodi (operatori “rref” un “rrefmovie”), lietot simetriskām matricām Hoļecka sadalījumu (“chol’), vispārīgām matricām LU un QR sadalījumus ( “lu” un “qr”), atrast matricas īpašvērtības un īpašvektorus (“eig”), izskaitļot matricas funkcijas (“sqrtm”, “expm”, “logm”, “funm”), veikt darbības ar retinātām matricām.

Piemēri:1) lineāras vienādojumu sistēmas Ax=b risina ar komandu “ x = A\b”, kur b ir labās

puses vektors-kolonna, A--- matrica, x--- nezināmais vektors: >> A = [2 3 3; 4 2 3; 6 5 6]; b = [8; 7; 7]; x = A\bizdod nepareizu rezultātu x=1.0e+016* (0.9007 1.8014 -2.4019), jo >> det(A) ans = 0 >> cond(A) ans = 2.7526e+016

2) var risināt arī vienādojumus ar taisnstūra matricu, kad vienādojumu skaits ir lielāks par nezināmo skaitu, piem. veidojot empirisku formulu y = a exp(-t) + bt (a,b nezināmie parametri) ar 6 mērījumiem (ti, yi) sastādam divus M-failus:

funkcijas “form” function y = form(t, a, b) y = a.*exp(-t) + b .*t; un programmas “fit” t = [0; 0.1; 0.2; 0.3; 0.4; 0.5]; y = [4.25; 3.95; 3.64; 3.41; 3.21; 3.04]; A = [exp(-t) t]; x = A\y; a = x(1) b = x(2) T = [0:0.01:0.5]; F:=form(T, a, b); plot(t, y, ‘s’, T, F)

tad izpildot komandu logā komandu “fit”iegūst ne tikai grafiku ar punktiem, bet arī vērtības a = 4.2478, b = 0.9070 (jo M-failā “fit” operatoru “a=x(1)” un “b=x(2)” beigās nav semikola),

3) izskaitļojot pseidoinverso matricu, iegūstam:>> A = [1 2; 3 4; 5 6;]; P = pinv(a); P*A ans = 2. kārtas vienības matrica,

4) atrodam matricas “A” īpašvērtību vektoru-kolonnu “lamb” >> A = [2 3; 3 5]; lamb = eig(A) lamb = 0.1459

71

6.8541izskaitļojam arī īpašvektorus, novietotus matricas “U” kolonās un arī īpašvērtības diagonālmatricā “Lamb”

>> [U, Lamb] =eig(A); u1 = U(: ,1) u1 = 1. īpšvektors-kolona>> Lamb Lamb = 0.1459 0

0 6.8541

5) aprēķinot matricu-funkciju, var kāpināt matricu “A” jebkurā pakāpē, piem., kāpinot kvadrātā

>> B = A^2 B= 13 2121 34

var veidot jebkuru matricu-funkciju bez iebūvētām “ sqrtm”, “ expm”, “logm” lietojot komandu “B=funm( A, ‘mf’)”, kur “mf” ir matricas funkcijas atbilstošais M-fails, piem.,

function B =matrf(A) B = exp(A) .* sin(A); tad >> B = funm(A, ‘matrf’) B = 141.6829 228.9756

228.9756 370.6585(elementārās funkcijas vārdu var rakstīt tieši “mf” vietā, piem., “B=funm(A, ‘sin’)”, izskaitļojot sin(A), tomēr ātrāk var veikt aprēķinus ar “expm(A)” nekā exp(A)),

6) veidojot LU-sadalījumu apskatīsim 3. kārtas matricu>> A=[3,5,4; 12,7,5; 34,65,23]; [L,U] = lu(A)

L = 0.0882 0.0461 1.0000 U = 34.0000 65.0000 23.0000 0.3529 1.0000 0 0 -15.9412 -3.1176 1.0000 0 0 0 0 2.1144 >> L*U (iegūstam izejas matricu).

7) lietosim Krāmera formulas lineāras algebriskas sistēmas Ax=b risināšanai, kur A ir 4.kārtasmatrica, b---4.kārtas vektors-kolona:

>>A=[1 2 3 4 ; -1 2 –3 4; 0 1 -1 1; 1 1 1 1]; b=[30 10 3 10]; >> A1=[b A(: , 2:4)]; d =det(A), x1= det(A1)/d d=-4, x1=1 >>A2=[A(: , 1) b A(: , 3:4)] ; x2=det(A2)/d x2=2 >> A3=[A(: , 1:2) b A(: , 4)] ; x3=det(A3)/d x3=3 >>A4=[A(: , 1:3) b ] ; x4=det(A4)/d x4=4pārbaudīsim šo atrisinājumu ar 3 metodēm: >> A\b, inv(A)*b, linsolve(A,b) ans = (vektors kolona [1; 2; 3; 4]).

8) lietosim Gausa izslēgšanas metodi ar daļēju galvenā elementa izvēli, izveidojot paplašināto matricu AA: >> AA=[A b]; C= rref(AA), C(: , 5) %AA---paplašinātā matrica C (4 x 5 matrica ar 4 x 4 vienības un atrisinājumu 5.kolonā), ans =(vektors kolona [1; 2; 3; 4]), >> rrefmovie(AA) ans = (izdod C, izpildot pa soļiem Gausa izslēgšanu pēc kaut kāda klaviatūras taustiņa nospiešanas)

72

9) izvirzīsim matricas A determinantu pēc 1. rindiņas elementiem: >> M1=A(2:4,2:4); M2=[A(2:4,1) A(2:4, 3:4)]; M3=[A(2:4,1:2) A(2:4,4)]; >> M4=A(2:4,1:3); >>d=A(1,1)*det(M1)-A(1,2)*det(M2)+A(1,3)*det(M3) - A(1,4)*det(M4) => d=-410) aprēķinam matricas A normas, nosacitības skaitli( ar 2 cipariem): >> digits(2);norm(A), norm(A,2) ans = 6.6 , 6.6 ( rezultāti sakrīt, aprēķina “max(svd(A))”, kur “svd(A)” ir singulāro skaitļu vektors), >> norm (A,1), norm(A,inf) ans = 10., 10. (lielākā kolonu summa “max(sum(abs((A))))” un lielākā rindiņu summa “max(sum(abs((A’))))”) >> norm(A,’fro’) ans = 8.2 (Frobēniusa norma “sqrt(sum(diag(A’*A)))”) >> cond(A), norm(A)*norm(inv(A)) => 46. (rezultāti sakrīt)

11) veidojam matricas A spektru, LU un QR izvirzījumus: >> [L,U[=lu(A), L*U ans = (L---apakšējā trīstūra matrica pa diagonāli 1, U---aukšējā trīstūra matrica ar diagonāles elementiem), A (izejas matrica), >>[Q, R]= qr(A), inv(Q), Q*R ans = (Q---ortogonāla matrica, R--- aukšējā trīstūra matrica ar diagonāles elementiem), Q’ (transponētā matrica), A ( izejas matrica), >>[U,D]=eig(A); vpa(U), vpa(D), U*D*inv(U) ans =( matricas U kolonās ir īpašvektori, bet diagonālmatricā D īpašvērtības, operators “vpa” pārvērš parastos daļskaitļus decimālajos) 3.9, -1.2, .14 +. 92i, .14 -. 92i (īpašvērtības), A (izejas matrica), >>vpa(svd(A)) ans = 6.6, 4.7, .89, .14 (singulārie skaitļi) >>[U, S, V] = svd(A); U*S*V’, vpa(S) ans = (U,V--- ortogonālās matricas, S--- diagonālmatrica ar singulāriem skaitļiem), A(izejas matrica), tie paši singulārie skaitļi;

12) risinām lineāru algebrisku vienādojomu sistēmu formā x=Bx+b ar vienkāršo iterācijas metodi (x0--- sākuma vektors-kolona): >>B=[0 0.1 –0.2; 0.5 0 0.3; 0.1 0.4 0]; b=[1; 0; 1];x0=[0;0;0];x=x0; >> x= B*x +b (ar ENTER un taustiņiem iegūstam katras iterācijas vērtības, redzam, ka iterācijas metode konverģē un pēc 10 iterācijām: x= (0.800, 0.823, 1.409)---vektors-kolona ar 3 pareiziem cipariem (konverģences pietiekamie nosacījumi ir spēkā, jo norm(B)=0.601 );

13) risinām lineāru algebrisku vienādojomu sistēmu ar 4 x 3 taisnstūru matricu Ax=b, lietojot mazāko kvadrātu metodi vai Gausa transformāciju (b--- 4 x 1 vektors-kolona): >> A=[1 2 3; 1 2 4; 2 5 7; 2 4 6]; b=[3; 3; 7; 6]; x= A’*A\ A’*b=> x= [1; 1; 0] (atrisinājums, kuru var iegūt arī ar Gausa izslēgšanas metodi, lietojot komandu “rref([A b])”, jo vienādojumu sistēma ir saderīga) >> r = abs(A*x – b) r = 1e-014*[0.1776; 0.1776; 0.1776; 0.3553].

Ja vienādojumu sistēma nav saderīga ar labo pusi, tad nesaite “r” ir daudzlielāka, piem. >> b1= [3; 3; 7; 7]; x1=A’*A\A’*b1 x1 = [3.4; 0.6; -0.4] >> r1 = abs(A*x1- b1) r1 = [0.4; 0; 0; 0.2]

73

>> abs(A’*A* x1 – A’* b1) ans = 1e-013*[0.2842; 0.5684; 0.8523]

4.2 Algebras operācijas ar MAPLE

Ar MAPLE var veikt plašus simboliskus pārveidojumus un izskaitļojumus gan veselo, racionālo, reālo un komplekso skaitļu laukā, gan darbībās ar polinomiem un izteiksmēm. Ar šo DP var atrisināt nelineārus vienādojumus un vienādojumu sistēmas. Risinot linārās algebras problēmas, efektīvi var izmantot paketi „linalg” un jaunajā versijā MAPLE-10 paketi „LinearAlgebra”.

4.2.1 MAPLE darbības ar veseliem skaitļiemDažas darbības ar skaitļiem jau tika apskatītas 1. nodaļā. Šeit apskatīsim

raksturīgākus piemērus.Pirmo n naturālo skaitļu virkni {k}, k=1,…,n var uzdot tieši, piem.,

N:=[1,2,3,4] vai ar operatoru seq, piem.n:=12: N:=[seq(k, k=1..n)];=> N:= [1,2,3,4,5,6,7,8,9,10,11,12], N[2]; => 2 (izdod virknes 2. elementu).

Varam arī definēt funkciju f (k) no naturāla argumenta k, piem.f:=kk^2: f(10); =>100.

Iespējams arī veidot vektoru a ar naturālo skaitļu koordinātēm, piem.a:=vector(5,if(i)); =>a:=[1,4,9,16,25], a[3]; => 9 (izdod vektora 3. koordināti).

Vektora a koordinātes var izdot uz ekrāna arī ar operatoru print, piem. print (a); =>[1,4,9,16,25].

Naturāla argumenta k funkcijas f(k) virkni var uzdot šādi:seq (f(k), k=kmin..kmax), kur kmin,kmax ir argumenta k sākuma un beigu vērtības, piem., f:=k2*k+1: seq (f(k), k=1..4); =>3,5,7,9.

Dolāra zīmi ( $ ) arī var lietot mainīgo vērtību atkārtošanai, piem.i^2 $ i=1..5; =>1,4,9,16,25.

Ar datorprogrammas iebūvēto standarta funkciju palīdzību:1) ifactor (n) izskaitļo naturāla skaitļa n reizinātājus–pirmskaitļus,2) iquo (n1,n2) veselo daļu no dalījuma n1/n2,3) irem (n1,n2) dalījuma n1/n2 atlikumu,4) igcd (n1,n2,...) skaitļu n1,n2,... lielāko kopīgo dalītāju,5) ilcm (n1,n2,...) skaitļu n1,n2,... mazāko kopīgo dalāmo,

6) iroot (n1,n) tuvāko naturālo skaitli saknei ,

7) isqrt (n) – tuvāko naturālo skaitli saknei , 8) ithprime (n) – n–to pirmskaitli (sākot no 2),9) nextprime (n) – mazāko pirmskaitli, kurš ir lielāks par n,10) readlib (ifactors): ifactors (n) – skaitļa n elementāros reizinātājus–pirmskaitļus ar to pakāpēm,11) readlib (issqr): issqr (n) pārbauda vai n ir kāda skaitļa kvadrāts (izdod true) vai ne (izdod false),12) isprime (n) nosauc vai skaitlis n ir pirmskaitlis,13) prevprime (n) izskaitļo lielāko pirmskaitli, kas nepārsniedz skaitli n,14) type (n,prime) pārbauda vai skaitlis n ir pirmskaitlis.

Izsaucot paketi "numtheory" ar komandu with (numtheory) ir iespēja veikt vēl šādas operācijas ar naturāliem skaitļiem (pārējās sk. "helpā"):

74

1) bigomega (n) izskaitļo pirmreizinātāju skaitu ar ko dalās veselais skaitlis n,2) divisors (n) – skaitļa n dalītājus,3) factorset (n) –skaitļa n pirmreizinātājus,4) M(n) vai mersenne (n) pārbauda vai 2n–1 ir pirmskaitlis, ja ir, tad to izdod,5) phi (n) izdod pirmskaitļu skaitu, kuri nepārsniedz skaitli n, 6) sigma (n) izskaitļo visu skaitļa n dalītāju summu,7) tau (n) izskaitļo skaitļa n dalītāju skaitu,8) mcombine (n1,m1,n2,m2) izskaitļo tādu naturālu skaitli no, kuram ir spēkā sakarības n0=m1 mod n1 un n0=m2 mod n2,

9) fermat (n) izskaitļo n–to Fermā skaitli ,Izsaucot paketi "combinat" var ar komandu fibonacci(k) izskaitļot k–to

Fibonači skaitli, kuram ir spēkā rekurences sakarība F (k)=F (k–1)+F (k–2), k³2,F (0)=0, F (1)=1.

Vienādojumus veselos skaitļos var risināt ar MAPLE komandām:1) isolve (vdj) – atrod vienādojuma vai vienādojumu sistēmas vdj ar veseliem koeficientiem visus veselos atrisinājumus,2) msolve (vdj,m) – izskaitļo vienādojumam vai vienādojumu sistēmai vdj veselos atrisinājumus pēc moduļa m,3) rsolve (vdj,main) – atrod rekurenču sakarības (diferenču vienādojumu) vdj atrisinājumus pēc mainīgajiem main.

Vienādojumu sistēmas katru vienādojumu atdala ar komatu un sistēmu ieslēdz figūriekavās.

Ar operatoru solve (vdj,main) arī var iegūt atrisinājumu veselos skaitļos, ja tāds ir, piem. solve ({x^2+y^2=0, x+y=1}, {x,y});=>{y=1, x=0}, {y=1, x=0}, {y=0, x=1}, {y=0, x=1} (atrisinājumi atkārtojas).

Ar vienādojumiem var veikt aritmētiskas darbības (pārveidojumus), piem.8*x–16=0: "+(16=16); =>8x=16, "/3; => x=2 (šeit " ir iepriekšējā rezultāta izmantošanas zīme).

Faktoriālu no naturāla skaitļa n izskaitļo ar operatoriem n!. Bezgalību apzīmē ar infinity. Ar operatoriem sum, product var atrast naturālo skaitļu virkņu summas vai reizinājumus, piem. sum (k, k=1..n): simplify (");

,product (k^2, k=1..4); =>576.

Ar operatoru simplify (izt) , savelkot līdzīgos locekļus, vienkāršo izteiksmi izt, reizinātājos sadala ar factor (izt), kopīgo reizinātāju (daļā) saīsina ar normal (izt), bet norādīto mainīgo main iznes aiz iekavām ar collect (izt,main).

Ar operatoru length (n) var uzzināt naturālā skaitļa n ciparu skaitu (garumu), piem. n:=4^(4^4): length (n); => 155.

Piemēri:1) fermat (3); =>257,2) X:=[seq (ithprime(i), i=1..6)]; =>X:= [2,3,5,7,11,13] (izdod pirmos 6 pirmskaitļus),3) with (combinat, fibonacci): seq (fibonacci(i), i=0..10);=>0,1,1,2,3,5,8,13,21,34,55,4) isolve (2*x+3*y=7); =>{x=2–3_N1, 1+2_N1}, kur _N1 patvaļīgs naturāls skaitlis,5) msolve ({2*x–3*y=5, x+y=–3},6); =>{y=5, x=4},

75

6) rsolve ({y(n)=n*y(n–1), y(0)=1},y); => n!,7) rsolve ({f(n)= –3*f(n–1)–2*f(n–2), f(1..2)=1}, f(n)); =>{f(n)= –3(–1)n+(–2)n},8) solve (sqrt(x^2)=2); =>{–2,2},9) solve (a/x=c, {x}); => {x=a/c},10) sum (k^2, k=1..n): simplify ("): factor (");=>n(n+1)(2n+1)/6,11) igcd (24, 150); => 6,12) nextprime (1000); => 1009,13) ifactors (10!); => [1, [[2,8], [3,4], [5,2], [7,1]]],14) prevprime (1000); =>997,15) with (numtheory): divisors (2001);=> {1,3,23,29,69,87,667,2001},16) sum (3*j^2+1, j=4..7); =>382.

4.2.2 Parastie daļskaitļi un racionālas izteiksmes ar MAPLEDatorprogramma MAPLE galvenokārt operē ar simboliem, tajā skaitā arī ar

parastajiem daļskaitļiem, veicot to vienkāršošanu, saīsināšanu ar kopīgu reizinātāju un darbības ar tiem. Jāņem vērā, ka skaitļi 24, –10, 234/526 ir precīzi un darbības ar tiem notiek bez noapaļošanas. Līdz ar to jāievēro, ka tieši aprēķināt funkcijas ar šādiem argumentiem nav iespējams, piem., sin(234/526). Šajā gadījumā jāpārvērš veselie skaitļi un daļskaitļi par reāliem (piem., ieviešot decimālo komatu–punktu) vai lietojot operatoru evalf. Lai pārvērstu decimāldaļskaitli a parastajā, lieto operatoruconvert (a,fraction), piem. convert (1.23456, fraction); => 3858/3135.

Ar operatoru convert var arī otrādi, pārvērst parasto daļskaitli par decimālo, mainīt skaitīšanas sistēmu un veikt daudz citu operāciju.

Piemēri:1) convert (9,binary); => 1001 (skaitli 9 pārvērš binārā sistēmā),2) convert (3858/3125, decimal); => 1.234560000, evalf (3856/3125); => 1.234560000,3) convert ([1,2,3,4], `+`); =>10 (skaitļi tiek sasummēti).

Ar operatoru solve (vdj, main) var atrisināt ne tikai vienādojumus vai vienādojumu sistēmas vdj ar mainīgajiem main, bet arī nevienādības vai nevienādību sistēmas, aprakstot tās vdj vietā ar nevienādības zīmēm <, >, <=, >=. Vienādojumu un nevienādību sistēmas vdj ieslēdz figūriekavās, piem.,vdj:= {x–y–z=1, x+y–z=4, x+y+z=6}: atr:=solve (vdj, {x,y,z});

,assign ("); => piešķir mainīgajiem x,y,z skaitliskas vērtības, kuras var izmantot tālākās izteiksmēs, x+y+z; => 6,x:='x': y:='y': z:='z': =>mainīgos x,y,z "atbrīvo" no skaitliskām vērtībām un tos var izmantot kā sākumā.

Vienādojuma vdj labo pusi var veidot ar operatoru rhs (vdj), bet kreiso ar lhs (vdj).

Racionālā izteiksmē izt var izdalīt tās saucēju ar operatoru denom (izt) un skaitītāju ar numer (izt). Ar operatoru expand (izt) izteiksmi izvērš, atverot iekavas. Ar operatoru normal (izt) daļas saīsina.

Piemēri:1) solve (f=m*a, a); => f/m,

76

2) solve (a/x=c/d, x); =>ad/c,3) solve ((x–1/3)/(x+1/2)>0, x);

,4) f:=n3*(1/2)^n: sum (f(n), n=0..9); => 3069/512,sum (f(n), n=0..infinity); =>6 (tā ir bezgalīgi dilstošās ģeometriskās progresijas summa),

4.2.3 MAPLE darbības ar reāliem skaitļiem un izteiksmēmReālie skaitļi raksturojas ar peldošu komatu–punktu (.). Tos var uzdot dažādi,

piem., –0.5; =>–.5, 0.5*10^(–10); =>.5000000000 10–10, Float (314, –3); =>3.14, –3e3; =>–300.Tiklīdz skaitļa pierakstā lieto decimālpunktu, tā skaitlis tiek interpretēts kā tuvināts (pēc noklusēšanas ar 10 zīmīgiem cipariem), piem., 2345/1000 (precīzs skaitlis–daļa)

nav tas pats, kas 0.2345000000. Jāņem vērā, ka skaitļi , kā arī konstante Pi ir precīzi skaitļi un to tuvinātai aprēķināšanai jālieto (.) vai operators evalf.

MAPLE var kalpot arī kā kalkulators, ar kuru var veikt dažādas darbības ar reāliem skaitļiem un izteiksmēm. Ja vienā rindiņā uzdod vairākas komandas atdalītas ar semikolonu (;), tad rezultāti tiek izdoti uz ekrāna kolonnā viens pēc otra, piem., 0.2*5; 100.1/4; 100/4; 100/6; => 1.0 25.025 25 50/3.

Ja elementāro funkciju (ln, sin, cos,...) argumenti nav uzdoti kā reālie skaitļi, tad datorprogrammas MAPLE šīs funkcijas neizskaitļo.

Skaitļus var novietot masīvos ar operatoru array palīdzību, piem.,array (1..n) – definē 1–dimensiju masīvu (vektoru-kolonnu) ar n elementiem,array (1..n, list) – izveido 1–dimensiju masīvu, kura n elementi atrodas sarakstā list(sarakstā list elementi ir vienmēr kvadrātiekavās).

Lai vienkāršotu izteiksmes, kas satur radikālus, lieto komanduradnormal (izt), piem. radnormal (sqrt(3+sqrt(3) + (10+6*sqrt (3))^(1/3)));

.Ar operatoru op (izt) var uzzināt izteiksmes izt komandas (mainīgos), bet ar

nops(izt) to skaitu, piem., izt:=x*y*z: op(izt); =>x,y,z, nops (izt); =>3.Reālās saknes (atrisinājumus) vienādojumiem f(x)=0 atrod ar operatoru

fsolve (f(x)=0, x, a..b), kur a, b ir sakņu robežas (skat. vienādojumu atrisināšana). Ja f(x)ir polinoms, tad operators, nenorādot a,b, izdod visas reālās saknes.

Aprēķinot izteiksmes vērtības no reāliem skaitļiem, tā ir jāpārvērš par funkciju f(x), lietojot operatoru f:=unapply (izt,x), piem., izt:= x^2–x+3: f:= unapply (izt,x): f(2.); => 5.

Piemēri:1) evalf (1/2+1/3);=> 0.833333333,2) a:=n1/n^2: sum (a(n), n=1..infinity);

,sum (a(n), n=1..50): S50:=evalf ("): kl:=evalf (Pi^2/6–S50);=> 0.019801334 (kļūdas novērtējums summas atlikuma loceklim),

77

3) evalf (sqrt(2)); =>1.414213562, Digits; =>10, Digits:= 20: evalf (sqrt (2));=> 1.4142...88 ( 20 zīmīgi cipari),4) c:= [black, read, green, yellow, blue, white]: nops(c); =>6,5) y:=4*x–3: expand (y^3); =>64x3–144x2+108x–27, subs (x=t,y); =>4t–3,

6) A:=x^2+1: B:=x^2–1: expand (A*B); =>x4–1,B:= A+2; =>B:= x2+3, expand (A*B); => x4+4x2+3.

4.2.4 Kompleksie skaitļi ar MAPLEAr datorprogrammu var veikt darbības ar kompleksiem skaitļiem tāpat kā ar

reāliem, risinot vienādojumus komplekso skaitļu laukā un izskaitļot kompleksas funkcijas. Apskatot iebūvētās funkcijas ir jāatzīmē tādas kā Re(z) (reālā daļa no kompleksā skaitļa z), Im(z) (imaginārā daļa), abs(z) (kompleksā skaitļa modulis), argument(z) (kompleksā skaitļa arguments), conjugate(z) (kompleksā skaitļa saistītais), I ( imaginārā vienība i,i2= –1).

Darbības komplekso skaitļu laukā notiek automātiski, piem.,(2+3*I)*(4+5*I);=> –7+22 I, Re ("), Im ("), conjugate ("), abs ("), argument ("),

–7, 22, –7–22 I, , –arctan (22/7)+Pi,

Analogi izskaitļo arī kompleksu funkciju vērtības, piem.,

cos (I); => cosh (1), sqrt (–8); => I , sqrt ((1.0+I)^2–1.0); =>.7861513778 + 1.272019650 I.

Lai izskaitļotu simboliski kompleksas izteiksmes, lieto operatoru evalc, piem.,1/(2+p–q*I): evalc (");(atdala reālo un imagināro daļu),

Lietojot konkrētus pieņēmumus, izteiksmes var vienkāršot, piem.,assume (p>0, q>0): evalc (sqrt (p+q * I));

(pie kam mainīgie p un q būs atzīmēti ar vilnīti (~)).Ar komandu alias var nomainīt imaginārās vienības nosaukumu, piem.

alias (I=I, J=sqrt (–1)): J^2; =>–1, (tātad jaunā vienība ir J vecās I vietā),evalc (1/(x+y * J));

.Kompleksas funkcijas grafiku var izvadīt ar komandu complexplot, piem.,

with (plots): complexplot (sin (Pi/3+t * I), t= –1..1);=> zīmē kompleksu līkni (x,y) plaknē kā apgāztu parabolu.

Ar komandu fsolve (vdj, main, opc) var izskaitļot vienādojuma vdj visas saknes (arī kompleksās) attiecībā pret mainīgajiem main, ja opcija opc ir `complex`. Operators solve (vdj, main) kompleksās saknes neizdod, ja polinoma pakāpe, kas ieiet vienādojumā vdj ir lielāka par 4, bet gan izdod ziņojumu formā RootOf (pēc šī ziņojuma, lai iegūtu visas vienādojuma saknes ieskaitot kompleksās, jālieto operators allvalues (") ).

Vairāknozīmīgais funkcijai kompleksā plaknē (x=Re(z), y=Im(z)) var zīmēt grafiku, ja izsauc komandu readlib (branches).

78

Piemēri:1) solve (x^4=1,x); => 1, –1, I, –I,2) solve (x^2+x+4,x);

,3) with (plots): complexplot (cos+sin* I, –Pi..Pi); => zīmē riņķa līniju kompleksā plaknē, complexplot ([1+2* I], x=0..3, style=point);=> attēlo plaknē (x,y) punktu ar koordinātēm (1,2),complexplot ([–1+2* I, 1+2* I], x= –2..2, style=point);=> attēlo plaknē (x,y) 2 punktus ar koordinātēm (–1,2) un (1,2).

4.2.5 MAPLE darbības ar polinomiemAr MAPLE var veikt dažādas darbības ar polinomiem. Apskatīsim dažas

komandas–operatorus, ko lieto polinomu veidošanai un dažādām darbībām ar tiem:1) degree (izt) – nosaka polinoma–izteiksmes pakāpi,2)coeff (poly,main,n) – nosaka polinoma poly koeficientu pie mainīgā main n–tās pakāpes,3) coeff (poly,main) – nosaka polinoma poly ar mainīgajiem main visus koeficientus,4) convert (poly,horner,main) – pārveido polinomu poly pēc Hornera shēmas ar mainīgo main,5) convert (poly,sqrfree,main) – izdala no poly pilno kvadrātu attiecībā pret mainīgo main,6) divide (poly1,poly2,name) – pārbauda vai polinoms poly1 dalās ar poly2 (izdod true vai false un dalījumam piešķir vārdu name),7) factor (poly) – izdala poly reizinātājus,8) factors (poly) – izskaitļo polinoma visus reizinātājus,9) gcd (poly1,poly2) – izskaitļo polinomu lielāko kopīgo dalītāju,10) lcm (poly1,...,polyn) – izskaitļo polinomu mazāko kopīgo dalāmo,11) interp ([x1,...,xn], [y1,...,yn],main) – izskaitļo (n–1)–pakāpes interpolācijas polinomu ar mainīgo main, kura grafiks iet caur plaknes punktiem (x1,y1),...,(xn,yn),12) op (poly) – izdod uz ekrāna (displeja) polinoma poly iekšējo struktūru (mainīgos, koeficientus, pakāpi),13) realroot (poly,eps) – izskaitļo ar precizitāti eps intervālus, kuros atrodas polinoma poly reālās saknes,14) rem (poly1,poly2,main,name) – izskaitļo polinoma poly1 dalījuma ar poly2 ar mainīgajiem main atlikumu, piešķirot dalījumam vārdu name,15) roots (poly) – izskaitļo polinoma poly visas saknes, norādot arī to kārtu,16) split (poly,main) – veic pilnu polinoma faktorizāciju (sadalīšanu reizinātājos) attiecībā pret mainīgo main,17) readlib (sturm), sturm (poly,main,a,b) – izskaitļo reālo sakņu skaitu intervālā (a,b) ar Šturma metodi,18) readlib (sturm), sturmseq (poly,main) – izdod Šturma sistēmas funkcijas polinomam poly attiecībā pret mainīgo main,19) type (izt,izvele) – pārbauda, izdodot true vai false, vai izteiksme izt sakrīt ar izvele, kura var būt cubic (kubiskais polinoms), linear (lineārs polinoms), monomial (monoms), polynom (polinoms),quadratic (kvadrātisks polinoms), quadratic (4.pakāpes polinoms),ratpoly (racionāls polinoms),20) lcoeff (poly,main) – nosaka polinoma poly ar mainīgo main vecāko koeficientu.

79

Ar paketi "orthopoly" var apskatīt dažādus ortogonālos polinomus (Čebiševa – T,U, Lagēra – L, Ležandra – P, Ermita - H un citus).

Polinoma saknes izdod operatori solve vai fsolve. Ar operatoru fsolve iegūstam visas polinoma reālās saknes vai vienu no tām, ja ir norādīts sakņu intervāls. Pievienojot opciju "complex" ir iespējams iegūt visas saknes (arī kompleksās). Ar operatoru solve arī var iegūt visas polinoma saknes, ja tā pakāpe nepārsniedz 4. Polinomiem ar augstāku pakāpi (kas pārsniedz 4) operators solve izdod atrisinājumu šifrētā formā RootOf (izt), kuru var izvērst ar operatoru allvalues vai evalf palīdzību.

Polinomu poly var atvasināt ar operatora D(poly) palīdzību un meklēt atvasinājuma nulles (kritiskos vai ekstrēma punktus), lietojot operatoru fsolve.

Polinomu poly ar argumentu x var uzdot arī kā funkciju f(x), lietojot operatorus f:=xpoly vai f:=unapply (poly,x).

Izsaucot procedūru realroot (p,Eps) ar komandu readlib (realroot) var fiksēt polinoma p visu reālo sakņu piederošos segmentus ar precizitāti Eps, t.i., sakņu atdalīšanas segmentus, piem.,readlib (realroot): p:=x^7–2*x^6–4*x^5–x^3+x^2+6*x+4:realroot (p);=>[[0,2], [2,4], [–2,–1]],realroot (p,1/100);

(segmentus sašaurina līdz 1/100).Izsaucot procedūru sturm ar komandu readlib (sturm) var noteikt polinoma

reālo sakņu skaitu dotā segmentā, izmantojot Šturma teorēmu, piem.,readlib (sturm): sturm (p,x,–infinity, infinity); =>3 (eksistē 3 reālas saknes),sturm (p,x,0,infinity); =>2 (eksistē 2 pozitīvas saknes),sturm (p,x,2,4); => 1 (eksistē 1 sakne segmentā [2,4]).Piemēri:1) x*a–2/Pi: type (",polynom); => true,2) p:= x^3+2*x^2–5*x+6: type (p,polynom (integer)); =>true,lcoeff (p); =>1, degree (p); =>3, op (p); =>x3, 2x2, –5x, 6,3) p1:= 3*x^3–3*x^2–15*x–9: p2:= x^3–7*x–6: p3:= x^2-3*x+2: expand (p1*p2); => 3x6–36x5–6x4–3x3+123x2+153x+54,divide (p2,p3,dal); => true, dal; => x-3, gcd (p1,p2); =>x2–2x–3,convert (p1,horner);=> –9+(–15+(–3+3x)x)x,4) with (orthopoly): T(2,x); =>2x2–1 (izdod 1.veida Čebiševa polinomu),5) vpol:= 45*x^6–2*x^5–45*x^4+10*x^2–12*x+1=0: solve (vpol,x);RootOf (45_z6–2_z5–45_z4+10_z2–12_z+1),allvalues (");=> izdod visas 6 saknes,fsolve (vpol,x); =>0.08981219600, 1.029868759 (izdod visas reālās saknes),fsolve (vpol,x,1..2); =>1.029868758 (izdod 1 reālo sakni starp 1 un 2),fsolve (vpol,x,complex); => izdod visas saknes,6) vdj:= x^4–5*x^2+6*x=2: sols:= {solve (vdj,x )]: evalf (sols);=> [0.732050808, –2.732050808, 1.,1.],sols [1]; =>1, evalf(subs (x=sols[1], vdj)); =>2=2 (pārbauda vienādojumu).7) p1:= x®x^4–4*x^3–22*x^2+4*x+23: p2:= D(p1): fs:= fsolve (p2(x)=0, x=–3..7): fs [1]; fs [2]; fs [3];

80

5.113090584–2.2019117770.08882119235 (izdod polinoma 3 ekstrēmus),p1 (fs [1]); p1 (fs [2]); p1 (fs [3]);–382.9164593–26.2625223823.17898160 (aprēķina funkcijas p1 vērtības ekstremālos punktos),plot ([p1(x), p2(x)], x=–4..8, y=–400..400);=> zīmē 2 grafikus (polinoma un polinoma atvasinājuma grafikus),8) solve (a*x^2+b*x+c=0,x); (kvadrātvienādojuma atrisinājums)

9) solve (x^2–5*x<0); => nevienādības atrisinājumu {0<x<5} izdod formā RealRange (Open(0), Open(5)),10) restart: f:= xa*x^2+b*x+c: vdj:= {f(0)=1, f(2)=4, f(3)=1 }:solve (vdj); assign ("); plot (f, –5..5);=>aprēķina 2.pakāpes polinomu, kura grafiks satur 3 punktus [0,1], [2,4], [3,1],11) f:=x8*x–7: g:=x®x^2+x: (f@g) (x); =>8x2+8x–7,(g@f) (x); =>(8x–7)2+8x–7, (f@ (f@g)) (x); 64x2-64x–63(tiek veidoti polinomi ar salikto funkciju f(g(x)), g(f(x)) un f(f(g(x))) palīdzību),12) f:= x®2*x^2–6*x+7: plot (f(x), x= –4..4); with (student): cmpletesquare (f(x));=> zīmē grafiku un izdod izteiksmi

no kuras var redzēt, ka parabolas virsotne ir (3/2,3,2) un tās zari ir vērsti uz augšu,13) y:= k*x^2–3*x+2: dis:= b^2–4*a*c: a:= k: b:= –3: c:= 2: k:= solve (dis); y;=>k:=9/8, 9/8x2–3x+2 (kvadrātiskai funkcijai y=kx2–3x+2 nosaka parametru k no nosacījuma, ka kvadrātvienādojumam ir tikai 1 reāla sakne, t.i., ka diskriminants dis ir vienāds ar nulli),14) y:= x^3–4*x^2+2*x–1: p1:= x–3: divide (y,p1);=>false (polinomi nedalās savā starpā bez atlikuma),atl:= rem (y,p1,x,dal); => atl:= –4, dal; => x2–x–1, expand (dal*p1+atl);=>x3–4x2+2x–1 (dalot polinomus veido dalījumu dal un atlikumu atl, izdarot beigās pārbaudi),15) vdj1:= x1^3+b*x1^2+c*x1+d = 0: vdj2:= x2^3+b*x2^2+c*x2+d = 0:vdj3:= x3^3+b*x3^2+c*x3+d = 0: solve ({ vdj1, vdj2, vdj3 }, { b,c,d });=> {b= –x2–x1–x3, c= x1x2+x1x3+x3x2, d= –x3x1x2} (atrod polinoma koeficientus, zinot tā saknes),

4.2.6 Vienādojumi un nevienādības ar MAPLEDefinējot vienādojumu un vienādojumu sistēmu vdj lieto vienādības zīmi (=),

ar ko atdala vdj labo vlp un kreiso vkp pusi, t.i., dj:=vkp=vlp.Vienādojumu sistēmas gadījumā atsevišķos vienādojumus atdala vienu no otra

ar komatiem un visu kopu iekļauj kvadrātiekavās [...] vai figūriekavās {...}.Lineāru un nelineāru vienādojumu risināšanai lieto operatorus solve, fsolve.

Ar operatoru solve (vdj,main) vai solve (vdj,{main}) iegūst vienādojuma vdj

81

attiecībā pret mainīgajiem (nezināmajiem) main simbolisku atrisinājumu. Ja main ir aprakstīti figūriekavās, tad arī rezultāts (atrisinājums) būs formā {main=...}.

Ar operatoru solve var risināt arī nevienādības, aprakstot tās vdj ar nevienādības zīmēm <, >, <=, >=.

Polinoma poly sakņu izskaitļošanai var lietot arī komandu roots (poly) komandas solve (...) vietā.

Lai noteiktu trigonometrisko vienādojumu vispārīgo atrisinājumu, jāizsauc iebūvēts operators forget ar komandu readlib (forget). Pēc tam jālieto komandasforget (solve) un _EnvAllSolutions:=true, piem.,readlib (forget): forget (solve); _EnvAllSolutions:=true: solve (sinx=1/2x);

,kur _B1 binārs skaitlis (0 vai 1), Z1 patvaļīgs vesels skaitlis

(atrisinājums ir , ).Ir iespējams lietot operatoru fsolve (izt,x,opc) ar opcijām opc, kuras var būt:

complex – izdod visas saknes, arī kompleksās, a..b – mainīgā x izmaiņas robežas, maxsols=n – maksimālais atrisinājumu skaits (n), fulldigits – lieto peldošo komatu ar Digits precizitāti.

Noslēgumā atzīmēsim 1991.g. Holandes matemātikas olimpiādes uzdevumu: ja 3 dažādiem reāliem skaitļiem ir spēkā vienādojumi

,tad kāda vērtība ir izteiksmei a4+b4+c4 ? Risinājums ar MAPLE ir triviāls: vdj:={a+b+c=3, a^2+b^2+c^2=9, a^3+b^3+c^3=24}:simplify (a^4+b^4+c^4, vdj); => 69.Piemēri:1) vdj:={u+v+w=1, 3*u+v=3, u–2*v–w=0}: atr:=solve (vdj);

=>atr:= ,subs (atr,vdj); => {3=3, 1=1, 0=0} (veic atrisinājuma pārbaudi),subs (atr,u); => 4/5, assign (atr): u; => 4/5,2) solve (cos(x)+y=9,x); => Pi – arccos(y–9),3) fsolve (cos(x)=1, x, 6..7); => 6.283185307,4) arccos (3*x)=2*arcsin (x): solve (", x);

5) vdj:={x^2+y^2=25, y=x^2–5}: main:={x,y}: solve (vdj,main);

=>{x=0, y=–5}, {x=0, y=–5}, {x=3, y=4}, {y=4, x= –3},6) fsolve (log [3](x)+log [3](2*x)=1, {x}); => {x=1.224744871} (logaritmiskā vienādojuma log3x+log3(2x)=1 atrisinājums),7) vdj:= A=P*(1+i*n): P:= 500: i:= 0.04: n:= 2:solve (vdj, {A});

82

=> {A=540.} (aprēķina cik naudas var iegūt noguldot bankā 500 Ls uz 2 gadiem ar 4%),8) vdj:= A = P*(1+i)^n: P:= 500: i:= 0.04: n:= 2: solve (vdj, {A});=>{A=540.8000000} (aprēķina cik naudas var iegūt no 500 Ls, noguldot tos uz 2 gadiem ar 4% katru gadu),9) vdj:= A = P*(1+i)^n: P:= 500: i:= 0.04/(365): n:= 2*365: A:= 'A':solve (vdj, {A}); => {A=541.6411435} (aprēķina naudas summu, ko var iegūt, noguldot 500 Ls uz 2 gadiem ar 4% katru dienu),10) fsolve (7^x=49^4, {x}); =>{x=8.000000000} (atrisina eksponentvienādojumu 7x= 494), 11) d:=6: a:= –1: solve (a+n*d=59, {n}); =>{n=10} (aprēķina aritmētiskās progresijas locekļu skaitu n, zinot vispārīgo locekli an=59, diferenci d=6 un pirmo locekli a0= –1),12) q:= 2: a:= 3: solve (a*q^n=384,n); => ln(128)/ln(2)evalf (");=>7.000000000 (aprēķina ģeometriskās progresijas locekļu skaitu n, zinot vispārīgo locekli an=384, kvocientu q=2 un pirmo locekli a0=3).

4.2.7 Matricas, vektori un MAPLE lineārās algebras pakete "linalg"Vektorus bez operatora array (…) var veidot arī ar operatoru v:=vector

(n,if(i)), kur skaitītājs i mainās no 1 līdz n un f(i) ir attiecīgā funkcija, kas nosaka vektora elementus v[i]. Analogi operators ir matricas elementu veidošanai, t.i.,M:=matrix(n,m,(i,j)f(i,j)), kur i=1,…,n, j=1…,m, f(i,j) ir funkcija, kas nosaka matricas elementus M[i,j]. Lai izvadītu masīvus uz displeja lieto komandu eval.

Izsaucot paketi "linalg" ar komandu with(linalg) var veikt rindu darbību ar šīs paketes operatoru palīdzību:

1) addcol(M,j1,j2,izt) – veido jaunu matricu, aizstājot matricā M kolonu j2 ar kolonu, kuras elementi tiek aprēķināti pēc formulas izt*j1+j2 (j1 arī kolona),2) addrow(M,i1,i2,izt) – līdzīgi iepriekšējam operatoram rindiņa i2 tiek aizstāta ar elementiem izt*i1+i2 (i1 – rindiņa),3) angle(v1,v2) – aprēķina leņķi starp 2 vektoriem v1 un v2,4) forwardsub(M,v) – veic Gausa izslēgšanas metodes atpakaļceļu, aprēķinot vienādojumu sistēmu Mx=v, kur M ir apakšējā trijstūra matrica), v – labo pušu (pārveidoto tiešajā ceļā) vektors, x – nezināmo vektors,5) gausselim(M,a1,a2) – veic matricai M elementāros pārveidojumus pēc Gausa izslēgšanas procedūras, a1 ir aprēķinātais matricas rangs r, a2 ir aprēķinātais determinants no operatora submatrix (M,1..r,1..r),6) submatrix(M,i1..i2, j1..j1) – izveido no matricas M apakšmatricu, kura satur matricas M rindiņas ar numuriem no i1 līdz i2 un kolonas ar numuriem no j1 līdz j2,7) genmatrix([vdj1,...vdjm], [x1,...,xn]) – ģenerē (veido) matricu m x n no lineāras m vienādojumu vdj1,...,vdjm sistēmas ar nezināmajiem x1,...,xn,8) geneqns(M,[x1,...,xm],v) – ģenerē m vienādojumu sistēmu Mx=v, kur v ir labās puses vektors, x ir nezināmais vektors ar elementiem x1,...,xm, matricas M kārta ir m,

9) H:=hilbert(n) – veido speciālu kvadrātisku Hilberta matricu ar kārtu n x n, kur matricas elementi H[i,j] tiek aprēķināti pēc formulas 1/(i+j+1),10) M1:=transpose(M) – no matricas M izveido transponēto matricu, t.i.M1[i,j] = M[j,i],11) innerprod(v1,M,v2) – veido reizinājumu v1×M×v2, kur v1,v2 – ir attiecīgi vektori, bet M – matrica (veido kvadrātisko formu),

83

12) inverse(M) – aprēķina kvadrātiskas matricas M inverso (līdzīgu rezultātu iegūst ar operatoru M^(–1) vai 1/M,13) jordan(M) – izskaitļo kvadrātiskas matricas M Žordano formu,14) leastsqrs([vdj1,...,vdjm],[x1,...,xn]) – atvasina ar mazāko kvadrātu metodi m vienādojumu sistēmu vdj1,..., vdjm attiecībā pret nezināmajiem x1,...,xn (m>n),15) linsolve(M,v) – aprēķina vektoru x no lineāras algebriskas vienādojumu sistēmas Mx=v,16) linsolve(M,v,r,x) – līdzīgi iepriekšējam, izdod papildus matricas M rangu r; nezināmā vektora koordinātes ir x[i],17) matadd(M1,M2) – saskaita matricas M1 un M2,18) M:=matrix(n,m,(i,j)®f(i,j)) – veido matricu M ar izmēriem n x m, kur i – rindiņas numurs, j – kolonas numurs, f(i,j) – atbilstošā funkcionālā sakarība,19) minor(M,i,j) – veido matricas M minoru, izsviežot no tās i–to rindiņu un j–to kolonu,20) mulcol(M,j,izt) – veido jaunu matricu reizinot matricas M j–to kolonu ar izt,21) mulrow(M,i,izt) – veido jaunu matricu, reizinot matricas M i–to rindiņu ar izt,22) multiply(M1,M2) – sareizina 2 matricas M1 un M2,23) multiply(M,v) – reizina matricu M ar vektoru v,24) norm(M) – aprēķina matricas M normu, kā maksimālo vērtību no katras rindiņas elementu moduļa summas,25) M:=randmatrix (n,m) – veido matricu M ar izmēriem n x m, izmantojot pseidogadījumu skaitļu ģeneratoru,26) N:=randvector(n) – veido pseidogadījuma skaitļu vektoru ar kārtu n robežās – 99..99,27) rank(M) – izskaitļo matricas M rangu,28) row(M,i) – izdod matricas M i–to rindiņu kā vektoru,29) rowdim(M) – nosaka matricas M rindiņu skaitu,30) scalarmul(M,izt) – matricu M reizina ar skalāru izt, 31) subvector(M,i,j1..j2) – izveido no i–tās rindiņas apakšvektoru, izmantojot matricas M elementus no j1 līdz j2 kolonai,32) subvector(M,i1..i2,j) – izveido no j–tās kolonas apakšvektoru, izmantojot matricas M elementus no i1 līdz i2 rindiņas,33) swapcol(M,j1,j2) – samaina matricā M vietām j1 un j2 kolonas,34) swaprow(M,i1,i2) – samaina matricā M vietām i1 un i2 rindiņas,35) trace(M) – izskaitļo matricas M pēdu, ,36) M:=vandermonde([a1,...,an]); – izveido Vandermonda matricu ar elementiem M[i,j]=(ai)j–1,37) vectdim(v) – nosaka vektora v kārtu,38) V:=vector(n,if(i)) – veido vektoru v ar kārtu n ar elementiem v[i], kur f(i) ir atbilstošā funkcionālā sakarība,i=1,…,n,39) cond(M) – aprēķina matricas M nosacītības skaitli,40) det(M) – izskaitļo matricas M determinantu,41) M:=array(1..n, 1..n): entermatrix(M); => ievada matricas M elementus no klaviatūras: vispirms pieprasa ievadīt elementu [1,1], to atliek uz klaviatūras un ievada; pēc tam pieprasa ievadīt elementu [1,2] utt. (jāatceras, ka aiz katra elementa jāievada semikols),42) eigenvals(M) – izskaitļo kvadrātiskās matricas M īpašvērtības,43) eigenvects(M) – izskaitļo kvadrātiskas matricas M īpašvērtības un īpašvektorus,44) charpoly(M,izt) – veido kvadrātiskas matricas M raksturīgo polinomu, t.i.

84

det(izt*E–M), kur E ir vienības matrica,45) toeplitz*[a1,...an]); – izveido speciālu simetrisku matricu (Toeplica matrica) ar elementiem a1,...,an,46) map(normal,M); map(factor,M) – vienkāršo matricas M elementus, ja tie ir sarežģītas izteiksmes,47) &*( ) – apzīmē vienības matricu, kura izveidojas, piemēram, operatora evalm (A&*(1/A)) darbības rezultātā,48) map (evalf,M) – izskaitļo matricas M elementus kā decimāldaļskaitļus (ar peldošo komatu).

Darbības ar matricām un vektoriem (+, –, ^ un &* –reizinājums) var veikt arī ar operatoru evalm, piemēram, evalm (A&*v) – matricas A reizinājums ar vektoru–kolonu v, evalm (v&*A) – vektora–rindiņas v reizinājums ar matricu A,evalm (v1&*v2) – vektoru v1, v2 skalārais reizinājums, evalm (A^3) – matricu A kāpina kubā, evalm (A^(–1)) vai evalm (1/A) – aprēķina inverso matricu. Piemēri:1) A:=array ([[1,1,1], [1,2,4], [1,0,0], [1,–1,1]]): b:=array ([3,10,3,9/10]):leastsqrs (A,b);

,2) A:=matrix ([[1,2], [1,3]]): b:=vector ([1,–2]): linsolve (A,b); => [7,-3],3) C:=matrix (3,2,(i,j)i+j–1);

,4) R:=randmatrix (20,20); => veido pseidogadījumu skaitļu matricu 20 x 20,5) M:=array (1..2, 1..2): entermatrix (M);pieprasa ievadīt elementu (1,1): a;pieprasa ievadīt elementu (1,2): b;pieprasa ievadīt elementu (2,1): c;pieprasa ievadīt elementu (2,2): d; => M:=

6) v:=vector([x,y]): w=vector([p,q]): A:=matrix(2,2,[a,b,c,d]):evalm(A&*v); =>[ax+by, cx+dy] (vektors–kolona),evalm(v&*A); =>[ax+cy, xb+dy] (vektors–rindiņa),evalm(v&*w); => xp+yq,innerprod(v,A,v); => ax2+(b+c)xy+dy2,7) A:=matrix([[1,2,3], [2,1,2], [3,2,1]]): trace(A), det(A); => 3, 8,8) A:=matrix(3,3, [1,2,3,1,2,3,2,5,6]): eigenvals (A);

,9) M:=matrix(3,3, [1,–3,3,3,–5,3,6,–6,4]: e:=eigenvals(M); => e:= 4,–2,–2,v:=[eigenvects (M)]; => v:=[[–2,2, {[1,1,0], [–1,0,1] }], [4,1, {[1,1,2] } ]],v[1] [1];=>–2 (pirmā īpašvērtība), v[1] [2]; => 2 (tās kārta),v[1] [3]; => {[1,1,0], [–1,0,1]} (atbilstošie īpašvektori),v[2] [1]; => 4 (otrā īpašvērtība),v[2] [3]; {[1,1,2]} (tās īpašvektors),

85

10) v:=array([1,2,3]): H:=matrix(3,3, (i,j)1/(i+j));(izveido spec. matricu)=> H:=

H1:=inverse(H); => H1:=

,11) A:=matrix(3,3 [1,–1,4,3,2,–1,2,1,–1]): eigenvects(A);=> [1,1, [–1,4,1]], [–2,1, [–1,1,1]], [3,1, [1,2,1]] (izdod 3 vienkāršās īpašvērtības 1,–2,3 ar atbilstošiem īpašvektoriem,12) with(linalg): with(plots): matrixplot(matrix (6,6,(j,k)4+(j/3(*(k/3–1)), heights=histogram, axes=boxed);=> zīmē ilustratīvu grafiku–histogramu, kurā uz Ox ass ir atlikti matricas rindiņu numuri, bet uz Oy ass – kolonas numuri,13) toeplitz([1,2,3]): trace(");=> 3, det(" "); =>8,14) J:=JordanBlock (2,4); =>J:=

,15) m:=vector(5,i fsolve (x*tan(x)=0.45, x=(2*i–3)*Pi/2...(2*i–1)*Pi/2));=> m:= [0.6244446443, 3.278018002, 6.353890006, 9.472249464, 12.60206389] (izdod 5 pozitīvās transcendenta vienādojuma xtg(x)=0.45 saknes),

16) with(linalg): A:= matrix([[1,x,0], [x,1,x], [0,x,1]]); => A:=

,det(A);=> –2x2+1 (izskaitļo matricas A determinantu atkarībā no parametra x).

4.3. Algebras operācijas ar MATHEMATICA

Ar DP MATHEMATICA var veikt dažādas algebriskas operācijas: veikt aritmētiskus un algebriskus pārveidojumus, risināt vienādojumus un vienādojumu sistēmas.

4.3.1 Aritmētiskie n algebriskie pārveidojumi ar MATHEMATICADP var lietot aritmētisku uzdevumu risināšanai, piem.,

Expand[(Sqrt[2+Sqrt[3]]) – Sqrt[2-Sqrt[3]])^2] =>2. Ar operatoru Expand[izt] izteiksmē izt atver iekavas (tikai skaitītājā, ja izteiksme ir daļa), ar ExpandAll[izt] izvērš izteiksmi kopā ar saucēju. Ar operatoriem ExpandNumerator[izt] vai ExpandDenominator[izt] izvērš izteiksmē-daļā tikai skaitītāju vai saucēju.

86

Ja rezultāts ir sarežģīta izteiksme, kurā var savilkt līdzīgos locekļus un vienkāršot, tad lieto Simplify[izt, nos] (nosacījumu nos var arī nerakstīt), piem., Simplify[a^3+b^3+c^3-3*a*b*c, a+b+c==0] => 0, Sum[2*n/(x^2-n^2)-11/((x-(11-n)) (x+n)),{n,1,10}]; %//Simplify => 0.

Operators Collect[izt,x] savelk izteiksmē izt locekļus ar vienādām x pakāpēm, piem., Collect[x+4y+5xy,x] => 4y +x(1+5y).

Funkcija Apart[izt] sadala racionālu daļu elementārās daļās, piem., Apart[1/((3+x) (1+x)^3)] => ½ /(1+x)3 -1/4 /(1+x)2 +1/8 /(1+x) -1/8 /(3+x).

Polinomus sadala reizinātājos ar operatoru Factor[izt]. Lai izdalītu arī kompleksos reizinātājus lieto Factor[izt, GaussianIntegers True], piem., Factor[x^2+4x+8, GaussianIntegers True]=> (2-2I +x)(2+2I +x).

Lai uzzinātu polinoma poly saskaitāmo skaitu, lieto Length[poly], piem., Length[Expand[(a+b+c+d)^100]] =>176851.

Lai varētu saīsināt kopīgo reizinātāju daļas saucējā un skaitītājā lieto Cancel[izt], bet operators Together[izt] savelk izteiksmi kopā ar vienu kopīgu saucēju.

Pētot algebriskas izteiksmes un polinomus var lietot:1) Numerator[izt] --- izdala skaitītāju,2) Denominator[iz] --- izdala saucēju,3) Coefficient[izt,form] --- nosaka form koeficientu izteiksmē izt,4) Exponent[izt,form] --- nosaka form maksimālo pakāpi izteiksmē,5) PolinomialQ[izt,x] --- pārbauda, vai izt ir polinoms pēc x pakāpēm, izdot True vai False,6) Short[izt,n] vai izt // Short --- izdod izt saīsinātā veidā skaitā līdz n rindiņām,7) izt /.x val --- aizvieto izteiksmē mainīgo x ar val.Piemēri: 1) t=1+x^2; t./x 2 => 5, 2) t1=Expand[(1+3 x +4y^2)^2]; Coefficient[ t1,x] =>6+24y2, Exponent[t1,y]

=>4, 3) t2= Expand[(x+5y+10)^4]; t2//Short =>10000 +4000x +<<12>> + 625y4; Length[t2] => 15.

4.3.2 Vienādojumu un vienādojumu sistēmu risināšana ar MATHEMATICAAlgebrisku vienādojumu un vienādojumu sistēmu risināšanai apskatīsim šādas

komandas:Solve[vkp = = vlp, x] => atrisina vienādojumu ar kreiso pusi vkr un labo pusi

vlp pret mainīgo x, Solve[vkp1 = = vlp1, vkp2 = = vlp2, { x,y}] => atrisina vienādojuma sistēmu

pret mainīgajiem (x,y), Solve[vkp = = vlp, x]//N => tuvināti atrisina ar 6 zīmīgiem cipariem,

N[Solve[vkp = = vlp, x],k] => tuvināti atrisina ar k zīmīgiem cipariem, Roots[poly= =0,x] => simboliska polinomu līdz 4.kārtai sakņu atrašana,

Roots[poly= =0,x] => skaitliska jebkura polinomu sakņu atrašana,Reduce[vdj,main] => vienādojuma vdj atrisināšana pret mainīgajiem main,

analizējot visas iespējas, AlgebraicRules[vdj, {x1,x2, …}] => algebrisku likumsakarību ģenerēšana, Eliminate[vdj, {x,…}] => mainīgo x, … izslēgšana no vienādojumu sistēmas

vdj. FindRoot[vdj, {x,x0}] => nelineāra vienādojuma atrisināšana ar Ņūtona metodi, kur x0 ir sākuma tuvinājums,

87

FindRoot[vdj, {x,{x0,x1}}] => risināšana ar hordas metodi (divi sākuma tuvinājumi x0,x1).Pimēri:1) Reduce[a x +b = = 0,x] =>a!=0&& x=-b/a // a= = 0&&b= =0 (!= ir negācija),2) p[x_]: =Exp[x] –x -2; Plot[p[x],{x,-3,3}] => zīmē grafiku, no kura redzams, ka saknes pieder intervāliem (-2,-1) un (1,2), FindRoot[p[x]= =0, {x,-2}] => {x -1.84141], FindRoot[p[x]= =0, {x,1}] => {x 1.14619].

4.3.3 Lineāru vienādojumu sistēmu risināšana ar MATHEMATICAVektoru v ar kārtu n un ar elementiem v[[i]] (i-tās rindiņas numurs) definē ar

operatoru Array[v,n], matricu M ar kārtu n1xn2 un ar elementiem M[[i,j]] (i,j-rindiņas, kolonnas numuri) definē ar operatoru Array[M, {n1,n2}], vienības matricu nxn veido ar IdentityMatrix[n], diagonāles matricu ar sarakstu list pa diagonāli veido ar DiagonalMatrix[list], n1xn2 matricu ar pseidogadījumu skaitļu elementiem veido ar Table[Random[],{n1}, {n2}].

Ar DP var veikt dažādas darbības ar matricām un vektoriem:Det[M] --- aprēķina matricas M determinantu,MatrixPower[M,n] --- ceļ matricu M n-tā pakāpē,MatrixExp[M] --- aprēķina matricu eksponenti,Inverse[M] --- inversās matricas aprēķināšana,Chop[M] --- noapaļošanas kļūdas 10-16 atmešana matricas elementos,Together[M] --- matricas elementu vienkāršošana,Transpose [M] --- transponētās matricas aprēķināšana,Minors[M,k] --- visu matricas M minoru kxk aprēķināšana,M1.M2 --- divu matricu M1,M2 reizinājums,M.v --- matricas M un vektora kolonnas v reizinājums,v.M --- vektora rindiņas v un matricas M reizinājums,v.M.v --- vektora rindiņas v un matricas M un vektora kolonnas v reizinājums (kvadrātiskā forma),v1.v2 --- divu vektoru v1,v2 skalārais reizinājums.

Ar LinearSolve [M,b] risina lineāru algebrisku vienādojumu sistēmu Mx=b, kur M ---matrica, m,x--- vektori kolonnas. Ar NullSpace[M] var izdot bāzes vektoru sarakstu y, kuri apmierina vienādojumu M.y = = 0. Var risināt arī diferenču vienādojumus, piem. Table[2 a[i] + a[i-1] = = a[i+1],{i,3}]; Solve[%, a[2],a[3],a[4]] => iegūst atrisinājumu atkarīgu no a[0],a[1].

Aprēķinot matricas M spektru, lieto komandas Eigenvalues[M], Eigenvectors[M], Eigensystem[M], bet operators {v,M1}=Eigensystem[M] izdod īpašvērtības vektorā v un matricu M1, kurā īpašvektori ir sakārtoti kolonnās. Piemēri:1) M={{3,2},{1,1}}; b=[5,2]; LinearSolve[M,b] => {1,1}, Solve[M,{x1,x2}= = b] => {{x11, x2 1}}; Inverse[M] . b => {1,2},2) M={{1,2},{1,2}}; NullSpace[M] => { { -2, 1}}, M.%[[1]] => {0,0},3) M=Table[1/(i+j-1), {i,3},{j,3}] => izveido 3.kārtas Hilberta matricu, M1=Transpose[M]; M2 =Inverse[M] => izdod inverso matricu, Inverse[M1] => inversās matricas sakrīt, M.M2 => vienības matrica, M-x*IdentityMatrix[3] => izveido raksturīgo matricu, Det[%] => 3. pakāpes raksturīgais polinoms, N[Solve[% = =0,x]] => matricas īpašvērtības, Eigenvalues[N[M]] => tās pašas īpašvērtības.4) m=Table[Random[],{500},{500}];=> izveido gadījumu skaitļu matricu 500x500.ListPlot[Abs[Eigenvalues[m]]]=> zīmē īpašvērtību grafiku:

88

100 200 300 400 500

2

4

6

8

10

5. Diferenciālvienādojumu simboliskā un skaitliskā atrisināšana

DP risina diferenciālvienādojumu problēmas plašā parametru izmaiņu diapozonā.

5.1. Diferenciālvienādojumi ar MATLAB

Pastāv plašas iespējas skaitliskai diferenciālvienādojumu (DV) risināšanai ar DP MATLAB. Risinot Košī problēmu parastajam DV var izmantot veselu virkni t.s. „solveru” vai iebūvētus algoritmus. Robežproblēmu galvenās risināšanas metodes ir redukcija uz Košī problēmu, piešaudes un režģa metodes. Jaunajā MATLAB 7 versijā robežproblēmas DV arī var risināt tieši.

5.1.1 Košī problēma Risinot Koši problēmu parastajiem DV,lieto dažādas MATLAB iebūvētās

funkcijas (solverus), kurus lieto atkarībā no DV stiegrības pakāpes (nestiegrās un stiegrās-stif). Ja iepriekš stiegrības pakāpi nezina, tad lieto vispirms solveru “ode45” un pēc tam “ ode15s”. Visi solveri cenšas atrast atrisinājumu ar relatīvo precizitāti 1.0e-3. Risinot konkrētas problēmas skaitļojumu precizitāte ir jākontrolē. Visos solveros ir rinda parametru ar kuriem var paaugstināt skaitļojumu precizitāti. Operatora “ options = odeset(…, kontroles veids, vērtība,…)” darbība ir līdzīga kā minimizācijas problēmā (3. nodaļā). Risināšanas shēma parasti ir šāda:1) reducē DV uz pirmās kārtas DV sistēmu“ y’=f(t,y)”(y, f vektori-kolonas),2) izveido speciālu M-failu funkciju “MF” DV normālsistēmas labās puses aprēķināšanai ar 2 ieejas argumentiem---neatkarīgais mainīgais “t” un vektors-kolona ”y”, kura garums ir vienāds ar DV nezināmo skaitu, 3) ar komandu “ [T, Y] = solver(‘MF’,[t0 tmax], y0, options)” (t0,tmax)---mainīgā t izmaiņas robežas, y0--- sākuma nosacījumu vektors ) izsauc atbilstošu solveru: “ode45” (4.kārtas Runges-Kutas nestiegrā vidējas precizitātes metode, ko parasti rekomendē sākuma risinājumam), “ode23” (2.kārtas Runges-Kutas nestiegrā zemas precizitātes metode), “ode113” (Ādamsa- Bešforta-Multona nestiegrā mainīgas un augstas precizitātes metode), “ode23t” (stiegrā trapeces metode), “ode15s”

89

(daudzsoļu Gīra stiegrā mainīgas precizitātes metode, lieto ja “ode45” nenodrošina precizitāti), “ode23s” (Rozenbroka stiegrā ātra zemas precizitātes metode), “ode23tb” (aizklāta Runges-Kuttas stiegrā zemas precizitātes metode, kas var izrādīties efektīgāka par “ode15s”),4) vizualizē rezultātu ar operatoru “odeplot” (zīmē trajektorijas), “odephas2” ( 2D fāzu plaknes), “odephas3” (3D fāzu plaknes).MATLAB risina arī DV sistēmas ar masas matricu “M(t,y)” formā M(t,y) y’ =F(t,y), kur y, F ir vektori-kolonnas, šīs sistēmas risina visi solveri, tikai “ode23s” risina ar konstantu matricu “M”, bet singulārai matricai “M” jālieto “ode15s” un “ode23t”.

DV robežproblēmu tiešā risināšana ir iespējama tikai sākot ar MATLAB 6.versiju. Citādi ir jālieto robežproblēmu redukcijas metodes uz Koši metodi (superpozicijas vai piešaudes metodes).

Piemēri:1) risināsim Košī problēmu y’’ + 2y’+ 10y = sin(t), y(0)=1, y’(0)=0, svārstības

vienādojumam, reducējot to normālformā y1’= y2, y2’=-2 y2 - 10 y1 +sin(t), y1(0)=1, y2(0)=0 un sastādam M-failu funkciju “oscil”un izskaitļojam DV laikā t15:

function F = oscil(t,y) F = [y(2); -2*y(2) –10*y(1) +sin(t)]; >>Y0 =[1; 0] % sākuma nosacījuma vektors-kolona >>[T, Y] = ode45(‘oscil’, [0 15], Y0); plot(T, Y(:,1), ‘r’) %atrisinājums >>hold on, plot(T, Y(:,2), ‘k- -‘) %vienā logā izdod arī atvasinājumu >>title(‘Atrisinājums (y) \prime \prime+2(ty) \prime +10(y)=sin(t)’) >>xlabel(‘\itt’), ylabel(‘\ity), (\ity) \prime ‘) >>legend(‘atrisinājums’, ‘atvasinājums’,4), grid on, hold off tad uz ekrāna būs 2 grafiki vienā logā

ja solveram neraksta klāt izejas argumentus “[T,Y]” un “plot”, tad tiek izdots grafiks ar 2 līknēm, kurās atspoguļojas DV integrēšanas process pa soļiem

90

0 5 10 15-2.5

-2

-1.5

-1

-0.5

0

0.5

1Atrisinā jums (y) +2(ty) +10(y)=sin(t)

t

y), (y

)

atrisinā jumsatvasinā jums

0 5 10 15-2.5

-2

-1.5

-1

-0.5

0

0.5

1

Tādu pašu rezultātu iegūst, ja lieto komandas:>> options=odeset(‘OutputFcn’, ‘odeplot’);>> [T,Y]=ode45(‘oscil’, [0 15],Y0, options);(ja nav semikola, tad drukā arī visas vektora-kolonas T un matricas Y(size(T),2) vērtības), bet ja grib izdot tikai vienu atrisinājumu, tad

>> options=odeset(‘OutputFcn’, ‘odeplot’, ‘OutputSel’, 1);>> [T,Y]=ode45(‘oscil’, [0 15], Y0, options) ;

ja atrisinājumu grib izdot fāzu plaknē, tad lieto komandas:>> options=odeset(‘OutputFcn’, ‘odephas2’);>> [T,Y]=ode45(‘oscil’, [0 15],Y0, options);

2) risināsim Lotka-Volterra modeli, kuru apraksta stiegrā DV sistēma y1’= p1 y1 p2 y1 y2, y2’= -r1 y2 +r2 y1 y2, kur y1 ir upuru skaits, y2--- plēsēju skaits, p1,p2,r1,r2--- parametri; šīs problēmas (uzdodot sākuma nosacījumus) atrisinājums fāzu plaknē (y1 y2) ir slēgta līnija (konkrēti apskatam p1=3, p2=r2=1, r1=2, y1(0)=3, y2(0)=4), kuru meklēsim ar M-failu funkciju “lvol” un programmu “atr2” laikā t 100, lietojot solverus “ ode45” un “ode23s”: function F = lvol(t,y) F = [3*y(1)-y(1)*y(2); -2*y(2) + y(1)*y(2)]; Y0 =[3, 4]; [T, Y] = ode45(‘lvol’, [0 100], Y0); subplot(1, 2, 1) plot(Y(:, 1), Y(:, 2)) title(‘Lotka-Volterra modeļa atrisinājums ar (ode45)’) xlabel( ‘upuri’), ylabel( ‘plēsēji’) [T, Y] = ode23s(‘lvol’, [0 100], Y0); subplot(1, 2, 2) plot(Y(:, 1), Y(:, 2)) title(‘Lotka-Volterra modeļa atrisinājums ar (ode23s)’) xlabel( ‘upuri’), ylabel( ‘plēsēji)tad komandu rindā izpildot “atr2” veidojas vienā logā 2 grafiki, no kuriem kļūdains ir grafiks, kas iegūts ar “ode45” solveri,3) parādīsim, lietojot M-failus funkcijai “piem” un programmai “atr3”, Koši

problēmas y1’=y2, y2’=-1/(t*t), y1(a) =ln(a), y2(a) =1/a risināšanai segmentā [a, 100] (a=0.001), ka parastā precizitāte 1.0e-3 nav pietiekama pareiza rezultāta iegūšanai, neatkarīgi no izvēlētā solvera (precīzais atrisinājums ir y1=ln(t), y2=1/t)

function F = piem(t,y) F=[y(2); -1/t^2]; a = 0.001; Y0 = [log(a); 1/a]; options=odeset(‘RelTol’,1.0e-3); % parastā precizitāte [T,Y] =ode45(‘piem’, [a 100], Y0, options); plot(T, Y(:,1), ‘k:’) options=odeset(‘RelTol’,1.0e-4); [T,Y]=ode45(‘piem’, [a 100], Y0, options); hold on plot(T, Y(:,1), ‘k --’), options=odeset(‘RelTol’,1.0e-6); [T,Y]=ode45(‘piem’, [a 100], Y0, options); hold on plot(T, Y(:,1), ‘k-’), t=[a:4:100]; y =log(t); hold on plot (t, y, ‘ko’) % precīzais atrisinājums xlabel(‘\itt’), ylabel(‘\ity’) title(‘Atrisinājumu salīdzināšana ar dažādām precizitātēm’) legend(‘10^(-3)’, ‘10^(-4)’, ‘10^(-6)’, ‘precīzais’, 4) grid on, hold off

91

tad komandu logā, izpildot “atr3”, veidojas vienā logā 4 grafiki, no kuriem redzams, ka atrisinājuma iegūšanu nodrošina tikai precizitāte 1.0e-6,4) klasisks piemērs ir Van-der-Pola DV formā y1’= y2, y2’=*(1-y1^2)*y2-y1, apskatam konkrēti =100, y1(0)=2, y2(0)=0 (pie lielām parametra vērtībām šī DV sistēma ir stiegra) un izveidojam M-failu “vdp(t,y)”, lietojot komandu logā “ ode15s”

function F=vdp(t,y)F=zeros(2,1); % jo jābūt ir vektoram-kolonaiF(1)=y(2); F(2)=100*(1-y(1)^2)*y(2)-y(1);

>>[T,Y]=ode15s(‘vdp’, [0 30],[2 0]); plot(T,Y)>> hold on; gtext(‘y1’), gtext (‘y2’)

iegūstam atrisinājuma grafikus, kur ar peli (pateicoties funkcijai “gtex”) var pie grafikiem pievienot uzrakstus “y1” un “y2”,5) apskatīsim DV sistēmu ar singulāru masas matricu (Robertsona piemērs), risinot 3 ķīmiskās kinētikas nelineārus DV (stiegrie DV):

y1’(t) = -0.04 y1(t) + 1e4 y2(t) y3(t), y2’(t) = 0.04 y1(t) - 1e4 y2(t) y3(t) – 3e7 y2(t) y2(t), y1(t) + y2(t) + y(t)) –1 =0, y1(0)=1, y2(0)=0, y3(0)=0, t [0,100]

(šeit 3. DV y3’(t)=3e7 y2(t) y2(t) ir aizstāts ar līdzsvara vienādojumu),šeit masas matrica M= 1 0 0

0 1 00 0 0 ir singulāra, tāpēc lietosim “ode15s”

sastādot M-failu “atrm” ar apakšfunkciju “vdj” function atrm

function F = vdj(t,y) F= zeros(3, 1); F(1) = -0.04*y(1) + 1e4 *y(2) *y(3);

F(2) = 0.04*y(1) - 1e4 *y(2) *y(3) 3e7 *y(2)^2;F(3) = y(1) + y(2) + y(3) – 1; endY0 = [1; 0; 0]; M =diag([1, 1, 0]); xtime = [0 100];Options = odeset(‘RelTol’, 1e-4, ‘mass’, M);[t,y] = ode15s(‘vdj’, xtime, Y0, options);subplot (3, 1, 1); plot(t, y(:, 1)) % formē 3 grafikus vienā logāgrid on, legend (‘y_1’);subplot (3, 1, 2); plot(t, y(:, 2))grid on, legend (‘y_2’);subplot (3, 1, 3); plot(t, y(:, 3))grid on, legend (‘y_3’, 4); end

Risinot simboliski DV, lieto operatoru “dsolve”, kura ieejas argumenti ir diferenciālvienādojums, nosacījumi (ja tos uzdod) un neatkarīgais mainīgais (ja tas nav uzrādīts, tad pēc noklusēšanas pieņem mainīgo “t” ), atvasinājumus uzdod šādi: Dy, D2y, … Kā piemēru apskatīsim Košī problēmu y’=y^2+1, y(0)=0, kuras atrisinājums ir y = tan(x). Izsaucot funkciju “dsolve”, iegūstam:

>>z =dsolve( ‘Dy= y^2 +1’, ‘y(0) = 0’, ‘x’); pretty(z) ans= tan(x)Ja tagad šo problēmu risina skaitliski, veidojot M-failu “vdj” formā

function F = vdj(x,y)F = [y(1)^2+1];

tad, lietojot solveri “ode45” un zīmējot abus grafikus, iegūst>> [X,Y] = ode45(‘vdj’, [0 pi/3], 0); plot(X,Y, ‘o’)

92

>> hold on ; ezplot(z) >> grid on

rezultātā pārliecināmies, ka analītiskais atrisinājums ir pareizs. Risinot differenciālvienādojumu sistēmas, atradīsim vispārīgo atrisinājumu

sistēmai f’=-g, g’=-f un pārbaudīsim to:>> [f,g]=dsolve(‘Df=-g, Dg =-f’)

f =1/2*C1*exp(-t)+1/2*C1*exp(t) –1/2*C2*exp(t) +1/2*C2*exp(-t),g =-1/2*C1*exp(-t)+1/2*C1*exp(t) +1/2*C2*exp(-t) +1/2*C2*exp(t),

>>syms t; u1 = diff(f,t)+g u1=0>> u2 = diff(g,t)+ f u2=0

Ja uzdod nosacījumus, tad constantes C1, C2 pazūd, piem.,>> [f,g] = dsolve(‘Df=-g, Dg =-f’, ‘f(5)=1, g(5)=3’)

f =2*exp(-t+5) – exp(t-5), g = exp(t-5) + 2*exp(-t+5)Viegli redzēt, ka sistēma ir ekvivalenta vienam 2. kārtas vienādojumam f’’=f vai g’’=g. Risinot 2.kārtas diferenciālvienādojumu attiecīgi iegūstam

>>z = dsolve(‘(1-x^2)*D2y – 2*x *Dy +2y=0’,’x’)z = C1*x -1/2*C2*log(x-1)*x +1/2*C2*log(x+1)*x –c2

>>z = dsolve(‘(1-x^2)*D2y – 2*x *Dy +2y=0’, ‘y(0)=0, y(1)=1’,’x’)z = x

5.1.2 RobežproblēmaLietojot DP sākot ar 6.versiju rodas papildus iespējas parasto

diferenciālvienādojumu robežproblēmu risināšanā. Apskatam 2. kārtas DV robežproblēmu segmentā [a,b] vispārīgā veidā:

y’’ = f(x,y,y’) , y(a) + y’(a) = A, y(b) + y’(b) = B,kur , , , , A, B --- doti skaitļi. Robežnosacījumi var būt cita formā, piem., y(a)=A, y(b)=B, vai y’(a) = A, y’(b) = B. MATLAB-ā ir funkcija “bvp4c”, kas risina robežproblēmu DV sistēmai y’=g(x,y), kur y--- vektors, y’--- atvasinājumu vektors, g(x, y)--- vektor-funkcija.Problēmas atrisinājums sastāv no šādiem etapiem:1. Pārveido 2.kārtas DV par 1.kārtas divu DV sistēmu .2. Izveido M-failu funkciju labās puses izskaitļošanai.3. Izveido M-failu funkciju, kura apraksta robežnosacījumus.4. Noformē sākuma tuvinājumu ar speciālu funkciju “bvpinit”.5. Izsauc solveri “bvp4c” robežproblēmas risināšanai.6. Vizualizē rezultātus.

Tātad, ievedot funkcijas y1(x) un y2(x), iegūstam šādu DV sistēmu: y1’=y2, y2’= f(x, y1, y2). M-failu labo pušu izskaitļošanai veido tāpat kā Košī problēmas gadījumā. Robežnosacījumi ir jāpārraksta tādā formā, lai labajā pusē būtu 0, proti, y(a) + y’(a) – A = 0, y(b) + y’(b) – B=0.M-faila funkcija, kas apraksta robežnosacījumus, ir atkarīga no 2 parametriem, t.i., vektora “ya” un “yb”un ir ar šādu struktūru:

function g = bound(ya, yb)g=[alpha *ya(1)+beta*ya(2)-A; gamma* yb(1) +delta* yb(2) – B=0];

Parametru “alpha, beta, gamma, delta“ vietā jāraksta dotie skaitļi.Izvēlētais sākuma tuvinājums iespaido solvera “bvp4c” darbību. MATLAB

atrod tuvinājumus ar galīgo diferenču metodi, t.i., vektoru ar nezināmajām funkcijas vērtībām režģa punktos. Funkcijas “bvpinit” argumenti ir vektors ar mezglu punktu koordinātēm segmentā [a, b] un vektors ar 2 elementiem, kas satur konstantu sākuma

93

tuvinājumu funkcijām y1, y2. Režģa punktus var izmainīt solvers, lai risinājuma procesā iegūtu attiecīgu precizitāti. Funkciju “bvpinit” izsauc šādi: initsol=bvpinit(režģa vektors, funkciju vērtību vektors)

Izsaucot solveri “bvp4c”, par ievada argumentiem jāņem labo pušu un robežnosacījumu M-failu vārdi, sākuma tuvinājums un ja nepieciešams, tad papildus parametri, ko formē “bvpset” un kas vada skaitļošanas procesu.

Piemērs.

Otrās kārtas DV y’’=-sin(x), y(0)= 0, y’(11/2) +y(11/2) = -1(precizais atrisinājums ir y = sin(x)) pirmās kārtas DV sistēma ir formā:y1’= y2, y2’= - sin(x), y1(0) = 0, y2(11/2) +y1(11/2) +1 = 0.M-failu funkciju “rside” labo pušu izskaitļošanai veido šādi:

function f = rside(x,y)r = [ y(2); -sin(x)];

M-failu funkciju “robez” robežnosacījumu izskaitļošanai veido šādi:function f = robez(ya, yb)

f = [ya(1); yb(2) + yb(1) +1];Risinot robežproblēmu ar M-failu programmu, nepieciešams tajā norādīt sākuma tuvinājumu ar “bvpinit” un izsaukt solveri “bvp4c”:

initsol = bvpinit([0:pi/2:11*pi/2], [1 0]); sol = bvp4c(‘rside’, ‘robez’, initsol); % sol.x, sol.y--- režģis un atris.plot(sol.x, sol.y(1, :), ‘k.‘) % izdod atrisinājumu y režģa punktosx = [0:pi/30:11*pi/2]; hold on , plot(x, sin(x), ‘b-‘) % prec. atr.hold off

( “sol.y(2, :)” atbilst funkcijas y2 vērtībām režģī “sol.x(:)” )

Grafikā redzama laba sakrišana ar precīzo atrisinājumu.

Robežproblēmu var risināt ar vispārīgāku komandu sol = bvp4c(‘odefun’, ‘bcfun’, solinit, options, P1, P2, …); kur ar “options” var uzdot vadības parametrus, bet “ P1, P2, …” ir papildus parametri-argumenti, kurus lieto labās puses M-failā “odefun” un robežnosacījumu M-failā “bcfun”. Visi vadības parametri tiek fiksēti ar komandu formā “bvpset( ‘parametrs’, vērtība, …)”, kur argumenti var būt šādi:

Parametrs VērtībaRelTol Relatīvā kļūda (1e-3 pēc noklus.) AbsTol Absolūtā kļūda (1e-6 pēc noklus.)Fjacobian f / y (M-faila vārds)BCJacobian [(bc)/(ya)] un [(bc)/(yb)]

(M-faila vārds)

94

0 2 4 6 8 10 12 14 16 18-1

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

1

Par parciālo DV skaitlisku risināšanu skat. 8.nodaļā.

5.2 Diferenciālvienādojumi ar MAPLE

Datorprogramma MAPLE dod plašas iespējas atrisināt diferenciāl-vienādojumus un to sistēmas skaitliski, pamatojoties uz dažādām skaitliskām metodēm.

5.2.1 Košī problēmaDiferenciālvienādojumu skaitļošanas komandā dsolve (vdj, main, numeric,

opc) opcijas opc vietā norāda izvēlēto skaitlisko metodi formā method=nosk, kur osk var būt viena no iespējām (pēc noklusēšanas tā ir rkf45):

classical (pēc noklusēšanas ir foreuler), classical[foreuler], classical[heunform], classical[impoly], classical[rk2], classical[rk3], classical [rk4], classical [adambash], classical [abmoulton],

lsode (pēc noklusēšanas ir adamsfunc, saīsinājums no “Livermore stiff ODE solver”), lsode [adamsfunc], lsode [adamsfull], lsode [adamsdiag], lsode [adamsband], lsode [backfunc], lsode [backfull], lsode [backdiag], lsode [backband],

gear (pēc noklusēšanas polyextr.bstoer), gear [bstoer], gear [polyextr.bstoer], gear [polyextr],

dverk 78 (Runges-Kutta 7.-8.kārtas metode), rkf 45 (Runges-Kutta 4.-5.kārtas metode), rosenbrock (stiegru DV (stiff) skaitliskai risināšanai).

Bez tam opcijā opc vēl papildus var tikt norādīts initial = y0array (sākuma vērtību masīvs), number = negns (vienādojumu skaits), output = OC (izdrukas veids), procedure = myproc (procedūras nosaukums), start = x0 (sākuma punkts), value = xarray (argumentu vērtību masīvs). Par OC var būt procedurelist (pēc noklusēšanas) vai listprocedure, myproc ir procedūra proc (N,x,Y,YP), kur N ir 1.kārtas DV skaits, x - neatkarīgais mainīgais, Y - atkarīgais mainīgais vektors, YP- atvasinājums jeb labo pušu vektors, kuru rēķina šī procedūra formā YP[1]:= -x*Y[2] + … end. Precīzāku informāciju par šīm opcijām var uzzināt sistēmas “helpā”.

Bez paketes komandas “DEtools [DEplot]” rezultātu noformēšanai (zīmēšanai) lieto paketes “plots” komandu odeplot (d, main, rarg, opc); kur d:= dsolve (..., numeric), main - mainīgo saraksts, kurus atliek uz asīm, rarg - argumenta izmaiņas robežas, opc - opcijas tādas pašas kā komandās plot vai plot3d.

Piemēri:1) with(plots): d:=dsolve({D(y)(x) = y(x), y(0) = 1}, y(x), type = numeric):odeplot (d, [x, y(x)], -1..1); izdod monotoni augošu atrisinājuma līkni y=y(x),

2) p:=dsolve({diff (y(x),x) = sin (x*y(x)), y(0) =2}, y(x), type = numeric):odeplot (p, [x,y(x)], 0..6, labels = [x,y]); izdod atrisinājumu ar izteiktu maksimumu līkni,

3) sis:=diff(y(x),x)=z(x), diff(z(x),x)=y(x): main:={y(x),z(x)}: p:=dsolve({sis, y(0)=0, z(0)=1}, main, type = numeric): odeplot(p, [x,y(x)], -4..4, numpoints=25); atrisinājuma kā nepāra funkcijas līkne,odeplot(p, [[x,y(x)], [x,z(x)]], -4..4, numpoints=25); 2 līknes,odeplot(p, [y(x), z(x)], -4..4, numpoints=25); zīmē līkni fāzu plaknē,

95

odeplot(p, [y(x), z(x)], -4..4, numpoints=25, view = [-3..3, 0..3]);zīmē fāzes līkni z=z(y) ar citu mērogu (z(0)=1),odeplot(p, [x,y(x), z(x)], -4..4, numpoints = 25,color=orange); telpiskais 3-D zīmējums (līkne oranžā krāsā),

4) with(DEtools): DEplot(diff (y(x),x)=1/2*(-x -(x^2 + 4 * y(x)))^ (1/2), y(x), x = -3..3, y = -3. .2, title = `Apgabals`, color = 1/2 * (-x - (x^2 + 4 * y))); zīmē virzienlauku izdalītā apgabalā,

5) f1:=proc(N,x,Y,YP); YP[1]:=-Y[1]-x^2 end:DEplot(f1, y(x), x= -1..2.5, [[y(0)=0], [y(0)=1], [y(0)= -1]], title = `Asimp.atr.lietojot proceduru`); 3 līknes, kas iziet no dažādiem punktiem un tuvojas viena otrai,

6) sis:= diff (y(x),x) = z(x) - y(x) -x, diff (z(x),x) = y(x):F:= dsolve ({sis, y(0)=0, z(0)=1}, {y(x), z(x)}, type = numeric);

=> F:= proc (rkf 45x) ... endF(1);

=> [x=1, y(x)= 343731408276753914, z(x) = 1.25897207653682308],

7) sys2:= {(D@@2) (y) (x) = 2*x^3* y(x), y(0)=1, D(y) (0) =1}:s:= dsolve (sys2, {y(x) }, type = numeric, method = dverk 78, value = array ([1.0, 1.5, 1.7]));

s[2,1] [2,3]; =>8.36391691654069902,

8) ans2:= dsolve ({x*y(x) - sin (y(x)) = diff (y(x), x), y(0) = -5.}, y(x),numeric, method = gear, start = 0, initial = array ([-5]), maxord = 3): ans2 (0.45); =>[x = 45, y(x) = -5.90260241046659218],

9) ans3:= dsolve ({x*y(x) - sin (y(x))= diff (y(x), x), y(0) = -5.}, y(x), type = numeric, method = lsode, start = 0, initial = array ([-5])):ans3 (0.45); =>[ x = .45, y(x) = -5.90260258275327043 ],

10) ff:= dsolve ({D(y)(x) = y(x), y(0)=1}, y(x), type = numeric, method = dverk 78); =>ff:= proc (dverk 78 t) ... end,ff (0); =>[x=0, y(x)=1.], ff (0.4);=>[x=.4, y(x) = 1.49182469764515613],

11) ff:= dsolve ({diff (x(t), t) = y(t), diff (y(t), t) = x(t)+y(t), x(0)=2, y(0)=1}, {x(t), y(t)}, type = numeric, output = listprocedure);=>ff:= [t = (proc(t) ... end), y(t) = (proc(t) ... end), x(t) = (proc(t) ... end)],fx:= subs (ff, x(t)): fy:= subs (ff, y(t)): fx(0), fy(0);=> 2., 1. ,

96

fx(0.4), fy(0.4);=> 2.69118464471980756, 2.60811757838169767,fx(1.0), fy(1.0);=> 5.58216868998039217, 7.82689113830031857,

12) g:= dsolve ({diff (x(t), t) = y(t), diff (y(t), t) = x(t)+y(t), x(0)=2, y(0)=1},{x(t), y(t)}, type = numeric, method = classical, output = procedurelist); =>g:= proc (x_classical) ... end ,g(0); =>[t=0, y(t)=1., x(t)=2.],g(1.0); =>[t=1.0, y(t) = 7.77426067615230654, x(t) = 5.54892884682497023].

5.2.2 RobežproblēmaRobežproblēmas 2.kārtas DV risināt tieši ar DP iepriekšējām versijām nevar.

Ja zināms DV analītiskais atrisinājums, kas iegūts ar komandu dsolve, tad patvaļīgās konstantes _C1,_C2,…var noteikt, izmantojot robežnosacījumus un iegūt analītisko atrisinājumu formulu veidā.

Lineāru robežproblēmu 2.kārtas DV formā var reducēt uz divām Košī problēmām, izmantojot atrisinājuma superpozīcijas metodi.

Nelineāras robežproblēmas redukcijai uz Košī problēmām lieto piešaudes metodi, kuru var realizēt ar paketi šādi:nos:= g D(y)(a)=g: (definē funkciju nos atkarīgu no nezināmā atvasinājuma y’ (a)=g)f1:= g dsolve ([ vdj, y(a)=alpha, nos(g)], y(x), type = numeric, value = array ([b])): (definē funkciju f1 kā vienādojuma vdj atrisinājuma vērtību galapunktā x=b, atkarīgu no g),f2:= g f1(g) [2,1] [1,2]: (definē funkciju f2 kā y(b) atkarīgu no g),f3:= vector (n, i gmin + (i-1) * (gmax - gmin) / (n-1)): (izveido vektoru f3 ar garumu n, g[gmin, gmax], gmin, gmax meklējamā atvasinājuma y’(a)=g vērtību izmaiņu robežas, kuras jānosaka eksperimentāli),f4:= vector (n, if2 (f3 [i])); izdod vektora f4 koordinātes kā funkciju y(b) atkarīgu no g, t.i., no vektora f3 koordinātēm; pārbauda vai vektora f4 koordinātes satur vērtību beta, ja nesatur, tad izmaina vektoru f3, koriģējot gmin, gmax un atkārto vektora f4 aprēķināšanu, kamēr vērtība beta ir starp šī vektora koordinātēm, readlib (spline): sp:= spline (f3, f4, x,3): (izveido kubiskos splainus ar funkciju tabulu [f3,f4] ), fsolve (sp = beta, x); izdod tuvināto atvasinājuma y’ (a) vērtību g, kuru var pārbaudīt, vēlreiz risinot Košī problēmu ar šo vērību.Piemērs.Ja y’’ (x) + 2x y’ (x) = 0, a=0, b=3.5, =1, =0, n=6, gmin= -1.5, gmax= -0.9, tad ar iepriekšējo algoritmu iegūstam g=-1.128380023 (precīzā vērtība g=

).

Robežproblēmā aizstājot atvasinājumus ar diferencēm, iegūst diferenču shēmu (diskrēto robežproblēmu, algebrisku vienādojumu sistēmu):ai y i-1 + bi yi + ci yi+1 = si , i = 2,..N, y1 =alpha, yN+1 = beta, kur yi ir tuvinātā vērtība y(xi), xi --- režģa punkts.Apskatot DV robežproblēmu formā:-y’’ (x) + p(x) y’ (x) + q(x) y(x) = f(x), y(a)=alpha, y(b)=beta, un, lietojot centrālās diferences vienmērīgā režģī ar soli h, iegūsta i = - 0.5 (1+0.5 hp(xi )), b i = 1+0.5 h2 q(xi ), ci = - 0.5 (1-0.5 hp(xi )),

97

si = 0.5 h 2 f(xi ).Sastādīsim funkciju-procedūru soltrid diskrētās robežproblēmas atrisināšanai

ar faktorizācijas metodi.

soltrid:= proc (N, A, B, C, F, alpha, beta)local X, Y, d, y1, i;# A ir vektors zem diagonāles # B ir vektors uz diagonāles# C ir vektors virs diagonāles# F ir vektors labām pusēm# rezultāts ir vektors (1..N+1)y1:= array (1..N+1); X [1]:= 0; Y [1]:= alpha;for i from 2 to N do d:= B [i] + A [i] * X [i-1]; X [i]:= - C [i]/d; Y [i]:= (F [i] - A [i] * Y [i-1])/d od; y1 [N+1]:= beta; for i from N by -1 to 1 doy1 [i]:= X [i] * y1 [i+1] + Y [i] od;eval (y1) end:#Galvenās programmas sākumā uzdodam funkcijas p:= xizt, q:= xizt, f:= xizt, #kur izt ir konkrēti atkarīga no mainīgā x; #noformējam vektorus:y:= array (1..N+1): A:= array (2..N): B:= array (2..N): C:= array (2..N): F:= array (2..N): #kur N ir dots dalījumu punktu skaits;#aprēķinam soli h:= (b-a)/N:#un vektorusA, B, C, F:for i from 2 to N do xi:= a + (i-1)*h; A [i]:= -0.5 * (1. + 0.5 * h * p(xi));B [i]:= 1. + 0.5 * h ^ 2 * q(xi); C [i]:= -0.5 * (1. -0.5 * h * p(xi));F [i]:= 0.5 * h ^ 2 * f(xi) od:

Pēc tam izpilda operatoru y:= soltrid (N, A, B, C, F, alpha, beta); iegūstot atrisinājuma vektoru y.

Piemērs.N = 20: p:= x+1 : q:= x ^ 2: f:= x ^ 3:a:= 0.: b:= 1.: alpha:= 0.: beta:= 1.:rezultātā izdod masīvu y:= [ 0,.04207238174, …, .9332302745, 1 ],kura grafiku var formēt šādi:plot ([ seq ([ a + (i-1) * h, y [i} ], i = 1..N+1 ]);

Jaunajā versijā MAPLE 10 robežproblēmu var risināt tieši, lietojot bvp un bvp advanced.

Piemērs (ar robežslāni).> bcs := y(0) = 0,y(1) = 0;

> newode := (1/10*(1-lambda)+1/100)*diff(y(x),x,x)+exp(y(x))*diff(y(x),x)-1/2*Pi*sin(1/2*Pi*x)*exp(2*y(x)) = 0;

98

> ds:=dsolve({newode,bcs},numeric,continuation=lambda);plots[odeplot](ds);

Par parciālo DV skaitlisku risināšanu skat. 8.nodaļā.

5.3 Diferenciālvienādojumi ar MATHEMATICA

DP dod plašas iespējas risināt DV analītiski (kur tas iespējams) un skaitliski. Viena DV vispārīgo atrisinājumu atrod ar komandu DSolve[DV, y[x],x], kur DV satur nezināmās funkcijas y[x] atvasinājumus y’[x], y’’[x].

DSolve pamatā analītiski risina tikai lineāros, homogēnos, nehomogēnos un dažus nelineārus DV. Risināšanas iespējas var palielināt ar komandu << Calculus `DSolve` , izsaucot attiecīgu paketi.

DV partikulāro atrisinājumu atrod, piešķirot patvaļīgajām konstantēm C[1], C[2], … vispārīgā atrisinājuma izteiksmē konkrētas skaitliskas vētības, piemēram, % /. C[1] 2. Košī problēmai ar DSolve var uzdot attiecīgos sākuma nosacījumust.i., DSolve[{DV,y[x0] = = y0, y’[x0] = = y1},y,x], kur DV ir 2.kārtas diferenciālvienādojums, x0 --- sākuma vērtība.

Ja Košī problēmai nevar atrast precīzo atrisinājumu, tad to var risināt skaitliski ar komandu NDSolve[{DV, nosac. punktā x0,} ,{y1,y2,…}, {x,xmin,xmax}, opc], kur y1,y2,… nezināmās funkcijas, x --- arguments, xmin, xmax --- intervāla robežas, kurā meklē atrisinājumu. NDSolve atrisinājumus y1,y2, … izdod InterpolatingFunction objektu veidā.

Robežproblēmas DV atrisinājumu (y(a)=alpha, y(b) =beta) var reducēt uz Košī problēmu, lietojot piešaudes metodi. Ar DP to var realizēt šādi: ybeig[g_]:=y[b]/.NDSolve[{DV,y[a]= =alpha, y’[a] = = g}, y,{x,a,b}] [[1]];fr=FindRoot[ybeig[g] = = beta, {g,gmin,gmax}] => izdod vienādojuma sakni g, t.i. īsto sākuma nosacījuma y’(a) vērtību g, lai būtu y(b) = beta,atr = NDSolve[{DV, y[a] = = a, y’[a] = = g/.fr},y,{x,a,b}];

99

Plot[Evaluate[y[x] /. atr [[1]], {x,a,b]] => zīmē atrisinājuma grafiku. Šeit gmin, gmax ir vienādojuma ybeig(g]=beta atrisinājuma robežas,kuras nosaka eksperimentāli, piem. zīmējot grafiku Plot[ybeig[g], {g,gmin,gmax}], ar fiksētām gmin, gmax vērtībām.

Skaitliskā atrisinājuma atr grafiku zīmē ar Plot[Evaluate[{x[t] /. atr}, { t, tmin,tmax}] vai ar ParametricPlot[Evaluate[{{x[t],y[t]} /. atr}, {t,tmin,tmax}, PlotRange All].Piemēri: 1) DV= y’’[x] +Sin[y[x]] = = Cos[5 x]; ybeig[g_]:=y[1]/.NDSolve[{DV,y[-1]= =0, y’[-1] = = g}, y,{x,-1,1}] [[1]]; Plot[ybeig[g], {g,-2,2}] => zīmē grafiku,fr=FindRoot[ybeig[g] = = 0, {g,-3, 3}] =>{g 0.218167};atr = NDSolve[{DV, y[-1] = = 0, y’[-1] = = g/.fr},y,{x,-1,1}];{y[-1], y[1]} /. atr[[1]] => { 0, 6.0 10 -11} pārbauda robežnosacījumus,Plot[Evaluate[y[x] /. atr [[1]], {x,-1,1]] => zīmē atrisinājuma grafiku,2 ) atr = NDSolve[{x’[t] = = -y[t] –x[t]^2, y’[t] == 2 x[t] – y[t], x[0] = =1, y[0] = = 1}, {x,y}, {t,10}] => {{ x InterpolatingFunction[{0.,10.},<>], y InterpolatingFunction[{0.,10.}},x[3.14] /. atr => {-0.0715258}, N[x[3.14] /. atr[[1]],20] => -0.07152575312670698.

MATHEMATICA 5 jaunā versija atļauj arī risināt robežroblēmas.

Piemēri:1) Robežproblēma parastajam diferenciālvienādojumam: u’’(x)+α2 u(x) =0, u(0)=0, u(10)=1, α =10 (svārstošs atrisinājums, precīzais atrisinājums u(x)=sin(αx)/sin(10α)):L=10; a=10sol=NDSolve[{u’’[x]+a^2 u[x]==0,u[0]==0,u[L]==1}, u,{ x, 0, L}];Plot[Evaluate[u[x]/.sol],{x,0,L}];

2 4 6 8 10

-2

-1

1

2

2) 3-ju vielu ķīmiskās reakcijas nelineāras diferenciālvienādojumu sistēmas (viens vienādojums ir algebrisks) skaitliska modulēšana laikā t segmentā [0,40000]x’(t)=-x(t)/25 + 104 y(t) z(t), y’(t)=x(t)/25 -104y(t)z(t) – 107 y(t)2

x(t)+y(t)+z(t) = 1, x(0)=1, y(0)=0.

atr= NDSolve[{x[t]==-x[t]/25+10^4 y[t] z[t], y[t]==x[t]/25-10^4 y[t] z[t]-10^7 y[t]^2, x[t]+y[t]+z[t]==1,x[0]==1,y[0]==0}, {x,y,z}, {t, 0, 40000}];{{xInterpolatingFunction[{{0.,40000.}},<>],yInterpolatingFunction[{{0.,40000.}},<>],zInterpolatingFunction[{{0.,40000.}},<>]}}Plot[Evaluate[x[t]/.atr],{t,0,40000},PlotLabel"x(t)"];

100

Plot[Evaluate[y[t]/.atr],{t,0,40000},PlotLabel"y(t)"];Plot[Evaluate[z[t]/.atr],{t,0,40000},PlotLabel "z(t)"];

Atrisinājums tiek iegūts skaitliski tuvināti.3) Definējot 4 DV sistēmu yi’=yi-1 –yi , i=2,3,4, y1’=-y1, y5’=y4, ja y1(0)=1,

yi(0)=0, i=2,3.4,5, iegūstam eqns=Join[Table[y[i]'[x]y[i-1][x]-y[i][x], {i,2,4}],{y[1]'[x]-y[1][x],y[5]'[x]y[4][x], y[1][0]1},Table[y[i][0]0,{i,2,5}]],NDSolve[eqns,Table[y[i],{i,5}],{x,10}]{{y[1]InterpolatingFunction[{{0.,10.}},<>],y[2]InterpolatingFunction[{{0.,10.}},<>],y[3]InterpolatingFunction[{{0.,10.}},<>],y[4]InterpolatingFunction[{{0.,10.}},<>],y[5]InterpolatingFunction[{{0.,10.}},<>]}}Plot[Evaluate[Table[y[i][x],{i,5}]/.%],{x,0,10}]

10000 20000 30000 40000

0.2

0.4

0.6

0.8

1x t

10000 20000 30000 40000

210-6410-6610-6810-6

0.00001

0.000012

y t

10000 20000 30000 40000

0.2

0.4

0.6

0.8

z t

101

2 4 6 8 10

0.2

0.4

0.6

0.8

1

4) Apskatīsim (vektoru) 4 DV sistēmu y’’=Ay ar gadījumu skaitļu matricu A:

NDSolve[{y''[x]-Table[Random[], {4},{4}].y[x],y[0]y'[0]Table[1,{4}]},y,{x,0,8}] {{yInterpolatingFunction[{{0.,8.}},<>]}}With[{s=y[x]/.First[%]},Plot[{s[[1]], s[[2]],s[[3]],s[[4]]},{x,0,8},PlotRangeAll]]

2 4 6 8

-40

-20

20

40

5) Apskatīsim DV ar dažādām labajām pusēm:NDSolve[{y'[x]If[x<0,1/(x-1),1/(x+1)],y[-5]5},y,{x,-5,5}] {{yInterpolatingFunction[{{-5.,5.}},<>]}} Plot[Evaluate[y[x]/.%],{x,-5,5}]

-4 -2 2 4

3.25

3.5

3.75

4.25

4.5

4.75

5

6)Var risināt kopā ar DV algebrisku vienādojumu:

102

NDSolve[{x'[t]y[t]^2+x[t] y[t],2 x[t]^2+y[t]^21,x[0]0,y[0]1},{x,y},{t,0,5}] {{xInterpolatingFunction[{{0.,5.}},<>],yInterpolatingFunction[{{0.,5.}},<>]}}Plot[Evaluate[{x[t],y[t]}/.%],{t,0,5}]

1 2 3 4 5

-0.5

-0.25

0.25

0.5

0.75

1

Par parciālo DV skaitlisku risināšanu skat. 8.nodaļā.

6. Skaitlisko metožu algoritmi

Daudzi skaitlisko metožu algoritmi tika jau apskatīti iepriekš. Tālāk mēs apskatīsim galvenokārt funkciju aproksimāciju un interpolāciju .

6.1 Skaitliskās metodes ar MATLAB

Tā kā MATLAB ir veltīta galvenokārt skaitliskiem aprēķiniem, tad apskatīsim raksturīgākos piemērus.

MATLAB satur iebūvētas funkcijas dažadām interpolācijas metodēm:1) algebriskā aproksimācija (arī interpolācija) ar polinomiem, lietojot mazāko kvadrātu metodi, operators “polyfit(x,y,n)”, kur “x,y” ir mezglu punktu tabula (vektori-rindas), “n” --- aproksimējošā polinoma pakāpe; 2) interpolācija ar splainiem, operators “ interp1(x,y,xi, ‘meth’)”, kur “xi”--- interpolācijas starppunkti (vektors-rinda), “meth”--- splainu veidi: “linear” (lineārie), “spline” (kubiskie), “ cubic” vai “pchip“ (Ermita interpolācija), “nearest” (0-tās kārtas, t.i., interpolācija pēc blakus elementiem, kad katrā starppunktā funkcijas vērtība ir vienāda ar vērtību tuvākā mezglu punktā); 3) 2D interpolācija, operators “interp2(x,y,z, xi, yi, opc)”, kur “opc”---interpolācijas

veidi: “bilinear” (bilineārā), “bicubic “(bikubiskā) un “nearest”(interpolācija pēc blakus elementiem);

4) 3D un daudzdimensiju interpolācija, operatori “interp3” un “ interpn”.Piemēri:

1) sastāda M-failu programmu “appr1.m”, kas realizē aproksimāciju ar mazāko kvadrātu metodi, apskatot dažādu pakāpju polinomus un zīmējot grafiku:

x = [0.1 0.2 0.4 0.5 0.6 0.8 1.2]; y = [-3.5 –4.8 –2.1 0.2 0.9 2.3 3.7]; plot(x, y, ‘ko’) %zīmē tabulas grafiku ar markeriem p4 = polyfit(x, y, 4); p5 = polyfit(x, y, 5); p6 = polyfit(x, y, 6); t =[0.1:0.01:1.2]; p4 =polyval(p4,t); p5 =polyval(p5,t); p6 =polyval(p6, t); hold on, plot(t, p4, ‘k-‘, t, p5, ‘k:’, t, p6, ‘k-.’)

103

legend(‘tabula’, ‘n=4’, ‘n=5’, ‘n=6’,0) title(‘Aproksimācija ar n-tās pakāpes polinomiem’)rezultātā, izpildot komandu rindā komandu “appr1”, iegūst grafiku, kurā var redzēt, ka aproksimācija “n=6” ienes lielas kļūdas segmentā [0.8, 1.2],

2) sastāda M-failu programmu “appr2.m”, kas realizē dažāda veida aproksimāciju ar splainiem:

x=….; y=…. % iepriekšējie vektori plot(x, y, ‘ko’) xi = [x(1):0.01:x(length(x))]; y0 = interp1(x, y, xi, ‘nearest’); y1 =interp1(x, y, xi, ‘linear’); y3 = interp1(x, y, xi, ‘spline’); hold on , plot(xi, y0, ‘k’, xi, y1, ‘k:’, xi, y3, ‘k-.’) title (‘Dažādi interpolācijas veidi’), xlabel( ‘\itx’), ylabel( ‘\ity’) legend (‘tabula’, ‘0-kārtas apr.’, ‘lineārā’, ‘kubiskā’, 4)rezultātā, izpildot komandu rindā komandu “appr2”, iegūstam grafiku, kurā var redzēt precizitāti dažāda veida aproksimācijai,3) sastāda M-failu programmu “appr3.m”, kas realizē dažāda veida aproksimāciju ar splainiem divu argumentu gadījumā: [X, Y] = meshgrid (0:0.2:1); Z = sin(3*pi*X) .* sin(3*pi*Y) .* exp(-X .^2 – Y .^ 2); subplot (2, 2, 1), surf(X, Y, Z), title(‘tabulētā funkcija’) [Xi, Yi] = meshgrid(0:0.02:1); z0 = interp2(X, Y, Z, Xi, Yi, ‘nearest’); z1 =interp2(X,Y,Z,Xi,Yi, ‘bilinear’); z3 =interp2(X,Y,Z,Xi,Yi, ‘bicubic’); subplot(2, 2, 2), surf( Xi, Yi, z0), title(‘intp. pēc blakus punktiem ‘) subplot(2, 2, 3), surf( Xi, Yi, z1), title(‘bilineārā intp.’) subplot(2, 2, 4), surf( Xi, Yi, z3), title(‘bikubiskā intp.’)

rezultātā, izpildot komandu rindā komandu “appr3”, iegūst 4 virsmas grafikus vienā logā . Plašākam interpolācijas apskatam ir veltīta pakete “Spline ToolBox”.

Risinot skaitliski DV arī izmanto interpolāciju, piem., risinot robežproblēmu y’’ + y = 0, y(0) = 0, y(pi/2) = 1 (analitiskais atrisinājums y=sin(x)), izveidojam 2 M-failus funkcijas:

1) function f = labp(x, y) f = [ y(2) -y(1)];

2) function res = rob(ya,yb)res = [ ya(1) yb(1)-1];

un komandu logā izpildam komandas

104

>> solinit = bvpinit(linspace(0, pi/2, 5), [0 1]);>>sol = bvp4c(‘labp’, ‘ rob’, solinit)

rezultātā iegūstam tabulu (yp ir y atvasinājumu vērtības):

sol.x Sol.y(1) Sol.y(2) Sol.yp(1) sol.yp(2) sin(sol.x)0 0 1.0000 1.0000 0 00.1963 0.1951 0.9808 0.9808 -0.1951 0.19510.3927 0.3827 0.9239 0.9239 -0.3827 0.38270.7854 0.7071 0.7071 0.7071 -0.7071 0.70711.1781 0.9239 0.3827 0.3827 -0.9239 0.92391.3744 0.9808 0.1951 0.1951 -0.9808 0.98081.5708 1.0000 0.0000 0.0000 -1.0000 1.0000

Salīdzinot “sol.x” ar sākotnējo xinit =[0 0.3927 0.7854 1.1781 1.5708], redzam, ka klāt nākuši 2 papildus mezglu punkti x=0.1963 un x= 1.3744.Ja mēģinātu zīmēt grafiku ar komandu “plot(sol.x, sol.y(1, :))”, tad tas nebūs gluds, jo ir pārāk maz elementu vektorā “sol.x”. Šo grūtību var pārvarēt, ja lieto funkciju “yy= bvpval(sol, xx)”, kura konstruē Ermita interpolācijas polinomu, aprēķinot tā vērtības “yy” dotiem mezglu punktiem “xx”. Radot ar komandu “xx = linspace (0,pi/2)” pēc noklusēšanas 100 punktus atbilstoši atrisinājumu atrod ar komandu “yy = bvpval(sol,xx)”. Katrs elements “yy” ir divu komponenšu vektors, tāpēc, zīmējot atrisinājuma grafiku, jālieto komanda “plot(xx,yy(1, :))”.

6.2 Skaitliskās metodes ar MAPLE

Lai gan galvenokārt datorprogramma ”Maple” ir veltīta simboliskiem aprēķiniem, tomēr skaitliskai analīzei tajā ir liela loma un to plaši var lietot skaitlisko metožu kursā. Ar to iespējams veikt darbības ar tuvinātiem skaitļiem, risināt algebriskus un transcendentus vienādojumus un vienādojumu sistēmas (sk. 2.nod.), skaitliski diferencēt un integrēt (sk. 3.nod.), veikt funkciju interpolāciju un aproksimāciju.

PC atmiņas(mainīgo) attīrīšanai aprēķinu sākumā ieteicams lietot operatoru restart. Mašīnlaika fiksēšanai lieto operatoru time ( ). Ar operatoru cost (izt) analizē operāciju skaitu aritmētiskā izteiksmē izt.Skaitliskā rezultāta izdošanai (interpretēšanai) lieto šādus operatorus:

1) allvalues - izskaitļo vērtības no izteiksmēm, kas satur RooOf,2) eval - izskaitļo masīvu un tabulu datu struktūras,3) evalb - izskaitļo Bula algebras izteiksmes,4) evalf - izskaitļošana aritmētikā ar peldošo komatu,5) evalc - simboliskā izskaitļošana kompleksā laukā (pēc tam jālieto evalf),6) evalhf - izskaitļo izteiksmes ar divkāršu precizitāti, lietojot fiksētu komatu (strādā 10 reizes ātrāk nekā evalf),7) evalm - izskaitļo matricu (vektoru) izteiksmes,8) evaln - attēlo vārdus - literārus, 9) evalpow - izskaitļo pakāpju rindas,10) evalr - izskaitļo izteiksmes, mainīgos ierobežotā aritmētikā,11) value - izskaitļo inertās formas.

105

Funkciju interpolācijai un aproksimācijai datorprogrammā Maple izsauc paketi numapprox. Lagranža interpolācijas polinomu konstruē ar komandu interp ([x1,...,xn], [y1,...,yn], x), kur (xi,yi) , i=1,n ir uzdotā interpolācijas tabula.Kļūdas novērtēšanai lieto komandas readlib (maximize), readlib (minimize).Lai paketē numapprox novērtētu normu funkcijai f(x) segmentā [a,b], lieto komandu infnorm (f, a..b). Racionālai (Padē) aproksimācijai lieto komandu pade (f(x), x, [n,m]) , kur racionālai daļai Rn,m saucējā ir m–tās pakāpes polinoms, bet skaitītājā – n–tās pakāpes polinoms, Čebiševa aproksimāciju un labāko minimax aproksimāciju realizē ar paketes numapprox komandām:chebmult, chebsort, chebdeg, confracform, chebyshev, chebpade, minimax. Konkrēta šo komandu realizācija ir formā: 1. minimax (f, x=a..b, [m,n], w, `maxerror`); kur funkcija f segmentā [a,b] ar svaru w>0 tiek aproksimēta ar racionālu funkciju Rn,m(x), 2. chebyschev (izt, x=a..b, eps); kur izteiksme izt atkarīga no x intervālā (a,b) tiek aproksimēta ar Čebiševa polinomu T(k,x), k=0,1,… rindu ar reāliem koeficientiem (rinda tiek “pārtraukta”, atmetot pēdējo saskaitāmo, kurš pēc moduļa ir mazāks par eps ); ja intervālu (a,b) nenorāda, tad ir izvēlēts standartintervāls (–1;1); ja nenorāda eps, tad pēc noklusēšanas eps=10^(–Digits), kur Digits ir zīmīgo ciparu skaits, 3. chebpade (f, x=a..b, [m,n]); kur funkcija f(x) intervālā (a,b) tiek aizstāta ar racionālu Čebiševa–Padē aproksimāciju ar pakāpēm [m,n], 4. chebdeg (p); tiek noteikta Čebiševa rindas nogriežņa p pakāpe, 5. chebmult (p,q); sareizina 2 Čebiševa rindas nogriežņus ar pakāpēm p un q, 6. chebsort (e); sagrupē rindā e locekļus augošā secībā pēc Čebiševa polinoma kārtām, 7. taylor (f(x), x=x0,n); lieto viena argumenta funkcijas izvirzīšanai Teilora rindā, punkta x=x0 apkārtnē, saglabājot n rindas locekļus, 8. convert (“, polynom); iepriekšējo rezultātu pārveido par polinomu, atmetot kļūdas locekli 0(x–x0) n.Piemēri. 1. xdata:= [1,2,3]: ydata:= [0.841, 0.909, 0.141]: L:= interp (xdata, ydata, x);

L:= –0.418x2 +1.322x–0.063 (izdod Lagranža interpolācijas polinomu), 2. R[3,2]: = minimax (exp, –2..2, [3,2], 1, `maxerror`): maxerror; => 0.0002945 (ir vismazākā kļūda, salīdzinot ar citām metodēm),

Funkciju aproksimācijai ar splainiem datorprogrammā Maple lieto komandasreadlib (spline): spline (X,Y,x,k), kur X,Y ir 2 vektoru saraksti (mezglu punkti un atbilstošās vērtības), kurus aizvieto ar lokāliem k–tās pakāpes polinomiem ar neatkarīgo mainīgo x (pēc noklusēšanas kubiskiem splainiem k=3), iespējams arī k vietā rakstīt vārdus linear, quadratic, cubic, kas ir līdzvērtīgi k = 1;2;3.Piemērs. readlib (spline): g1:= spline ( [0,1,2,3], [0,1,4,3], x, cubic): g:= unapply (g1, x);

,g(1); => 1 (izdod splaina funkcijas vērtību punktā x=1).

106

Ar operatoru unapply splainu pārvērš par gabaliem nepārtrauktu funkciju, kurai var zīmēt grafiku un aprēķināt tās vērtības punktos.

6.3 Skaitliskās metodes ar MATHEMATICA

Lietojot operatoru NSolve[poly,x] skaitliski var atrast visas saknes polinomiem poly. Ar Ņūtona metodi, skaitliski risinot nelineārus vienādojumus vdj sākuma tuvinājuma x0 apkārtnē lieto FindRoot[vdj,{x,x0},opc], FindRoot[Print[InputForm[x]],vdj,{x,x0}, opc] (izvada visus tuvinājumus). Ja atvasinājumus nevar izskaitļot analītiski, tad saknes precizējot ar hordas metodi lieto FindRoot[vdj,{x,x0,x1},opc], kur x0,x1 ir 2 tuvinājumi.

Lagranža vai Ņūtona interpolācijas polinomam lieto komandu InterpolatingPolynomial[{x1,f1}, {x2,f2},…},x], (xi,fi) ir uzdotā tabula. Ermita interpolācijas polinomam lieto InterpolatingPolynomial[{x1,f1,df1,ddf1,…}, {x2,f2,df2,ddf2,…},…},x], kur dfi,ddfi,… ir uzdotās atvasinājumu vērtības.

Interpolāciju ar splainu palīdzību uzdod ar Interpolating[list,opc], kur list={{x1,f1},{x2,f2},…}, opcija (opc) ir formā InterpolationOrder k (k=1---lineārie splaini, k=2 --- kvadrātiskie splaini, k=3 --- kubiskie splaini). Ar paketes<<Graphics`Spline` palīdzību ir iespējams zīmēt grafikus, lietojot komandasShow[Graphics[Spline[list,Cubic]]], Show[Graphics[Spline[list,Bezier]]]. Lai palielinātu punktu lielumu, lieto SplineDots={PointSize[0.04]}.

2D gadījumā ar mezglu ar mezglu punktiem (xi,yi) sarakstu list uzdod formālist ={{x1,y1,f1},{x2,y2,f2},…},…} un operators Interpolation[list] veido 2D splainu ar interpolācijas funkcijas palīdzību.

Funcijas aproksimāciju ar mazāko kvadrātu metodi realizē ar komandu Fit[list,{f1,f2,…},x], kur f1,f2,… ir aproksimējošo funkciju saraksts, kuru lineāro kombināciju meklē ar mazāko kvadrātu metodi.Piemērs.<<Graphics`Spline`; pts = {{0, 0}, {1, 2}, {-1, 3}, {0, 1}, {3, 0}};Show[Graphics[Spline[pts, CompositeBezier, SplineDots Automatic]]]

Graphics

107

7. Programmēšana ar DP

Visas DP satur augsti attīstītas programmēšanas valodas, veidojot kompaktas makro komandas.

7.1 Progammēšanas elementi ar MATLAB

M-faili funkcijas un programmas ir paši vienkāršākie programmu piemēri, kur visas komandas tiek izpildītas pakāpeniski viena aiz otras. Vienkāršāko ciklu var veidot ar operatoru “for” formā:“for main = start:step:final Cikla Kodols end”, kur “ main” ir cikla mainīgais, “start” --- sākuma vērtība, “final” --- beigu vērtība, “step” --- solis, par kuru palielinās “main” (ne tikai veseli skaitļi, bet arī reālie skaitļi ar jebkuru zīmi). Ja solis ir vienāds ar 1, tad “step” var nerakstīt.

Ciklu veido ar operatoru “ while”formā: “ while cikla nosacījums Cikla Kodols end”, kur “ cikla nosacījums” satur attiecību operācijas “= =”(vienādība), “<”(mazāks), “<=” (mazāks vai vienāds), “>“ (lielāks), “>=” (lielāks vai vienāds), “~=” (nav vienāds) vai loģiskās operācijas “and“ vai “(&)”, “or” vai “ | “ un “not” vai “ ~ “ (piem., nosacījumus x<3 un k=4, x=1 vai 2,a 2 realizē MATLAB-ā šādi: and(x<3, k = =4) vai (x<3) & (k = = 4), or (x = =1, x = =2) vai (x = =1) | (x = = 2), not( a= = 2) vai ~ (a = = 2)). Piemēram, izskaitļojot sin(x) no Teilora rindas segmentā [-, ], summējam to tik ilgi, kamēr tekošais rindas saskaitāmais pēc moduļa nepārsniedz 1.0e-10, sastādam M-failu funkciju “msin.m” formā: function s=msin(x) s =0; k = 0; while abs( x .^ (2*k +1)/factorial(2*k +1) > 1.0e-10 s = s + (-1)^k x .^(2k +1)/factorial (2*k +1); k = k +1; endkomandu rindā salīdzināsim 2 grafikus: funkcijas sin(x) un aproksimējošo >> fplot( ‘msin’, [-pi, pi]), hold on, fplot(‘sin’, [-pi,pi], ‘k .’)ja rinda var diverģēt, tad drošības dēļ, lai programma „nesaciklētos”, var veidot cikla nosacījumu formā (abs(x .^ (2*k +1)/factorial(2*k +1) > 1.0e-10) & ( k <= 100000)vai and (abs(x .^ (2*k +1)/factorial(2*k +1) > 1.0e-10 , k <= 100000) ).

Lai radītu elastīgus algoritmus lieto nosacījumu operatoru “if”. Operatoru “if” var lietot vienkāršā veidā vai kombinācijā “if-elseif-else”. Vienkāršā veidā “if” darbība ir formā “if nosacījums MATLAB komandas end” (ja nosacījums ir spēkā, tad izpildās MATLAB komandas starp “if” un “end”, bet ja nav, tad pāriet uz komandu izpildi, kas atrodas aiz “end”).

Izeju no faila-funkcijas var realizēt arī ar operatoru “return”. Lai cikla izpildes laikā izietu no tā lieto operatoru “ break”, piem., šāds programmas fragments: y = zeros(length(x) –1); for i = 1: length(x) - 1

108

if x(i) = = 0 break end y(i) = x(i+1)/x(i); endOperatoru “break” var lietot arī “while” ciklā. Iekļautos ciklos “break” realizē izeju no iekšējā cikla.

Ja M-faila funkcijā vairākas reizes jāizskaitļo cita funkcija (apakšfunkcija), tad to var pierakstīt klāt galvenajai funkcijai, piem., function mff ; % Galvenā funkcija f1 = f(1,2); f2 =f(3,4); f3 = f(5,1); function z = f(x,y) % Apakšfunkcija z = x^3- x*y +19;

7.2. Progammēšanas elementi ar MAPLE

Par loģiskiem izvēles operatoriem lieto if/then/else/end if, tie sākas ar if un beidzas ar end if (vecajās versijās ar fi). Kā otrreizēju nosacījumu, veidojot operatoru ķēdīti if/then/elif/then.../else/ end if, lieto operatoru elif.

Ciklus veido ar 3 veida operatoru virknēm:1)for/from/by/to/do/ end do,2)for/from/by/while/do/end do,3) for/in/do/ end do,kuri noslēdzas ar operatoru end do (vecajās versijās od - apgrieztais do).

Lai radītu procedūru (apakšprogrammu), kuru varētu izmantot vairākas reizes MAPLE izmanto konstrukciju proc/end. Procedūru pieraksta šādi:vards:=proc(param 1, param 2,...) local L1, L2,...;global G1, G2,...; options op1, op2,...; Procedūras ķermenis; end; kur vards ir piešķirtais procedūras nosaukums, param 1, param 2,... formālie parametri. Lokālos mainīgos L1, L2,... glabājas mainīgo vērtības, ko izmanto tikai procedūrā. Globālos mainīgos G1, G2,... var izmantot visur, gan procedūrā, gan arī ārpus tās interaktīvā režīmā. Formālo parametru param 1, param 2,... nosaukumi var būt patvaļīgi, tomēr svarīgs ir to skaits un tips. Ja to nav vispār, tad jāraksta proc ( ). Lai varētu operēt ar procedūras parametriem, lieto speciālas funkcijas args [i], args [i...j] , nargs.

Piemēri.t:= proc( ) Digits:= Digits+5; end:t( ) ; => 15 (zīmju skaits izpildot procedūru t tiek palielināts par 5),print (Digits); => 10 (tomēr interaktīvā režīmā vērtība operatoram Digits atgriežas sākuma normālā stāvoklī --- 10).

Sastādīsim 2 veida procedūras, kas realizē Ņūtona iterācijas metodi vienādojuma expr(x) =0 vai f(x)=0 sakņu atrašanai:1) Newit1:=proc(expr::algebraic, x::name) local it;

109

it:= x-expr/diff (expr,x); unapply (it,x); end;

2)Newit2:=proc(f::procedure)(xx)-f/D(f);end;

Ja expr:= x*sin (x) - sqrt (x); g:= x->x*sin (x) - sqrt (x); tad Form1:=Newit1(expr,x);

=> Form 1:= xx –

Form2: = Newit2 (g); => līdzīgs rezultāts, tikai skaitītājā ir g.

Uzdodot sākuma tuvinājumu x0:=9.0; iegūstam 4 tuvinājumus šādi:1) to 4 do x0:= Form1 (x0) end do; => x0:= 9.089137810; 9.086631757; 9.086629934; 9.086629934,2) x0:=9.0; to 4 do x0:= Form2 (x0) end do ; => x0:= 9.089137610; 9.086631757; 9.086629934; 9.086629934.

Piemēri:1) g:=x if x < = 0 then 2x+1 else x^2+1 end if; => definē funkciju ar 2 formulām, g (-2) => -3, g (5); => 26,2) h:=x if x< -2 then x+3 elif x< =2 then 5-x^2 else 3-x end if; => definē funkciju ar 3 formulām, h(-3); =>0, h(0); => 5, h(3); => 0.

3) for i from 1 to 5 by 2 do print (i!) end do; => 1, 6, 120, 4) y1:= (-1+sqrt (1+4*x^2))/(2*x) ; for k from 1 to 5 do 0.1^k, evalf (subs (x=0.1^k, y1));end do; => 0.1, .099019515... 5) for n from 1 by 4 while ithprime (n)<100 do print (n, ithprime(n)); end do; => 1,2 ... 25, 97, (izvada pa 2 skaitļiem kolonnā, var operatoru print arī atmest), kur komanda ithprime(n) izskaitļo n-to pirmskaitli, sākot no 2,6) p:= proc (x,y) if x^2<y then x^2 + y^2 else x-y end fi end: plots [implicitplot] (p, -2..2, -1..3); => zīmē aizklāto 2-D grafiku atkarībā no funkcijas definīcijas procedūrā p ar 2 formulu palīdzību, 7) p:= proc (x,y) if x^2 < y then cos (xy) else xsin (xy) end if end:h:= proc(x) x^2 end: plot 3d (p, -2..2, -1..h); =>zīmē 3-D grafiku atkarībā no funkcijas definīcijas procedūrā p ar 2 formulu palīdzību.8) a:=3: b:=5: if (a>b) then a else b end if ; => 5

7.3. Progammēšanas elementi ar MATHEMATICA

DP lieto apzīmējumus: i+=di (i+di), i- =di (i-di), x*=c (x*c), x/=c (x/c),i++ (i+1), i - - (i-1).

110

Programmas blokus veido ar:1) Block[{x,y,…},izt]--- izteiksme tiek novērtēta ar lokālām simbolu x,y,… vērtībām,2) Module[{x,y,…},izt] --- darbojas analogi Block (lieto biežāk),3) With [{x=x0, y=y0, …}, izt] --- izpilda izt, aizvietojot x,y,… ar x0,y0,…

Cikla operatori ir:1) Do[izt,{i,imin,imax,di}] --- izt izpilda no segmenta [imin,imax] ar soli di,2) For[start,test,step,izt] --- izpilda start ,tad cikliski atkārto test, izt ar soli step, līdz test vērtība vairs nav True,3) While[tst,izt] --- izpilda test, izt, kamēr test kļūst False,4) Nest[f,izt,n] --- lieto f izteiksmi izt n reizes, izdodot pēdējo rezultātu, ar NestList[…] izdod visus starprezultātus,5) FixedPoint [f,izt] --- lieto f atkārtoti ar izt, kamēr rezultāts nemainās, parādot pēdējo, FixedPoint [f,izt,n] lieto ne vairāk kā n reizes, parādot pēdējo,FixedPointList [f,izt], FixedPointList [f,izt,n] analogi iepriekšējiem, izdodot visus starprezultātus,6) Trace[izt,form] --- var pētīt izteiksmi pa soļiem.

Loģiskie izvēles operatori ir:1) If [nos,t,f] --- izvēlas izteiksmi t, ja nosacījums nos ir True un izteiksmi f, ja nos ir False, If [nos,t,f,u] papildus var izvēlēties izteiksmi u, ja nos nav ne True, ne False,2) Which[test1, val1, test2, val2,…] --- novērtē pēc kārtas katru testi, līdz novērtējums ir True, tad tiek izvēlēta atbilstošā vali vērtība.

Piemēri:1) For[i=1, i<4, i++, Print[i]] => 1;2;3,

2) For[i=1; t=x, i^2 <10, i++, t=t^2 +i; Print[t]] => 1=x2; 2+(1+x2)2; 3+(2+(1+x2)2)2,

3) g[x_]:=Sin[x] – 0.5; f[x_]: = x –g[x]/ g’[x]; FixedPointList[N[f],1.0] =>izdod 7 Ņūtona iterācijas, kur pēdējās sakrīt ar 16 zīmēm (π/6 = 0.523599…)

4) Trace[(k=2; Do[k=i/k,{i,4}]; k),k=_] => {{k=2},{{k=1/2},{k=4},{k=3/4},{k=16/3}}},

5) Table[Which[i= = =j,b,i+1 = = = j,c, i-1 = = = j, a, True,0],{i,n},{j,n}] => veido 3-diagonālu matricu ar elementiem a,b,c,

6) sign[x_]:=If[x>0,1,If[x= = =0,0,-1]]; sign[0] =>0, sign[4] =>1, sign[-3] => -1.

8. Konkrētu matemātikas problēmu modelēšana ar DP

Apskatīsim dažus matemātiskās modelēšanas uzdevumus (piemērus) ar DP.

8.1. Modelēšana ar MATLAB

111

Apskatīsim 2 matemātiskās modelēšanas piemērus, risinot parastos un parciālos DV.

1. Apskatot žiratrona modelēšanu, risina veselu saimi parasto DV Košī problēmu formā p’+i(Δ-1+|p|2)p=if(x,φ), p(0,φ)= exp(iφ), kur i=(-1)0.5, parametrs φ pieder [0,2π], x pieder [0,L], f ir dota funkcija. Aprēķinos izskaitļo lietderības

koeficientu η=1- un vidējās vērtības pv (x)= .

Skaņošanas nolūkos apskata L=15, Δ=0.6 un funkciju f(x,φ)=exp(iφcos(πx/L))(Δ-(φπ/L) sin(πx/L)), tad p(x,φ)= exp(iφcos(πx/L)), η=0, pv (x)= (exp(2πicos(πx/L))-1)/ (2πicos(πx/L)).Programmas M-fails:%p_x+i(Delta-1+|p|^2)p=if,p(0)=exp(i*fi)function pf(N,M)L=15;Delta=0.6;N1=N+1;N2=N-1;x=linspace(0,L,N1);hf=2*pi/M;tspan=x; pv=zeros(N1,1);eta=0;f=@(x,ff) exp(i*ff*cos(x*pi/L))*(Delta-. . .ff*pi/L*sin(pi*x/L));%anonīmāfunk. ar 2 argumentiemfor jf=1:Mff=jf*hf; y0=exp(i*ff);options=odeset('RelTol',1e-3); % precizitāte[tout,yout]=ode45(@labp,tspan,y0,options);p=yout; eta=eta+(abs(p(N1)))^2;pv=pv +p;endpv=pv/M; eta=1-eta/M , figurep1=2*i*pi*cos(x*pi/L);pp=(exp(p1)-1)./p1;subplot(2,1,1);plot(real(pv),imag(pv),'.','markersize',16)grid ontitle('Functions p_{aver.}(x),of \Delta=0.6')ylabel('Im(p_{aver.})')xlabel('Re(p_{aver.})')subplot(2,1,2);plot(real(pp),imag(pp),'.','markersize',16)grid ontitle('Functions pexact_{aver.}(x),\Delta=0.6')ylabel('Im(pexact_{aver.})'),xlabel('Re(pexact_{aver.})') function dydt=labp(t,y) dydt=i*(f(t,ff)- (Delta-1 +(abs(y(1)))^2)*y(1)); endendPalaižot šo programmu ar >> pf(101,180) (precizitāte 1e-3), iegūstam η=0.2418 (0 vietā) un nesimetrisku tuvināto grafiku:

112

-0.4 -0.2 0 0.2 0.4 0.6 0.8 1 1.2-1

-0.5

0

0.5

1

Functions paver.(x),of =0.6

Im(p

aver

.)

Re(paver.)

-0.4 -0.2 0 0.2 0.4 0.6 0.8 1-1

-0.5

0

0.5

1

Functions pexactaver.(x),=0.6

Im(pex

act

aver

.)

Re(pexactaver.)

Ja palielinam precizitāti, lietojot operatoru options=odeset( ‘RelTol ‘,1e-4).Tad η=0.1254 un nesimetrija saglabājas. Ar precizitāti 1e-5, η=0.0074, bet ar 1e-6, η=0.00005 un abi grafiki sakrīt.

Ja funkcija f būtu iegūta ar citu metodi tikai režģa punktos, tad jālieto interpolācija ar splainiem, piem., galvenajā programmas pf(N,M) daļā jābūt operatoram cp=spline(x,f), bet apakšprogrammā labp(t,y) operatoram ppvap(cp,t), kas izskaitļo interpolēto funkciju DV labajā pusē jebkurai argumenta t vērtībai. Interpolācijas gadījumā precizitāte saglabājas.

Apskatot Košī problēmas Runges-Kutas risināšanas metodes soļu sadalījumu atkarībā no precizitātes RelTol, lietojam operatoruode45(@labp,tspan,y0,options) kopā ar options=odeset('RelTol',1e-3,’Stats’,’on’), ja N=M=1:

1) RelTol=10-3 ,21 successful steps, 139 function evaluations

0 5 10 15-1.5

-1

-0.5

0

0.5

1

1.5Functions Re(p)(x),of RelTol=1e-3

x

Re(

p)

2) RelTol=10-6, 99 successful steps, 601 function evaluations

0 5 10 15-1.5

-1

-0.5

0

0.5

1

1.5Functions Re(p)(x),of RelTol=1e-6

x

Re(

p)

113

2. Apskatīsim piemēru ar periodiskiem nosacījumiem x-ass virzienā, bet y-virzienā uzdodot 1.veida robežnosacījumus U|y=0=0, U|y=1=cos(2x)sh(2) risinot Laplasa parciālo diferenciālvienādojumu (PDV), (precīzais atrisinājums ir U(x,y)=cos(2x)sh(2y) ). Diskretizējot Laplasa PDV ar 6.kārtas aproksimāciju, iegūstam 9-punktu šablona diferenču vienādojumus:4(uj-1,k +uj+1,k+uj,k-1+uj,k+1) –20uj,k+uj-1,k-1+uj-1,k+1+uj+1,k-1+uj+1,k+1 =0, kur uj,k aproksimē U(xj,yk), xj = jh, yk =kh, j=0(1)N, k=0(1)M, hN=hM=1 (h ---solis).

Realizējot šo diferenču shēmu ar MATLAB programmu “laplas” iegūstam%Laplasa PDV ar 6.kārtas DS, periodiskie nos.pa x % precizais atrisinājums U=cos(2pi x) sinh(2pi y)function laplas(N,M)l=1;L=1;N2=N-1;N1=N+1;h=l/N;M2=M-1;M1=M+1;h1=L/M;NM=N*M;NM2=NM-N;M3=M2-1;NM3=NM2-N;M4=M3-1;x=linspace(0,l,N1);y=linspace(0,L,M1)';x=x(2:N1); h12=1/h^2 +1/h1^2;y=y(2:M);%1.veida nosB=zeros(N,N);B2=zeros(N,N);B3=zeros(N,N);B=B-(2/h^2+2/h1^2-h12/3)*diag(ones(N,1))+ ...(1/h^2-h12/6)*diag(ones(N2,1),-1)+(1/h^2-h12/6) ... *diag(ones(N2,1),1);B(1,N)=1/h^2-h12/6;B(N,1)=1/h^2-h12/6; B1=sparse(B);B=B1;for k=1:M3 B=blkdiag(B,B1);endB2=B2+(1/h1^2-h12/6)*diag(ones(N,1))+ ...h12/12*diag(ones(N2,1),-1) ... +h12/12*diag(ones(N2,1),1);B2(1,N)=h12/12;B2(N,1)=h12/12;B1=sparse(B2);B2=B1; for k=1:M4 B2=blkdiag(B2,B1); endB(1:NM3, N1:NM2)=B(1:NM3, N1:NM2)+B2(1:NM3,1:NM3);B(N1:NM2,1:NM3)=B(N1:NM2,1:NM3)+B2(1:NM3,1:NM3);spy(B,'.k',10);f=zeros(NM2,1);f(NM3+1:NM2,1)=-cos(2*pi*x)'*sinh(2*pi)* ...((1/h1^2-h12/6)+h12/6*cos(2*pi*h)) ;u=B\f; u=(reshape(u,N,M2))';pr=sinh(2*pi*y)*cos(2*pi*x);u=u-pr;X=ones(M2,1)* x; Y=y*ones(1,N);figuresurfc(X,Y,u),colormap(gray),colorbar,xlabel('x'), ylabel('y'), zlabel('u')view(135,45)title(sprintf('Period. x-virz., ... 4.un6.kārt.DS,h=%4.2f,h1=%4.2f',h,h1))

114

Ja N=M=4 iegūstam matricai A(diferenču vienādojumu matrica) ar operatoru spy(A) šādu šablonu:

Skaitļojot šo programmu ar N= M=20, iegūstam augstu precizitāti 10-5 , skat. kļūdas grafiku:

Ar datoru “ Pentium 3”, lietojot retinātās matricas A algoritmus izdevās 20 sek. laikā veikt aprēķinus ar N=100, M=100 (matricā A ir ap 50000 nenulles elementu).

Kā 3. piemēru apskatīsim stabilitātes apgabala robežas noteikšanu diferenču shēmām (DS) parastajam testa diferenciālvienādojumam U’(t)= U(t) (1)ar kompleksu parametru . Lietojot vienmērīgu laika režģi tn=n, n=0,1,2,… (- laika solis, n- laika slānis), apskatām tajā tuvinātās (režģa) vērtības un, kas aproksimē U(tn) laika momentā tn. Lietojot divu slāņu atklāto diferenču shēmu (DS) ar svaru (-metode), aizstāj DV (1) formā un+1=un +(1-)un +un+1, n 0, u0=U(0), (2)kur parametrs [0,1].

115

0 2 4 6 8 10 12

0

2

4

6

8

10

12

nz = 84

Lietojot šo -metodes DS (2) testa vienādojuma (1) aproksimācijai varam to uzrakstīt formā un+1=R() un, R(z)=(1+(1-)z)/(1-z), (3)kur R(z) ir stabilitātes funkcija (z=τ). Par DS (metodes) stabilitātes apgabalu sauc kopu S={z C: |R(z)| 1} (4)kompleksā plaknē C. Ja kopa S satur kompleksās plaknes kreiso pusplakni Re(z) 0, tad DS sauc par absolūti stabilu. Ja z=x+iy un < 0.5, tad no (4) seko nevienādība (x+1/(1-2 ))2+y2 1/(1-2). (5)Tātad stabilitātes apgabals S ir riņķis kompleksās plaknes kreisajā pusē ar centru punktā x=-1/(1-2) (uz reālās ass) un rādiusu . Ja =0, tad tas ir vienības riņķis (Eilera metode). Ja =0.5, tad šī riņķa iekšpuse sakrīt ar visu kreiso pusplakni (Re(z) 0) un -metodes DS kļūst absolūti stabila . Ja >0.5, tad nevienādība (4) ir formā (x-|1/(1-2 )|)2+y2 |1/(1-2)| (6)un stabilitātes apgabals S ir visa kompleksā plakne ārpus riņķa, kura rādius ir

un kurš atrodas labajā pusplaknē ar centru punktā x=1/|(1-2)|. Ja =1, tad šis riņķis kļūst par vienības riņķi.

Aizklāto trapecas metodi (=0.5) var modificēt kā atklātu (Eilera-Košī metode), ja par prediktoru lieto atklāto Eilera metodi , proti un+1=un +0.5un +0.5(un+un ). (7)DS (7) stabilitātes funkcija ir R(z)=1+z+0.5z2.Stabilitātes līkni var iegūt ar MATLAB palīdzību, lietojot m- failufunction stab[x,y]=meshgrid(-4:0.01:0,-2:0.01:2);z=x+i*y;f=1+z+0.5*z.^2;v=[1 1];colormap(gray);contour(x,y,abs(f),v)Ar komandu >> stab iegūstam DS (26) stabilitātes līkni. Šeit vektors v=[1 1] norāda, ka jāzīmē viena līmeņu līnija ar vērtību Z=|R(z)|2 =1.

-4 -3 -2 -1 0 1 2-2

-1.5

-1

-0.5

0

0.5

1

1.5

2

Ir iespēja zīmēt arī pašu stabilitātes apgabalu, ja izveido M-failu stab1.m:

function stab1clfx=-3:0.02:0.5; y=-2:0.02:2;

116

for k1=1:length(x) for k2=1:length(y) z=x(k1)+i*y(k2); if abs(1+z+z.^2/2)<=1 plot(x(k1),y(k2), 'Color', 'black') hold on end endendtitle('Adamsa 3-slāņu DS stab. apg.')axis equal

-3 -2.5 -2 -1.5 -1 -0.5 0 0.5 1

-1.5

-1

-0.5

0

0.5

1

1.5

Eilera-Kosi DS stab. apg.

Runge-Kuttas (RK) atklātai s-tās kārtas DS stabilitātes funkcija ir formā R(z)=1+z+z2/2+z3/6+ … + zs/s! t.i. Teilora rindas nogrieznis( s=2—Eilera-Košī DS).

Lineāru k+1-slāņu metodi (DS ) testa vienādojumam (1) definē ar formulu

(8.8)

kura izmanto k vērtības un, . . . , un+k-1 lai izskaitļotu aizklāti un+k. Šī (k+1)-slāņu DS ir atklāta, ja koeficients k=0, citādi tā ir aizklāta. Pieņemsim, ka koeficients k >0. Ja k=1, tad iegūst RK un - metodes. Pētot DS stabilitāti testa problēmai (1), meklē k-tās kārtas homogēno diferenču vienādojumu (8) (z=) atrisinājumu formā un=()n. Iegūstam k-tās pakāpes raksturīgo polinomu

(9)

Stabilitātes nosacījums: Visām polinoma (9) saknēm jāatrodas vienības riņķī, t.i. ,

|| 1, (10)turklāt vienādība ir pieļaujama tikai vienkāršām saknēm. Pētot DS (8) stabilitāti, pielīdzinot (9) nullei

z=P1()/P2(), kur P1() = P2()=

Tā kā uz stabilitātes apgabala robežas raksturīgā polinoma (9) saknēm jābūt pēc moduļa vienādām ar 1, tad ņemot = exp(it), kur t[0, 2], iegūstam stabilitātes līkni kompleksajā plaknē no funkcijas

117

z=P1(eit)/P2(eit), t[0, 2] (11)parametriskā veida grafika.

Piemēram, atklātai 3-slāņu Ādamsa DS z=(2-)/(1.5*-0.5) skaitļojot ar MATLAB iegūstam: >> t=0:0.1:2*pi; r=exp(i*t);z=(r.^2-r)./(1.5*r-0.5);plot(z),axis equal

-1.5 -1 -0.5 0 0.5-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

Lietojot MATLAB m-failu stab2.m var redzēt arī pašu stabilitātes apgabalu:function stab2clfR=0.5:0.01:1; t=0:0.02:2*pi;for k1=1:length(R) r=R(k1)*exp(i*t); z=(r.^2-r)./(1.5*r-0.5); plot(z, 'Color', 'black') hold onendtitle('Adamsa 3-slanu DS stab. apg.')axis equal

-1.5 -1 -0.5 0 0.5-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8Adamsa 3-slanu DS stab. apg.

Līdzīgi var iegūt stabilitātes līknes arī citām DS.

118

8.2. Modelēšana ar MAPLE

Apskatīsim robežproblēmu parastajam DV un jaukta veida problēmu parciālajam DV (siltuma vadīšanas vienādojums).

1. Nelineāra robežproblēma DV :

> deq2 := diff(y(x),x,x)+(2+y(x)^2)*y(x)/(1+y(x)^2)=1;

> bc2 := y(0)=0,y(2)=3: dsol2 := solve({deq2,bc2},numeric,output=listprocedure);

> fy := subs(dsol2,y(x));

> seq(fy(2*i/4),i=0..4);

> odeplot(dsol2);

> odeplot(dsol2,[x,y(x)],0..2, numpoints=25); => grafiks sakrīt ar iepriekšējo.

2. Risinot parciālos DV (PDV) vai sistēmas, kas ir skaitliski atkarīgas no laika, lieto komandu pdsolve(PDV, nos, numeric, main, opc), kur nos ir sākuma un robežnosacījumi, main --- atkarīgie mainīgie. Modelējot siltuma vadīšanas PDV uz taisnes nogriežņa ar fiksētu temperatūru kreisajā galā un izolētu otru galu, iegūst:

> PDE := diff(u(x,t),t)=1/10*diff(u(x,t),x,x);

> IBC := {u(x,0)=1, u(0,t)=0, D[1](u)(1,t)=0};

> pds := pdsolve(PDE,IBC,numeric);

119

> p1 := pds:-plot(t=0): p2 := pds:-plot(t=1/10):p3 := pds:-plot(t=1/2): p4 := pds:-plot(t=1): p5 := pds:-plot(t=2): plots[display]({p1,p2,p3,p4,p5}, title=`Heat profile at t=0,0.1,0.5,1,2`);

> pds:-value(t=1,output=listprocedure);

> uval := rhs(op(3,%));

> fsolve(uval(x)=1/2,x=0..1);

> pds:-plot3d(t=0..1,x=0..1,axes=boxed, orientation=[-120,40], color=[0,0,u]);

3. Zīmejot stabilitātes līknes atklātajai Eilera-Košī DS, var veidot MAPLE komandas:

120

restart:with(plots):implicitplot((1+x+0.5*(x^2-y^2))^2+(y+y*x)^2-1,x=-2..1,y=-2..2,view=[-4..0,2..2],color=black, thickness=3);

Analogi 3-slāņu (2-soļu) atklātai Ādamsa DS iegūstam (cos(x)+I*sin(x) vietā var rakstīt exp(I*x)):

restart:with(plots): complexplot(((2*(cos(x)+I*sin(x))^2- 2*(cos(x)+I*sin(x)))/(3*(cos(x)+I*sin(x))-1)),x=0..2*Pi, title=`k=2`,color=black, thickness=3);

Iespējams arī cits variants:

>

121

8.3. Modelēšana ar MATHEMATICA

Siltuma vadīšanas (difūzijas) parciālā diferenciālvienādojuma jaukta veida problēmas tu(x,t)=uxx(x,t), u(x,0)=6sin(πx), u(0,t)=u(1,t)=0 skaitliska modelēšanalaika segmentā [0,0.5] (analītiskais atrisinājums u(x,t)=6sin(πx) exp(-π2 t)):

solt=NDSolve[{t D[u[x,t],t]-D[D[u[x,t],x],x]==0, u[0,t]==6 Sin[Pi x], u[0]==0, u[L]==0}, u, {x,0,1}, { t, 0, 0.5}];InterpolatingFunction[{{0.,1.},{0.,0.5}},<>] {{uInterpolatingFunction[{{0.`,1.`},{0.`,0.5`}},"<>"]}}Plot3D[solt[x,t],{x,0,1},{t,0,0.5},PlotRange->All,PlotPoints->25];Plot3D[6 Sin[Pi x] Exp[- Pi*Pi t],{x,0,1},{t,0,0.5},PlotRange->All,PlotPoints->25] {{uInterpolatingFunction[]}}

00.2

0.40.6

0.81 0

0.1

0.2

0.3

0.4

0.5

0

2

4

6

00.2

0.40.6

0.81

122

00.2

0.40.6

0.81 0

0.1

0.2

0.3

0.4

0.5

0

2

4

6

00.2

0.40.6

0.81

No grafikiem redzams, ka abi atrisinājumi (tuvinātais un precīzais) sakrīt.

Ar MATHEMATICA var tieši zīmēt stabilitātes apgabalu, piemēram, atklātai 2-slāņu DS (Eilera-Košī metode) iegūstam <<Graphics`InequalityGraphics` ComplexInequalityPlot[ Abs[1+z+z^2/2] 1, {z} ]

-2 -1.5 -1 -0.5

-1.5

-1

-0.5

0.5

1

1.5

-2 -1.5 -1 -0.5

-1.5

-1

-0.5

0.5

1

1.5

Zīmējot stabilitātes līknes daudzslāņu DS ir iespējams lietot operatoru ParametricPlot, piemēram, atklātai Ādamsa 3-slāņu DS iegūstamg[t_]:=(Exp[2*I*t]-Exp[I*t])/(1.5*Exp[I*t]-0.5); ParametricPlot[{Re[g[t]],Im[g[t]]},{t,0,2 Pi},AspectRatio->Automatic];

123

-1 -0.8 -0.6 -0.4 -0.2

-0.75

-0.5

-0.25

0.25

0.5

0.75

Ir iespējams lietot arī paketi > > Graphics ‘ComplexMap’, piemēram, <<Graphics`ComplexMap`g[t_]:= (Exp[2*I*t]-Exp[I*t])/(1.5*Exp[I*t]-0.5);CartesianMap[g,{0,2*Pi},{0,500000000}]

-1 -0.8 -0.6 -0.4 -0.2

-0.75

-0.5

-0.25

0.25

0.5

0.75

8.4 Uzdevumi

1) zīmēt θ- metožu (2) stabilitātes līkni, ja θ=0; 0.1; 0.5; 0.8; 1., lietojot 3 veidu DP,

2) zīmēt daudzslāņu DS (8) stabilitātes līkni Ričardsona 3-slāņu atklātai shēmai, ja z=(ρ2 -1)/ 2 ρ, lietojot 3 veidu DP,

3) zīmēt daudzslāņu DS (8) stabilitātes līkni Richtmeiera-Mortona 3-slāņu aizklātai shēmai, ja z=(1.5 ρ2 -2 ρ+0.5)/ ρ2, lietojot 3 veidu DP,

4) zīmēt daudzslāņu DS (8) stabilitātes līkni Simpsona 3-slāņu aizklātai shēmai, ja z=3(ρ2 -1)/ ( ρ2 +4 ρ +1), lietojot 3 veidu DP,

5) zīmēt daudzslāņu DS (8) stabilitātes līkni Ādamsa 3-slāņu atklātai shēmai, ja z=(ρ2 - ρ )/ (1.5 ρ-0.5), lietojot 3 veidu DP,

124

6) zīmēt daudzslāņu DS (8) stabilitātes līkni Ādamsa 4-slāņu atklātai shēmai, ja z=(ρ3 - ρ 2)/( 23/12 ρ2-16/12 ρ+ 5/12) lietojot 3 veidu DP,

7) zīmēt daudzslāņu DS (8) stabilitātes līkni Ādamsa 3-slāņu aizklātai shēmai, ja z=(ρ2 - ρ )/ (5/12 ρ2 + 8/12 ρ -1/12), lietojot 3 veidu DP,

8) zīmēt daudzslāņu DS (8) stabilitātes līkni Ādamsa 4-slāņu aizklātai shēmai, ja z=(ρ3 - ρ 2)/( 9/24 ρ3+19/24 ρ2 - 5/24 ρ +1/24 ) , lietojot 3 veidu DP,

9) zīmēt daudzslāņu DS (8) stabilitātes līkni BDF( diferences atpakaļ) 4-slāņu aizklātai shēmai, ja z=(11/6 ρ3 -3 ρ2 + 3/2 ρ-1/3)/ ρ3, lietojot 3 veidu DP,

10) zīmēt daudzslāņu DS (8) stabilitātes līkni ekstrapolācijas 3-slāņu atklātai shēmai, ja z=(3/2ρ2 -2 ρ +1/2)/ (2 ρ-1), lietojot 3 veidu DP,

11) zīmēt daudzslāņu DS (8) stabilitātes līkni ekstrapolācijas 4-slāņu atklātai shēmai, ja z=(11/6 ρ3 -3 ρ2 +3/2 ρ -1/3 )/ (3 ρ2 -3 ρ +1), lietojot 3 veidu DP,

LITERATŪRA

1. H.Kalis, S.Lācis, O.Lietuvietis, I.Pagodkina. Programmu paketes “Mathematica” lietošana mācību procesā, māc.līdz., “Mācību grāmata”, Rīgā, 1997, 1-41 lpp.2. H.Kalis. Izvēlētas nodaļas diferenču shēmu skaitliskajā analīzē ar datorprogrammām „Matlab”, „Maple” lietošanu, māc. līdz., izdales materiāls izveidots pēc ESF projekta, LU, 2006, 183. lpp.3. H.Kalis. Skaitliskās metodes ar datorprogrammu „Maple”, „Mathematica” lietošanu, māc. līdz., Rīga, 2001, 410 lpp.4. T.B.Bahder. Mathematica for scientists and engineers. Addison-Wesley , 1995, 846 pp.5. R.E.Maeder. Programming in Mathematica. Addison-Wesley, 1991, 279 pp.6. E.W. Char, K.O.Geddes, G.H.Gonnet a.o. First leaves: a tutorial introduction to MAPLE V. Springer – Verlag, 1991, 400 pp. 7. I. Anufrijevs, A. Smirnovs, J. Smirnova . MATLAB-7, Sankt- Pēterburga, 2005, 1089 lpp. (krievu valodā) 8. A. Heck. Introduction to MAPLE. Springer-Verlag, New-York, Inc., 1996

125