Rezolvarea ecuatiilor. Elemente de programare ın Mathematica

1 Specificarea ecuatiilor si a sistemelor de ecuatii

O ecuatie este o expresie relationala, avand ca operator principal operatorul de egalitate, si carepentru unele valori ale variabilelor (necunoscutelor) este adevarata iar pentru altele este falsa.

Forma generala a unei ecuatii ın Mathematica este:

ms == md

unde ms (membrul stang) si md (membrul drept) sunt expresii ın care intervine simbolul necunoscutei(ın cazul ecuatiilor algebrice) sau derivate ale functiei necunoscute (ın cazul ecuatiilor diferentiale).Exemple:

1. In[]:=ec=x^2-3x+2==0 (* specificare ecuatie cu numele ec *)Out[]=x2 − 3x+ 2 == 0In[]:=ec/.x->1 (* verificare daca 1 este solutie *)Out[]=True (* raspuns afirmativ *)In[]:=ec/.x− >3 (* verificare daca 3 este solutie *)Out[]=False (* raspuns negativ *)

2. In[]:= ecdif1=y’[x]+y[x]==2 (* ecuatie diferentiala de ordin 1 *)

3. In[]:= ecdif2=D[y[x],{x,3}]-y’[x]==1 (* ecuatie diferentiala de ordin 3 *)

Un sistem de ecuatii poate fi specificat ın una dintre formele:

• ca lista de ecuatii:{ec 1,..., ec n}

• ca egalitate a doua liste cu acelasi numar de elemente:{ms 1,..., ms n}=={md 1,..., md n}

• ca expresie relationala compusa:ec 1 && ...&& ec n

Exemple:

1. Sistemul de ecuatii algebrice:ax+ by = cdx+ ey = f

se poate descrie prin sistem={a x+b y==c,d x+e y==f} sau prin sistem=(a x+b y==c) &&(d x+e y==f).

1

2. Sistemul de ecuatii diferentiale:

x′(t) = ax(t) + by(t)y′(t) = cx(t) + dy(t)

se poate descrie prin sisdif={x’[t]==a x[t]+b y[t], y’[t]==c x[t]+d y[t]}.

3. Problema cu conditie initiala:

y′′(x) + 4y′(x) + 4y(x) = 0y(0) = 0y′(0) = −1/2

se poate descrie prin:{y’’[x]+4y’[x]+4y[x]==0, y[0]==0, y’[0]==-1/2}.

Observatie. Sistemele liniare pot fi descrise si ın modul urmator: A.x==b, unde A este matriceasistemului, b este vectorul termenilor liberi, iar x este vectorul necunoscutelor.

2 Ecuatii algebrice

Mathematica permite rezolvarea de ecuatiilor si sistemelor de ecuatii polinomiale si transcendente,furnizand fie solutii exacte fie solutii aproximative. In rezolvarea ecuatiilor sunt folosite fie metodeexacte fie metode aproximative.

2.1 Rezolvare prin metode exacte

Mathematica poate rezolva analitic orice ecuatie polinomiala de grad mai mic decat 5 precum siecuatii ın care intervin functii inversabile. Pot fi obtinute valori exacte ale solutiilor (prin functiaSolve) sau valori aproximative (prin functia NSolve).

Rezolvarea simbolica a unei ecuatii ın raport cu necunoscuta x se face prin:

Solve[ecuatie,x]

Rezultatul furnizat de Solve este o lista cu reguli de transformare pentru x corespunzatoaretuturor radacinilor. Pentru a obtine lista radacinilor trebuie aplicate aceste reguli de transformare(de exemplu daca obiectul returnat de Solve este retinut ın variabila solutie, atunci extragereavalorilor propriu-zise ale radacinilor se face prin: x/.solutie).Exemple:

1. In[]:= Solve[x^2-2x-7==0,x] (* rezolvare exacta *)Out[]= {{x− > −2+4Sqrt[2]

2 }, {x− > −2−4Sqrt[2]2 }}

In[]:=N[x/.%] (* lista valorilor aproximative *)Out[]={−1.82843, 3.82843}

2. In[]:= ec=x^3-6x^2+11x-6==0;In[]:=sol=Solve[ec,x] (* retinerea rezultatului in sol *)Out[]={{x− > 1}, {x− > 2}, {x− > 3}}In[]:=ec/.sol (* verificarea rezultatului *)Out[]={True, True, True}

2

3. In[]:= Solve[Sin[x]]==a,x]Out[]={{x− > ArcSin[a]}}

4. In[]:=Solve[f[x^2]==a,x] (* expresia lui f nu e cunoscuta *)Out[]={{x− > Sqrt[f−1[a]]}, {x− > −Sqrt[f−1[a]]}}

Pentru rezolvarea sistemelor de ecuatii se foloseste varianta:

Solve[sistem,{x,y,...}]

unde x,y, ... sunt simbolurile asociate necunoscutelor.Uneori Solve returneaza rezultatele prin intermediul unui obiect special (numit Root). Pentru

a obtine aproximari numerice ale solutiilor trebuie aplicata functia N.Pentru sistemele pentru care nu pot fi furnizate explicit toate solutiile exista posibilitatea sim-

plificarii lor prin eliminarea unor necunoscute sau obtinerea unui set de ecuatii simplificate careinclud toate solutiile posibile. Astfel de prelucrari pot fi facute cu ajutorul functiilor Roots, Reducesi Eliminate.

Functia Roots[ecuatie,x] rearanjeaza ecuatia ıntr-o forma echivalenta ın care sunt puse ınevidenta solutiile. Se bazeaza pe factorizarea expresiei ce intervine ın ecuatie si rezultatul furnizateste o expresie logica compusa din care pot fi extrase valorile solutiilor.

Functia Reduce[ecuatie,x] furnizeaza solutiile sub forma unor expresii logice analizand sivalorile critice ale parametrilor. Spre deosebire de Solve care returneaza doar solutiile gen-erale, ignorandu-le pe cele care sunt valide doar pentru valori particulare ale parametrilor, Reducefurnizeaza setul complet de solutii. Permite efectuarea de discutii asupra radacinilor.

Functia Eliminate[{ec1,...,ecn},x] permite eliminarea necunoscutei x din toate ecuatiilesistemului.Exemple:

1. In[]:=Solve[{x^2+y^2==1,x+3y==0},{x,y}]Out[]={{x− > −3

Sqrt[10] , y− >1

Sqrt[10]}, {x− >3

Sqrt[10] , y− >−1

Sqrt[10]}}

2. In[]:=Roots[5 x^2 + 3x - 2 == 0, x]Out[]:= x == 2/5||x == −1

3. In[]:= Eliminate[{ax+y==0,2x+(1-a)y==1},y]Out[]:= −(ax) + a2x == 1− 2x

4. In[]:=Reduce[{x==1,x==a},x]Out[]= a == 1&&x == 1

5. Rezolvarea unui sistem ın care necunoscutele sunt variabile indexate. Ecuatiile sunt de forma:2ai + ai−1 = ai+1 cu i = 1, 5.In[]:=sistem = Table[2 a[i] + a[i - 1] == a[i + 1], {i, 1, 5}];In[]:=ColumnForm[sistem] (* afisare pe o singura coloana *)Out[]=

a[0] + 2a[1] == a[2]a[1] + 2a[2] == a[3]a[2] + 2a[3] == a[4]a[3] + 2a[4] == a[5]a[4] + 2a[5] == a[6]

3

In[]:=Solve[sistem, Table[a[i], {i, 5}]] ;In[]:=%/.{a[0]->b,a[6]->c} (* inlocuirea parametrilor cu b si c *)Out[]={{a[1]− > 1/70(−29b+ c), a[2]− > 1/35(6b+ c), . . .}}

Cand toti coeficientii ecuatiei sunt valori numerice se poate solicita obtinerea unor valori aprox-imative ale radacinilor ecuatiei utilizand functia NSolve:

NSolve[ecuatie,x] sau NSolve[sistem,{x,y,...}]

NSolve permite determinarea tuturor solutiilor si pentru ecuatiile care nu pot fi rezolvate cuSolve (caz ın care solutiile sunt exprimate prin obiectul Root).Exemple:

1. In[]:=NSolve[x^5+x+1==0,x]Out={{x− > −0.754878}, {x− > −0.5− 0.866025I}, {x− > −0.5 + 0.866025I}, {x− > 0.877439− 0.744862I}, {x− > 0.877439 + 0.744862I}}.

2. In[]:=ec = x^8 + 3x^4 - 4x^3 + 1 == 0;In[]:=Solve[ec,x]Out={{x− > Root[1−4#13+3#14+#18&, 1]}, {x− > Root[1−4#13+3#14+#18&, 2]}, . . .}}In[]:=NSolve[ec,x]Out={{x− > −1.15507− 0.968699I}, {x− > −1.15507 + 0.968699I}, . . .}

2.2 Rezolvare prin metode aproximative

Pentru ecuatiile sau sistemele de ecuatii care nu pot fi rezolvate analitic se folosesc metode nu-merice iterative pentru determinarea cate unei solutii (de exemplu metoda lui Newton sau metodasecantei). In acest caz utilizatorul trebuie sa furnizeze si o valoare pentru aproximatia initiala.

Functia utilizata ın acest caz este FindRoot. Ea poate fi apelata ın unul dintre modurile:FindRoot[ecuatie,{x,x0}]

pentru rezolvarea ecuatiei pornind de la aproximatia initiala, x0, respectivFindRoot[sistem,{x,x0},{y,y0},...]

pentru rezolvarea sistemului pornind de la aproximatia ınitiala (x0, y0, . . .).Observatie. Mathematica foloseste implicit metoda lui Newton pentru rezolvarea ecuatiilor neliniare.Daca se doreste utilizarea metodei secantei (de exemplu, atunci cand nu poate fi calculata sim-bolic derivata functiei ce intervine ın ecuatie), atunci trebuie specificate doua valori ca aproximatiiinitiale. Numarul maxim de iteratii poate fi controlat prin optiunea MaxIterations->val, valoareaimplicita fiind 15.Exemple.

1. In[]:=sol1=FindRoot[3 Cos[x]==Log[x],{x,1}]Out[]={x− > 1.44726}In[]:=3 Cos[x]-Log[x]/.sol1 (* verificarea solutiei *)Out[]=4.15834× 10−13

2. In[]:=sol2=FindRoot[3 Cos[x]==Log[x],{x,1,2}] (* varianta cu metoda secantei *)Out[]={x− > 1.44726}In[]:=3 Cos[x]-Log[x]/.sol2 (* verificarea solutiei *)Out[]=−4.01623× 10−8

4

3. Rezolvarea numerica a unui sistem neliniar:In[]:=sistem = {Sin[x] + y^2 + Log[z] == 7, 3 x + 2^y - z^3 == -1, x + y + z ==5};In[]:=FindRoot[sistem, {x, 0}, {y, 1}, {z, 1}]Out[]={x− > 0.599054, y− > 2.39593, z− > 2.00501}

3 Ecuatii diferentiale

3.1 Rezolvare simbolica

Mathematica permite rezolvarea analitica a ecuatiilor si sistemelor de ecuatii diferentiale ordinareliniare sau neliniare prin intermediul functiei DSolve. Pentru rezolvarea ecuatiilor (pentru care nuse specifica conditia initiala) se apeleaza DSolve ın unul dintre urmatoarele moduri:

DSolve[ecdif,y[x],x] sau DSolve[ecdif,y,x]In prima varianta DSolve returneaza reguli de transformare pentru y[x] membrul drept fiind subforma unei expresii. In a doua varianta de apel se returneaza reguli de transformare pentru y,membrul drept fiind sub forma unei functii pure.

In cazul sistemelor de ecuatii sau a ecuatiilor pentru care se specifica conditii initiale (problemeCauchy) se foloseste DSolve ıntr-una dintre variantele:

DSolve[sistem,{y1[x],...,yn[x]},x] sau DSolve[sistem,{y1,...,yn},x]diferentele dintre ele fiind aceleasi ca ın cazul ecuatiilor. Pentru ecuatii cu derivate partiale se poateapela tot DSolve ıntr-una dintre variantele

DSolve[ecdifpar,y[x1,...,xn],{x1,...,xn}] sau DSolve[ecdifpar,y,{x1,...,xn}]observatiile specificate mai sus ramanand valabile.Exemple:

1. Rezolvarea unei ecuatii cu obtinerea solutiei sub forma unei expresii:In[]:=DSolve[y’[x]==a*y[x],y[x],x]Out[]={{y[x]− > EaxC[1]}}

2. Obtinerea solutiei sub forma unei functii pure:In[]:= DSolve[y’[x]==a*y[x],y,x]Out[]={{y− > Ea#1C[1]&}}

3. Variantele cu rezultatul furnizat ca expresie (y[x]) sau ca functie pura (y) difera ıntre eleprin modul ın care poate fi folosit rezultatul.In[]:=sol1=DSolve[{y’[x]==a*y[x],y[0]==1},y[x],x] (* problema Cauchy *)Out[]={{y[x]− > Eax}}In[]:=y[x]/.sol1[[1]]/.x->0 (* valoarea solutiei in 0*)In[]:=sol2=DSolve[{y’[x]==a*y[x],y[0]==1},y,x] (*varianta cu functie pura*)Out[]={{y− > (Ea#1)&)}}In[]:=y[0]/.sol2[[1]] (* valoarea solutiei in 0*)

4. Permite rezolvarea ecuatiilor liniare cu derivate partiale:In[]:= ecdifpar=D[u[x,t],t]==D[u[x,t],x]; (* definirea ecuatiei *)In[]:= DSolve[ecdifpar,u,{x,t}] (* rezolvarea ecuatiei *)Out[]= {{u− > (C[1][#2 + #1]&)}}

5

In acest caz solutia generala este exprimata prin intermediul unor functii notate tot cu C[1],C[2] etc.

Observatii.

1. DSolve poate rezolva orice ecuatie diferentiala liniara cu coeficienti constanti precum si ecuatiicu coeficienti variabili de ordin mai mic sau egal cu 2.

2. DSolve poate rezolva orice sistem de ecuatii diferentiale liniare de ordinul 1 care nu continemai mult de 4 ecuatii.

3. Constantele ce apar ın forma generala a solutiei sunt variabile indexate de forma C[i]. Numelelor poate fi schimbat prin optiunea DSolveConstants->simbol.

4. Daca ecdif este ecuatia diferentiala iar sol reprezinta functia solutie (obtinuta ca functiefara argument) atunci pentru a verifica solutia este suficient sa se scrie ecdif/.sol.In[]:=ecdif=y’’’[t]-y’’[t]-3y’[t]+3 y[t]==0;In[]:=sol=DSolve[ecdif,y,t];In[]:=ecdif/.sol//Simplify (* aplicare postfixata a lui Simplify *)Out[]= {True} (* solutia este corecta *)Varianta ın care se specifica doar numele functiei necunoscute nu si argumentul acesteia (caın exemplul de mai sus) este mai flexibila.

3.2 Rezolvare numerica

Sisteme de ecuatii diferentiale ordinare (avand coeficienti numerici) care sunt completate cu conditiiinitiale pot fi rezolvate numeric cu functia NDSolve. In cazul ecuatiilor NDSolve se apeleaza astfel

NDSolve[pbCauchy,y,{x,xmin,xmax}]iar pentru sisteme de ecuatii prin:

NDSolve[pbCauchy,{y1,y2,...},{x,xmin,xmax}]Observatie. Metodele numerice folosite de catre sistem depind de natura problemei fiind selectatedintre metodele Adams, Runge-Kutta, Gear.

Rezultatul este returnat sub forma unui functii sistem numita InterpolatingFunction careare ca argumente valorile obtinute prin procedura de integrare numerica si care prin interpolarepoate furniza valori ale solutiei. Principalele modalitati de utilizare a rezultatelor returnate deNDSolve sunt:

• Calculul valorii functiei solutie pentru un argument dat: y[argument]/.solutie unde yreprezinta functia necunoscuta, argument reprezinta valoarea pentru care trebuie calculatafunctia iar solutie reprezinta solutia furnizata de NDSolve.

• Reprezentarea grafica a solutiei: Plot[Evaluate[y[x]/.solutie]],{x,xmin,xmax}]. Dome-niul reprezentarii grafice trebuie sa fie inclus ın domeniul de reprezentare.

Exemple:

1. In[]:=solutie=NDSolve[{y’[x]==y[x],y[0]==1},y,{x,0,2}]Out[]={{y− > InterpolatingFunction[{0., 2.}, <>]}}In[]:=y[1.5]/.solutie (* determinarea valorii solutiei ın 0.5 *)Out[]={4.48171}

6

2. NDSolve permite rezolvarea unor ecuatii cu derivate partiale folosind metoda liniilor (se real-izeaza o discretizare ın raport cu unele dintre necunoscute si se ajunge la un sistem de ecuatiidiferentiale ordinare. Consideram un caz particular (unidimensional) al ecuatiei caldurii com-pletat cu conditii la limita si o conditie initiala:

∂u(x,t)∂t = ∂2u(x,t)

∂x2

u(x, 0) = −6x4 + x2 + 6xu(0, t) = 0u(1, t) = 1

In[]:=

sol=NDSolve[{D[u[x,t],t]==D[u[x,t],x,{x,2}], u[x,0]==-6x^4+x^2+6x,u[0,t]==0,u[1,t]==1},u,{x,0,1},{t,0,0.5}];

In[]:=Plot3D[u[x,t]/.sol[[1]],{x,0,1},{t,0,0.5}] (* reprezentarea suprafetei solutie*)

Pe langa a utiliza functiile predefinite oferite de sistemul de software matematic mai exista posi-bilitatea de a defini functii proprii utilizatorului si de a grupa prelucrari care se repeta de maimulte ori ın structuri modularizate. Mathematica este un sistem deschis care permite completareasi modificarea functiilor sale. El este un puternic limbaj de programare care combina programareaprocedurala cu cea functionala si cea bazata pe reguli de transformare. Limbajul este adecvatpentru a gestiona principalele paradigme de programare: modularizare, tipuri abstracte de date,gestiunea listelor si a sirurilor de caractere, programare logica si programare orientata pe obiecte.

Pentru a putea utiliza eficient facilitatile de programare oferite de sistem trebuie cunoscuteprincipiile care stau la baza acestuia.

4 Principii de baza

Sistemul se bazeaza pe doua principii fundamentale:

• toate obiectele sunt reprezentate ın acelasi mod putand fi astfel tratate unitar (de exemplutoate obiectele pot fi vazute ca liste sau expresii);

• prelucrarile au la baza un mecanism de evaluare bazat pe reguli (asemanator celui din Lisp).

4.1 Forma interna a obiectelor

In Mathematica toate obiectele (formule, ecuatii, liste, grafice, etc.) pot fi vazute ca fiind expresiifunctionale cu prototipul:

functie[argumente]

sau ca fiind liste cu prototipul:

{antet,arg1,arg2,. . . }

antetul fiind pe pozitia 0 ın lista.Exemple:

7

Obiect Forma functionala Semnificatiex+y+z Plus[x,y,z] expresie algebricaxˆn Power[x,n] expresie algebrica{a,b,c} List[a,b,c] listaa−>b Rule[a,b] regula de transformarea=b Set[a,b] asignarea<b Less[a,b] inegalitate

Reprezentarea sub forma de expresie functionala a oricarui obiect se poate obtine cu ajutorulfunctiei sistem FullForm. Antetul unei expresii poate fi obtinut cu ajutorul functiei Head si poatefi de unul dintre urmatoarele tipuri: functie (Sin[x]), comanda (Factor[a^2+b^2]), operator(Plus[x,y,z]) sau tip (List[a,b,c]).Exemple:

1. In[]:=Head[f[x,y]] (* antetul expresiei *)Out[]=f

2. In[]:=Head[a+b+c]Out[]=PlusIn[]:=FullForm[a+b+c] (* forma functionala *)Out[]=Plus[a, b, c]

3. In[]:=Head[{a,b,c}] (* antetul unei liste *)Out[]=List

4. In[]:=Head[35] (* antetul unui ıntreg *)Out[]=Integer

Observatii:

1. Expresiile functionale pot fi specificate ın mai multe moduri:

f[x,y] forma standard pentru f(x, y)x f y forma infixata pentru f(x, y)f @ x forma prefixata pentru f(x)x // f forma postfixata pentru f(x)

2. Cum expresiile pot fi vazute ca liste, accesul la parti ale acestora poate fi realizat analog cuaccesul la parti ale listelor.

Exemple:

(a) In[]:= (a+b+c)[[0]] (* returneaza antetul expresiei *)Out[]=Plus

(b) In[]:= (a+b+c)[[2]] (* al doilea termen al expresiei *)Out[]=b

(c) In[]:= f[g[a],g[b]][[1,1]] (* lista asociata acestei expresii are doua nivele *)Out[]=a

8

3. Fiecarui operator ıi corespunde o functie:

Operator Functie Operator Functie+ Plus − Subtract++ Increment −− Decrement∗ sau spatiu Times / Divideˆ Power == Equal< Less <= LessEqual> Greater >= GreaterEqual! = Unequal ! Not&& And || Or

4. Un obiect poate fi vizualizat ın diferite formate: InputForm (formatul specific introduceriicomenzilor), TeXForm (descrierea ın limbajul TeX a expresiei), CForm (descrierea ın limbajulC a expresiei), TreeForm (descrierea structurii arborescente a expresiei).

4.2 Mecanismul de evaluare

Nucleul sistemului efectueaza permanent un ciclu de forma:

• preluare expresie;

• evaluare;

• returnare rezultat.

Principiul de baza al evaluarii este urmatorul: pentru o expresie se aplica succesiv toate regulile(definitiile) pe care le cunoaste sistemul pana cand nu se mai poate aplica nici o regula, rezultatulfinal putand fi o valoare numerica sau o expresie.Exemplu. Definirea functiei factorial:In[]:= fac[1]=1; fac[n ]:=n*fac[n-1]In[]:= fac[4] (* apelul functiei *)Out[]= 24

In evaluarea lui fac[4] s-a aplicat succesiv regula de definire a factorialului pana s-a ajuns lafac[1] care avea afectata valoarea 1.

Pentru a urmari modul ın care se efectueaza evaluarea unei expresii se poate utiliza functiaTrace care furnizeaza etapele parcurse ın evaluarea expresiei.In[]:=Trace[fac[4]]Out[]={fac[4], 4fac[4− 1], {{4− 1, 3}, fac[3], 3fac[3− 1], {{3− 1, 2}, fac[2], 2fac[2− 1],{{2− 1, 1}, fac[1], 1}, 21, 2}, 32, 6}, 46, 24}

Modul ın care se evalueaza o functie depinde de unele dintre atributele asociate functiei respec-tive. Atributele pot fi manipulate cu ajutorul urmatoarelor functii sistem:

Functie SemnificatieAttributes[f] furnizeaza atributele lui fAttributes[f]={atr1,atr2,...} seteaza atributele lui fAttributes[f]={} anuleaza atributele lui fSetAttributes[f,atr] adauga atributul specificatClearAttributes[f,atr] elimina atributul specificat

9

Atributele care influenteaza modul de evaluare sunt:

Atribut SemnificatieOrderless functie comutativaFlat functie asociativaOneIdentity f[f[...f[a]] este echivalent cu aListable functia este automat aplicata elementelor

listei argument: f[{a,b}] conduce la {f[a],f[b]}Constant functie constantaHoldFirst primul argument al functiei nu se evalueazaHoldRest argumentele functiei, cu exceptia primului,

nu se evalueazaHoldAll nu se evalueaza nici unul dintre argumente

Exemplu:In[]:= Attributes[Plus] (* atributele functiei de adunare *)Out[]= {Flat,Listable,OneIdentity, Orderless,Protected}

Procedura standard de evaluare cuprinde pasii:

• se evalueaza antetul expresiei (acesta poate fi la randul sau o expresie);

• se evalueaza fiecare element al expresiei (ın conformitate cu atributele);

• se aplica transformarile asociate atributelor:

Atribut Transformare SemnificatieOrderless Sort[f[arg]] ordoneaza argumenteleFlat Flatten[f[arg]] aduce toate argumentele pe primul nivelListable Thread[f[arg]] aplica functia fiecarui element din lista

• se aplica definitiile utilizator;

• se aplica definitiile sistem;

• se evalueaza rezultatul final.

Exemple de cazuri ın care nu toate argumentele se evalueaza sunt:

Operatia Specificms = md la asignare ms nu se evalueaza, ci doar mdms := md la definire nu se evalueaza nici un membrums :> md regula de transformare la care nu se evalueaza membrul

drept. La ms->md se evalueaza ambii membri.

Evaluarea poate fi solicitata explicit prin functia Evaluate si inhibata prin functia Unevaluated.Exemple:

1. In[]:=Plot[Table[Sin[n x],{n,1,3}],{x,0,2 Pi}] (* incorect *)In[]:= Plot[Evaluate[Table[Sin[n x],{n,1,3}]],{x,0,2 Pi}] (* corect *)

10

2. In[]:= Length[1+1] (* implicit 1+1 este evaluat *)Out[]= 0In[]:= Length[Unevaluated[1+1]] (* 1+1 ramane neevaluat *)Out[]= 2

5 Elemente de programare procedurala

Programarea procedurala se caracterizeaza prin specificarea prelucrarilor ın structuri de control(secventiale, alternative sau repetitive) si prin gruparea acestora ın module.

5.1 Prelucrari secventiale si operatii simple de intrare/iesire

Prelucrarile care trebuie efectuate secvential se specifica succesiv, separate prin punct-virgula:

prel1; prel2; ...

sau prin intermediul functiei CompoundExpression[prel1,prel2,...].Observatie. Prezenta caracterului ”;” dupa o expresie inhiba afisarea rezultatului expresiei. Dacase doreste afisarea unui rezultat ın interiorul unei succesiuni de expresii se poate folosi functia Print:

Print[expr]

al carei efect este afisarea valorii expresiei argument.O alta operatie de intrare/iesire este asigurata de functia Input care permite introducerea de

la tastatura a unei valori prin intermediul unei ferestre de dialog.Exemplu.In[]:=a=Input["Introduceti un numar"](* valoarea va fi completata prin intermediul unei ferestre de dialog *)In[]:=Print["Valoarea introdusa este:",a]

5.2 Prelucrari conditionale

Principalele prelucrari conditionale sunt:

• If[test,expr1,expr2]: daca testul este adevarat se evalueaza expr1 altfel se evalueazaexpr2. Functia If returneaza rezultatul expresiei evaluate.

• Which[test1,expr1,test2,expr2,...]: se evalueaza expresia imediat urmatoare primuluitest adevarat;

• Switch[expr,sablon1,expr1,sablon2,expr2,...]: se compara prima expresie cu fiecaresablon si se returneaza valoarea expresiei asociata sablonului pentru care se obtine egalitate.

Exemple:

1. Definirea functiei signum:In[]:= f[x ]:=If[x>=0,1,−1]sau folosind definirea conditionataIn[]:= g[x ]:=1/;x>=0 ; g[x ]:=-1/;x<0

2. Generarea unei matrici inferior tringhiulara avand toate elementele nenule egale cu 1:In[]:=Table[If[i>=j,1,0],{i,m},{j,n}]

11

3. Generarea unei matrici tridiagonale pornind de la trei vectori (vectorul b reprezinta diago-nala principala, vectorul a determina diagonala aflata deasupra celei principale, iar c diagonalaaflata sub cea principala:In[]:=Table[Switch[i-j,-1,a[[i]],0,b[[i]],1,c[[i-1]], ,0],{i,m},{j,n}]sauIn[]:=Table[Which[i-j==-1,a[[i]],i==j,b[[i]],i-j==1,c[[i-1]],Abs[i-j]>1,0],{i,m},{j,n}]

4. Definirea unei functii care returneaza 1 daca argumentul este un numar de tip Integer sauRational si 0 ın toate celelalte cazuri:In[]:=f[x ]:=Switch[x, Integer| Rational,1, ,0]

5.3 Prelucrari repetitive

Principalele modalitati de a efectua prelucrari repetitive sunt:

• Do[prelucrare,iterator]. Prelucrarea (simpla sau structurata) se repeta de atatea ori decate ori specifica iteratorul (acesta trebuie sa respecte regulile precizate la functia Table).

• While[test,prelucrare]. Atat timp cat testul este adevarat se efectueaza prelucrarea.

• For[start,test,modificare,prelucrare]. Modul de functionare consta ın parcurgereaurmatoarelor etape: se evalueaza prelucrarea de start dupa care, cat timp testul este adevaratse efectueaza prelucrarea si modificarea elementelor care controleaza prelucrarea ciclica. Atatprelucrarea de start cat si cea de modificare poate fi o secventa de prelucrari simple.

Observatii.

1. Ciclul Do poate contine mai multi iteratori, ın felul acesta specificandu-se ciclurile suprapuse(cu restrictia ca iteratorii sa foloseasca contoare diferite).

2. In fiecare dintre situatii prelucrarea poate fi simpla (o expresie) sau structurata (secventa deexpresii) iar rezultatul returnat este valoarea ultimei prelucrari efectuate. Uneori prelucrarilerepetitive au si un efect lateral care consta ın modificarea valorilor unor obiecte sau afisareaunor valori intermediare.

Exemple:

1. Afisarea primelor 10 numere naturale:In[]:=Do[Print[n],{n,10}]sau In[]:=n=1; While[n<=10, Print[n];n++]sau In[]:=For[i=1,i<=10,i++,Print[i]]

2. Calculul aproximarii cu precizia ε = 0.0001 a sumei seriei∞∑n=0

1/n!:

In[]:=n=1; s=1; While[(t=1/n!)>0.0001,s+=t;n++]In acest caz rezultatul se obtine ın s.

12

5.4 Functii de control a executiei

In programarea modulara uneori este necesar sa se controleze executia programului. In limbajelede programare procedurala exista instructiuni de control. Si Mathematica ofera astfel de functii,principalele fiind:

• Break[]: asigura parasirea ciclului curent.

• Continue[]: provoaca trecerea la urmatorul pas ın ciclu.

• Return[expr]: returneaza valoarea expresiei parasind prelucrarea curenta.

• Goto[nume]:se trece la elementul Label[nume].

5.5 Specificarea modulelor

Frecvent este util ca mai multe prelucrari sa fie grupate ıntr-un modul care sa poate fi apelatulterior. Lucrul cu module ın Mathematica este similar modului de lucru cu subprograme dinlimbajele de programare de uz general. Modulele pot utiliza parametri, obiecte locale (care nu potfi accesate din afara modulului), pot sa returneze valori sau pot sa produca efecte laterale (afisareaunor valori, modificarea valorilor unor obiecte externe modulului).

Doua variante de specificare a modulelor ın Mathematica sunt:

• Module[{a,b,...},corp]: defineste un modul cu variabilele locale a,b,....

• Block[{a,b,...},corp]: defineste bloc de prelucrari asupra variabilelor locale a,b,...

Exemple:

1. Definirea unui modul fara nume, folosit doar pentru a izola variabilele utilizate local.

In[]:=Module[{p,aria},p=(a+b+c)/2,aria=Sqrt[p(p-a)(p-b)(p-c)]]sau In[]:=Block[{p,aria},p=(a+b+c)/2,aria=Sqrt[p(p-a)(p-b)(p-c)]]Dupa efectuarea prelucrarii (ın oricare dintre variante) simbolurile p si aria raman neinitializatesau la vechea valoare (de dinaintea executiei modulului).

2. Definirea unui modul cu nume (cu sau fara parametri) care poate fi ulterior apelat.

In[]:=ariatriunghi[a ,b ,c ]:=Module[{p,aria},p=(a+b+c)/2;aria=Sqrt[p(p-a)(p-b)(p-c)]]

Pentru efectuarea prelucrarii se apeleaza functia pentru valorile actuale ale parametrilor (deexemplu: ariatriunghi[3,4,5]).

Observatie. Singura diferenta ıntre modulele specificate prin Module si prin Block consta ın modulın care sunt denumite si gestionate variabilele locale. Variabilelor locale specificate ıntr-un moduldefinit cu Module, sistemul le afecteaza nume standard construite ın felul urmator: <nume>$nnnn,unde <nume> este numele local al variabilei, iar nnnn este un numar de ordine stabilit de sistem. Infelul acesta nu poate exista suprapunere ıntre variabilele externe si cele definite local, acestea dinurma fiind unice.

13

Variabilele specificate ın cadrul unui bloc ısi pastreaza numele dat de utilizator chiar daca acestacoincide cu un simbol extern. Astfel simbolurile din Block sunt globale ınsa afectarile de valori aucaracter local.Exemplu.In[]:= a=5; (* initializarea simbolului global a *)In[]:= Module[{a},Print[a]; a=4] (* definirea unei variabile locale *)Out[]= a$1 (* efectul lui Print: numele afectat variabilei locale *)Out[]= 4 (* valoarea atribuita local *)In[]:= Block[{a},Print[a]; a=4] (* definirea unei variabile locale *)Out[]= a (* a este simbol global neinitializat ın Block *)

6 Elemente de programare functionala

Programarea functionala se caracterizeaza prin faptul ca prelucrarile se realizeaza ın exclusivitateprin aplicarea (eventual repetata) unor functii si compunerea lor. De asemenea, Mathematicapermite utilizarea numelor de functii ca argumente ale altor functii (de exemplu, InverseFunctioneste o functie sistem care returneaza inversa functiei pe care o primeste ca argument).

Principalele caracteristici ale programarii functionale sunt:

• Functii de ordin ınalt: functiile pot avea ca argumente alte functii. De exemplu, compunereaa doua functii este o operatie de ordin doi.

• Absenta efectelor laterale: evaluarea unei functii nu provoaca alte efecte ın afara de producereavalorii functiei. Astfel valoarea unei expresii depinde doar de valorile subexpresiilor care ocompun fara sa depinda de ordinea evaluarii lor. Aceasta presupune ca ın corpul functiilor sanu se efectueze asignari asupra unor variabile externe acestora.

• Absenta memoriei: de fiecare data cand o functie este apelata pentru acelasi set de argumenteea produce aceeasi valoare.

• Evaluare ”lenesa”: argumentele functiilor sunt evaluate doar cand este necesar. Controlulevaluarii argumentelor poate fi facut prin atributele de tip Hold.

6.1 Aplicarea repetata a functiilor

Mathematica permite specificarea compunerii unei functii cu ea insasi de un numar precizat de orisau pana cand valoarea functiei nu se mai schimba. Functiile sistem prin care se pot realiza acesteprelucrari sunt:

• Nest[f,x,n]: aplica succesiv functia f asupra lui n (f[f[f...[x]]] - de n-ori). Returneazadoar rezultatul compunerii.

• NestList[f,x,n]: efectueaza aceeasi prelucrare ca si Nest cu diferenta ca returneaza listatuturor rezultatelor intermediare: {x,f[x],f[f[x]],...]}.

• NestWhile[f,x,conditie]: aplica f succesiv pana cand conditia devine falsa.

• NestWhileList[f,x,conditie]: similar cu NestWhile doar ca returneaza lista tuturor rezul-tatelor partiale.

14

• FixedPoint[f,x]: aplica f succesiv pana cand rezultatul nu se mai schimba si returneazavaloarea acestui rezultat. De fapt, determina punctul fix al functiei f prin metoda iteratiilorsuccesive pornind de la aproximatia initiala, x.

• FixedPointList[f,x]: similar cu FixedPoint cu diferenta ca returneaza lista cu toate rezul-tatele intermediare.

• ComposeList[{f1,f2,...},]: construieste lista {x,f1[x],f2[f1[x]],...}.

Exemple.

1. Determinarea lui√

3 cu precizia 0.0001 folosind metoda Newton pentru rezolvarea ecuatieix2 = 3 pornind de la aproximatia initiala x0 = 1:In[]:=newton[x ]:=N[1/2 (x+3/x)] (* functia asociata metodei lui Newton *)In[]:=FixedPoint[newton,1]sauIn[]:=NestWhile[newton, 1, (Abs[#1 - #2] > 10^(-4)) &, 2](* al 4-lea argument al lui NestWhile indica numarul de argumente ale functiei pure folositadrept conditie *)

2. Construirea unei fractii continue:In[]:=NestList[(1/(1 + #)) &, x, 3]Out[]={x, 1

1+x ,1

1+ 11+x

, 11+ 1

1+ 11+x

}

3. Derivarea succesiva a unei expresii:In[]:= NestList[D[#,x]&,x^n,3]Out[]= {xn, n x−1+n, (−1 + n) nx−2+n, (−2 + n) (−1 + n) nx−3+n}

Aplicarea repetata a functiilor poate fi extinsa si pentru cazul functiilor cu doua variabile:

• FoldList[f,x,{a,b,. . . }]: genereaza lista {x,f[x,a],f[f[x,a],b],...}.

• Fold[f,x,{a,b,. . . }]: furnizeaza ultimul element al listei produse de FoldList.

Exemple:In[]:= FoldList[Plus,0,{a,b,c}]Out[]= {0, a, a+ b, a+ b+ c}In[]:= fact[n ]:=Fold[Times,1,Range[1,n]] (* definirea unei functii recursive pentru n!*)

6.2 Aplicarea functiilor asupra listelor

Aplicarea unei functii asupra unei liste se poate face ın doua moduri: global (functia se aplicaasupra listei ın ıntregime) sau local la nivelul fiecarui element al listei (mapare).

6.2.1 Aplicare la nivelul antetului

Se realizeaza ın unul dintre urmatoarele moduri:

• Apply[f,{a,b,...}]: returneaza f[a,b,...].

15

• Apply[f,expr]: ınlocuieste antetul expresiei cu f. In acest caz se aplica la nivelul 0 alexpresiei (vazuta ca lista).

• Apply[f,expr,specificator nivel]: se aplica f la nivelul/nivelele specificate al expresiei.

De regula, Apply se foloseste atunci cand obiectele asupra carora se doreste efectuarea unei pre-lucrari sunt colectate ıntr-o lista, Apply asigurand schimbarea antetului List cu cel corespunzatoroperatiei dorite. Poate fi ınsa utilizat ori de cate ori se doreste schimbarea antetului unui obiect(de tip List sau de alt tip). Efectul lui Apply este acelasi cu al operatorului @@.Exemple:

1. Determinarea mediei valorilor dintr-o lista:In[]:= medie[l ]:=Apply[Plus,l]/Length[l]

2. Transformarea antetului unei expresii:In[]:=Apply[Times,a+b+c] sau Times@@ a+b+cOut[]=a ∗ b ∗ c

3. Aplicare la nivelul 0:In[]:= Apply[f,{{a,b},{c,d}}]Out[]= f [{a, b}, {c, d}]

4. Aplicare la nivelul 1:In[]:= Apply[f,{{a,b},{c,d}},{1}]Out[]= {f [a, b], f [c, d]}

5. Aplicare la toate nivelele listei (cu exceptia nivelului 0):In[]:= Apply[f,{{{{a}}}},Infinity]Out[]={f [f [f [a]]]}

6.2.2 Aplicare la nivelul elementelor

Se realizeaza cu ajutorul functiilor:

• Map[f,{a,b,...}]: genereaza lista: {f[a],f[b],...}.

• Map[f,lista, specificator nivel]: aplica f asupra elementelor de la nivelul/nivelelespecificate.

• MapAll[f,lista]: aplica f la toate nivelele listei.

• MapAt[f,lista,poz]: aplica f ın pozitia poz a listei.

• Thread[f[{a1,b1,...},{a2,b2,...}...]]: genereaza lista {f[a1,a2,...],f[b1,b2,...],...}.

Observatie. Efectul lui Map poate fi realizat prin operatorul /@ iar al lui MapAll prin //@.

Exemple:

1. In[]:=Map[Sqrt,g[x^2,x^3]] sau Sqrt/@ g[x^2,x^3]]Out[]=g[Sqrt[x2], Sqrt[x3]] (* aplica radicalul fiecarui argument al lui g *)

16

2. In[]:= Map[# ^2&,a+b+c] (* se ridica la patrat fiecare termen *)Out[]= a2 + b2 + c2

3. In[]:= Map[f,a+b+c](* aplica f asupra fiecarui termen *) Out[]= f [a] + f [b] + f [c]

4. In[]:= MapAll[f,{{a,b},{c,d}}] (* aplicare la toate nivelele *)Out[]= f [{f [{f [a], f [b]}], f [{f [c], f [d]}]}]

5. In[]:= MapAt[f,a+b+c,{2}] (* aplicare doar asupra celui de al doilea element *)Out[]= a+ f [b] + c

6. Construirea unei liste cu reguli de transformare folosind Thread:In[]:=var={x,y,z}; val={1,2,3};In[]:=Thread[var->val]Out[]={x− > 1, y− > 2, z− > 3}

In Mathematica numele functiilor pot fi vazute ca expresii si pot fi prelucrate ca atare. Deexemplu:

1. Numele functiilor pot fi ınlocuite prin reguli de transformare:In[]:= f[x]+f[1-x]/.f->gOut[]= g[x] + g[1− x]

2. Numele functiilor pot fi asignate ca orice alte simboluri:In[]:= p1=p2; p1[x,y]Out[]= p2[x, y]

3. Pot fi definite functii care au ca argument nume de functii:In[]:= pf[f ,x ]:=f[x]+f[1-x]In[]:= pf[Log,q]Out[]= Log[1-q]+Log[q]

6.3 Aplicarea unei liste de functii asupra acelorasi argumente

Poate fi realizata prin functia:Through[{f1,f2,...}[argumente]]

care produce lista {f1[argumente],f2[argumente],...}Exemplu.In[]:=Through[{Sin, Cos, Tan}[Pi]]Out[]={0,−1, 0}

7 Elemente de programare bazata pe reguli

Programarea bazata pe reguli are ca suport notiunea de sablon si pe cea de regula de transformare.Potrivirea sabloanelor (”pattern matching”) si ınlocuirea obiectelor (”term rewriting”) reprezintaprincipiul de baza al evaluarii ın Mathematica. Sabloanele sunt ın special utile pentru imple-mentarea regulilor corespunzatoare transformarilor bazate pe formule (formule de calcul algebric,formule de derivare, de integrare etc.). De fapt chiar definitiile functiilor pot fi vazute ca reguli, iarapelul acestora nu reprezinta altceva decat aplicarea regulilor.

17

7.1 Sabloane

Sabloanele (”pattern-uri”) reprezinta clase de expresii cu o structura data. Prin intermediul lorpot fi efectuate prelucrari nu numai asupra unei expresii ci asupra unei ıntregi clase de obiecte.Sabloanele pot fi simple sau compuse. Sabloanele simple pot fi specificate ın unul dintre modurile:

desemneaza un obiect oarecarex desemneaza un obiect oarecare, care va putea fi referit

prin simbolul xtip desemneaza un obiect de tipul specificat

succesiune de unul sau mai multe de obiecte(pentru functii cu numar variabil de argumente )succesiune de zero sau mai multe de obiecte

Observatie. Pot fi specificate si sabloane compuse (alternative) de forma: sablon1 | sablon2care desemneaza clasa obiectelor care se potrivesc fie primului, fie celui de al doilea sablon. Deexemplu prin Symbol | Complex se desemneaza clasa obiectelor care sunt fie simboluri fie numerecomplexe.Exemple de sabloane:

1. f[n ] desemneaza o functie f cu un argument oarecare, care va putea fi referit prin n;

2. f[n ,m ] desemneaza o functie f cu doua argumente oarecare, care vor putea fi referite prinm si n;

3. x^n desemneaza obiectul x ridicat la o putere oarecare care poate fi referita prin n;

4. x ^n desemneaza un obiect oarecare (ce poate fi referit prin x) ridicat la o putere oarecare(ce poate fi referita prin n);

5. + desemneaza suma a doua expresii oarecare (anonime);

6. { , , } desemneaza o lista cu trei elemente oarecare;

7. f[n ,n ] desemneaza o functie cu numele f avand doua argumente identice;

8. x Integer desemneaza o expresie de tip ıntreg.

9. nume :x ^n : sablon compus care poate fi identificat atat la nivelul elementelor cat si globalprin numele specificat.

Cateva dintre functiile ın care pot fi folosite sabloane sunt:

• Cases[lista,sablon, nivel]: returneaza toate elementele din lista care se potrivesc cusablonul (de pe nivelul specificat).

• Count[lista,sablon,nivel]: returneaza numarul elementelor de pe nivelul specificat carese potrivesc cu sablonul.

• Position[lista,sablon,nivel]: returneaza pozitiile elementelor din lista care se potrivesccu sablonul.

18

• DeleteCases[lista,sablon,nivel]: returneaza lista obtinuta prin eliminarea elementelordin lista initiala care se potrivesc cu sablonul.

• MatchQ[expr,sablon]: returneaza True daca expresia se potriveste sablonului si False ıncaz contrar.

”Potrivirea” unui sablon poate fi controlata prin impunerea unor conditii. In aceste situatii potfi utilizate sabloanele cu restrictii de forma:

sablon /; conditie sau sablon?conditie

conditia putand fi o expresie relationala sau numele unei functii care returneaza True sau False.Exemple:

1. In[]:= fac[n /;n>0]:=n! (* redefinire a factorialului doar pentru argumente pozitive *)In[]:= fac[6]+fac[-4] (* apel *)Out[]= 720 + fac[−4] (* pentru -4 sablonul nu se aplica *)

2. In[]:= Cases[{3,-4,5,-2},x /;x<0] (* selecteaza valorile negative *)Out[]= {−4,−2}sauIn[]:= Cases[{3,-4,5,-2}, ?((#<0)&)] (* selecteaza valorile negative *)Out[]= {−4,−2}sauIn[]:= Cases[{3,-4,5,-2}, ?Negative)] (* selecteaza valorile negative *)Out[]= {−4,−2}

3. Apelul urmator verifica daca expresia este o suma cu trei termeni. In[]:= MatchQ[expresie, + + ]

O alta categorie de sabloane cu restrictii este cea ın care conditia se refera la tipul sablonului.Exemple:

1. In[]:={a,4,5,b}/.x Integer->p[x](* aplicarea transformarii doar asupra elementelor ıntregi *)

Out[]={a, p[4], p[5], b}

2. In[]:={a,4,5,b}/.x Symbol->p[x](* aplicarea transformarii doar asupra simbolurilor *)

Out[]={p[a], 4, 5, p[b]}

7.2 Aplicarea regulilor de transformare

In functie de modul de evaluare a membrilor exista doua tipuri de reguli de transformare:

• ms->md: membrul drept este evaluat o singura data, la specificarea regulii

• ms:>md: membrul drept este evaluat la fiecare aplicare a regulii.

Membrul stang poate fi orice obiect, inclusiv sabloane. Principalele moduri de aplicare a uneireguli de transformare sunt:

• expresie /. regula: regula se aplica o singura data.

19

• expresie //. regula: regula se aplica repetat atata timp cat este posibil.

Observatii. La un moment dat pot fi aplicate mai multe reguli, grupate ıntr-o lista. Daca sedoreste ca o regula sa fie aplicata doar ın anumite situatii se poate folosi varianta conditionata:ms->md/;conditie sau ms:>md/;conditie.Exemple:

1. In[]:= x+y/.x->4Out[]= 4 + y

2. In[]:= r=(a+b)->4; Sin[a+b]/.rOut[]= Sin[4]

3. In[]:= x+y/. {x->a,y->b} (* aplicarea unei liste de reguli *)Out[]= a+ b

4. In[]:= x+y/.{{x->1,y->2},{x->4,y->2}}Out[]= {3, 6}

5. Definirea prin reguli a functiei factorial:In[]:= reguli={fac[1]->1,fac[n ]->n*fac[n-1]/;(n>=2)}In[]:= fac[6]/.reguli (* regulile se aplica o singura data*)Out[]= 6fac[5]In[]:= fac[6]//.reguli (* aplicare repetata *)Out[]= 720

8 Utilizarea fisierelor

Din Mathematica fisierele pot fi utilizate ın principal ın doua scopuri:

• pentru stocarea unor comenzi din Mathematica;

• pentru stocarea unor date de lucru.

8.1 Comenzi ın fisiere

Un fisier cu comenzi poate contine mai multe expresii (fiecare corespunzand unei prelucrari) ınsaacestea trebuie sa fie pe linii diferite. Expresiile complexe pot fi separate pe mai multe linii.Fisierul cu comenzi poate fi construit fie prin salvarea unor expresii introduse ın cadrul unei sesiuniMathematica, fie utilizand un editor de texte.

Principalele prelucrari care pot fi efectuate asupra unor fisiere de comenzi sunt:

• <<fisier sau Get["fisier"]: ıncarca comenzile din fisier.

• !!fisier: afiseaza continutul fisierului.

• expresie >> fisier sau Put[expresie,"fisier"]: scrie expresia ın fisier.

• expresie >>> fisier sau PutAppend[expresie,"fisier"]: adauga expresia la fisier.

• Definition[f] >> fisier: scrie definitia obiectului f ın fisier.

20

Exemple.1. In[]:= g[x ,y ]:=(x+y)/;(x>0 || y>0) (* definirea unei functii *)In[]:= Definition[g]>>defg.m (* salvarea definitiei lui g *)In[]:= !!defg.m (* vizualizarea continutului fisierului *)... (* incarcarea definitiei in alta sesiune *)In[]:= <<defg.mIn[]:= g[1,-1] (* apelul functiei *)Out[]= 0 (* rezultat *)In[]:= g[-1,-2] (* alt apel *)Out[]= g[−1,−2] (* functia nu e definita in acest caz *)In[]:=x=Table[Random[],{5},{5}]; (* definirea unei liste *)In[]:=x>>"C:\\Director\\Exemplu.dat" (*valorile din lista sunt scrise ın fisier *)2. Reprezentarea unui grafic pornind de la coordonatele punctelor stocate ıntr-un fisier:In[]:=ListPlot[Get["puncte.dat"]]

8.2 Date ın fisiere

Datele aflate ıntr-un fisier pot fi transferate ıntr-o lista utilizand functia ReadList ale carei moduride apel sunt:

• ReadList["fisier",tip]: citeste ıntr-o lista toate elementele fisierului.

• ReadList["fisier",tip,n]: citeste primele n elemente ale fisierului.

• ReadList["fisier",Table[tip,{n}]]: pune cate n elemente ın cate o noua lista (returneazao lista cu doua nivele).

Principalele tipuri de date sunt:

Number valoare numerica exacta;Byte valoare ıntreaga reprezentata pe un octet;Real valoare reala aproximativa;Character un caracter;String sir de caractere terminat cu codul <LF>;Word secventa de caractere delimitata de separatori de cuvant;

Observatie. Pentru a avea acces la informatiile unui fisier prin ReadList nu este necesar ca fisierulsa fie deschis ın prealabil.Exemplu. Sa consideram un fisier cu numele "nr.dat" care contine valorile: 1, 1, 1, 2, 2, 2, 3, 3, 3.Citirea acestui fisier ın Mathematica poate fi efectuata ın unul dintre modurile:In[]:=ReadList["nr.dat",Number] (* citirea ca o lista de numere *)Out[]:={1, 1, 1, 2, 2, 2, 3, 3, 3} (* lista rezultata *)sauIn[]:=ReadList["nr.dat",Number,4] (* se citesc doar primele 4 valori *)Out[]:={1, 1, 1, 2}sau (* fiecare element al listei va fi o lista cu trei numere *)In[]:=ReadList["nr.dat",{Number,Number,Number}]Out[]={{1, 1, 1}, {2, 2, 2}, {3, 3, 3}}

21

sau, cu acelasi efect:In[]:=ReadList["nr.dat",Table[Number,{3}]Out[]={{1, 1, 1}, {2, 2, 2}, {3, 3, 3}}

9 Functii cu numar variabil de argumente

Pentru specificarea unui numar variabil de argumente la apelul unei functii se utilizeaza sabloanede forma: simbol (doua liniute de subliniere)si simbol (trei liniute de subliniere). Cu ajutorulprimului sablon se specifica o secventa de unul sau mai multe argumente, iar prin al doilea sespecifica o secventa de zero sau mai multe argumente. Pentru a accesa argumentele, ın cadrulmodulului secventa de argumente trebuie transformata ıntr-o lista. Astfel numarul argumentelorpoate fi determinat pe baza numarului de elemente ale acestei liste, iar fiecare argument este accesatprin specificarea elementului corespunzator al listei.

Un exemplu simplu ın care se defineste o functie cu numar variabil de parametri (nici unul, unulsau mai multi) si care nu face decat sa reafiseze valorile argumentelor este prezentat ın continuare.Exemplu.

f[argum___]:=Module[{l={argum}}, Do[Print[l[[i]]],{i,Length[l]}];]

La apelul f[a,b,c] vor fi afisate cele trei simboluri, iar la apelul f[1,2,3,4] vor fi afisate cele4 valori.

O alta varianta de a apela o functie cu numar variabil de parametri este de a specifica valoriimplicite pentru unii dintre parametri. Astfel, daca la apelul functiei unul dintre parametri lipsesteatunci ın corpul functiei el va fi ınlocuit prin valoarea implicita specificata la definirea functiei.

Pentru specificarea unei valori implicite asociata unui argument se foloseste un sablon de forma:simbol :valoare implicita.Exemplu. Definim o functie cu doua argumente care determina produsul acestora. Daca la apel sespecifica doar primul argument dorim ca valoarea celui de al doilea sa fie considerata 1. Functia vafi definita prin: g[x ,y :1]:=x y. La apelul g[2,3] se returneaza valoarea 6, iar la apelul g[2] sereturneaza valoarea 2.

10 Contexte

Pentru a asigura un mecanism eficient de gestiune a simbolurilor ın Mathematica s-a introdusnotiunea de context. Fiecare simbol apartine unui context. In cadrul unui context fiecare simboldesemneaza ın mod unic un obiect, pe cand ın contexte diferite poate sa apara acelasi simbol,desemnand ınsa obiecte diferite. Contextele sunt ıntr-un fel similare domeniilor de vizibilitate dinlimbajele de programare sau directoarelor din sistemele de fisiere.

Contextele sunt identificate prin numele lor. Numele unui context este de forma: sir decaractere‘ (un sir de caractere urmat de apostroful invers). In mod implicit, toate simboluriledefinite de utilizator apartin contextului cu numele Global‘, ınsa utilizatorii pot defini contexteproprii. Pe de alta parte simbolurile sistem apartin contextului System‘.

Un context este delimitat de comenzile: Begin["nume‘"] si End[]. Contextele sunt organizateın mod ierarhic, toate contextele definite de catre utilizator putand fi vazute ca subcontexte alecontextului implicit (Global‘). La specificarea unui simbol, sistemul ıl cauta la ınceput ın contextulcurent (cel definit ultima data) iar daca nu-l gaseste ıl cauta ın contextele care contin contextulcurent de la cel mai restrans catre cel mai cuprinzator precum si ın alte contexte cuprinse ın lista

22

de cautare. In cazul ın care simbolul sepcificat nu este gasit ın nici unul dintre contexte, atuncieste introdus ın tabelul de simboluri al contextului curent.

Numele contextului curent este retinut ın variabila sistem $Context, iar lista tuturor contextelorın care se efectueaza cautarea este retinuta ın variabila $ContextPath.

Definirea unui context utilizator este ın special utilizata la proiectarea pachetelor.

11 Definirea pachetelor

Un pachet este un ansamblu de simboluri si definitii de functii care poate fi ıncarcat doar atuncicand sunt necesare functiile pe care le contine. De regula pachetele se stocheaza ın fisiere cu extensia”*.m” ın directorul Packages. Pentru ıncarcarea unui pachet trebuie specificata calea prin care seajunge la pachet precum si numele acestuia. De exemplu, pentru ıncarcarea pachetului cu numeleNonlinearFit din pachetul Statistics se specifica: <<Statistics‘NonlinearFit‘. Structuraunui pachet este urmatoarea:

BeginPackage["pachet‘", "pachet importat‘"]

(* descrierea pachetului si a functiilor componente *)pachet::usage = " un exemplu de pachet "functie1::usage = " una dintre functii "functie2::usage = " cealalta functie "

(* definirea contextului intern pachetului *)Begin["Private‘"]

functie1[ ... ] := ...functie2[ ... ] := ...End[ ] (* sfirsitul contextului *)EndPackage[ ] (* sfirsitul pachetului *)

Exemplu. Un exemplu de pachet care cuprinde doua functii, una pentru calculul sumei argumentelorsi una pentru calculul produsului argumentelor este prezentat ın continuare.

BeginPackage["exemplu‘"]exemplu::usage= " exemplu de pachet "suma::usage = " suma argumentelor "produs::usage =" produsul argumentelor "Begin["Private‘"]suma[args__]:=Apply[Plus,{args}];produs[args__]:=Apply[Times,{args}];End[]EndPackage[]

Dupa ıncarcarea pachetului, variabila $ContextPath are valoarea exemplu‘,Global‘,System‘.

23