| CATEGORII DOCUMENTE |
| Astronomie | Biofizica | Biologie | Botanica | Carti | Chimie | Copii |
| Educatie civica | Fabule ghicitori | Fizica | Gramatica | Joc | Literatura romana | Logica |
| Matematica | Poezii | Psihologie psihiatrie | Sociologie |
Maple este un sistem de calcul algebric (CAS) dezvoltat de firma Maplesoft (https://www.maplesoft.com), care poate fi utilizat in:
In cele ce urmeaza, vom prezenta principalele elemente necesare in programarea unor metode numerice, corespunzatoare softului MapleV4
Un document MapleV4 poate avea patru tipuri de campuri:
comenzi Maple (introduse de catre utilizator);
rezultate Maple (raspunsuri ale CAS-ului la comenzile introduse);
grafice (raspunsuri ale CAS-ului);
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);
> 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;
> x := 'x';
x : = ′x′
> x;
x
3. Comentariile sunt precedate de caracterul #. De exemplu:
> x:=3; # se atribuie lui x valoarea 3
x
4. Maple face diferenta intre litere mici si litere mari:
> x:=3; X:=5; a:=X-x;
x
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
lista
multime
6. Argumentele unei functii se pun intre paranteze rotunde, ( ) , iar indicii intre paranteze patrate, [ ].
> a:=cos(Pi); b:=lista[2];
a
b
7. Procentul, % , face referire la ultima comanda executat¡ anterior. De exemplu:
> a := 2;
a
> b:=%+1;
b
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;
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]
Constantele folosite de Maple sunt:
|
Constanta |
Semnificatie |
|
false |
"fals" |
|
true |
"adevarat" |
|
gamma |
constanta lui Euler |
|
infinity |
+∞ |
|
Catalan |
constanta lui Catalan |
|
Fail |
valoare de adevar necunoscuta |
|
Pi | |
|
I |
unitatea imaginara |
|
NULL |
secventa vida |
Operatorii folositi frecvent sunt:
|
Operator |
Sintaxa |
Semnificatie |
|
a+b a-b |
suma a + b (diferenta a − b) |
|
|
a*b 2*a |
produsul a b, sau 2a |
|
|
a/b |
catul |
|
|
a^b a**b |
puterea ab |
|
|
n! |
factorialul 1 2 n |
|
|
max min |
max(a,b,c) |
maximul (minimul) dintre a, b, c |
|
min(a,b,c) |
||
|
< <= > >= = <> |
operatori booleeni |
|
|
f:=expr |
operatorul de asignare f = expr |
|
|
= |
a=b |
ecuatia a = b |
|
x=a..b |
a ≤ x ≤ b |
|
|
and or xor |
operatori logici |
|
|
implies not |
|
Functii folosite frecvent in Maple:
|
Functie |
Sintaxa |
Semnificatie |
|
sin cos tan cot |
sin(x) |
functii trigonometrice |
|
arcsin arctan arccos |
arctan(x) |
|
|
ln log10 |
ln(x) log10(x) |
logaritmi |
|
exp |
exp(x), exp(1) |
functia exponentiala |
|
sqrt |
sqrt(x) |
radical |
|
abs |
abs(x) |
modul |
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
t:= a, b, c
b) cu ajutorul functiei seq:
> seq(3*x, x=2..7);
c) cu ajutorul unui ciclu for
Cu ajutorul functiilor min si max se poate calcula minimul, respectiv maxi-mul unei secvente.
> min(s); max(s,2,15);
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);
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
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 ]
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;
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
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;
v1 := a
v2 := b
v3:=
v4 := 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
> 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 aij se scriu a[i,j]. Astfel, pentru matricea a din exemplul anterior, putem avem:
> a
a3,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
sau
> f:=x-> 2*x+1;
f := x → 2x + 1
> w:=vector(5,f); # adica w[i]=f(i)
w
Elementul i al vectorului v, vi, se scrie v[i]. Astfel, pentru vectorul v din exemplul anterior, putem avea:
> v[3];
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
|
Functie |
Descriere |
|
addcol(A,c1,c2,m) |
inlocuieste coloana c2 a matricei A cu m*c1+c2 |
|
addrow(A,r1,r2,m) |
inlocuieste linia r2 a matricei A cu m*r1+r2 |
|
adj(A) adjoint(A) |
calculeaza matricea adjuncta a matricei A |
|
angle(u,v) |
calculeaza unghiul vectorilor u si v |
|
augment(A,B) |
concateneaza (alatura) matricile A si B pe orizontala |
|
backsub(U,b) |
rezolva sistemul Ux=b, prin substitutie inversa, unde U este o matrice superior triunghiulara |
|
band(b,n) |
construieste o matrice n x n care are pe diagonala principala elementele vectorului b, iar celelalte elemente sunt nule |
|
cholesky(A) |
efectueaza descompunerea Cholesky a matricei A |
|
col(A,i) col(A,i..k) |
extrage coloana i, respectiv coloanele i pana la k, din matricea A |
|
coldim(A) |
returneaza numarul de coloane ale matricei A |
|
crossprod(u,v) |
returneaza produsul vectorial al vectorilor u si v |
|
delcols(A,r..s) |
sterge coloanele de la r la s din matricea A |
|
delrows(A,r..s) |
sterge liniile de la r la s din matricea A |
|
det(A) |
calculeaza determinantul matricei A |
|
diverge(f) |
calculeaza divergenta vectorului f |
|
dotprod(u,v) |
calculeaza produsul scalar al vectorilor u si v |
|
exponential(A) |
calculeaza eA |
|
extend(A,m,n,x) |
adauga m linii si n coloane matricei A, initializate cu x |
|
forwardsub(L,b) |
rezolva sistemul Lx=b prin substitutie inainte, unde L este o matrice inferior triunghiulara |
|
gausselim(A) |
efectueaza eliminarea gaussiana cu semipivot asupra matricei A |
|
geneqns(A,x) |
genereaza un sistem de ecuatii pornind de la matricea A si vectorul necunoscutelor x |
|
genmatrix(sist, var) |
genereaza matricea coeficientilor sistemului sist, in raport cu multimea variabilelor var |
|
grad(expr, vect) |
calculeaza gradientul expresiei expr, in functie de variabilele vect |
|
inverse(A) |
calculeaza inversa matricei A |
|
matadd(A,B,c1,c2) |
calculeaza c1*A+c2*B |
|
minor(r,c) |
calculeaza minorul de ordin (r,c) (elimina linia r si coloana c) din matricea A |
|
mulcol(A,c,expr) |
multiplica coloana c a matricei A cu expresia expr |
|
mulrow(A,r,expr) |
multiplica linia r a matricei A cu expresia expr |
|
multiply(A,B) |
efectueaza inmultirea matricelor A si B |
|
norm(A) |
calculeaza norma matricei A |
|
normalize(v) |
calculeaza versorul vectorului v |
|
rank(A) |
calculeaza rangul matricei A |
|
row(A,i) row(A,i..j) |
extrage linia i, respectiv liniile de la i la j, ale matricei A |
|
rowdim(A) |
returneaza numarul de linii din matricea A |
|
scalarmult(A,s) |
inmulteste toate elementele matricei A cu scalarul s |
|
stack(A,B) |
concateneaza matricele A si B pe verticala |
|
submatrix(A,r1..r2,c1..c2) |
extrage o submatrice a matricei A, intre liniile r1 r2, si coloanele c1 c2 |
|
subvector(A,r1..r2) |
extrage un subvector al vectorului A, de la rangul r1 la rangul r2 |
|
swapcol(A,c1,c2) |
interschimba coloanele c1 si c2 ale matricei A |
|
swaprow(A,r1,r2) |
interschimba liniile r1 si r2 ale matricei A |
|
trace(A) |
calculeaza urma matricei A |
|
vectdim(v) |
returneaza dimensiunea vectorului v |
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
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
s
s
> l:=[];
l
> for i from 1 to 4 do l:=[op(l),i^2] od; # definirea unei liste
l
l
l
l
> 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
v1 :=
v2 :=
v3:=
> 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 elementele 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.
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 → x2 + 1
> g:=(x,y)->x^2+y;
g := (x, y) → x2 + y
> f(3);
> g(3,4);
> g(4,3);
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);
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
> 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
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.
|
Politica de confidentialitate | Termeni si conditii de utilizare |
Vizualizari: 1333
Importanta: 
Termeni si conditii de utilizare | Contact
© SCRIGROUP 2024 . All rights reserved
