MapleV4 - scurta introducere

MapleV4 - scurta introducere

Maple este un sistem de calcul algebric (CAS) dezvoltat de firma Maplesoft (http://www.maplesoft.com), care poate fi utilizat in:

1. calcule simbolice;
2. calcule numerice;
3. programarea unor metode numerice;
4. reprezentari grafice.

In cele ce urmeaza, vom prezenta principalele elemente necesare in programarea unor metode numerice, corespunzatoare softului MapleV4.

1.1 Reguli generale de introducere a comenzilor

Un document MapleV4 poate avea patru tipuri de campuri:

1.     comenzi Maple (introduse de catre utilizator);

2.     rezultate Maple (raspunsuri ale CAS-ului la comenzile introduse);

3.     grafice (raspunsuri ale CAS-ului);

4.     texte (introduse de catre utilizator).

In continuare, vom prezenta cateva reguli de introducere a comenzilor.

1. Orice comanda se termina cu ; (daca dorim sa afiseze rezultatul) sau : (daca nu dorim ca rezultatul sa fie afisat). De exemplu:

> sin(Pi);

0

> 1+3:

2. Asignarea se face cu : = , iar dezasignarea se face prin asignarea numelui variabilei. De exemplu, putem avea secventa:

> x:= 7;

x : = 7

> x := x + 1:

> x;

8

> x := 'x';

x : = ^′x^′

> x;

x

3. Comentariile sunt precedate de caracterul #. De exemplu:

> x:=3; # se atribuie lui x valoarea 3

x : = 3

4. Maple face diferenta intre litere mici si litere mari:

> x:=3; X:=5; a:=X-x;

x : = 3

X : = 5

a : = 2

5. Secventele sunt scrise intre paranteze rotunde, ( ), listele intre paranteze patrate, [ ], iar multimile intre acolade, . De exemplu:

> secv:=(1,2,3); lista:=[2,1,2,3]; multime:=;

secv := 1, 2, 3

lista := [2, 1, 2, 3]

multime

6. Argumentele unei functii se pun intre paranteze rotunde, ( ) , iar indicii intre paranteze patrate, [ ].

> a:=cos(Pi); b:=lista[2];

a : = −1

b : = 1

7. Procentul, % , face referire la ultima comanda executatt anterior. De exemplu:

> a := 2;

a : = 2

> b:=%+1;

b := 3

8. Daca rezultatul furnizat de Maple este identic cu comanda introdusa (Maple raspunde prin ecou la comanda), atunci aceasta arata ca Maple nu poate interpreta comanda introdusa. Pentru a remedia situatia, verificati daca ati introdus corect comanda sau daca nu cumva functia utilizata face parte dintr-un pachet care trebuie incarcat in prealabil.

> arctg(1); # o incercare de a calcula arctangenta de 1 arctg(1)

arctg(1)

> arctan(1); # apelarea corecta a funcției arctangenta

9. Pentru a nu retine eventuale atribuiri anterioare, este util ca pentru rezolvarea unei probleme noi sa incepem cu instructiunea

> restart;

1.2. Pachete de programe

Pachetele sunt colectii de functii care permit efectuarea de calcule specifice. Apelarea lor se face cu ajutorul comenzii with(nume_pachet). Pentru a apela o anumita functie dintr-un pachet, se foloseste sintaxa:

pachet['functie'](argumente)

Printre cele mai utilizate pachete sunt:

plots - pentru reprezentari grafice;

DEtools - pentru rezolvarea ecuatiilor diferentiale;

linalg - pentru rezolvarea unor probleme de algebra liniara; student - pentru analiza matematica.

De exemplu, la apelarea pachetului grafic, se obtine lista tuturor functiilor apelabile:

> with(plots);

Warning, the name changecoords has been redefined

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

1.3. Constante, operatori si functii des utilizate

Constantele folosite de Maple sunt:

Operatorii folositi frecvent sunt:

Functii folosite frecvent in Maple:

1.4. Structuri de date: secvente, liste, multimi, siruri de caractere

1.4.1 Secvente

O secventa este o insiruire de expresii, separate prin virgule. Exista mai multe moduri de a defini o secventa:

a) direct:

> s:=1,2,3,4; t:=(a,b,c);

s:= 1, 2, 3, 4

t:= a, b, c

b) cu ajutorul functiei seq:

> seq(3*x, x=2..7);

6, 9, 12, 15, 18, 21

c) cu ajutorul unui ciclu for (vezi sectiunea 1.7.1)

Cu ajutorul functiilor min si max se poate calcula minimul, respectiv maxi-mul unei secvente.

> min(s); max(s,2,15);

3

15

1.4.2 Liste

O lista este o secventa de expresii, scrisa intre paranteze patrate, []. De exemplu, putem avea lista:

> ll:=[1,2,5,2,4,2,7,2,a,2,c];

ll := [1, 2, 5, 2, 4, 2, 7, 2, a, 2, c]

Putem afla numarul de operanzi din lista cu ajutorul functiei nops

> nops(ll);

11

Al n-lea element din lista poate fi afisat cu una din comenzile op(n,ll) sau ll[n]

> aa:=ll[3]; bb:=op(9,ll);

aa : = 5

bb : = a

Functia member(elem, ll) returneaza true daca elementul respectiv se afla in lista ll, si false in caz contrar:

> member(d, ll);

false

Lista vida este desemnata prin

> lista:=[];

lista := [ ]

Se poate adauga un element nou la lista ll astfel: [op(ll),elem]. De exemplu:

> lista:=[op(lista), d, e, f];

lista := [d, e, f ]

Se poate sterge al n-lea element din lista ll astfel: subsop(n=NULL,ll). De exemplu:

> lista:=subsop(2=NULL, lista);

lista := [d, f ]

1.4.3 Multimi

O multime este o secventa de expresii, scrisa intre acolade, , in care fiecare element figureaza o singura data. De exemplu:

ll:=; ll :=

Adaugarea unui nou element la multime, sau stergerea elementului de pe pozitia n se face la fel ca la liste.

Multimea vida este desemnata prin

Reuniunea a doua multimi se face utilizand operatorul union:

s:= : t:= :

> s union t;

Intersectia a doua multimi se realizeaza cu ajutorul operatorului intersect:

> s intersect t;

Diferenta a doua multimi se realizeaza utilizand operatorul minus:

> s minus t;

> s minus s;

1.4.4 Siruri de caractere

Sirurile de caractere sunt delimitate de apostrof invers ,', dupa cum urmeaza:

> 'acesta este un sir';

acesta este un sir

Sirurile de caractere se pot concatena cu ajutorul comenzii cat. De exemplu, putem avea:

> i:=4;

i:= 4

> 'Valoarea lui i este ' cat( i);

Valoarea lui i este 4

Atentie! La concatenarea unui sir de cifre, se obtine un sir de caractere, nu un numar:

>       a:=cat(5,7,9); b:=52;

a:=579

b := 52

> whattype(a); # afla tipul expresiei a

symbol

>       whattype(b); # afla tipul expresiei b

integer

> a+b;

a :=579+52

>       whattype(a+b); # afla tipul expresiei a+b

symbol

1.5. Calcule cu matrice si vectori. Pachetul linalg

Cu ajutorul cuvantului-cheie array se pot defini vectori si matrice.

Un vector se defineste in urmatorul mod:

> v:=array(1..dim_vect);

Elementele unui vector se pot defini unul cate unul, sau printr-un ciclu for (vezi sectiunea 1.7.1):

>       v:=array(1..4);

v:= array(1..4, [ ])

>       v[1]:=a; v[2]:=b; v[3]:=; v[4]:=3;

v₁ := a

v₂ := b

v₃:=

v₄ := 3

>       evalm(v); # evalueaza valoarea lui v

[a, b, , 3]

matrice se defineste astfel:

M:=array(1..nr_rand, 1..nr_col);

Elementele unei matrice se pot defini unul cate unul, sau printr-un ciclu for (vezi sectiunea 1.7.1):

> M:=array(1..2,1..2);

M := array (1..2, 1..2, [ ])

> M[1,1]:=1 : M[1,2]:=a : M[2,1]:=3 : M[2,2]:= :

> evalm(M); # evalueaza valoarea lui M

Un alt mod de a defini matrice si vectori, precum si de a efectua operatii specifice cu aceste obiecte, este folosirea pachetului linalg. Pachetul linalg se incarca astfel:

>       with(linalg);

Warning, the protected names norm and trace have been redefined and unprotected

[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp, QRdecomp, Wronskian, addcol, addrow, adj, adjoint, angle, augment, backsub, band, basis, bezout, blockmatrix, charmat, charpoly,cholesky, col, coldim, colspace, colspan, companion, concat, cond, copyinto, crossprod, curl, definite, delcols, delrows, det, diag, diverge, dotprod, eigenvals, eigenvalues, eigenvectors, eigenvects, entermatrix, equal, exponential, extend, ffgausselim, fibonacci, forwardsub, frobenius, gausselim, gaussjord, geneqns, genmatrix, grad, hadamard, hermite, hessian, hilbert, htranspose, ihermite, indexfunc, innerprod, intbasis, inverse, ismith, issimilar, iszero, jacobian, jordan, kernel, laplacian, leastsqrs, linsolve, matadd, matrix, minor, minpoly, mulcol, mulrow, multiply, norm, normalize, nullspace, orthog, permanent, pivot, potential, randmatrix, randvector, rank, ratform, row, rowdim, rowspace, rowspan, rref, scalarmul, singularvals, smith, stack, submatrix, subvector, sumbasis, swapcol, swaprow, sylvester, toeplitz, trace, transpose, vandermonde, vecpotent, vectdim, vector, wronskian]

O matrice se defineste cu comanda matrix:

>       matrix(nr_randuri, nr_coloane, lista_elem sau fc_generatoare)

Astfel, putem avea:

> a:=matrix(3,2,[1,2,3,4,5,6]);

a:=

Dar si

>       f:=(i,j)->i+j; # functia generatoare a elementelor matricei

f := (i, j) → i + j

>       b:=matrix(2,3,f); # adica b[i,j]=f(i,j)

b:=

Elementele a_ij se scriu a[i,j]. Astfel, pentru matricea a din exemplul anterior, putem avem:

>       a[3,1];

a_3,1

Un vector se defineste cu ajutorul comenzii vector: vector (nr_elem, lista_elem sau fc_generatoare)

Astfel, putem avea:

>       v:=vector([2,4,8,2]);

v := [2, 4, 8, 2]

sau

>       f:=x-> 2*x+1;

f := x → 2x + 1

>       w:=vector(5,f); # adica w[i]=f(i)

w := [3, 5, 7, 9, 11]

Elementul i al vectorului v, v_i, se scrie v[i]. Astfel, pentru vectorul v din exemplul anterior, putem avea:

> v[3];

8

Redam mai jos cele mai utilizate functii din pachetul linalg, impreuna cu descrierea lor. Pentru mai multe detalii referitoare la aceste functii, precum si la celelalte functii din pachetul linalg, se poate consulta pagina de help referitoare la pachetul linalg

1.6. Grafice

Graficul unei functii se realizeaza folosind comanda plot, a carei sintaxa este

plot(functie, x=x_min..x_max, y_min..y_max)

unde argumentul y_min..y_max este optional.

De exemplu, putem avea:

> plot(sin(x), x=-5..5);

> plot(cos(x)^2, x=-5..5);

> plot([sin(x),cos(x)^2], x=-5..5);

Mai multe detalii despre grafice se pot gasi accesand pagina de help referitoare la instructiunea plot, sau la pachetul plots

1.7. Elemente de programare

1.7.1 Conditionarea si ciclarea

A. Conditionarea

Sintaxa unei instructiuni conditionale este

if CONDITIE then EXPRESIE

elif CONDITIE then EXPRESIE ]

else EXPRESIE ]

fi

Instructiunile puse intre paranteze patrate, [ ], sunt optionale. De exemplu, putem avea secventa:

>       if a<0 then -a else a fi; # pentru calculul modulului pentru a returna modulul numarului a.

Un alt exemplu este dat de secventa:

> if x<0 then -1 elif x=0 then 0 else 1 fi; # functia signum pentru a returna semnul unui numar (functia sgn).

B. Ciclarea

O instructiune repetitiva poate avea una din urmatoarele doua sintaxe:

[for CONTOR ] [ from EXPR ] [ by EXPR ] [ to EXPR ]

while EXPR ]

do INSTRUCTIUNI od;

sau

[for CONTOR ] [ in EXPR ] [ while EXPR ] do INSTRUCTIUNI od;

unde:

from indica punctul de plecare in iteratie (daca este omis, valoarea sa implicita este 1);

- by indica pasul contorului (daca este omis, se considera implicit ca are valoarea 1);

- to indica punctul de oprire a iteratiei (daca este omis, se considera implicit ca are valoarea +∞ si se obtine o bucla infinita);

- while indica o expresie booleana, care trebuie sa poata fi evaluata ca adevarata sau falsa;

- in indica elementele succesive ale expresiei EXPR

De exemplu, pentru a scrie toate numerele pare de la 6 la 100 putem folosi:

> for i from 6 by 2 to 100 do print(i) od;

Cu ajutorul buclei for se pot defini secvente, liste, multimi, vectori sau matrice.

> s:=NULL;

s

> for i from 1 to 3 do s:=s,2*i+1 od; # definirea unei secvente

s : = 3

s : = 3, 5

s : = 3, 5, 7

> l:=[];

l

> for i from 1 to 4 do l:=[op(l),i^2] od; # definirea unei liste

l := [1]

l := [1, 4]

l := [1, 4, 9]

l := [1, 4, 9, 16]

> v:=vector(3); # definirea vectorului

v := array(1..3, [ ])

> for i from 1 to 3 do v[i]:=i^3-i^2+1 od; # definirea elem vect evalm(v); # vizualizarea vectorului

v₁ := 1

v₂ := 5

v₃:= 19

[1, 5, 19]

> M:=array(1..3,1..4); # definirea matricei

M:= array(1..3, 1..4, [ ])

>       for i from 1 to 3 do # definirea elem matricei

for j from 1 to 4 do

M[i,j]:=i^j

od;

od;

> evalm(M);

Putem afisa elemetele unei liste (secvente, multimi, matrice, vector) astfel:

> lista:=[3,2,4,5,1]:

> for i in lista do print(i) od;

Mai multe detalii despre instructiunile de conditionare si de ciclare se pot gasi accesand pagina de help referitoare la acestea.

1.7.2 Functii si proceduri

O functie poate fi definita cu ajutorul operatorului ->. Putem defini functii de o variabila sau functii de mai multe variabile.

> f:=x->x^2+1;

f := x → x² + 1

> g:=(x,y)->x^2+y;

g := (x, y) → x² + y

> f(3);

10

> g(3,4);

13

> g(4,3);

19

O procedura este un grup de instructiuni, variabile si constante. Sintaxa este:

proc (ARGUMENTE)

local VARIABILE_LOCALE;

global VARIABILE_GLOBALE;

options OPTIUNI;

description SIR_DE_CARACTERE;

INSTRUCTIUNI;

end;

O procedura returneaza ultimul rezultat obtinut. Pentru a forta returnarea unui alt rezultat, se foloseste RETURN. De asemenea, pentru a returna un mesaj de eroare, se foloseste ERROR

De exemplu, putem defini procedura:

> modul:=proc(a) if a<0 then -a else a fi; end;

modul := proc(a) if a < 0 then −a else a end if end proc

pe care o putem apela astfel:

> modul(-3);

3

Un alt exemplu de procedura este urmatorul:

> ec2:=proc(a,b,c)

local delta,x1,x2;

description 'Rezolvarea ecuatiei de gradul 2';

delta:=b^2-4*a*c;

if delta>0 then

x1:=(-b+sqrt(delta))/(2*a);

x2:=(-b-sqrt(delta))/(2*a);

RETURN(x1,x2);

elif delta=0 then RETURN(-b/(2*a));

else

RETURN('ecuatia nu ere solutii reale');

fi;

end:

care produce urmatoarele rezultate:

> ec2(1,6,9); # ecuatia x^2+6*x+9=0

−3

> ec2(1,2,9); # ecuatia x^2+2*x+9=0 ecuatia nu are solutii reale

ecuatia nu are solutii reale

> ec2(1,2,-3); # ecuatia x^2+2*x-3=0

1, −3

Pentru a defini tipul unui argument, se foloseste sintaxa

argument::tip.

De exemplu, sa luam urmatoarea procedura si situatiile care pot aparea:

> # procedura care returneaza determinantul unei matrice

> determinant:=proc(A) RETURN(det(A)) end:

> determinant(2);

Error, (in linalg:-det) expecting a matrix

Procedura determinant se poate "imbunatati" astfel:

> determinant1:=proc(A)

if not type(A, matrix)

then ERROR('argumentul trebuie sa fie matrice!!!')

fi;

RETURN(det(A))

end:

care produce urmatorul rezultat:

> determinant1(2);

Error, (in determinant1) argumentul trebuie sa fie matrice!!!

Se mai poate defini argumentul A ca fiind de tipul matrice:

> determinant3:=proc(A::matrix) RETURN(det(A)) end: # si se obtine urmatorul rezultat:

determinant3(2);

Error, invalid input: determinant3 expects its 1st argument, A, to be of type matrix, but received 2

Mai multe detalii despre tipurile existente se pot gasi accesand pagina de help (cuvantul cheie este type).

Un alt exemplu este procedura rdc, procedura pentru calculul lui

> rdc:=proc(x)

if x<0 then ERROR('numar negativ!')

elif x=0 then RETURN(infinity)

else simplify(x^(-1/2));

fi;

end;

> rdc := proc(x) if x < 0 then ERROR('numar negativ!')

elif x = 0 then RETURN(∞)

else simplify(1/(x^ (1/2))) end if end proc

> rdc(-1);

Error, (in rdc) numar negativ!

> rdc(0);

∞

> rdc(4);

Pentru a putea urmari executia unei proceduri, se foloseste debug, iar pentru a stopa urmarirea, se foloseste undebug. De exemplu, putem avea:

> f:=proc(a,b)

local y,z;

y:=a+b/2;

z:=1/y;

RETURN(y+z)

end;

> f := proc(a, b)

local y, z;

y := a + 1/2 b; z := 1/y

RETURN(y + z) end proc

> debug(f);

f

> f(2,4);

> f(0,1);

undebug(f)

f

> f(10,20);

Alte detalii despre functii si proceduri, precum si despre optiunile debug si undebug, puteti gasi pe paginile de help referitoare la acestea.