Matemātiskās modelēšanas praktikums I
Matemātiskās un statistiskās datorprogrammu
paketes (1.daļa)
H.Kalis
Rīga
2007
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ā.
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…………………………………………………………..21
2. 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………………………48
3. 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………………………….64
4. 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
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……………………….88
5. 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...………………………………...99
6. 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………………………………….…107
7. 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………………………………………...111
8. 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……………………………………………………………………...124
Literatūra……………………………………………………………………………125
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) ( Anglijā izstrādātā sistēma MATHCAD),
2) (Amerikā profesoru izstrādātā sistēma MATHEMATICA),
3) (Kanādā studentu izstrādātā sistēma MAPLE),
4) (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
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 un
Zinā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 vide
Ielā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 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 MATLAB
Komandas, 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, 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+2
ans = 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 = 10
7) veidot kompleksu skaitli 2+3i no reālas un imaginārās daļas
>> complex(2,3) ans =2.0000 + 3.0000i
8) 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));
>> 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.4636
18) 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 un aizzīmējot programmas operatorus un izpilda tās ar Evaluate Selection (vai ).
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.
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 komanda
f = 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:
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 "[pic]" 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 MAPLE
Galvenās iebūvētās funkcijas ir:
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=[pic]) (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, >, [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.,
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+[pic]) (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));
[pic][pic],
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.,
taylor (sin(x), x,6);
[pic][pic],
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); [pic][pic],
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); [pic][pic](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]);[pic] [pic]
(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:= [pic],
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.,
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);
[pic], [pic],
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)
[pic],
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),
[pic]
1.2.3 Funkciju veidošana un darbības ar tām
Patvaļīgas funkcijas y = f(x) definīcijai lieto komandu f:= x(izt, 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 komandu
piecewise (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 +, =, < >.
Piemēram, assume (a f(x) = x2/3+1.
Var veidot arī aritmētiskas operācijas ar funkcijām, piem.,
f:= x (izt1: g:=x(izt2: (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 virkni
if, then, elif, then, ..., else, end if.
Var veidot funkcijas arī no diviem un vairāk argumentiem, piem., operators
f:= (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 -3, g(5); => 26
(definē funkciju ar 2 formulām un aprēķina tās vērtības),
4) h:= x(if x< –2 then x+3 elif x0,
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:=x(x^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)
[pic]
y:= f(x); => y:= x2+3x–18 (pārvērš funkciju par izteiksmi),
g:= unapply (izt, x); => g:= x(x2+3x-18 (pārvērš izteiksmi par funkciju),
g(x); => x2+3x–18,
7) f:=x(x^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:= x(x^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:= x(x^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)
[pic],
solve (" " 6x (atrod funkcijas otro atvasinājumu),
solve (">0); => {0 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,
11) sqrt (cosh(x)^2–1)*sqrt (cosh(x)^2+1): "=combine (", `trig`);
[pic](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 (")
[pic]· ,
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) = [pic](kompleksa izteiksme),
map (convert,",`trig`);
cos(x) = [pic]
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([pic]+Ix),
23) arcsinh(x): "=convert (",ln); => arcsinh(x) = ln(x+[pic]),
24) arccosh(x): "=convert (",ln); => arccosh(x) = ln(x+[pic]).
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));
[pic].
28) simplify ((–1)^(1/3), assume=real);
[pic][pic](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
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{-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] => [pic],
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+ [pic])/2 = 1.61805…
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 [pic].
Piemēri.
1.) a=1470./180*N[Pi]; Series [Sin[x], {x,0,160}]; p:= Normal [%];
N [p/.x(a] => –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/.x(a] => –6.87538, aprēķina
sin (14700) ar 161 saskaitāmiem pakāpju rindā,
Series [Sin[x], {x,0,166}]; p2:= Normal [%]; N[p2/.x(a]
=> –6.87538, aprēķina sin (14700) ar 166 saskaitāmiem pakāpju rindā; izskaitļojumi 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 [pic]precīzo vērtību,
For [y0=1.–Exp[–1.]; k=1, k –437.0, izdod vērtību aprēķinātu pēc nestabilas rekurences sakarības
Ik = 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 operatoriem
fc = 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).
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)
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 MATLAB
Ar 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 MATLAB
MATLAB-ā 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)
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 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 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,
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), trajektoriju
x = 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
>> 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
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
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 MATLAB
MATLAB 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”( ), “\pm” ((), “\partial”( (), “\rightarrow”(-->), “\downarrow”((), “\uparrow”((), “\propto”((), “\leftarrow”(> [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), colorbar
krā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:
>> [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
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)
13) pīķveida iebūvētās funkcijas “peaks” grafiks:
>> peaks %izdod grafiku un sekojošu formulu
z = 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
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 objekti
Visi 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).
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ši
operatorā 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.
2.1.6 MATLAB 7 iespējas
Izdodot 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 redaktoru
3) 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 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:
[pic]
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.
2) 3-dimensiju grafika instrumentu paneļa rīki:
[pic]
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),
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 [pic](a,b), y[pic](c,d) ar uzrakstiem uz asīm.
Ja funkcijas definīcija ir formā f:=x(izt, tad var zīmēt grafiku šādi:
1) plot (f(x), x=a..b, opc) – zīmē grafiku x[pic](a,b),
2) plot (f, a..b, c..d, opc) – zīmē grafiku x[pic](a,b), y[pic](c,d),
3) plot (f, opc) – zīmē grafiku intervālā x[pic](–10,10).
Var veidot arī aritmētiskas operācijas ar funkcijām un zīmēt to grafikus,
piem. f:= x(izt1: g:=x(izt2: (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);
[pic][pic],
"^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[pic][–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.
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(");
[pic]
(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));
[pic]
(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:=x(limit ((g(x+h)–g(x)) / h, h=0);
=> g1:= [pic](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 x0 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:= x(5x4+36x3–57x2–482x–150
(funkcijas atvasinājums f'(x)=f1(x)),
To:=x(f1(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:= x(f1 (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:= x(f1 (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:= x(f1 (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.6440691308
y4:= 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:= x(piecewise (x>3, x^2, x–5);
=> f:=x([pic],
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:= x(x^2: g:=x(x^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,
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:= x(2*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:= x(x^(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:= x(3*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 );
[pic]
[pic]
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
[pic]
2.2.3 MAPLE 3- dimensiju grafiki un to lietojumi
Lietojot 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 komandu
plot3d (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.
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
[pic]
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 lietojumi
Funkcijas 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 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 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),
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ā
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
[pic]
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,PlotStyle(PointSize[0.02]]; => zīmē punktveida grafiku
[pic]
4) ParametricPlot[{Cos[5t],Sin[3t]},{t,0,2Pi},AspectRatio(Automatic]; =>zīmē sarežģītu līkni plaknē
[pic]
5) izsauc paketi un zīmē aizklātās funkcijas y=f(x) grafiku (līknes )
[pic]
?ContourGraphics?
6) 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) līkne telpā
[pic]
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*h
Funkcija “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/2
Pā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/100
Lietojot 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
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*e
Algebriskie 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= 0
Augstā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^2
var 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:
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īniju
k=diff(f,x,1); K=subs(k, ‘x‘,X0); yt=sym(‘y0+k*(x-x0)’); % simb. vdj.-s
yt=subs(yt, ‘k’, K); yt=subs(yt, ‘x0’, X0); yt=subs(yt, ‘y0’, Y0); hold on
ezplot(yt,[A B]) % ievieto pieskares vienād. reālos param. un zīmē to
plot(X0, Y0, ‘o’) % pieskares punkts tiek atzīmēts ar riņķi
grid 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:
>>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 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
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:=n(izt (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 [pic][pic] konverģences pētīšanai lieto Dalambēra, Košī un integrālo kritērijus:
[pic], [pic], [pic].
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(");
[pic]
2) Limit (a(n)+b(n), n=infinity): "=expand (");
[pic],
3)Limit (a(n)+b(n), n=infinity): "=expand(");
[pic],
4) Limit (a(n)^b(n), n=infinity): "=expand(");
[pic].
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,
plot (f, 0..5); => zīmē grafiku,
2) a:=n(2^(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:=n(ln(n)/n^2: int (a(n), n=1..infinity): value(");
=>1 (rinda konverģē pēc integrālā kritērija),
4) g:=x(sqrt (x^2–4*x)–x: limit (g(x), x=infinity);=> –2,
5) f:=x(piecewise(x–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 (");
[pic],
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(");
[pic], [pic],
Limit (",k=infinity): "=value(");
[pic],
12) ln (x)–ln (x+exp (–x)): Limit (",x=infinity ): "=value (");
[pic],
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
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);
[pic],
solve(",diff(y(x),x)); => atvasinājuma y' (x) izteiksme,
[pic],
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.
Zinot funkcijas augstākas kārtas atvasinājumus, var veidot Teilora rindu [pic]
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:=x(x^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:=x(x^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:=x(evalf (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:=x(a^x:eval (f); =>x(ax, D (f); => x( axlna,
13) taylor (sin(x),x,10); => x
[pic],
p1:=convert (",polynom); => p1:=x
[pic],
plot ({sinx,p1}, x= –5..5, y= –2..2);=> zīmē 2 grafikus, kur redzama Teilora rindas tuvinājuma precizitāte,
14) y:= x(exp (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.
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 komandu
convert (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:=x(int (f(t), t=a..x): var viegli pārbaudīt sakarību [pic], 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`).
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);
[pic]
(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)
[pic],
value (");=> –xcos(x)+sinx,
6) A:=Int ((cos(x)+1)^3*sin(x),x): changevar (cos(x)+1=u,A,u);
[pic][pic],
A1:=value (");=>A1:= –u4/4, A2:=subs (u=cos(x)+1,A1);
[pic],
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);
[pic],
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:=x(int (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:=x(arcsin(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), 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);
[pic][pic],
g3:=limit (g2, n=infinity);
[pic],
expand (g3);
[pic],
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);
[pic]
(aprēķina divkāršo integrāli).
15) y:= x®(2*x+8)/(18*x^2+52*x–6): convert (y(x), parfrac,x);
[pic],
int (",x);
[pic]
16) y:= x(–1/3*x^2–4*x+9: with (student): trapezoid (y(x), x= –13..1,20);
[pic],
evalf ("); => 217.3966667 (aprēķina tuvināti laukumu segmentā [–13,1], lietojot trapecas formulu),
simpson (y(x), x= –13..1,20);
[pic]
[pic],
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"
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ā
[pic].
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 komandu
taylor (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);
[pic],
4) taylor (sin(x), x=0,6); p:=convert (",polynom);
[pic], [pic],
ss:=series (sin(x), x=0,6): diff (ss,x);
[pic],
integrate (ss,x);
[pic],
solve (y=ss,x);
[pic],
convert (ss,ratpoly); => racionāla daļveida funkcija
[pic],
convert (ss,ratpoly,1,2); =>racionāla daļveida funkcija ar 1.pakāpes polinomu skaitītājā un 2.pakāpes – saucējā
[pic],
convert (ss,'confrac'); => nepārtrauktā vai ķēdes daļa)
[pic].
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);
[pic],
2) s1:=powadd (powpoly (1+x^2+x,x), powlog (1+x)):
tpsform (s1,x,6);
[pic],
3) s:=evalpow (tan(x)): tpsform (",x,5);
[pic],
4) s:=series (exp(–x), x=0,6): inverse (s):subs (x=s,");
⇨ x+0(x6) (pārbauda inverso pakāpju rindu),
5) s1:=series (sin(x),x);
s1 [pic],
s2:=series (cos(x),x);
s2: [pic],
⇨ s3:=series (exp(x),x);
s3: [pic],
powadd (s1,s2);
[pic].
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]/.x(x0.
Nenoteiksmes gadījumā lieto Limit[f[x], x(x0].
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],x(x0,Direction (1] (robeža no kreisās puses vai uz priekšu), Limit[f[x],x(x0,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
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
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/. x(0=> [pic] (nevar izskaitļot), Limit[t, x( 0]=> 1,
2) Limit[1/x, x(0, 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 [pic]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
13) sinseries=Series[Sin[x],{x,0,7}] => [pic]
cosseries=Series[x Cos[x],{x,0,7}] => [pic]
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—vektoriem
Visi 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”, 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*h
Funkcija “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/2
kur 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
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.0000i
16) 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ām
Matricas 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 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 no
matricas 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 elementu
kvadrā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),
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 0
3) 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
>> 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 MATLAB
MATLAB-ā 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\b
izdod 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
6.8541
izskaitļ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 21
21. 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
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=4
pā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)
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=-4
10) 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 daudz
lielā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]
>> 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ļiem
Daž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:=k(k^2: f(10); =>100.
Iespējams arī veidot vektoru a ar naturālo skaitļu koordinātēm, piem.
a:=vector(5,i(f(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:=k(2*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 [pic],
7) isqrt (n) – tuvāko naturālo skaitli saknei [pic],
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ā"):
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 [pic],
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 (");
[pic],
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},
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 MAPLE
Datorprogramma 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 operatoru
convert (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});
[pic],
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,
2) solve (a/x=c/d, x); =>ad/c,
3) solve ((x–1/3)/(x+1/2)>0, x);
[pic],
4) f:=n(3*(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ēm
Reā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 [pic], 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 komandu
radnormal (izt), piem. radnormal (sqrt(3+sqrt(3) + (10+6*sqrt (3))^(1/3)));
[pic].
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:=n(1/n^2: sum (a(n), n=1..infinity);
[pic],
sum (a(n), n=1..50): S50:=evalf ("): kl:=evalf (Pi^2/6–S50);
=> 0.019801334 (kļūdas novērtējums summas atlikuma loceklim),
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 MAPLE
Ar 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, [pic], –arctan (22/7)+Pi,
Analogi izskaitļo arī kompleksu funkciju vērtības, piem.,
cos (I); => cosh (1), sqrt (–8); => I [pic], 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),
[pic]
Lietojot konkrētus pieņēmumus, izteiksmes var vienkāršot, piem.,
assume (p>0, q>0): evalc (sqrt (p+q * I));
[pic]
(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));
[pic].
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).
Piemēri:
1) solve (x^4=1,x); => 1, –1, I, –I,
2) solve (x^2+x+4,x);
[pic],
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 polinomiem
Ar 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.
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:=x(poly 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);
[pic]
(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];
5.113090584
–2.201911777
0.08882119235 (izdod polinoma 3 ekstrēmus),
p1 (fs [1]); p1 (fs [2]); p1 (fs [3]);
–382.9164593
–26.26252238
23.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)
[pic]
9) solve (x^2–5*x nevienādības atrisinājumu {0{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});
=> {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,i(f(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),
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,i(f(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.
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);
[pic],
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);
[pic],
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:=
[pic]
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);
[pic],
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),
10) v:=array([1,2,3]): H:=matrix(3,3, (i,j)(1/(i+j));(izveido spec. matricu)=> H:=
[pic]
H1:=inverse(H); => H1:=
[pic],
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:=
[pic],
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:=
[pic],
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 MATHEMATICA
DP 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.
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 + + 625y4;
Length[t2] => 15.
4.3.2 Vienādojumu un vienādojumu sistēmu risināšana ar MATHEMATICA
Algebrisku 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,
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 MATHEMATICA
Vektoru 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] => {{x1(1, 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:
[pic]
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” (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ā t(15:
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
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
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-kolonai
F(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 0
0 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; end
Y0 = [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’)
>> 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ēma
Lietojot 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 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 punktos
x = [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ība
|RelTol |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) |
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ēma
Diferenciā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ē,
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) ... end
F(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]));
[pic]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. ,
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ēma
Robež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= [pic]).
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ūst
a i = - 0.5 (1+0.5 hp(xi )), b i = 1+0.5 h2 q(xi ), ci = - 0.5 (1-0.5 hp(xi )),
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 do
y1 [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 vektorus
A, 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;
[pic]
> 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;
[pic]
> ds:=dsolve({newode,bcs},numeric,continuation=lambda);
plots[odeplot](ds);
[pic]
[pic]
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
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}];
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=10
sol=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}];
[pic]
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}];
{{x→InterpolatingFunction[{{0.,40000.}},],y→InterpolatingFunction[{{0.,40000.}},],z→InterpolatingFunction[{{0.,40000.}},]}}
Plot[Evaluate[x[t]/.atr],{t,0,40000},PlotLabel("x(t)"];
Plot[Evaluate[y[t]/.atr],{t,0,40000},PlotLabel("y(t)"];
Plot[Evaluate[z[t]/.atr],{t,0,40000},PlotLabel ("z(t)"];
[pic] [pic]
[pic]
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}]
[pic]
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}]
{{y→InterpolatingFunction[{{0.,8.}},]}}
With[{s=y[x]/.First[%]},Plot[{s[[1]], s[[2]],s[[3]],s[[4]]},{x,0,8},PlotRange→All]]
[pic]
5) Apskatīsim DV ar dažādām labajām pusēm:
NDSolve[{y'[x]’If[x0.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 [pic] 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.5((un +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- failu
function 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.
[pic]
Ir iespēja zīmēt arī pašu stabilitātes apgabalu, ja izveido M-failu stab1.m:
function stab1
clf
x=-3:0.02:0.5; y=-2:0.02:2;
for k1=1:length(x)
for k2=1:length(y)
z=x(k1)+i*y(k2);
if abs(1+z+z.^2/2)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
[pic] (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(() = [pic] P2(()= [pic]
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
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
[pic]
Lietojot MATLAB m-failu stab2.m var redzēt arī pašu stabilitātes apgabalu:
function stab2
clf
R=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 on
end
title('Adamsa 3-slanu DS stab. apg.')
axis equal
[pic]
Līdzīgi var iegūt stabilitātes līknes arī citām DS.
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;
[pic]
> bc2 := y(0)=0,y(2)=3: dsol2 := solve({deq2,bc2},numeric,output=listprocedure);
[pic]
> fy := subs(dsol2,y(x)); [pic]
> seq(fy(2*i/4),i=0..4);
[pic]
> odeplot(dsol2);
[pic]
> 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);
[pic]
> IBC := {u(x,0)=1, u(0,t)=0, D[1](u)(1,t)=0};
[pic]
> pds := pdsolve(PDE,IBC,numeric);
[pic]
> 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`);
[pic]
> pds:-value(t=1,output=listprocedure);
[pic]
> uval := rhs(op(3,%));
[pic]
> fsolve(uval(x)=1/2,x=0..1);
[pic]
> pds:-plot3d(t=0..1,x=0..1,axes=boxed, orientation=[-120,40], color=[0,0,u]);
[pic]
3. Zīmejot stabilitātes līknes atklātajai Eilera-Košī DS, var veidot MAPLE komandas:
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);
[pic]
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);
[pic]
Iespējams arī cits variants:
> [pic]
[pic]
[pic]
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ēšana
laika 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}},]
{{u(InterpolatingFunction[{{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]
{{u→InterpolatingFunction[]}}
[pic]
[pic]
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 ‘ComplexMap’, piemēram,
................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.