Pdf24 Merged

Software de analiza numerica si simbolica 1
CURS 1
PREZENTARE GENERALĂ
MATLAB®=Limbaj de înaltă performanță pentru proiectarea asistată de calculator.

MATLAB este în același timp un limbaj de programare și un sistem de dezvoltare care integrează
calculul, vizualizarea și programarea într-un mediu ușor de utilizat (easy-to-use), problemele și
soluțiile acestor probleme fiind exprimate într-un limbaj matematic accesibil.
Domenii de utilizare:
❑ Matematică și calcul numeric
❑ Dezvoltarea algoritmilor
❑ Modelarea, simularea și testarea prototipurilor
❑ Analiza și vizualizarea datelor
❑ Grafică inginerească și din științele aplicate
❑ Dezvoltarea de aplicații, inclusiv GUI (Graphical User Interface)
➢ MATLAB=sistem interactiv care are ca element de bază tabloul, matricea, ceea ce permite
rezolvarea problemelor de calcul numeric
➢ Numele MATLAB provine de la Matrix laboratory. Firma producătoare este The MathWorks,
Inc., SUA
➢ MATLAB-ul a evoluat:
❑ în mediul universitar, unde este pachetul standard pentru cursurile introductive și
avansate de matematică, inginerie și științe
❑ în mediul economic, unde este utilizat pentru cercetarea de înalt randament, dezvoltare
și producție
➢ MATLAB-ul permite dezvoltarea unei familii de aplicații sub forma toolbox-urilor. Aceste
toolbox-uri permit învățarea și aplicarea tehnologiilor specializate din diverse domenii. Sunt
disponibile toolbox-uri pentru diverse domenii
Sistemul MATLAB constă în cinci părți principale:

❑ Limbajul MATLAB
❑ Mediul de lucru MATLAB
❑ Handle Graphics®
❑ Biblioteca de funcții matematice ale MATLAB-ului
❑ Interfața de aplicații program a MATLAB-ului (API)
Limbajul MATLAB: Reprezintă un limbaj de nivel înalt de tip matrice/tablou cu instrucțiuni de control
al salturilor, funcții, structuri de date, intrări/ieșiri și cu proprietăți de programare orientată pe
obiecte1. Facilitățile de programare sunt organizate în 6 directoare:
ops
Operators and special characters (Operatori și caractere
speciale)
Lang
Programming language constructs (Construcția limbajului de
programare)
Strfun Character strings (Șiruri de caractere)
Iofun File input/output (Fișierul de intrare/ieșire)
Timefun Time and dates (Oră și date)
Datatypes Data types and structures (Tipuri de date și structuri)
Mediul de lucru MATLAB: Reprezintă un set de facilități care permit manevrarea variabilelor în spațiul
de lucru, importul și exportul de date, dezvoltarea, manipularea, editarea și depanarea fișierelor
MATLAB (.m) și a aplicațiilor MATLAB. Aceste facilități sunt organizate în directorul:
general General purpose commands (Comenzi de uz general)
1
Programarea orientată pe obiect este unul din cei mai importanți paşi făcuți în evoluția limbajelor de programare spre o
mai puternică abstractizare în implementarea programelor. Ea a apărut din necesitatea exprimării problemei într-un mod
mai natural ființei umane. Astfel, unitățile care alcătuiesc un program se apropie mai mult de modul nostru de a gândi decât
modul de lucru al calculatorului.
Handle Graphics®: Reprezintă sistemul grafic al MATLAB-ului. Cuprinde comenzi de înalt nivel pentru
vizualizarea datelor bi și tridimensional, procesarea imaginilor, animație, prezentări de grafice.
Permite de asemenea utilizarea unor comenzi pentru crearea unor interfețe grafice GUI. Funcțiile
grafice sunt organizate în 5 directoare:
Graph2d Two-dimensional graphs (Grafice bidimensionale)

Graph3d Three-dimensional graphs (Grafice tridimensionale)
Specgraph Specialized graphs (Grafice de specialitate)
Graphics Handle Graphics (Manipularea graficelor)
Uitools
Graphical user interface tools (Instrumente de interfață
grafică pentru utilizator)
Biblioteca de funcții matematice a MATLAB-ului: Reprezintă o colecție complexă de algoritmi de

calcul pornind de la funcții elementare (sinus, cosinus etc.) până la funcții sofisticate (inversarea de
matrice, valori proprii, funcții Bessel, FFT etc.). Funcțiile matematice sunt organizate în 8 directoare:
elmat
Elementary matrices and matrix manipulation (Matrice
elementare și manipularea lor)
Elfun
Elementary math functions (Funcții matematice
elementare)
Specfun
Specialized math functions (Funcții matematice
specializate)
Matfun
Matrix functions – numerical linear algebra (Funcții de
matrice - algebră liniară numerică)
Datafun
Data analysis and Fourier transforms (Analiza datelor și
transformări Fourier)
Polyfun Interpolation and polynomials (Interpolare si polinoame)
Funfun
Function functions and ODE solvers (Funcțiile de funcții și
de rezolvare a ecuațiilor diferențiale ordinare)
Sparfun Sparse matrices (Matrice rare)
Interfața de aplicații program a MATLAB-ului (API) este o bibliotecă care permite scrierea de
programe în C sau Fortran care interacționează cu MATLAB-ul. Include facilități pentru apelarea
rutinelor din MATLAB, apelarea MATLAB-ului ca mașină de calcul, scrierea și citirea fișierelor de tip
.MAT.
Pachetul SIMULINK
❑ SIMULINK® este un pachet software atașat MATLAB-ului și reprezintă un sistem interactiv
pentru simularea dinamicii sistemelor. Este conceput sub forma unei interfețe grafice care
permite crearea unui model prin “trasarea” schemei bloc a sistemului și apoi simularea
dinamicii sistemului
❑ SIMULINK poate lucra cu sisteme liniare, neliniare, continue, discrete, multivariabile etc.
❑ SIMULINK beneficiază de așa-numitele Blockset-uri, care sunt de fapt biblioteci
suplimentare ce conțin aplicații specializate din domenii cum ar fi: comunicații, procesarea
semnalelor etc.
❑ Real-time Workshop® este un program foarte important care permite generarea unui cod C
pentru schemele bloc create în SIMULINK și prin urmare permite rularea de aplicații în timp
real de o mare diversitate
Toolbox-urile MATLAB
❑ Toolbox-urile reprezintă o familie de aplicații care permit învățarea și aplicarea
tehnologiilor specializate din diverse domenii. Aceste toolbox-uri sunt colecții de funcții
MATLAB (functions) (M-files) care extind mediul MATLAB pentru rezolvarea unor clase
particulare de probleme
Câteva din cele mai utilizate aplicații sunt prezentate în figura următoare.
FUNDAMENTELE PROGRAMĂRII ÎN MATLAB (partea 1)
1. Expresii fundamentale
Matlab-ul lucrează cu expresii matematice ca și celelalte limbaje de programare, dar spre deosebire
de majoritatea acestor limbaje, aceste expresii implică lucrul cu tablouri/matrice la scară largă.
Expresiile sunt alcătuite cu ajutorul următoarelor tipuri:
➢ Variabile
➢ Numere
➢ Operatori
➢ Funcții
Variabile
➢ Matlab-ul nu necesită declararea dimensiunii variabilelor, deoarece la întâlnirea unui nou nume
de variabilă generează automat variabila respectivă și alocă spațiul necesar de memorie
➢ Numele unei variabile este o literă, urmată de un număr oricât de mare de litere, cifre sau
simboluri. Din acest număr “oricât de mare” sunt oprite primele 31 de caractere
➢ Matlab-ul este case sensitive - face distincție între literele mici și cele mari
Exemplu:
a = 30
creează o matrice 1x1 cu numele a și stochează valoarea acesteia, 30, într-o singură locație
corespunzătoare singurului element al matricei.
Numere
➢ MATLAB-ul utilizează notația zecimală, cu punct zecimal opțional și cu semn + sau -. Se
utilizează și notația științifică cu litera e pentru a specifica o putere a lui 10. Reprezentarea
numerelor imaginare este realizată cu litera i sau j ca sufix
Exemple:
3 -99 0.0001
9.6397238 1.60210e-20 6.02252e23
1i -3.14159j 3e5i
➢ Toate numerele sunt stocate intern utilizând formatul long specificat de standardul IEEE2 în
virgulă mobilă
2
Organizația internațională Institute of Electrical and Electronics Engineers
Operatori
➢ Expresiile utilizează operatori aritmetici uzuali:
+ Adunare
- Scădere
* Multiplicare
/ Împărțire la dreapta
\ Împărțire la stânga
^ Ridicarea la o putere
' Transpusa complex conjugată
( ) Operatorul de specificare a ordinii de evaluare
Funcții
➢ MATLAB-ul furnizează un mare număr de funcții matematice elementare standard (abs,
sqrt, exp, sin …)
➢ Există și funcții matematice avansate (funcții Bessel, gama etc.), multe dintre acestea
acceptând argumente complexe
➢ Pentru vizualizarea funcțiilor elementare se poate tasta:
help elfun
➢ Pentru a vedea lista funcțiilor avansate se poate tasta:

help specfun
help elmat
➢ O parte din funcții (cum ar fi sqrt, sin) sunt de tip built-in, adică sunt o parte a nucleului
MATLAB, au o mare eficiență, dar detaliile constructive nu sunt accesibile utilizatorului
➢ Alte funcții sunt implementate ca fișiere MATLAB (M-files) și pot fi chiar modificate
➢ Câteva funcții furnizează valorile unor constante universale:
pi 3.141592653589793
i Imaginary unit, -1
j Same as i
eps Floating point relative precision 2.220446049250313e-016
realmin
The smallest positive normalized single precision floating point number on
your computer: 2^(-1022), aprox. 2.225073858507201e-308
realmax
The largest single precision floating point number representable on your
computer: 2^1024, aprox. 1.797693134862316e+308
Inf Infinity
NaN Not-a-number
➢ Atenție: numele funcțiilor nu sunt rezervate și deci este posibilă suprascrierea lor !!!
Exemplu:
eps = 1.e-6
Funcția originală este reconstituită prin comanda:

clear eps
Expresii
➢ Exemple de expresii și rezultatele corespunzătoare ale evaluării acestor expresii:
rho = (1+sqrt(5))/2
rho =
1.6180
a = abs(3+4i)
a =
5
z = sqrt(besselk(4/3,rho-i))
z =
0.3730 + 0.3214i
nr_foarte_mare = exp(log(realmax))
nr_foarte_mare =
1.7977e+308
nr_prea_mare = pi* nr_foarte_mare

nr_prea_mare =
Inf
2. Help on-line, formatul datelor, opțiuni de salvare

Help on-line
Pentru rularea MATLAB pe un PC trebuie pur și simplu executat un dublu click cu mouse-ul pe icon-ul
MATLAB. Dacă sistemul de operare nu este de tip Windows (este de tip UNIX) trebuie tastat matlab
după prompter-ul sistemului de operare.
➢ Limbajul MATLAB este mult mai simplu de învățat dacă se renunță la inspectarea aridă a listelor
cu variabile, funcții și operatori și se utilizează în schimb comenzile help, helpdesk, demo,
tastate direct de la prompterul MATLAB
➢ Pentru aflarea tuturor informațiilor utile despre o comandă sau o funcție se tastează help
urmat de numele comenzii sau funcției respective
➢ Pachetul MATLAB dispune de asemenea de informații complete despre utilizare sub forma unei
documentații tip .pdf
➢ În cazuri particulare se poate apela la INTERNET, existând o legătură la pagina Web a firmei
producătoare
➢ Alte comenzi utile pentru aflarea de informații sunt: helpwin, lookfor, help help
Exemple sugestive de utilizare a comenzii help:
help sin
SIN Sine of argument in radians.
SIN(X) is the sine of the elements of X.
See also asin, sind.
Overloaded methods:
codistributed/sin
Reference page in Help browser

doc sin
_________________________________________________________________________
help exp
EXP Exponential.
EXP(X) is the exponential of the elements of X, e to the X.
For complex Z=X+i*Y, EXP(Z) = EXP(X)*(COS(Y)+i*SIN(Y)).
See also expm1, log, log10, expm, expint.
Overloaded methods:
lti/exp
codistributed/exp
fints/exp
xregcovariance/exp

doc exp
___________________________________________________________________________
help plot
PLOT Linear plot.
PLOT(X,Y) plots vector Y versus vector X. If X or Y is a matrix,
then the vector is plotted versus the rows or columns of the matrix,
whichever line up. If X is a scalar and Y is a vector, disconnected
line objects are created and plotted as discrete points vertically at
X.
PLOT(Y) plots the columns of Y versus their index.

If Y is complex, PLOT(Y) is equivalent to PLOT(real(Y),imag(Y)).
In all other uses of PLOT, the imaginary part is ignored.
Various line types, plot symbols and colors may be obtained with
PLOT(X,Y,S) where S is a character string made from one element
from any or all the following 3 columns:
b blue . point - solid

g green o circle : dotted
r red x x-mark -. dashdot
c cyan + plus -- dashed
m magenta * star (none) no line
y yellow s square
k black d diamond
w white v triangle (down)
^ triangle (up)
< triangle (left)
> triangle (right)
p pentagram
h hexagram
For example, PLOT(X,Y,'c+:') plots a cyan dotted line with a plus
at each data point; PLOT(X,Y,'bd') plots blue diamond at each data
point but does not draw any line.
PLOT(X1,Y1,S1,X2,Y2,S2,X3,Y3,S3,...) combines the plots defined by

the (X,Y,S) triples, where the X's and Y's are vectors or matrices
and the S's are strings.
For example, PLOT(X,Y,'y-',X,Y,'go') plots the data twice, with a

solid yellow line interpolating green circles at the data points.
The PLOT command, if no color is specified, makes automatic use of

the colors specified by the axes ColorOrder property. By default,
PLOT cycles through the colors in the ColorOrder property. For
monochrome systems, PLOT cycles over the axes LineStyleOrder property.
Note that RGB colors in the ColorOrder property may differ from
similarly-named colors in the (X,Y,S) triples. For example, the
second axes ColorOrder property is medium green with RGB [0 .5 0],
while PLOT(X,Y,'g') plots a green line with RGB [0 1 0].
If you do not specify a marker type, PLOT uses no marker.

If you do not specify a line style, PLOT uses a solid line.
PLOT(AX,...) plots into the axes with handle AX.
PLOT returns a column vector of handles to lineseries objects, one

handle per plotted line.
The X,Y pairs, or X,Y,S triples, can be followed by

parameter/value pairs to specify additional properties
of the lines. For example, PLOT(X,Y,'LineWidth',2,'Color',[.6 0 0])
will create a plot with a dark red line width of 2 points.
Example
x = -pi:pi/10:pi;
y = tan(sin(x)) - sin(tan(x));
plot(x,y,'--rs','LineWidth',2,...
'MarkerEdgeColor','k',...
'MarkerFaceColor','g',...
'MarkerSize',10)
See also plottools, semilogx, semilogy, loglog, plotyy, plot3, grid,

title, xlabel, ylabel, axis, axes, hold, legend, subplot, scatter.
Overloaded methods:
robot/plot
quaternion/plot
timeseries/plot
phytree/plot
HeatMap/plot
clustergram/plot
channel.plot
sfit/plot
cfit/plot
fints/plot
idmodel/plot
idfrd/plot
iddata/plot
idnlhw/plot
idnlarx/plot
cgrules/plot
xregtwostage/plot
xregtransient/plot
xregmodel/plot
xregarx/plot
localmulti/plot
localmod/plot
localavfit/plot
sweepset/plot
mdevtestplan/plot
cgdatasetnode/plot
mpc/plot
rfckt.plot
frd/plot
dspdata.plot
wdectree/plot
ntree/plot
dtree/plot
wvtree/plot
rwvtree/plot
edwttree/plot
doc plot
Formatul datelor
MATLAB-ul afișează numerele cu 4 zecimale (setare implicită). Această setare se poate modifica cu
ajutorul comenzii format:
help format
FORMAT Set output format.
FORMAT with no inputs sets the output format to the default appropriate
for the class of the variable. For float variables, the default is
FORMAT SHORT.
FORMAT does not affect how MATLAB computations are done. Computations
on float variables, namely single or double, are done in appropriate
floating point precision, no matter how those variables are displayed.
Computations on integer variables are done natively in integer. Integer
variables are always displayed to the appropriate number of digits for
the class, for example, 3 digits to display the INT8 range -128:127.
FORMAT SHORT and LONG do not affect the display of integer variables.
FORMAT may be used to switch between different output display formats

of all float variables as follows:
FORMAT SHORT Scaled fixed point format with 5 digits.
FORMAT LONG Scaled fixed point format with 15 digits for double
and 7 digits for single.
FORMAT SHORT E Floating point format with 5 digits.
FORMAT LONG E Floating point format with 15 digits for double and
7 digits for single.
FORMAT SHORT G Best of fixed or floating point format with 5
digits.
FORMAT LONG G Best of fixed or floating point format with 15
digits for double and 7 digits for single.
FORMAT SHORT ENG Engineering format that has at least 5 digits
and a power that is a multiple of three
FORMAT LONG ENG Engineering format that has exactly 16 significant
digits and a power that is a multiple of three.
FORMAT may be used to switch between different output display formats

of all numeric variables as follows:
FORMAT HEX Hexadecimal format.
FORMAT + The symbols +, - and blank are printed
for positive, negative and zero elements.

Imaginary parts are ignored.
FORMAT BANK Fixed format for dollars and cents.
FORMAT RAT Approximation by ratio of small integers. Numbers
with a large numerator or large denominator are
replaced by *.
FORMAT may be used to affect the spacing in the display of all

variables as follows:
FORMAT COMPACT Suppresses extra line-feeds.
FORMAT LOOSE Puts the extra line-feeds back in.
Example:
format short, pi, single(pi)
displays both double and single pi with 5 digits as 3.1416 while
format long, pi, single(pi)
displays pi as 3.141592653589793 and single(pi) as 3.1415927.
format, intmax('uint64'), realmax

shows these values as 18446744073709551615 and 1.7977e+308 while
format hex, intmax('uint64'), realmax
shows them as ffffffffffffffff and 7fefffffffffffff respectively.
The HEX display corresponds to the internal representation of the value
and is not the same as the hexadecimal notation in the C programming
language.
See also disp, display, isnumeric, isfloat, isinteger.
Overloaded methods:
quantizer/format

doc format
Exemple:
» c=1.333456789233
c =
1.3335
» format long
» c
c =
1.33345678923300
» format short e
» c
c =
1.3335e+000
» format long e
» c
c =
1.333456789233000e+000
» format
» c
c =
1.3335
Opțiuni de salvare ale variabilelor

➢ Pentru salvarea variabilelor curente cu care se lucrează în MATLAB la încheierea unei sesiuni de
lucru se poate utiliza comanda save
➢ Această comandă va salva toate variabilele curente generate de către utilizator într-un fișier
numit matlab.mat . Dacă se dorește se poate da un nume fișierului de date în care se salvează
variabilele
Exemplu:
save date c determ A
realizează salvarea datelor c, determ și A într-un fișier date.mat

➢ Pentru restituirea variabilelor într-o sesiune de lucru ulterioară se folosește comanda load
Exemplu:
load date
➢ Dacă se dorește aflarea variabilelor curente se pot utiliza comenzile who sau whos:
who
Your variables are:
A c determ
whos
Name Size Bytes Class
A 2x2 32 double array

c 1x1 8 double array
determ 1x1 8 double array
Grand total is 6 elements using 48 bytes
➢ Pentru ștergerea tuturor variabilelor curente din memoria de lucru se poate utiliza comanda
clear
Bibliografie
1. ***, Fundamente de Matlab, telecom.etti.tuiasi.ro/
2. Iulian Lupea, Curs Matlab
3. Nicoleta Breaz ș.a., Modelarea matematică prin Matlab
4. ***, MATLAB User’s Guide, The Mathworks Inc., SUA
CURS 2
FUNDAMENTELE PROGRAMĂRII ÎN MATLAB (partea 2)
3. Crearea fișierelor MATLAB (.m files)

Deoarece este mult mai comod și util decât introducerea comenzilor linie după linie în fereastra de
comenzi (Command Window), se lucrează cu fișiere de tip text care conțin aceste linii program cu
comenzile necesare.
Aceste fișiere conțin coduri în limbajul MATLAB și sunt denumite .m files (sau M-files). Fișierele
se creează utilizând Editorul de text al MATLABULUI (Editor), se salvează și apoi se utilizează ca o
comandă MATLAB obișnuită.
Numele unui fișier care calculează, de exemplu, venitul poate fi denumită pur și simplu
calculeaza_venitul. Unii programatori folosesc pentru notarea funcțiilor metoda numită “cocoașă
de camilă” (camelCase), adică calculeazaVenitul.
Există două tipuri de fișiere .m:
➢ Fișiere de tip script, care nu acceptă argumente de intrare și nu returnează argumente de
ieșire. Aceste fișiere operează cu date din spațiul de lucru (Workspace)
➢ Fișiere (rutine) function, care acceptă argumente de intrare și returnează argumente de
ieșire. Variabilele utilizate sunt variabile locale (interne) ale funcției
Crearea fișierelor de tip .m:
Pentru a vedea conținutul unui fișier de tip .m se folosește comanda:

type numeFisier
Caracteristicile celor două tipuri de fișiere sunt prezentate în tabelul următor:
Fișiere script Fișiere function

Nu acceptă argumente de intrare și nu Acceptă argumente de intrare și returnează
returnează ieșiri ieșiri
Variabilele interne ale funcției sunt locale
Operează cu datele din workspace
(implicit)
Utile pentru automatizarea unei serii de pași Utile pentru extinderea limbajului MATLAB
care trebuie executați de multe ori pentru diverse aplicații
Fișiere script
Fișierele script sunt cele mai simple fișiere MATLAB, nu au argumente de intrare sau de ieșire și sunt
utile pentru executarea secvențială a unor calcule care altfel ar trebui executate în mod repetat de la
linia de comandă. Script-urile operează cu datele din workspace și pot crea date noi. Aceste date sunt
disponibile după terminarea execuției fișierului.
Exemplu de fișier script salvat cu numele pitagoraGen_script.m
z=x^2+y^2-2*x*y*cos(alfa);
r=sqrt(z)
În Command Window tastăm:

x=6;
y=7;
alfa=pi/3;
La tastarea numelui fișierului script (fără extensia .m):

pitagoraGen_script
MATLAB-ul execută comenzile:

r =
6.5574
După ce se termină execuția fișierului script, toate variabilele rămân în spațiul de lucru.
Rutine (function)
Aceste fișiere acceptă argumente de intrare și furnizează argumente de ieșire. Numele fișierului
MATLAB (m-file) și cel al funcției (rutinei) respective trebuie să fie identice. Funcțiile (rutinele)
lucrează cu variabile proprii, separate de spațiul de lucru (workspace) uzual al MATLAB-ului.
O funcție .m are următoarele părți componente:
➢ Linia de definire a funcției
➢ Linia de prim help H1
➢ Textul Help-ului
➢ Corpul funcției
➢ Comentarii
➢ Linia de end (end-ul funcției nu este obligatoriu)
Exemplu:
Linia de definire
Această linie informează MATLAB-ul că fișierul conține o funcție și specifică argumentele.
Linia H1
Linia H1 este o linie de comentariu care începe cu semnul "%" și furnizează prima linie text atunci când
utilizatorul tastează help numeleFunctiei la prompterul MATLAB.
Textul Help-ului
Se poate crea un help online prin introducerea uneia sau mai multor linii de comentariu după linia H1,
fiecare linie începând cu "%".
Corpul funcției
Corpul funcției conține toate instrucțiunile în cod MATLAB care permit efectuarea calculelor și
asignează valori argumentelor de ieșire. Declarațiile din corp pot conține apelări de funcții, instrucțiuni
de salt, intrări/ieșiri interactive, calcule etc.
Comentarii
O linie de comentariu începe după cum s-a precizat cu semnul "%" și poate fi plasată oriunde într-un
fișier. Pot fi adăugate linii albe oriunde în fișier, acestea fiind ignorate.
Linia end-ului (nu este obligatorie)
Exemplu: funcția pitagoraGen

function [r]=pitagoraGen(x,y,alfa)
%pitagoraGen Teorema lui Pitagora generalizata
%Calculeaza lungimea unei laturi a unui triunghi in functie
%de celelalte doua laturi ale sale si cosinusul unghiului dintre ele:
% BC^2=AB^2+AC^2-2*(AB)*(AC)*cos(BAC)
%Numarul argumentelor de intrare este 3: AB, AC si BAC
z=x^2+y^2-2*x*y*cos(alfa);
r=sqrt(z);
end %end-ul nu este obligatoriu
În Command Window tastăm:

latura=pitagoraGen(6,7,pi/3)
latura =
6.5574
După ce se termină execuția funcției, doar variabila latura rămâne în spațiul de lucru.
Se poate vizualiza fișierul cu comanda:

type pitagoraGen
Variabile globale
Dacă se dorește ca mai multe astfel de subrutine să utilizeze o anume variabilă comună, se declară
variabila respectivă ca globală, utilizând comanda global în toate funcțiile respective.
Exemplu: fișierul cadereLibera.m:
function [h]=cadereLibera(t)
%cadereLibera Calculeaza spatiul parcurs de un corp in cadere libera
%Argumentul de intrare este timpul exprimat in secunde
global ACC_GRAVITATIONALA
h=1/2*ACC_GRAVITATIONALA*t.^2;
end %nu este obligatoriu
Se introduc în Command Window, în mod interactiv liniile:

global ACC_GRAVITATIONALA
ACC_GRAVITATIONALA=9.81;
h=cadereLibera([0:0.1:5])
h =
Columns 1 through 12
0 0.0491 0.1962 0.4415 0.7848 1.2263 1.7658 2.4035
3.1392 3.9731 4.9050 5.9351
7.0632 8.2895 9.6138 11.0363 12.5568 14.1755 15.8922 17.7071
19.6200 21.6311 23.7402 25.9475
28.2528 30.6563 33.1578 35.7574 38.4552 41.2510 44.1450 47.1370
50.2272 53.4155 56.7018 60.0863
63.5688 67.1495 70.8282 74.6051 78.4800 82.4531 86.5242 90.6934
94.9608 99.3263 103.7898 108.3515
113.0112 117.7691 122.6250
4. Matrice, vectori
Pentru a lucra ușor și bine cu limbajul MATLAB trebuie în primul rând să se învețe manipularea
matricelor.
În MATLAB, o matrice este un tablou dreptunghiular de numere.
Scalarii sunt matrice 1 × 1, iar vectorii sunt matrice cu o singură linie sau coloană.
Matricele se pot introduce în mai multe moduri:
➢ Introducerea unei liste explicite cu elementele matricei
➢ Încărcarea unor date din fișiere externe de date
➢ Generarea de matrice utilizând funcții built-in
➢ Crearea de matrice în fișierele M-files
Trebuie respectate câteva convenții simple:
➢ Elementele unei linii sunt separate prin virgule sau spații
➢ Sfârșitul unei linii se marchează cu punct și virgulă
➢ Lista de elemente care formează matricea se delimitează cu paranteze drepte [ ]
Pentru introducerea matricei lui Dürer tastăm:
A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]
MATLAB-ul va afișa matricea:

A =
16 3 2 13
5 10 11 8
9 6 7 12
4 15 14 1
O dată introdusă, matricea este memorată în workspace și poate fi apelată simplu, ca A.
Operatorul :
Operatorul : este foarte important.
De exemplu, expresiile următoare sunt vectori linie:
a=1:10
a =
1 2 3 4 5 6 7 8 9 10
b=100:-7:50
b =
100 93 86 79 72 65 58 51
c=0:pi/4:pi
c =
0 0.7854 1.5708 2.3562 3.1416
5. Operațiuni elementare cu matrice

MATLAB-ul operează cu matricele cu aceeași ușurință cu care lucrează cu scalarii. Pentru adunarea a
două matrice de exemplu se folosește pur și simplu semnul + ca la o adunare obișnuită. Bineînțeles că
matricele trebuie să aibă aceleași dimensiuni pentru a putea fi adunate.
Exemplu:
A=[2 3;15 -3];
B=[11 -21; 12 4];
C=A+B
C =
13 -18
27 1
Pentru înmulțirea a două matrice se folosește operatorul * valabil de altfel și pentru operațiile cu
scalari.
Exemplu:
D=A*B
D =
58 -30
129 -327
Dacă dimensiunile matricelor care se înmulțesc nu sunt corespunzătoare, atunci va fi furnizat un mesaj
de eroare:
E=[1 23; -12 2;1 2]
E =
1 23
-12 2
1 2
F=A*E
??? Error using ==> *
Inner matrix dimensions must agree.
PROGRAMAREA ÎN LIMBAJUL MATLAB (partea 1)
1. Operatori și funcții logice

Operatorii MATLAB pot fi clasificați în trei categorii:
➢ Operatori aritmetici
➢ Operatori relaționali, care compară operanzii d.p.d.v. cantitativ
➢ Operatori logici
Operatori aritmetici
+ Adunare + Plus unar (B = uplus(A))

- Scădere - Minus unar (B = uminus(A))
.* Înmulțire * Înmulțire de matrice
./ Împărțire la dreapta / Împărțire matriceală la dreapta
.\ Împărțire la stânga \ Împărțire matriceală la stânga
.^ Putere ^ Putere de matrice
.' Transpusa (B = transpose(A)) ' Transpusa complex conjugată
: Operatorul două puncte (B = ctranspose(A))
Cu excepția operatorilor matriceali, operatorii aritmetici lucrează cu elementele corespondente ale

unor tablouri de dimensiuni egale. Pentru vectori și tablouri dreptunghiulare ambii operanzi trebuie
să aibă aceeași dimensiune, cu excepția situației în care unul dintre ei este scalar. În aceste cazuri
MATLAB-ul aplică scalarul fiecărui element al celuilalt operand (proprietatea de expansiune scalară).
Operatori relaționali
< Mai mic

<= Mai mic sau egal
> Mai mare
>= Mai mare sau egal
== Identic
~= Diferit de
Operatorii relaționali compară elementele corespondente ale unor tablouri de dimensiune egală.
Operatorii relaționali lucrează totdeauna element cu element !!!.
Exemplu:
A = [2 7 6;9 0 5;3 0.5 6];
B = [8 7 0;3 2 5;4 -1 7];
A == B
ans =
0 1 0
0 0 1
0 0 0
Operatori logici
& and (și)
| or (sau)
~ not (nu)
➢ O expresie care utilizează operatorul & este adevărată dacă ambii operanzi sunt adevărați. În
termeni numerici, expresia este adevărată dacă ambii operanzi sunt nenuli.
Exemplu:
u = [1 0 2 3 0 5];
v = [5 6 1 0 0 7];
u & v
ans =
1 0 1 0 0 1
➢ O expresie care utilizează operatorul | este adevărată dacă unul dintre operanzi este logic
adevărat sau dacă ambii operanzi sunt adevărați. În termeni numerici, expresia este falsă dacă
ambii operanzi sunt nuli.
Exemplu:
u | v
ans =
1 1 1 1 0 1
➢ O expresie care utilizează operatorul ~ neagă operandul. În termeni numerici, orice operand
nenul devine nul și orice operand nul devine unu.
Exemplu:
~u
ans =
0 1 0 0 1 0
Operatorii logici lucrează cu elementele corespondente ale unor tablouri de dimensiuni egale. Pentru
vectori și tablouri dreptunghiulare ambii operanzi trebuie să aibă aceeași dimensiune, cu excepția
situației în care unul dintre ei este scalar. În acest caz, ca și la operatorii aritmetici, MATLAB-ul aplică
scalarul fiecărui element al celuilalt operand.
Funcții logice
În plus față de operatorii logici, MATLAB-ul furnizează și funcții logice:
Funcție Descriere Exemple

xor EXCLUSIVE OR (SAU EXCLUSIV). Returnează logic a=1; a=1;
b=1; b=0;
adevărat dacă unul din operanzi este adevărat și xor(a,b) xor(a,b)
celălalt fals. În termeni numerici, returnează 1 dacă ans = ans =
un operand este nenul și celălalt este zero; în caz 0 1
contrar returnează 0.
all ALL (TOATE). Returnează 1 dacă toate elementele u=[0 1 2 0];
all(u)
unui vector sunt adevărate sau nenule; în caz contrar ans =
returnează 0. Operează și cu matrice (pe coloane). 0
A=[0 1 2;3 5 0];

all(A)
ans =
0 1 0
any ANY (ORICARE). Returnează 1 dacă oricare din v=[5 0 8];
any(v)
elementele argumentului sunt adevărate sau nenule; ans =
în caz contrar returnează 0. 1
isnan TRUE FOR NOT-A-NUMBER (ADEVARAT PENTRU w=[5 NaN 8 Inf];
isnan(w)
ELEMENTELE NENUMERE). Returnează un vector care ans =
conține 1 pentru oricare din elementele argumentului 0 1 0 0
care sunt NaN și 0 pentru cele care sunt numere.
isinf TRUE FOR INFINITE ELEMENTS (ADEVARAT PENTRU w=[5 NaN 8 Inf];
isinf(w)
ELEMENTELE INFINIT). Returnează un vector care ans =
conține 1 pentru oricare din elementele argumentului 0 0 0 1
care sunt Inf și 0 pentru cele care sunt finite.
find Găsește indicii elementelor unei matrice care A se folosi help-ul
pentru mai multe
îndeplinesc o condiție relațională detalii
Prioritatea operatorilor
Deoarece se pot construi expresii cu diverse tipuri de operatori, nivelurile de prioritate determină
ordinea în care sunt evaluate expresiile. În cadrul fiecărui nivel, operatorii au prioritate egală și sunt
evaluați de la stânga la dreapta.
Regulile de prioritate de la nivelul de prioritate cel mai mare spre cel mai mic sunt prezentate în tabelul
următor.
Operator Nivel de prioritate

() Prioritate maximă
~ (negare)
.' .^ ' ^ + (plus unar)
- (minus unar)
.* ./ .\ * / \
+ (adunare) - (scădere)
: < <= > >= == ~=
& | Prioritate minimă
Bibliografie
CURS 3
2. Instrucțiuni de salt și bucle (instrucțiuni pentru controlul derulării unui program) (partea 1)
În MATLAB există mai multe tipuri de instrucțiuni de control al buclelor:
✓ if, else și elseif
✓ switch, case și otherwise
✓ for
✓ while
✓ break
✓ continue
✓ return
✓ try, catch
✓ error
Toate instrucțiunile de control folosesc comanda end pentru a indica sfârșitul blocului respectiv.
Instrucțiunile if, if-else, if-elseif, if-elseif-else

Execută un grup de instrucțiuni pe baza unei condiții logice.
Poate lucra și cu șiruri de caractere doar împreună cu funcția strcmp care compară șiruri de
caractere!!!
➢ if (simplu)
Sintaxa Schema logică

codul anterior
if conditie logica
blocul de cod al lui if
end
codul ulterior
Exemplu: Un fișier script cu numele tempMasurataVar1 care stabilește dacă temperatura măsurată
este corespunzătoare efectuării măsurătorilor.
%stabileste daca temperatura masurata este corespunzatoare efectuarii
masuratorilor
temperatura=input('Introduceti temperatura masurata: ');

if temperatura>=20 && temperatura<=22 %sintaxa corecta este &&
disp(['Temperatura de ',num2str(temperatura),...
' grade Celsius este corespunzatoare efectuarii masuratorilor'])
end
if temperatura<20 || temperatura>22 %sintaxa corecta este ||
' grade Celsius nu este corespunzatoare efectuarii masuratorilor'])
end
Se tastează în Command Window:

tempMasurataVar1
▪Funcția input dă controlul la tastatură

Sintaxe:
val=input('sir de caractere') afișează șirul sir de caractere pe ecran, așteaptă
introducerea de la tastatură, evaluează orice expresie din intrare și returnează valoarea în val.
Pentru evaluarea expresiilor, input accesează variabile din spațiul de lucru. Dacă se apasă
tasta RETURN fără a introduce nimic, este returnată matricea goală []
str=input('sir de caractere','s') returnează textul introdus sub forma unui șir de
caractere MATLAB, fără a evalua expresia
Exemple:
a=7;b=3;
rezultat=input('scrieti a+b sau a-b = ') %pt. afisarea rez. nu se foloseste 's'
scrieti a+b sau a-b = a-b

rezultat =
10
a=7;b=3;
rezultat=input('scrieti a+b sau a-b = ','s')
scrieti a+b sau a-b = a-b

rezultat =
a-b
▪Funcția disp afișează în fereastra de comandă

disp(X) afișează tabloul X, fără a tipări numele tabloului. Dacă X este un șir de caractere,
este afișat textul
Exemple:
X=[3.3 1/3;log(11) sqrt(7)];
disp(X)
3.3000 0.3333
2.3979 2.6458
disp('de afisat')
de afisat
▪Funcția num2str convertește numerele în șiruri de caractere

Sintaxe:
S=num2str(A) transformă tabloul numeric A într-unul format din șiruri de caractere;
formatul de ieșire depinde de cel al valorilor numerice originale
S=num2str(A,precission) numărul de zecimale semnificative sunt specificate prin
precission
▪Funcția int2str convertește numerele întregi în șiruri de caractere

Sintaxă:
S=int2str(A) rotunjește valorile tabloului numeric A la numere întregi și transformă
rezultatul într-un tablou de șiruri de caractere
Exemple:
X=[3.3 1/3;log(11) sqrt(7)]
X =
3.3000 0.3333
2.3979 2.6458
Y=num2str(X,2) %converteste numerele in siruri de caractere

Y =
3.3 0.33
2.4 2.6
Z=int2str(X) %converteste numerele in siruri de caractere

Z =
3 0
2 3
➢ if-else

codul anterior
if conditie logica
else
blocul de cod al lui else
end
codul ulterior
Exemplu: Un fișier script cu numele tempMasurataVar2 care stabilește dacă temperatura măsurată
este corespunzătoare efectuării măsurătorilor.
%stabileste daca temperatura masurata este corespunzatoare efectuarii
masuratorilor
temperatura=input('Introduceti temperatura masurata: ');

if temperatura>=20 && temperatura<=22 %sintaxa corecta este &&
' grade Celsius este corespunzatoare efectuarii masuratorilor'])
else
' grade Celsius nu este corespunzatoare efectuarii masuratorilor'])
end
➢ if-elseif

codul anterior
if conditie logica 1
elseif conditie logica 2
blocul de cod al lui elseif
end
codul ulterior
Exemplu:
u=input('u=');
v=input('v=');
if u>v
disp('u este mai mare ca v')
elseif u<v
disp('u este mai mic ca v')
end
➢ if-elseif-else

codul anterior
elseif conditie logica 2
blocul de cod al lui elseif
else
end
codul ulterior
Exemplul 1:
u=input('u=');
v=input('v=');
if u>v
disp('u este mai mare ca v')
elseif u<v
disp('u este mai mic ca v')
else
disp('u este egal cu v')
end
Exemplul 2: Un fișier script cu numele calculPretCuDiscount pentru calculul prețului de

vânzare aplicând un discount variabil.
%calculul pretului de vanzare aplicand un discount variabil:
%daca pretul la raft este mai mic de 100 lei, discount-ul este 0%
%daca pretul la raft este mai mare de 100 lei, discount-ul este 5%
pretRaft=input('Introduceti pretul la raft: ');

if pretRaft>2000
discount=20/100;
elseif pretRaft>1000
discount=15/100;
elseif pretRaft>500
discount=10/100;
elseif pretRaft>100
discount=5/100;
else
discount=0/100;
end
disp(['Discount-ul este: ',num2str(100*discount),'%']);
pretVanzare=pretRaft*(1-discount);
TVA=pretVanzare-pretVanzare/(1+0.19);
disp(['Pretul final este ',num2str(pretVanzare),' lei']);
disp(['din care TVA-ul reprezinta ',num2str(TVA),' lei.']);
Exemplul 3: Un fișier script cu numele parSauImpar pentru stabilirea parității sau imparității unui
număr întreg strict pozitiv.
%script-ul stabileste paritatea sau imparitatea unui numar intreg strict
pozitiv
n=input('n=');
if n<=0
disp('valoarea furnizata trebuie sa fie strict pozitiva');
elseif rem(n,2)==0 %functia rem returneaza restul impartirii
disp('n par');
else %daca n este strict pozitiv si impar
disp('n impar');
end
Se pot scrie instrucțiuni if în corpul unei alte instrucțiuni if (if imbricat).

Exemplul 4: Să se scrie un fișier script cu numele acordareRate în scopul verificării condițiilor de
acordare de rate pentru cumpărarea unui produs din magazin.
%indeplinire conditii pentru acordare rate cumparare produs
%conditii: vechimea in munca minima 3 ani, salariul net minim 2000 lei
vechimeMunca=input('Vechimea in munca: ');

if vechimeMunca>=3
salariulNet=input('Salariul net: ');
if salariulNet>=2000 %if in if
disp('Puteti cumpara produsul in rate')
else
disp('Nu indepliniti conditia ca salariul net sa fie minim 2000 lei');
end %end-ul de la if-ul interior
else
disp('Nu indepliniti conditia vechimii in munca minime de 3 ani');
end %end-ul de la if-ul exterior
Funcția strcmp(S1,S2) compară șirurile de caractere S1 și S2: dacă sunt identice returnează 1
(true), în caz contrar 0 (false).
strcmp('bicicleta','trotineta')
ans =
0
Exemplul 5: Un fișier script cu numele calculArieVar1 pentru triunghi, dreptunghi și cerc.

figura=input('Tastati triunghi, dreptunghi sau cerc: ','s');
if strcmp(figura,'triunghi')==1
b=input('Tastati valoarea numerica a bazei in [mm] = ');
h=input('Tastati valoarea numerica a inaltimii in [mm] = ');
aria=b*h/2;
disp(['aria triunghiului = ',num2str(aria),' [mm^2]']);
elseif strcmp(figura,'dreptunghi')==1
a=input('Tastati valoarea numerica a bazei in [mm] = ');
b=input('Tastati valoarea numerica a inaltimii in [mm] = ');
aria=a*b;
disp(['aria dreptunghiului = ',num2str(aria),' [mm^2]']);
elseif strcmp(figura,'cerc')==1
r=input('Tastati valoarea numerica a razei in [mm] = ');
aria=pi*r^2;
disp(['aria cercului = ',num2str(aria),' [mm^2]']);
else
disp('Ati tastat altceva decat triunghi, dreptunghi sau cerc');
end
Instrucțiunile switch, case, otherwise

Execută grupuri de instrucțiuni pe baza condiției logice de identitate a unor șiruri de caractere.

codul anterior
switch expresie
case valoare 1
grup 1 de instructiuni
case valoare 2
grup 2 de instructiuni
...
case valoare n
grup n de instructiuni
otherwise
grup n+1 de instructiuni
end
codul ulterior
Exemplu: Un fișier script cu numele calculArieVar2 pentru triunghi, dreptunghi și cerc.

figura=input('Tastati triunghi, dreptunghi sau cerc: ','s');
switch figura
case 'triunghi'
b=input('Tastati valoarea numerica a bazei in [mm] = ');
h=input('Tastati valoarea numerica a inaltimii in [mm] = ');
aria=b*h/2;
disp(['aria triunghiului = ', num2str(aria), ' [mm^2]']);
case 'dreptunghi'
a=input('Tastati valoarea numerica a bazei in [mm] = ');
b=input('Tastati valoarea numerica a inaltimii in [mm] = ');
aria=a*b;
disp(['aria dreptunghiului = ', num2str(aria), ' [mm^2]']);
case 'cerc'
r=input('Tastati valoarea numerica a razei in [mm] = ');
aria=pi*r^2;
disp(['aria cercului = ', num2str(aria), ' [mm^2]']);
otherwise
disp('Ati tastat altceva decat triunghi, dreptunghi sau cerc');
end
Comparație între switch-case-otherwise și if-elseif-else
switch-case-otherwise if-elseif-else
mai ușor de scris/înțeles mai greu de scris/înțeles
pentru a compara șiruri de caractere

poate compara șiruri de caractere
trebuie folosită funcția strcmp
testează doar pe baza condiției logice testează pe baza condițiilor logice de
de identitate identitate sau inegalitate
Instrucțiunea for
Execută un grup de instrucțiuni de un număr fixat de ori.

codul anterior
for index=start:increment:end
corpul de instrucțiuni ale lui for
end
codul ulterior
Exemplul 1: Să se scrie un fișier script numit sumaSerieNumereVar1 pentru calculul sumei unei
serii de n valori numerice introduse de utilizator.
%Calculeaza suma unei serii de n valori numerice introduse de utilizator
%Se foloseste bucla FOR
%Numarul de valori numerice din serie

n=input('Introduceti numarul de valori din serie: ');
disp(['Numarul de valori insumate va fi ',num2str(n)])
%Initializez acumulatorul (variabila) suma
suma=0; %acumulatorul se intializează intotdeauna cu 0
for i=1:1:n %se poate scrie si i=1:n
numar=input('Introduceti un numar: ');
suma=suma+numar; %se recalculeaza variabila ”suma”
end
%Afisez suma
disp(['Suma celor ',num2str(n),' valori introduse este ',num2str(suma)])
Exemplul 2: Să se genereze 5 numere egale cu dublul celui anterior, primul fiind introdus de utilizator.
x(1)=input('Introduceti valoarea primului numar: ');
for n=2:1:6 %se poate scrie si n=2:6
x(n)=2*x(n-1);
end
disp(x)
Se pot scrie instrucțiuni for în corpul unei alte instrucțiuni for (for imbricat).
Exemplul 3: Să se scrie un fișier script numit generareMatriceVar1 pentru generarea unei matrice
M cu m linii și n coloane având valorile elementelor dată de relația M(i,j)=1/(i+j-1)
%Generarea unei matrice m x n cu elementele calc. cu rel. M(i,j)=1/(i+j-1)
m=input('numarul de linii = ');

n=input('numarul de coloane = ');
M=zeros(m,n); %functia zeros genereaza o matrice m x n cu elemente = 0
for i=1:m %se repeta de m ori
for j=1:n %se repeta de m x n ori
M(i,j)=1/(i+j-1);
end
end
disp('Matricea generata este:');
disp(M)
Combinarea instrucțiunilor if și for

Exemplul 4: Să se scrie un fișier script numit nrValStrictPozitive care să returneze numărul de
valori strict pozitive dintr-un șir numeric introdus de utilizator.
%Script-ul returneaza numarul de valori strict pozitive dintr-un sir numeric
%Sirul numeric se da sub forma unui vector linie, de exemplu [1 -2 3 -9 4 1]
a=input('Tastati un sir numeric ');

contor=0; %initializez variabila contor care va numara valorile strict poz.
for i=1:length(a)
if a(i)>0
contor=contor+1;
end
end
disp(['Numarul de valori strict pozitive este ',num2str(contor)])
Instrucțiunea while
Execută un grup de instrucțiuni de un număr nedefinit de ori pe baza unei condiții logice.

codul anterior
while conditie logica
corpul de instrucțiuni ale lui while
end
codul ulterior
serii de n valori numerice introduse de utilizator.
%Se foloseste bucla WHILE

i=1;% se initializeaza indicele ”i” cu valoarea 1
while i<=n
i=i+1; %se indexeaza indicele ”i”
end
%Afisez suma
Exemplul 2: Să se scrie un fișier script numit traiectorie pentru calculul elementelor traiectoriei
unui proiectil (înălțime, distanță) lansat sub un anumit unghi față de orizontală, sub acțiunea
gravitației: la orice moment t, componentele deplasării (orizontală și verticală a proiectilului) sunt

date de relațiile (1):
x = v 0  cos (  )  t

 t2 (1)
y = v 0  sin (  )  t − g
 2
%Script-ul calculeaza inaltimea maxima si distanta maxima parcurse de un

%proiectil lansat cu viteza data sub un unghi dat
v=input('Introduceti valoarea vitezei de lansare in [m/s]: ');

alfa=input('Introduceti valoarea unghiului de lansare in [grd]: ');
t=0; %initializare timp
deltaT=10^-5; %variatia timpului se stabileste 10^-5 sec
x(1)=0; %valoarea initiala a deplasarii pe axa X la t=0
y(1)=0; %valoarea initiala a deplasarii pe axa Y la t=0
i=1; %initializare indice ”i”
while y(i)>=0 %la primul ciclu y(1)=0, deci adevarat
i=i+1; %indexare indice i
t=t+deltaT;
x(i)=v*cosd(alfa)*t; %cosd are argumentul de intrare in grd
y(i)=v*sind(alfa)*t-9.81/2*t^2; %sind are argumentul de intrare in grd
end
%functia max gaseste valoarea maxima a vectorului y
disp(['inaltimea maxima= ',num2str(max(y)),' [m]'])
%x(end) inseamna ultima valoare din vectorul x
disp(['distanta maxima= ',num2str(x(end)),' [m]'])
plot(x,y) %functia plot creează un grafic 2-D de tip linie
Aplicație numerică: viteza de lansare 20m/s, unghiul de lansare 30grade.

inaltimea maxima=5.0968 [m]
distanta maxima=35.312 [m]
Exemplul 3: Să se scrie un fișier script cu numele celsToFahr care să transforme temperaturile în

grade Celsius introduse de la tastatură în grade Fahrenheit.
%Scriptul celsToFahr pentru transformarea gradelor Celsius in Fahrenheit
%Formula de transformare: F=32+9/5*C
raspuns=input('Continuati? (da/nu): ','s');

while strcmp(raspuns,'da')==1
C=input('Temperatura in grade Celsius= ');
F=32+9/5*C;
disp(['Temparatura in grade Fahrenheit= ',num2str(F)]);
raspuns=input('Continuati? (da/nu): ','s');
end
Exemplul 4: Validarea intrărilor folosind bucla while. Validarea intrărilor (input-ului) este procesul de
verificare a datelor care sunt introduse într-un program ca să fim siguri că sunt corecte înainte de a fi
folosite în calcule. Dacă un user introduce date greșite, programul va returna răspunsuri eronate sau
erori logice care sunt cel mai greu de depanat. Calculatorul nu poate să facă diferența între datele
corecte și cele incorecte. Ce s-ar întâmpla dacă la orele lucrate într-o săptămână, operatorul în loc de
50 de ore ar introduce 500 de ore? Rezultatul ar fi aberant. Același lucru se poate întâmpla și cu salariul
orar. Cum prevenim o astfel de greșeală? Simplu! Utilizăm bucle while.
Să se scrie un script salariulBrutSapt care să calculeze salariul brut săptămânal al angajaților.
%Script-ul afiseaza salariul brut saptamanal pentru orele lucrate

%intr-o saptamana
%Se introduc numele si prenumele angajatului

nume=input('Introdu numele angajatului: ','s');
prenume=input('Introdu prenumele angajatului: ','s');
%Introducem numarul orelor lucrate intr-o saptamana
ore=input('Introdu numarul orelor lucrate: ');
%Ne asiguram ca userul nu introduce o valoare absurda
while ore>60
disp('Eroare! Nu pot fi mai mult de 60 de ore!');
ore=input('Introdu orele corecte: ');
end
%Introducem salariul orar
salOrar=input('Introdu salariul orar: ');
%Ne asiguram ca userul nu introduce o valoare absurda
while salOrar>70
disp('Eroare! Salariul orar nu poate fi mai mare de 70 lei!');
salOrar=input('Introdu salariul orar corect:');
end
%Calculam salariul brut
salariu=ore*salOrar;
%Afiseaza salariul
disp(['Sal. brut/sapt. al lui ',nume,' ',prenume,' este: ',num2str(salariu)]);
Se pot scrie instrucțiuni while în corpul unei alte instrucțiuni while (while imbricat).
Exemplul 5: Să se scrie un fișier script numit generareMatriceVar2 pentru generarea unei matrice
M cu m linii și n coloane având valorile elementelor dată de relația M(i,j)=1/(i+j-1)
%Generarea unei matrice m x n cu elementele calc. cu rel. M(i,j)=1/(i+j-1)
m=input('numarul de linii = ');

n=input('numarul de coloane = ');
M=zeros(m,n); %functia zeros genereaza o matrice m x n cu elemente = 0
i=1; %se initializeaza indicele ”i” cu valoarea 1
while i<=m %se repeta de m ori de 1 la m
j=1; %se initializeaza indicele ”j” cu valoarea 1
while j<=n %se repeta de m x n ori
M(i,j)=1/(i+j-1);
j=j+1; %se indexeaza indicele ”j”
end
end
disp('Matricea generata este:');
disp(M)
Observație: este mai dificilă gestionarea indicilor în cazul folosirii ciclului while decât în cazul ciclului
for.
Bibliografie
CURS 4
2. Instrucțiuni de salt și bucle (instrucțiuni pentru controlul derulării unui program) (partea 2)
Instrucțiunea break
Provoacă întreruperea ciclurilor for și while și salt la prima instrucțiune după instrucțiunea end
a ciclului. Se recomandă a fi utilizată și în cazul în care o condiție de eroare este detectată în interiorul
unei bucle. În cazul unor cicluri imbricate, break comandă ieșirea din cel mai interior ciclu.
Sintaxa (pentru while) Schema logică

codul anterior
while conditie logica 1
corp instructiuni 1;
break
end
corp instructiuni 3
end
codul ulterior
Dacă conditie logica 1 este adevărată se execută corp instructiuni 1 și:

a) dacă conditie logica 2 este adevărată se execută corp instructiuni 2, iar
instrucțiunea break face să se iasă din ciclul while
b) dacă conditie logica 2 este falsă, instrucțiunea break nu este luată în considerare și se
execută corp instructiuni 3 și se trece la următoarea iterație din ciclul while
Exemplul 1: Să se scrie un fișier script cu numele sumaValPozVar1 care să calculeze suma unei serii
de n valori numerice pozitive introduse de utilizator. Dacă se introduce un număr negativ, acesta nu
este luat în considerare și se calculează suma valorilor pozitive introduse până la acesta.
%Acest script calculeaza suma unei serii de n

%valori numerice pozitive introduse de utilizator.
%Daca se introduce un numar negativ, acesta nu este luat in considerare
%si se calculeaza suma valorilor pozitive introduse pana la acesta

disp(['Numarul de valori insumate va fi ',num2str(n)]);
%Initializez variabila suma
suma=0.0; %acumulatorul se intializează intotdeauna cu 0.0
%Initializez variabila de control i
i=1;
while i<=n
if numar<0
disp('Numarul introdus nu este considerat pentru calculul sumei')
break %dacă numar < 0 bucla while este intrerupta
end
suma=suma+numar;
i=i+1;
end
%Afisez suma valorilor pozitive introduse
disp(['Suma celor ',num2str(i-1),' valori pozitive introduse corect este ',num2str(suma)]);
serii de n valori numerice introduse de utilizator folosind o buclă while infinită și instrucțiunea
break.

%Se foloseste bucla WHILE infinita si instructiunea BREAK

i=1; %se initializeaza indicele ”i” cu valoarea 1
while 1 %1 este adevarat intotdeauna (ciclu while infinit)
if i>n
break
end
end
Instrucțiunea continue
Transferă controlul următoarei iterații din ciclurilor while și for în care apare, sărind peste
celelalte instrucțiuni din corpul ciclului. Este utilă în cazul unor bucle mari, când trebuie sărite anumite
instrucțiuni. În cicluri imbricate controlul este dat următoarei iterații a ciclului care conține
instrucțiunea continue.
Sintaxa (pentru while) Schema logică

codul anterior
while conditie logica 1
if conditie_2
continue
end
end
codul ulterior
Dacă conditie logica 1 este adevărată se execută corp instructiuni 1 și:

a) dacă conditie logica este adevărată, instrucțiunea continue face ca
2
corp instructiuni 2 să nu se execute și se trece la următoarea iterație din ciclul while
b) dacă conditie logica 2 este falsă, instrucțiunea continue nu este luată în considerare și
se execută corp instructiuni 2 și se trece la următoarea iterație din ciclul while
Exemplul 1: Se generează numere aleatoare întregi cu distribuție uniformă mai mici sau egale cu 10
atât timp cât numărul aleator generat este mai mare decât indicele acestuia. Când numărul aleator
generat este mai mic decât indicele acestuia se termină generarea (combinație a instrucțiunilor
continue și break).
i=0; %se initializeaza indicele
while 1 %1 este adevarat intotdeauna (ciclu while infinit)
i=i+1; %indexez valoarea lui i
nrAleator=randi(10); %generez un numar aleator intreg <=10
if nrAleator>=i
disp([num2str(nrAleator) '>=' num2str(i)]);
continue %se trece la generarea urmatorului numar aleator
end
disp([num2str(nrAleator) '<' num2str(i)]);
break %daca nrAleator < i se opreste ciclul
end
Rutina este analoagă cu următoarea în care se folosește else în loc de continue:

i=0; %se initializeaza indicele
while 1
i=i+1; %indexez valoarea lui i
nrAleator=randi(10); %generez un numar aleator intreg <=10
if nrAleator>=i
disp([num2str(nrAleator) '>=' num2str(i)]);
else
disp([num2str(nrAleator) '<' num2str(i)]);
break %daca nr_aleator < i se opreste ciclul
end
end
Exemplul 2: Să se scrie un fișier script cu numele sumaValPozVar2 care să calculeze suma unei serii
de n valori numerice pozitive introduse de utilizator. Dacă se introduce un număr negativ, acesta nu
este luat în considerare și se calculează suma valorilor pozitive introduse.
%Acest script calculeaza suma unei serii de n
%valori numerice pozitive introduse de utilizator
%Daca se introduce un numar negativ, acesta nu este luat in considerare

disp(['Numarul de valori insumate va fi ',num2str(n)]);
%Initializez variabila suma
suma=0.0; %acumulatorul se intializează intotdeauna cu 0.0
%Initializez variabila de control i
i=1;
while i<=n
if numar<0
disp('Numarul nu este considerat pentru calculul sumei');
continue %daca numar < 0 bucla while sare la urmatoarea iteratie
end
suma=suma+numar;
i=i+1;
end
%Afisez suma valorilor pozitive introduse
disp(['Suma celor ',num2str(n),' valori pozitive este ',num2str(suma)]);
Instrucțiunea return
Provoacă ieșirea forțată din funcție sau script și întoarcerea la funcția apelantă (care a apelat
procedura) sau dă controlul la tastatură.
Exemplu general:
function [argIesire]=numeFunctie(x,y,...)
while conditie 1
if conditie 2
argIesire=valoare 1;
return;
end
corp instructiuni 3
end
argIesire=valoare 2;
end %end-ul functiei nu este obligatoriu
Dacă conditie 1 este adevărată se execută corp instructiuni 1 și:

a) dacă conditie 2 este adevărată, se execută instrucțiunea corp instructiuni 2, se
calculează argIesire, după care instrucțiunea return face ca corp instructiuni 3 să
nu se execute, se iese din ciclul while și nu se execută nici corp instructiuni 4; se
returnează argIerire (=valoare 1) (se iese din funcție)
b) dacă conditie 2 este falsă, nu se execută nimic între if și end, inclusiv instrucțiunea
return; se va executa corp instructiuni 3 și se trece la următoarea iterație din ciclul
while
Dacă conditie 1 este sau devine falsă se execută corp instructiuni 4 și se returnează
argIerire (=valoare 2) (se iese din funcție).
Exemplul 1: Să se calculeze valoarea absolută a determinantului unei matrice.

function [x]=ValAbsDet(X)
%Exemplu cu instructiunea return
%Calculul valorii absolute a determinantului unei matrice
if isempty(X) %isempty returneaza 1 dacă matricea X este goala si 0 in caz contrar
x=1; %prin definitie determinantul unei matrice goale este 1
return
end
x=abs(det(X));
Apel: r=ValAbsDet([8 4 -3; 12.1 6.05 -7; 11 3 9])

Exemplul 2: Să se găsească poziția și primul număr divizibil cu o valoare dată dintr-un șir de numere
întregi strict pozitive.
function [indx,val]=returnDemo(a,x)
%Exemplu cu instructiunea return
%Functia returnDemo gaseste pozitia si valoarea primului numar divizibil
%cu o valoare data dintr-un sir de numere intregi
i=1;
while i<=length(x)
if rem(x(i),a)==0
indx=i;
val=x(i);
return
end
indx=NaN; %indx nu este un numar
val=NaN; %nu exista nicio valoare din sir divizibila cu valoarea data
i=i+1;
end
disp(['nu exista in sir numar divizibil cu ',num2str(a)]);
Apel: [i,v]=returnDemo(3,[2 4 5 5 6 7 6 7 10 9])
Instrucțiunile try, catch

Prin utilizarea unei secvențe de instrucțiuni try/catch, se evită oprirea rulării unui program datorită
unei erori apărute.
Forma generală a unei secvențe try/catch este:
try
corp instructiuni ale lui try
catch
corp instructiuni ale lui catch
end
Se execută corp instructiuni dintre try și catch până la întâlnirea unei erori și apoi se execută
corp instructiuni dintre catch și end. Dacă apare o eroare între catch și end, MATLAB termină
execuția, dacă nu s-a specificat o altă secvență try/catch.
Exemplu: Înmulțirea unor matrice.

A=[1 4 5;5 7 8;3 5 7];
B=[3 6 4;8 3 2;6 8 9];
C=[2 6;8 9];
try
X1=A*B
X2=A*C
X3=B*C
catch
disp('**Eroare la inmultire**')
end
disp('Programul ruleaza mai departe')
Instrucțiunea error
Instrucțiune pentru afișarea unui mesaj de eroare și termină execuția instrucțiunilor ulterioare.
Exemplu:
function [c]=functieTest(a,b,x)
%FUNCTIA CALCULEAZA..................
if nargin~=3
error('Numarul argumentelor de intrare este 3')
end
c=(a+b)^x;
Apel: v=functieTest(2,3,0.15)
3. Funcții specifice argumentelor de intrare/ieșire

Funcția nargin. Pentru testarea numărului argumentelor de intrare care trebuie introduse pentru
apelarea unei funcții, este disponibilă variabila permanentă nargin, care se apelează cu sintaxa:
nargin('numeFunctie')
Se returnează numărul variabilelor de intrare, iar dacă funcția nu are intrări, se returnează un număr
negativ.
Exemplu:
nargin('functieTest')
ans =
3
În interiorul corpului unei funcții definite de utilizator, nargin returnează numărul de argumente de
intrare care au fost folosite pentru a apela funcția.
Funcția nargout. Pentru testarea numărului argumentelor de ieșire care pot fi introduse pentru
apelarea unei funcții, este disponibilă variabila permanentă nargout, care se apelează cu sintaxa:
nargout('numeFunctie')
Se returnează numărul variabilelor de ieșire, iar dacă funcția nu are ieșiri, se returnează un număr
negativ.
Exemplu: să se ceară numărul argumentelor de ieșire al funcției returnDemo
nargout('returnDemo')
ans =
2
În interiorul corpului unei funcții definite de utilizator, nargout returnează numărul de argumente de
ieșire care au fost folosite pentru a apela funcția.
4. Intrări utilizator
Pentru a obține o intrare de la utilizator în timpul execuției unui fișier există următoarele posibilități:
➢ Afișarea unui prompter prin intermediul unei funcții tip input și introducerea unor date de la
tastatură
➢ Oprirea execuției cu o comandă pause (reluarea execuției la apăsarea unei taste)
➢ Construirea unei interfețe grafice GUI completă
Funcția input. Asigură afișarea unui prompter și așteaptă un răspuns de la utilizator.

Sintaxa este:
n=input('numeVariabila=')
Funcția determină afișarea șirului de caractere numeVariabila=, așteaptă o intrare de la tastatură și

returnează valoarea introdusă de la tastatură.
Funcția este utilă pentru implementarea aplicațiilor de tip meniu.
Funcția input poate să returneze intrarea de la utilizator sub formă de șiruri de caractere.
adresa=input('Adresa de domiciliu: ','s')
Comanda pause. Fără argument, oprește execuția până la apăsarea unei taste. Pentru a avea o pauză
de n secunde se folosește comanda:
pause(n)
5. Instrucțiuni pentru evaluare și execuție

Evaluarea datelor de tip caracter (string) asigură putere și flexibilitate limbajului MATLAB.
Funcția eval. Evaluează un șir de caractere care conține o expresie, o declarație sau un apel de
funcție. Sintaxa este următoarea:
[y1,..,yn]=eval('expresie')
Exemplul 1: Evaluarea unei funcții.

a=eval('log(7)') %evalueaza functia log(7) si returneaza rezultatul
a =
1.9459
Exemplul 2: Evaluarea unei expresii

n=10;
for i=1:n
for j=1:n
B(i,j)=eval('1/(i+j-1)'); %evalueaza expresia 1/(i+j-1)
end
end
disp(B)
Exemplul 3: Utilizarea funcției eval pentru declararea unei variabile.

eval('a=sin(pi/4)') %echivalenta cu a=sin(pi/4)
Se pot concatena (concatenare = lipire) șirurile de caractere pentru a crea expresii de intrare necesare
funcției eval.
Exemplul 4: Se creează 10 variabile de forma Pi (P1, P2, ..., P10) și se setează fiecare variabilă
la valoarea i*10, utilizând funcția eval
for i=1:10
eval(['P',num2str(i),'=i*10'])
end
Funcția feval. Execută o anumită funcție specificată sub forma unui șir de caractere. Sintaxa are
forma:
[y1,..,yn]=feval('numeFunctie',x1,...,xn)
[y1,..,yn]=feval(@numeFunctie,x1,...,xn)
în care x1,...,xn sunt argumentele de intrare pentru funcția respectivă, iar y1,..,yn sunt
argumentele de ieșire ale funcției.
Exemplul 1:
a=feval('log',7) %evalueaza functia log pt. 7 si returneaza rezultatul
a =
1.9459
Exemplul 2: Evaluarea funcției functieTest

[x]=feval(@functieTest,2,3,0.15)
x =
1.2731
Exemplul 3:
function [y]=calculFunTrig(x)
%Functia calculFunTrig calculeaza valorile principalelor functii
%trigonometrice (sinus, cosinus, tangenta, cotangenta) pentru un unghi
%exprimat in grade
if nargin~=1
error('Numarul argumentelor de intrare este 1')
end
funTrig=['sind';'cosd';'tand';'cotd']; %vectorul coloana al functiilor
y=zeros(length(funTrig),1); %definesc dimensiunea vectorului y
for i=1:1:length(funTrig);
y(i)=feval(funTrig(i,:),x);
end
Este indicată folosirea funcției feval în locul funcției eval, deoarece execuția este mai rapidă!!!
6. Funcții handle
O funcție handle (function handle) este un tip de date din MATLAB care stochează o asociere
cu o funcție. O utilizare tipică a function handle este de a transmite o funcție unei alte funcții. De
exemplu, se poate utiliza o function handle ca argument de intrare pentru o funcție care evaluează
expresii matematice într-un interval de valori (vom vedea în cursurile următoare).
Function handle poate să fie o funcție deja definită (salvată) sau o funcție anonimă.
Function handle se creează folosind operatorul @.
Exemplul 1: function handle pentru o funcție deja definită (salvată), sind

f=@sind;
a=f(30)
a =
0.5000
Exemplul 2: function handle pentru o funcție deja definită (salvată), ValAbsDet

g=@ValAbsDet;
r=g([8 4 -3; 12.1 6.05 -7; 11 3 9])
r =
49.2500
7. Funcția anonimă
Funcția anonimă este o function handle care nu este stocată într-un fișier de program. Este definită
printr-o singură declarație și poate avea orice număr de argumente de intrare și un singur argument
de ieșire. O funcție anonimă poate conține doar o singură instrucțiune executabilă.
Sintaxa:
nume=@(var. formale de intrare) expresia functiei
Exemplu:
func=@(x,y) (x+1)/10+sind(y);
rez=func(5,30)
rez =
1.1000
8. Subfuncții
Fișierele .m de tip funcție pot conține mai mult de o funcție. Prima funcție din fișier se numește
funcție primară, iar celelalte se numesc subfuncții, fiind vizibile numai din funcția primară sau din
alte subfuncții din același fișier. Fiecare funcție are propria sa linie de definiție.
Numele funcției trebuie să fie unic într-un fișier .m !!!
Exemplu: Funcția primară este RezEcGr2 și ea conține și apelează subfuncția discr.

function [sol]=RezEcGr2(a,b,c)
%Functia RezEcGr2 gaseste solutiile pentru o ecuatie de gradul 2
%a*x^2 + bx + c = 0
%Argumentele de intrare sunt valorile numerice ale coeficientilor a, b si c
%Functia RezEcGr2 este functia primara
if nargin~=3
error('Numarul de argumente de intrare este 3')
end
if a==0
error('Coeficientul a trebuie sa fie diferit de 0')
end
%calculez delta cu subfunctia discr
delta=discr(a,b,c);
%calculez x1 si x2
x1=(-b+sqrt(delta))/(2*a);
x2=(-b-sqrt(delta))/(2*a);
%scriu vectorul solutiilor
sol=[x1,x2];
%Subfunctia discr incepe de aici
function [d]=discr(a,b,c)
%Subfunctia discr calculeaza discriminantul delta a ecuatiei
d=b^2-4*a*c;
Apel: s=RezEcGr2(1,12,32)
9. Funcții private
Ele se păstrează într-un subdirector cu numele special private și sunt vizibile numai din directorul
părinte.
De exemplu, presupunem că în calea (path) MATLAB avem un director numit Statistica. Putem
crea un subdirector al acestuia cu numele private, care să conțină funcții vizibile numai în funcțiile
din directorul Statistica.
Astfel de funcții sunt utile pentru a crea versiuni proprii ale unor funcții, păstrând în același timp
versiunile originale într-un alt director.
Subdirectorii de tip private nu trebuie adăugați la calea (path) MATLAB !!!
Bibliografie
CURS 5
GENERAREA VECTORILOR ȘI MATRICELOR
1. Generarea vectorilor cu pas liniar

Sintaxe:
v=initial:final generează un vector linie v cu elementele începând de la initial la
final, cu pasul egal cu 1 (initial<=final)
v=initial:pas:final generează un vector linie v cu elementele începând de la initial la

final, cu pasul egal cu pas (pasul poate fi și negativ, dar atunci valoarea inițială trebuie să fie
mai mare decât valoarea finală)
v=linspace(initial,final,nrElemente) generează un vector linie v cu elementele
începând de la initial la final, având un număr de elemente egal cu nrElemente, cu un
pas constant calculat automat
Exemple:
a=1:15 %sau a=1:1:15
b=1:3:15
c=14:-2:4
d=linspace(17,58,4)
e=linspace(pi,-pi,6)
f=linspace(3,200,30)
2. Generarea vectorilor cu pas logaritmic

Sintaxă:
v=logspace(initial,final,nrElemente) generează un vector linie v având nrElemente
distribuite logaritmic între 10initial și 10final
Observație: dacă final=pi atunci elementele vor fi distribuite logaritmic între 10initial și π.
Exemple:
h=logspace(2,1,5)
k=logspace(0,pi,5)
3. Matricea goală
Sintaxa:
X=[] generează o matrice goală (fără nici un element)
Exemplu:
X=[]
X =
[]
4. Matricea unitate
Sintaxe:
ones(m,n) returnează o matrice de dimensiune m x n cu toate elementele 1
ones(size(M)) returnează o matrice de dimensiunea matricei M cu toate elementele 1
Exemple:
ones(1,5)
ones(5,5)
ones(3,2)
D=[1 5 7; 3 6 8];ones(size(D))
5. Matricea zero
Sintaxe:
zeros(m,n) returnează o matrice de dimensiune m x n cu toate elementele 0
zeros(size(M)) returnează o matrice de dimensiunea matricei M cu toate elementele 0
Exemple:
zeros(1,5)
zeros(5,5)
zeros(3,2)
D=[1 5 7; 3 6 8];zeros(size(D))
6. Matricea identitate
Sintaxe:
eye(m,n) returnează o matrice de dimensiune m x n având elementele diagonalei principale
egale cu 1, iar restul elementelor egale cu 0
eye(size(M)) returnează o matrice de dimensiune egală cu dimensiunea matricei M având
elementele diagonalei principale egale cu 1, iar restul elementelor egale cu 0
Exemple:
eye(1,5)
eye(5,5)
eye(3,2)
D=[1 5 7; 3 6 8];eye(size(D))
7. Matricea cu numere aleatoare cu distribuție uniformă (cu aceeași probabilitate) între 0 și 1

Sintaxe:
rand returnează un număr aleator (scalar) cu distribuție uniformă între 0 și 1
rand(m,n) returnează o matrice de dimensiune m x n având drept elemente numere aleatoare
cu distribuție uniformă între 0 și 1
rand(size(M)) returnează o matrice de dimensiunea matricei M având drept elemente numere
aleatoare cu distribuție uniformă între 0 și 1
Exemple:
rand
rand(1,5)
rand(5,5)
rand(3,2)
D=[1 5 7; 3 6 8];rand(size(D))
r=a+(b-a)*rand(1,100) %genereaza un vector cu 100 de numere aleatoare cu
distributie uniforma in intervalul (a,b)
8. Matricea cu numere aleatoare întregi cu distribuție uniformă

randi(imax) returnează un număr aleator (scalar) cu distribuție uniformă între 1 și imax
randi(imax,m,n) returnează o matrice de dimensiune m x n având drept elemente numere
aleatoare cu distribuție uniformă între 1 și imax
randi(imax,size(M)) returnează o matrice de dimensiunea matricei M având drept elemente
numere aleatoare cu distribuție uniformă între 1 și imax
randi([imin,imax],m,n) returnează o matrice de dimensiune m x n având drept elemente
numere aleatoare cu distribuție uniformă între imin și imax
randi([imin,imax],size(M)) returnează o matrice de dimensiunea matricei M având drept
elemente numere aleatoare cu distribuție uniformă între imin și imax
Exemple:
randi(7)
randi(23,2,5)
randi([0,5],10,1)
randi([0,10],3,2)
D=[1 5 7; 3 6 8];randi([1,10],size(D))
9. Matricea cu numere aleatoare cu distribuție normală (gaussiană)

Sintaxe:
randn returnează un număr aleator (scalar) cu distribuție normală având media egală cu 0 și
abaterea standard egală cu 1
randn(m,n) returnează o matrice de dimensiune m x n având drept elemente numere
aleatoare cu distribuție normală (gaussiană) având media egală cu 0 și abaterea standard egală
cu 1
randn(size(M)) returnează o matrice de dimensiunea matricei M având drept elemente
numere aleatoare cu distribuție normală (gaussiană) având media egală cu 0 și abaterea
standard egală cu 1
Exemple:
rand
randn(1,5)
randn(5,5)
randn(3,2)
D=[1 5 7; 3 6 8];randn(size(D))
r=1+2*randn(1,200) %genereaza 200 de numere aleatoare cu distributie normala
cu media 1 si abaterea standard 2)
MANIPULAREA VECTORILOR ȘI MATRICELOR
MATLAB-ul oferă următoarele funcții pentru manipularea matricelor:
: Specifică indicii, rearanjează sau decupează o matrice

diag Creează sau extrage diagonalele matricei
fliplr Rotește matricea în jurul axei verticale (inversează ordinea coloanelor)
flipud Rotește matricea în jurul axei orizontale (inversează ordinea liniilor)
reshape Schimbă dimensiunile matricei (redimensionează matricea)
rot90 Rotește matricea cu un multiplu de 90 de grade
tril Extrage matricea inferior triunghiulară dintr-o matrice
triu Extrage matricea superior triunghiulară dintr-o matrice
1. Manipularea matricelor prin indici

Elementele individuale ale unui vector se apelează cu numele acestuia, urmat de un indice.
Elementele individuale ale unei matrice se apelează cu numele acesteia, urmat de doi indici, cuprinși
între paranteze rotunde și separați de virgulă. Primul indice semnifică linia, iar al doilea coloana în care
se găsește elementul apelat.
Exemplul 1: înlocuirea elementului din linia 3 și coloana 3, A(3,3), al matricei A, cu suma dintre
elementul din linia 1 - coloana 3, A(1,3), și elementul din linia 3 - coloana 1, A(3,1)
A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
A(3,3)=A(1,3)+A(3,1)
A =
2 4 7 3
5 1 0 4
7 4 14 9
Crearea vectorilor și matricelor mari, precum și manipularea acestora se face cu multă flexibilitate dacă
se utilizează indici de tip vector.
Pentru extragerea vectorilor cu elemente decupate din alți vectori, se folosesc formele:
a(j:k) selectează elementele [j,j+1,...,k] ale vectorului; dacă j>k, vectorul rezultat
este gol
a(j:i:k) selectează elementele [j,j+i,j+2i,...,k] ale vectorului; vectorul rezultat este
gol dacă i>0 și j>k sau dacă i<0 și j<k
Exemplul 2: extragerea elementelor 3:7 din vectorul a

a=[2 6 4 8 3 7 1 0 6];
b=a(3:7)
b =
4 8 3 7 1
Exemplul 3: extragerea elementelor 2,4,6,8 din vectorul a

a=[2 6 4 8 3 7 1 0 6];
c=a(2:2:8)
c =
6 8 7 0
Pentru extragerea matricelor cu elemente decupate din alte matrice, se folosesc formele:
A(:,j) selectează coloana j a matricei A
A(i,:) selectează linia i a matricei A
A(:,:) selectează întreaga matrice A
A(:,j:k) selectează toate liniile și coloanele de la j la k (A(:,j),A(:,j+1),...,A(:,k))
A(j:k,:) selectează liniile de la j la k și toate coloanele (A(j,:),A(j+1,:),...,A(k,:))
A(:) selectează toate elementele matricei A, privite ca o singură coloană, începând cu
prima
Dacă indicii x și y sunt vectori cu elemente numere întregi, instrucțiunea N=M(x,y) creează o
matrice N, care conține elementele din liniile x ale coloanelor y ale matricei M.
Exemplul 4: extragerea matricei B de dimensiunea 3 x 3, constând din elementele liniilor 1:3 ale
coloanelor 2:4 ale matricei A
A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
B=A(1:3,2:4)
B =
4 7 3
1 0 4
4 8 9
Exemplul 5: extragerea din matricea A a matricei C de dimensiune 3 x 1 care să conțină toate liniile
din coloana a 3-a
A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
C=A(:,3)
C =
7
0
8
Exemplul 6: extragerea matricei D de dimensiune 2 x 4 care conține liniile 1:2 ale coloanelor
matricei A
A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
D=A(1:2,:)
D =
2 4 7 3
5 1 0 4
Exemplul 7: înlocuirea coloanele 1,3 și 4 ale matricei A, cu coloanele 1:3 ale matricei E
A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
E=[4 7 2 6;7 3 5 6;9 4 7 3]
E =
4 7 2 6
7 3 5 6
9 4 7 3
A(:,[1,3,4])=E(:,1:3)
A =
4 4 7 2
7 1 3 5
9 4 4 7
Exemplul 8: transformarea unei matrice A într-un vector coloană d

A=[1 2;3 4];
d=A(:)
d =
1
3
2
4
Exemplul 9: generarea un vector prin întrețeserea elementelor a doi vectori

A=[1 3 5 7 9];
B=[2 4 6 8];
n=length(A)+length(B);
C(1:2:n)=A;
C(2:2:n)=B;
C
C =
1 2 3 4 5 6 7 8 9
Exemplul 10: inversarea coloanelor unei matrice A se face cu sintaxa A(:,n:-1:1), unde n
reprezintă numărul de coloane
A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
F=A(:,size(A,2):-1:1)
F =
3 7 4 2
4 0 1 5
9 8 4 7
Exemplul 11: inversarea liniilor unei matrice A se face cu sintaxa A(m:-1:1,:), unde m reprezintă
numărul de linii
G=A(size(A,1):-1:1,:)
G =
7 4 8 9
5 1 0 4
2 4 7 3
2. Extragerea matricelor prin vectori cu elemente 0-1

Vectorii cu elemente 0 și 1, generați de operatorii logici sau relaționali, au proprietăți deosebite,
care pot conduce la scrierea unor programe foarte compacte.
Dacă A este o matrice m × n și v un vector coloană cu elemente logice (0 și 1) de lungime m,
instrucțiunea
B=A(v,:)
returnează în matricea B toate elementele din liniile matricei A pentru care elementul corespunzător
ca poziție din vectorul v are valoarea 1. Prin acest procedeu se poate extrage o matrice prin
intermediul unui vector returnat de funcții logice.
Pentru coloane, pentru un vector linie u cu elemente logice de lungime n, expresia este:
C=A(:,u)
Exemplu: Să se extragă din matricea A toate liniile care au elementul din coloana a 3-a mai mare sau
egal cu 4, respectiv coloanele a căror linie 3 au elementele mai mari decât 5.
A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
v=A(:,3)>=4
v =
1
0
1
H=A(v,:)
H =
2 4 7 3
7 4 8 9
u=A(3,:)>5
u =
1 0 1 1
G=A(:,u)
G =
2 7 3
5 0 4
7 8 9
3. Redimensionarea unei matrice

Funcția reshape redimensionează o matrice X cu dimensiunea p × r într-o altă matrice Y, cu
dimensiunea m × n = p × r.
Se apelează cu sintaxa:
Y=reshape(X,m,n)
Elementele matricei Y vor fi în ordinea succesivă a coloanelor și pe fiecare coloană de sus în jos a
elementele matricei argument X (citite de sus în jos și de la stânga la dreapta).
Exemplu: redimensionarea matricei A cu dimensiunea 3 × 4 într-o matrice cu dimensiunea
2 × 6.
A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
I=reshape(A,2,6)
I =
2 7 1 7 8 4
5 4 4 0 3 9
4. Rotirea matricei în jurul unei coloane sau linii

Funcțiile fliplr și flipud inversează ordinea coloanelor sau liniilor matricelor.
Se apelează cu sintaxele:
Y=fliplr(X) returnează matricea rezultată prin pivotarea matricei argument în jurul ultimei
coloane, operație prin care aceasta devine prima coloană
Z=flipud(X) returnează matricea rezultată prin pivotarea matricei argument în jurul ultimei
linii, operație prin care aceasta devine prima linie
Exemplu: rotirea matricei A:

A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
 în jurul ultimei coloane

J=fliplr(A)
J =
3 7 4 2
4 0 1 5
9 8 4 7
 în jurul ultimei linii

K=flipud(A)
K =
7 4 8 9
5 1 0 4
2 4 7 3
5. Rotirea matricei cu multiplu de 90 de grade

Rotirea unei matrice cu multipli de 90 de grade în sens trigonometric se face cu funcția rot90.
Y=rot90(X,k) argumentul k reprezintă multiplul de 90 de grade cu care se face rotația:
pozitiv pentru sens trigonometric și negativ pentru cel orar.
Exemplu: rotirea matricei A:

A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
 în sens trigonometric cu 90 de grade

M=rot90(A,1)
M =
3 4 9
7 0 8
4 1 4
2 5 7
 în sens orar cu 180 de grade

N=rot90(A,-2)
N =
9 8 4 7
4 0 1 5
3 7 4 2
6. Matricea diagonală și triunghiulară

Matricea diagonală. Sintaxe:
➢ dacă v este un vector (linie sau coloană) atunci:
diag(v) returnează o matrice pătrată diagonală, cu elementele vectorului v pe diagonala
principală
diag(v,k) returnează o matrice pătrată cu elementele vectorului v pe diagonala k deasupra
celei principale dacă k>0, sau sub cea principală dacă k<0; restul elementelor sunt 0
➢ dacă M este o matrice atunci:
diag(M) returnează un vector coloană care conține elementele de pe diagonala principală a
matricei M
diag(M,k) returnează un vector coloană care conține elementele din matricea M de pe
diagonala k deasupra celei principale dacă k>0, sau sub cea principală dacă k<0
Exemple:
a=randn(1,5)
A=randn(5)
diag(a)
diag(a,1)
diag(a,-1)
diag(a,2)
diag(a,-2)
diag(A)
diag(A,2)
diag(A,-2)
diag(diag(A))
Matricea inferior triunghiulară. Sintaxe:

tril(M) extrage matricea inferior triunghiulară din matricea M (anulează toate elementele
matricei M de deasupra diagonalei principale)
tril(M,k) înlocuiește cu 0 toate elementele de deasupra diagonalei k din matricea M
(raportarea se face la diagonala principală – vezi sintaxa de la diag)
Pentru matricea A definită anterior verificați următoarele exemple:

A=randn(5)
tril(A)
tril(A,1)
tril(A,-1)
Matricea superior triunghiulară. Sintaxe:

triu(M) extrage matricea superior triunghiulară din matricea M (anulează toate elementele
matricei M de sub diagonala principală)
triu(M,k) înlocuiește cu 0 toate elementele de sub diagonala k din matricea M (raportarea
se face la diagonala principală – vezi sintaxa de la diag)
Exemple:
A=randn(5)
triu(A)
triu(A,1)
triu(A,-1)
TABLOURI MULTIDIMENSIONALE
MATLAB-ul permite utilizarea tablourilor cu mai mult de 2 indici. Ele pot fi create și apelând funcțiile
specifice matricelor (zeros, ones, rand, randn etc.) cu mai mult de două argumente de intrare.
Exemplul 1: Crearea unui tablou cu dimensiunea 3 × 4 × 5 (60 de elemente), având toate elementele
egale cu 1.
U=ones(3,4,5)
U(:,:,1) =
1 1 1 1
1 1 1 1
1 1 1 1
U(:,:,2) =
1 1 1 1
1 1 1 1
1 1 1 1
U(:,:,3) =
1 1 1 1
1 1 1 1
1 1 1 1
U(:,:,4) =
1 1 1 1
1 1 1 1
1 1 1 1
U(:,:,5) =
1 1 1 1
1 1 1 1
1 1 1 1
Exemplul 2: În figura 1 se dă reprezentarea grafică a tabloului B de dimensiune 3 × 3 × 6.
Fig.1 Tablou tridimensional
B(:,:,1)=[3 2 1;6 5 4;9 8 7]

B(:,:,2)=[3 1 2;6 4 5;9 7 8]
B(:,:,3)=[2 3 1;5 6 4;8 9 7]
B(:,:,4)=[2 1 3;5 4 6;8 7 9]
B(:,:,5)=[1 2 3;4 5 6;7 8 9]
B(:,:,6)=[1 3 2;4 6 5;7 9 8]
B(:,:,1) =
3 2 1
6 5 4
9 8 7
B(:,:,2) =
3 1 2
6 4 5
9 7 8
B(:,:,3) =
2 3 1
5 6 4
8 9 7
B(:,:,4) =
2 1 3
5 4 6
8 7 9
B(:,:,5) =
1 2 3
4 5 6
7 8 9
B(:,:,6) =
1 3 2
4 6 5
7 9 8
Dimensiunea tabloului B returnată de MATLAB este:

size(B)
ans =
3 3 6
Referirea unui element individual al tabloului B se face prin 3 indici reprezentând dimensiunile 1, 2
și 3:
B(2,3,3) %linia 2, coloana 3, matricea 3
ans =
4
Linia a 2-a a matricei 3:

B(2,:,3)
ans =
5 6 4
A 5-a matrice:
B(:,:,5)
ans =
1 2 3
4 5 6
7 8 9
TABLOURI DE CELULE
Un tablou de celule în MATLAB este un tablou multidimensional ale cărui elemente sunt copii ale
altor tablouri. Crearea unui tablou de celule și indexarea elementelor se realizează folosind acolade
{} în loc de paranteze [], respectiv ().
Un tablou de celule poate conține elemente de diverse tipuri (scalari, vectori, matrice, șiruri de
caractere (string-uri)).
Exemplu: Tablou de celule unidimensional 1 × 3:
A=ones(4); %matrice 4 × 4
C={A,A(:,2),A(2,3)} %A(:,2) este un vector coloana, A(2,3) este un scalar
C =
[4x4 double] [4x1 double] [1]
produce un tablou de celule 1 × 3. Cele trei celule conțin o matrice, un vector coloană și un scalar.
Afișarea de tipul [4x4 double] [4x1 double] [1] se datorează lipsei de spațiu; ori de câte
ori apare această situație MATLAB dă un sumar al structurilor și componentelor.
Trebuie reținute două aspecte importante:
1. utilizarea acoladelor în cazul indexurilor:
C{1} %se cere elementul 1 al structurii, adica matricea A
ans =
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
desemnează matricea unitate 4 x 4,

C{2} %se cere elementul 2 al structurii, adica vectorul coloană A(:,2)
ans =
1
1
1
1
reprezintă coloana a 2-a a matricei unitate,

C{3} %se cere elementul 3 al structurii, adica scalarul A(2,3)
ans =
1
este elementul A(2,3) al matricei unitate
2. Celulele conțin copii ale tablourilor, nu pointeri pe tablouri. Astfel, dacă se modifică matricea A,
tabloul C nu se modifică.
Pot fi create și tablouri de celule multidimensionale (având linii și coloane).
Exemplu:
D={'psi',9,eye(2);'miu',2-3i,pi}
D =
'psi' [ 9] [2x2 double]
'miu' [2.0000 - 3.0000i] [ 3.1416]
creează un tablou de celule 2 × 3.

A treia celulă din prima linie se obține astfel:
D{1,3}
ans =
1 0
0 1
ȘIRURI DE CARACTERE
Șirurile de caractere se introduc în MATLAB încadrate între apostrofuri.
Exemplu:
a='Centrul Universitar Nord din Baia Mare'
a =
Centrul Universitar Nord din Baia Mare
Rezultatul este un tablou 1 × 38 (atenție, nu este un tablou de celule!!!)

size(a) %nefiind tablou de celule se folosesc paranteze (), nu acolade {}
ans =
1 38
Intern, caracterele sunt memorate ca numere.

Funcția double convertește șirul de caractere într-un vector numeric care conține reprezentările
flotante ale codurilor ASCII ale fiecărui caracter:
b=double(a)
b =
67 101 110 116 114 117 108 32 85 110 105 118 101
114 115 105 116 97 114 32 78 111 114 100 32 100
105 110 32 66 97 105 97 32 77 97 114 101
Funcția char realizează conversia inversă (din cod ASCII în caracter):

c=char(b)
c =
Centrul Universitar Nord din Baia Mare
Caracterele ASCII imprimabile au codurile 32:127. Valorile mai mici decât 32 sunt coduri de caractere
de control neimprimabile.
Concatenarea șirurilor de caractere se realizează prin încadrarea lor între paranteze pătrate [].
Instrucțiunea următoare concatenează șirurile pe orizontală (se folosesc parantezele []):
d=['Forta∙','de∙','reactiune'] %sau d=['Forta∙' 'de∙' 'reactiune']
d =
Forta de reactiune
Rezultatul este un tablou 1 × 18.

Pentru a putea trata un text format din linii cu lungimi diferite, există trei posibilități:
1. Completarea cu blancuri: instrucțiunea următoare concatenează șirurile pe verticală:
e=['Forta∙∙∙∙';'de∙∙∙∙∙∙∙';'reactiune']
e =
Forta∙∙∙∙
de∙∙∙∙∙∙∙
reactiune
Rezultatul este un tablou 3 × 9. Dezavantajul este reprezentat de faptul că trebuie introduse

spații în primul și al doilea șir, pentru ca acestea să aibă aceeași lungime cu cel de-al treilea. Nu
folosiți această posibilitate.
2. Funcția char acceptă la intrare orice număr de linii, adaugă spații dacă este nevoie pentru a face
liniile de aceeași lungime și formează un tablou de caractere având fiecare linie pe un rând:
f=char('Forta','este','egala','cu','masa','inmultita','cu','acceleratia.')
f =
Forta∙∙∙∙∙∙∙
este∙∙∙∙∙∙∙∙
egala∙∙∙∙∙∙∙
cu∙∙∙∙∙∙∙∙∙∙
masa∙∙∙∙∙∙∙∙
inmultita∙∙∙
cu∙∙∙∙∙∙∙∙∙∙
acceleratia.
Rezultatul este un tablou de 8 × 12.

3. Textul mai poate fi memorat într-un tablou de celule 8 × 1 folosind acoladele {}:
g={'Forta';'este';'egala';'cu';'masa';'inmultita';'cu';'accelaratia.'}
g =
'Forta'
'este'
'egala'
'cu'
'masa'
'inmultita'
'cu'
'accelaratia.'
STRUCTURI
1. Crearea structurilor
Structurile sunt tablouri de celule multidimensionale (eterogene), ale căror elemente pot fi
desemnate prin nume de câmpuri.
Exemplu: structură care conține informații despre produsele dintr-o magazie: denumire, furnizor, preț
și numărul de bucăți
MAG(1).denumire='surub cap hexagonal M8';

MAG(1).furnizor='S.C. SERV S.R.L.';
MAG(1).pret=0.2;
MAG(1).bucati=214;
creează o structură numită MAG, cu patru câmpuri: denumire, furnizor, pret, bucati.
MAG
MAG =
struct with fields:
denumire: 'surub cap hexagonal M8'
furnizor: 'S.C. SERV S.R.L.'
pret: 0.2000
bucati: 214
Structurile sunt tablouri care permit inserarea unor elemente adiționale prin două metode:
a) Câmpurile pot fi adăugate unul câte unul:
MAG(2).denumire='surub cap hexagonal M10';
MAG(2).furnizor='S.C. SERV S.R.L.';
MAG(2).pret=0.22;
MAG(2).bucati=143;
b) Cu ajutorul funcției struct:

MAG(3)=struct('denumire','piulita autoblocanta M8','furnizor',...
'S.C. MAGNA IMPEX S.R.L.','pret',0.1,'bucati',203);
Deoarece structura a devenit destul de mare, la apelare se va afișa numai un sumar al ei:
MAG
MAG =
1x3 struct array with fields:
denumire
furnizor
pret
bucati
2. Interogarea structurilor
Există mai multe moduri de a interoga structurile:
a) Dacă se tastează:
MAG.pret
ans =
0.2000
ans =
0.2200
ans =
0.1000
este ca și cum s-ar tasta pe rând:

MAG(1).pret
ans =
0.2000
MAG(2).pret
ans =
0.2200
MAG(3).pret
ans =
0.1000
Forma aceasta nu este foarte utilă, deoarece ia separat fiecare pret, îl atribuie variabilei
implicite ans și afișează rezultatul fiecărei atribuiri.
b) Dacă se încadrează între paranteze pătrate (devine un vector linie):
[MAG.pret]
ans =
0.2000 0.2200 0.1000
efectul este ca și cum s-ar tasta:

[MAG(1).pret, MAG(2).pret, MAG(3).pret]
ans =
0.2000 0.2200 0.1000
care are ca rezultat vectorul linie numeric al prețurilor.

Pentru a obține lista furnizor se va tasta (se folosesc acolade {}):
{MAG.furnizor}
ans =
'S.C. SERV S.R.L.' 'S.C. SERV S.R.L.' 'S.C. MAGNA IMPEX S.R.L.'
rezultatul fiind în acest caz un tablou de celule.

c) Utilizând funcția char se creează un tablou de caractere:

char(MAG.furnizor)
ans =
S.C. SERV S.R.L.
S.C. SERV S.R.L.
S.C. MAGNA IMPEX S.R.L.
d) Utilizarea funcției de concatenare cat care este utilă pentru crearea și gestionarea tablourilor și
structurilor de date avansate:
C=cat(dim,A1,A2,A3,A4,...)
concatenează tablourile de intrare A1,A2,A3,... după dimensiunea dim.
Exemplu: concatenarea a două matrice:

A=[1,2;3,4];
B=[5,6;7,8];
cat(1,A,B) %concatenare dupa dimensiunea 1 (linie)
ans =
1 2
3 4
5 6
7 8
este echivalent cu: [A;B]

cat(2,A,B) %concatenare dupa dimensiunea 2 (coloana)
ans =
1 2 5 6
3 4 7 8
este echivalent cu: [A,B]
cat(3,A,B) %concatenare dupa dimensiunea 3

ans(:,:,1) =
1 2
3 4
ans(:,:,2) =
5 6
7 8
produce un tablou tridimensional 2 × 2 × 2.

Sintaxele cu liste separate prin virgulă de forma:

cat(dim,C.field)
se pot utiliza pentru a concatena un tablou de celule sau de structuri care conține câmpuri numerice
într-o singură matrice.
Exemplu:
cat(3,MAG.pret) %produce un tablou tridimensional 1 × 1 × 3
ans(:,:,1) =
0.2000
ans(:,:,2) =
0.2200
ans(:,:,3) =
0.1000
cat(2,MAG.pret) %produce un vector linie 1 × 3

ans =
0.2000 0.2200 0.1000
cat(1,MAG.pret) %produce un vector coloana 3 × 1

ans =
0.2000
0.2200
0.1000
Bibliografie
5. Guide, The Mathworks Inc., SUA
CURS 6
GRAFICĂ ÎN MATLAB. REPREZENTĂRI GRAFICE 2D
Principalele funcții MATLAB pentru reprezentări grafice 2D:
plot Reprezintă grafice în coordonate X-Y liniare

loglog Reprezintă grafice în coordonate X-Y logaritmice
semilogx Reprezintă grafice în coordonate X-Y semilogaritmice (axa X este
logaritmică)
semilogy Reprezintă grafice în coordonate X-Y semilogaritmice (axa Y este
logaritmică)
Reprezintă două grafice în aceeași fereastră figură: unul cu axa Y
plotyy
afișată în stânga, iar celalalt cu axa Y afișată în dreapta
bar Reprezintă grafice cu bare
area Reprezintă grafice de tip arie
pie Reprezentări grafice de tip “plăcintă”
fplot Realizează controlul reprezentărilor grafice cu parametri impuși
comet Reprezintă dinamic (în mișcare) traiectoria unui punct
1. Reprezentarea grafică în coordonate liniare

Pentru reprezentarea datelor în coordonate liniare se utilizează funcția plot.
Sintaxe:
plot(Y) reprezintă grafic argumentul Y funcție de indici, cu următoarele precizări:
a) dacă Y este vector, se trasează graficul Y=Y(i), unde i=1, 2,..., n este numărul de
ordine al elementului Y, culoarea liniei fiind albastră
b) dacă Y este o matrice m x n, se trasează graficele Yj=Yj(i), unde i=1, 2...., n
este numărul de ordine al elementului de pe coloana j, culorile liniilor fiind alese de
program
plot(X,Y) reprezintă grafic argumentul Y funcție de X cu următoarele precizări:
a) dacă X este vector, iar Y este o matrice, atunci coloanele lui Y sunt trasate funcție de
vectorul X; curba graficului este de tip continuu, culorile liniilor fiind alese de program
b) dacă X și Y sunt matrice de aceeași dimensiune, se reprezintă coloanele lui Y funcție de
coloanele lui X; curba graficului este de tip continuu, culorile liniilor fiind alese de
program
plot(X1,Y1,...,Xn,Yn) reprezintă simultan mai multe grafice Y funcție de X în același sistem
de coordonate, observațiile de la plot(X,Y) rămân valabile
plot(X,Y,'Tip linie,marker,culoare') graficele se pot reprezenta utilizând linii, markere

și culori după codul din tabelul 1; pentru reprezentările grafice, se asociază fiecărei
caracteristici un șir de 1, 2 sau 3 caractere, dintre cele menționate în tabelul 1; aceste șiruri de
caractere trebuie cuprinse între apostrofuri și menționate în combinația tip linie-tip marker-
culoare, tip linie-culoare, sau tip marker-culoare; dacă se precizează o singură caracteristică
(marker, linie sau culoare), celelalte sunt alese de program
Tabelul 1
Tipul liniei Tipul markerului Culoare
continuă - plus + roșu r
întreruptă -- cerc o verde g
puncte : steluță * albastru b
linie-punct -. punct . albastru deschis c
cruce x mov m
pătrat 'square' sau s galben y
hexagon 'diamond' sau d negru k
triunghi cu vârful în sus ^ alb w
triunghi cu vârful în jos v
triunghi cu vârful în dreapta >
triunghi cu vârful în stânga <
stea în 5 colțuri 'pentagram' sau p
stea în 6 colțuri 'hexagram' sau h
De asemenea, pot fi setate următoarele caracteristici:

a) grosimea liniilor graficelor: 'LineWidth',valoare
b) culoarea laturilor markerelor: 'MarkerEdgeColor','culoare'
c) culoarea fețelor markerelor: 'MarkerFaceColor','culoare'
d) dimensiunea markerelor: 'MarkerSize',valoare
Exemplu: Să se traseze pe același grafic variația funcțiilor sin și cos pentru valori cuprinse între 0 și
2π pentru exact 20 de valori discrete.
x=linspace(0,2*pi,20);
y1=sin(x);y2=cos(x);
plot(x,y1,'-ob',x,y2,'--sm','LineWidth',1,'MarkerEdgeColor','k',...
'MarkerFaceColor','y','MarkerSize',5)
2. Reprezentarea grafică în coordonate logaritmice și semilogaritmice

Pentru reprezentările grafice în coordonate logaritmice sau semilogaritmice se utilizează funcțiile
loglog, semilogx, semilogy.
Sintaxe:
loglog(X,Y)
semilogx(X,Y)
semilogy(X,Y)
Funcția loglog scalează ambele axe utilizând logaritmul în baza 10, în timp ce funcțiile semilogx
și semilogy scalează logaritmic numai axa x, respectiv axa y, cealaltă axă fiind scalată liniar.
Modul de utilizare al acestor funcții este identic cu cel al funcției plot.
Exemplu: Să se reprezinte în coordonate semilogaritmice funcția y = 10x , pentru x Î[0,10]

x=0:10;
y=10.^x;
semilogy(x,y,'-or','LineWidth',1,'MarkerEdgeColor','k',...
'MarkerFaceColor','y','MarkerSize',5);
3. Reprezentarea grafică în coordonate liniare cu axa Y pe stânga și dreapta

Atunci când domeniile datelor care se doresc a fi reprezentate pe axa y sunt mult diferite, sau când
se dorește reprezentarea grafică în același sistem de axe a unor funcții cu axele y scalate diferit, este
utilă funcția plotyy. Aceasta reprezintă două perechi de grafice ale căror gradații pe axele y sunt
în stânga, respectiv dreapta graficelor.
plotyy(X1,Y1,X2,Y2) trasează grafic funcția Y1=f(X1) cu axa y plasată la marginea stânga
a zonei delimitate de sistemul de axe și funcția Y2=f(X2) cu axa y plasată în dreapta;
reprezentările grafice sunt în coordonate liniare (cu funcția plot)
plotyy(X1,Y1,X2,Y2,'tipGrafic') permite, față de sintaxa precedentă, specificarea
modului de scalare a axelor, deci a funcției folosite la reprezentări, prin argumentul
tipGrafic: plot, loglog, semilogx, semilogy
plotyy(X1,Y1,X2,Y2,'tipGrafic1','tipGrafic2') utilizează tipGrafic1(X1,Y1)

pentru reprezentarea grafică în sistemul de axe cu axa y în stânga și tipGrafic2(X2,Y2)
pentru reprezentarea grafică în sistemul de axe cu axa y în dreapta
Exemplu: Să se reprezinte funcțiile f1 ( x ) = 200 × e-0.05×x × sin( x ) și f2 ( x ) = 0,5 × e-0.05×x × sin(10 × x ) , pentru
x Î[0,30] cu funcția plotyy.
x=0:0.01:30;
y1=200*exp(-0.05*x).*sin(x);
y2=0.5*exp(-0.5*x).*sin(10*x);
plotyy(x,y1,x,y2,'plot');
4. Reprezentarea graficelor cu bare

Reprezentarea grafică cu bare se face cu funcția bar.
Sintaxe:
bar(Y) dacă Y este vector se trasează un grafic de bare egale ca înălțime cu elementele sale;
dacă Y este matrice barele sunt grupate pe linii!!!; axa X este generată automat, în funcție
de length(Y) când Y este un vector și size(Y,1) când Y este o matrice
bar(x,Y) trasează un grafic de bare cu elementele vectorului sau matricei Y la locațiile
specificate de vectorul x; dacă Y este vector, lungimea vectorului x trebuie să fie egală cu
length(Y), respectiv size(Y,1) când Y este matrice; elementele vectorului x nu trebuie
să fie monotone, dar nu pot fi duplicate
bar(...,latime) stabilește lățimea relativă a barei și controlează separarea barelor în cadrul
unui grup; lățimea implicită este de 0.8, caz în care barele din cadrul unui grup au o ușoară
separare; dacă lățimea este setată la 1, barele dintr-un grup sunt alăturate; valoarea lățimii
trebuie să fie un scalar
bar(...,'stil') specifică stilul barelor:
'grouped' (grupat) grupează m bare = numărul de coloane ale lui Y, în n grupuri =

numărul de rânduri ale lui Y; este stilul implicit
'stacked' (suprapuse) afișează o bară pentru fiecare rând al lui Y; înălțimea barei
reprezintă suma elementelor din rândul respectiv; fiecare bară este multicoloră, cu culori
corespunzătoare elemente distincte și care arată contribuția relativă a fiecărui element
din rând la suma totală
bar(...,'culoare') afișează barele folosind culoarea specificată: 'r', 'g', 'b', 'c',
'm', 'y', 'k', 'w'
Exemplul 1: Să se reprezinte graficul cu bare al datelor conținute în vectorul y=[1 3 7 6 5 2 3]

specificate de vectorul x=[2 4 6 8 10 12 14].
y=[1 3 7 6 5 2 3];
x=[2 4 6 8 10 12 14];
bar(x,y,'r');
Exemplul 2: Să se reprezinte graficul cu bare al datelor conținute în matricea Y=[1 3 7 6 5 2 3;4

6 2 7 4 5 8]
Y=[1 3 7 6 5 2 3;4 6 2 7 4 5 8];
bar(Y,'stacked');
5. Reprezentarea graficelor de tip arie

Reprezentarea grafică de tip arie se face cu funcția area. Afișează elemente din Y cu una sau mai
multe curbe și umple (colorează) zona de sub fiecare curbă. Atunci când Y este matrice, curbele sunt
suprapuse astfel încât arată contribuția relativă a elementelor fiecărui rând la înălțimea totală a
curbei.
Sintaxe:
area(Y) dacă Y este vector se trasează graficul ca și în cazul funcției plot cu diferența că
zona dintre axa Ox și curbă este colorată; dacă Y este matrice, curbele sunt suprapuse astfel
încât arată contribuția relativă a elementelor fiecărui rând la înălțimea totală a curbei (sumele
pe rânduri), iar axa X este generată automat, în funcție de length(Y) când Y este un vector
și size(Y,1) când Y este o matrice
area(X,Y) dacă X este vector, trebuie să fie monoton, iar lungimea sa trebuie să fie egală cu
lungimea vectorului Y; dacă X este o matrice, fiecare coloană trebuie să fie monotonă, iar
dimensiunea ei trebuie să fie egală cu dimensiunea matricei Y; pentru a face un vector/
matrice monoton/ monotonă, se utilizează funcția sort
Exemplul 1: Să se traseze variația funcției sin pentru valori cuprinse între 0 și 2π pentru exact 200
de valori discrete.
x=linspace(0,2*pi,200);
y=sin(x);
area(x,y);
Exemplul 2: Să se reprezinte graficul de tip arie al datelor conținute în matricea Y=[1 5 3;3 2 7;1
5 3;2 6 1]
Y=[1 5 3;3 2 7;1 5 3;2 6 1];
area(Y);colormap autumn
Numele hărților de culoare de tip built-in sunt următoarele:

6. Reprezentări grafice de tip “plăcintă”

Se face cu funcția pie.
Sintaxe:
pie(X) trasează o diagramă cu structură radială folosind datele din X; fiecare element din X
este reprezentat ca o felie din diagrama de tip plăcintă
pie(X,explode) detașează una sau mai multe felii din plăcintă; explode este un vector/
matrice cu elemente 0 și 1 care corespund vectorului/ matricei X după cum urmează:
valorile 1 corespund feliilor care se doresc detașate, 0 celor care rămân pe loc
pie(...,labels) precizează etichetele text pentru felii; numărul de etichete trebuie să fie
egal cu numărul de elemente din X
Observație: Valorile din X sunt normalizate prin X/sum(X) pentru a determina mărimea fiecărei
felii de plăcintă. În cazul în care sum(X)≤1, valorile din X specifică direct mărimea feliilor de
plăcintă. În cazul în care sum(X)<1 va fi generată doar o parte dintr-o plăcintă.
Exemplu: Notele obținute de o grupă de studenți au fost următoarele: 3 note sub nota 5, 4 note între
5 și 6, 5 între 6 și 7, 5 între 7 și 8, 4 între 8 și 9 și 3 între 9 și 10. Să se reprezinte rezultatele printr-un
grafic de tip plăcintă, cu feliile corespunzătoare notelor sub 5, respectiv notelor cuprinse între 9 și 10
detașate.
x=[3 4 5 5 4 3]; x=[3 4 5 5 4 3];
pie(x,[1 0 0 0 0 1],... pie(x,[1 0 0 0 0 1])
{'<5','5-6','6-7','7-8','8-9','9-10'}) colormap HSV
colormap jet
7. Reprezentări grafice cu parametri impuși

Funcția fplot realizează o reprezentare grafică cu anumite restricții.
Sintaxă:
fplot('functie',limite,n) funcția fplot reprezintă grafic 'functie' între limitele
specificate de argumentul limite; argumentele funcției fplot au următoarele semnificații:
'functie' - numele fișierului funcție (șir de caractere)
limite=[xmin xmax] - limitele axei x pentru care se dorește reprezentarea grafică
n - numărul de eșantioane cu care este reprezentată funcția (implicit n=25)
Exemplu: Fie fișierul funcție înregistrat cu numele test.m :

function y=test(x)
y=sin(x)./x;
Să se reprezinte grafic funcția din fișierul test.m, între limitele [-20,20], cu n=50 eșantioane.
fplot('test',[-20 20],50);grid
8. Reprezentări grafice dinamice

Se folosește funcția comet.
Sintaxe:
comet(y) realizează reprezentarea grafică a vectorului y prin intermediul unei "comete"
formată din "cap" (marker de tip cerc) și o "coadă" cu lungimea de 0,1 din cea a vectorului y
comet(x,y) realizează reprezentarea grafică a vectorului y funcție de valorile vectorului x
prin intermediul unei "comete" formată din "cap" (marker de tip cerc) și o "coadă" cu lungimea
de 0,1 din cea a vectorului y
comet(x,y,p) p setează lungimea cozii din cea a vectorului y
Exemplu: Să se reprezinte dinamic funcția test pe intervalul [-20,20] cu "coada" de 0,2

x=linspace(-20,20,10000);
y=test(x);
comet(x,y,0.2);
GRAFICĂ ÎN MATLAB. REPREZENTĂRI GRAFICE 3D
Principalele funcții MATLAB pentru reprezentări grafice 3D elementare sunt:
plot3 Reprezintă grafice 3D în coordonate X, Y, Z liniare

bar3/bar3h Reprezintă grafice 3D cu bare verticale/orizontale
pie3 Reprezentări grafice 3D de tip “plăcintă”
comet3 Reprezintă dinamic (în mișcare) traiectoria unui punct
1. Reprezentarea grafică în coordonate 3D liniare

Pentru reprezentarea datelor în coordonate 3D liniare se utilizează funcția plot3.
Sintaxe:
plot3(X,Y,Z) unde X,Y,Z sunt vectori sau matrice și realizează o curbă în spațiul
tridimensional după cum urmează:
a) dacă X,Y,Z sunt vectori de aceeași dimensiune, reprezintă grafic o linie în spațiul 3D,
linie care trece prin punctele ale căror coordonate sunt tripletele [X(i),Y(i),Z(i)]
b) dacă X,Y,Z sunt matrice de aceeași dimensiune, reprezintă grafic câte o linie în
spațiul 3D, pentru fiecare triplet al coloanelor matricelor [X(:,i),Y(:,i),Z(:,i)]
plot3(X1,Y1,Z1,X2,Y2,Z2,...) reprezintă simultan mai multe grafice X1,Y1,Z1, ...,
Xn,Yn,Zn
plot3(X1,Y1,Z1,'Tip linie,marker,culoare',...) graficele sunt realizate utilizând linii,

markere și culori specificate
Exemplu: Să se reprezinte grafic o elice tridimensională.

t=linspace(0,10*pi,100);
plot3(sin(t),cos(t),t,'-ob','LineWidth',1,'MarkerEdgeColor','k',...
'MarkerFaceColor','y','MarkerSize',5);grid
2. Reprezentarea graficelor 3D cu bare

Reprezentarea grafică 3D cu bare se face cu funcția bar3, respectiv bar3h.
Sintaxe:
bar3(Y) dacă Y este vector se trasează un grafic de bare egale ca înălțime cu elementele sale;
dacă Y este matrice barele sunt grupate pe linii; axa X este generată automat, în funcție de
length(Y) când Y este vector și size(Y,1) când Y este matrice
bar3(x,Y) trasează un grafic de bare cu elementele vectorului sau matricei Y la locațiile

specificate de vectorul x; dacă Y este vector, lungimea vectorului x trebuie să fie egală cu
length(Y), respectiv size(Y,1) când Y este matrice; elementele vectorului x nu trebuie
să fie monotone, dar nu pot fi duplicate
bar3(...,latime) stabilește lățimea relativă a barei și controlează separarea barelor în
cadrul unui grup; lățimea implicită este de 0,8, caz în care barele din cadrul unui grup au o
ușoară separare; dacă lățimea este setată la 1, barele dintr-un grup sunt alăturate; valoarea
lățimii trebuie să fie un scalar
bar3(...,'stil') specifică stilul barelor:
'grouped' (grupat) grupează n bare=numărul de coloane ale lui Y, în m

grupuri=numărul de rânduri ale lui Y; este stilul implicit
'stacked' (suprapuse) afișează o bară pentru fiecare rând al lui Y; înălțimea barei
reprezintă suma elementelor din rândul respectiv; fiecare bară este multicoloră, cu culori
corespunzătoare elemente distincte și care arată contribuția relativă a fiecărui element
din rând la suma totală
bar3(...,'culoare') afișează barele folosind culoarea specificată: 'r', 'g', 'b', 'c',
'm', 'y', 'k', 'w'
bar3h(...) reprezintă grafice 3D cu bare orizontale fiind valabile sintaxele de la bar3

Exemplu: Să se reprezinte graficul 3D cu bare al datelor conținute în matricea Y=[1 3 7 6 5 2

3;4 6 2 7 4 5 8]
Y=[1 3 7 6 5 2 3;4 6 2 7 4 5 8];
bar3(Y);colormap HSV;
3. Reprezentări grafice 3D de tip “plăcintă”

Se face cu funcția pie3.
Sintaxe:
pie3(X) generează o diagramă 3D cu structură radială folosind datele din X; fiecare element
din X este reprezentat ca o felie din diagrama de tip plăcintă
pie3(X,explode) detașează una sau mai multe felii din plăcintă; explode este un vector/
matrice cu elemente 0 și 1 care corespund vectorului/ matricei X după cum urmează:
valorile 1 corespund feliilor care se doresc detașate, 0 celor care rămân pe loc
pie3(...,labels) precizează etichetele text pentru felii; numărul de etichete trebuie să fie
egal cu numărul de elemente din X
Observație: Valorile din X sunt normalizate prin X/sum(X) pentru a determina mărimea fiecărei felii
de plăcintă. În cazul în care sum(X)≤1, valorile din X specifică direct mărimea feliilor de plăcintă. În
cazul în care suma(X)<1 va fi generată doar o parte dintr-o plăcintă.
Exemplu: Notele obținute de o grupă de studenți au fost următoarele: 3 note sub nota 5, 4 note între
5 și 6, 5 între 6 și 7, 5 între 7 și 8, 4 între 8 și 9 și 3 între 9 și 10. Să se reprezinte rezultatele printr-un
grafic 3D de tip plăcintă, cu feliile corespunzătoare notelor sub 5, respectiv notelor cuprinse între 9 și
10 detașate.
x=[3 4 5 5 4 3]; x=[3 4 5 5 4 3];
pie3(x,[1 0 0 0 0 1],... pie3(x,[1 0 0 0 0 1])
{'<5','5-6','6-7','7-8','8-9','9-10'}) colormap HSV
colormap jet
4. Reprezentări grafice 3D dinamice

Se folosește funcția comet3.
Sintaxe:
comet3(z) realizează reprezentarea grafică 3D a vectorului z prin intermediul unei "comete"
formată din "cap" (marker de tip cerc) și o "coadă" cu lungimea de 0,1 din cea a vectorului z
comet3(x,y,z) realizează reprezentarea grafică 3D a vectorului z funcție de valorile
vectorilor x,y prin intermediul unei "comete" formată din "cap" (marker de tip cerc) și o
"coadă" cu lungimea de 0,1 din cea a vectorului z
comet3(x,y,z,p) p setează lungimea cozii din cea a vectorului z
Exemplu: Să se reprezinte dinamic funcțiile cos(2t)2·sin(t) și sin(2t)2·cos(t)pe intervalul [-10π, 10 π].

t=linspace(-10*pi,10*pi,5000);
comet3((cos(2*t).^2).*sin(t),(sin(2*t).^2).*cos(t),t);
REPREZENTAREA SUPRAFEȚELOR (FUNCȚII DE 2 VARIABILE)
mesh Reprezentări de tip cadru de sârmă cu ochiurile necolorate a suprafețelor

surf Reprezentări de tip cadru de sârmă cu ochiurile colorate a suprafețelor
1. Reprezentări de tip ”cadru de sârmă” colorat

Se face cu funcția mesh.
Sintaxe:
mesh(Z) desenează o suprafață tip cadru de sârmă definită de matricea Z pe baza vectorilor
x=1:n și y=1:m, unde [m,n]=size(Z). Culorile “sârmei” folosite în reprezentare depind de
valorile matricei Z
mesh(X,Y,Z) dacă X,Y sunt vectori, length(X)=n și length(Y)=m, unde [m,n]=size(Z);

în acest caz (X(i),Y(j),Z(i,j)) sunt intersecțiile liniilor grilei cadrului de sârmă, iar X și Y
corespund coloanelor, respectiv liniilor lui Z. Dacă X,Y,Z sunt matrice de aceeași dimensiune
se obține o reprezentare de tip cadru de sârmă a suprafeței parametrice specificate de X,Y,Z;
valorile (X(i,j),Y(i,j),Z(i,j)) sunt intersecțiile liniilor cadrului de sârmă
Exemplu:
[X,Y]=meshgrid(-10:.5:10,-10:.5:10);
R=sqrt(X.^2+Y.^2);
Z=sin(R)./R;
mesh(X,Y,Z)
2. Reprezentări de tip ”cadru de sârmă” cu ochiuri colorate

Se face cu funcția surf.
Sintaxe:
surf(Z)
surf(X,Y,Z)
Funcția surf produce grafice asemănătoare cu cele obținute cu ajutorul funcției mesh, dar cu
deosebirea că ochiurile suprafeței sunt colorate.
Exemplu:
[X,Y]=meshgrid(-10:.5:10,-10:.5:10);
R=sqrt(X.^2+Y.^2);
Z=sin(R)./R;
surf(X,Y,Z)
MANIPULAREA ȘI PERSONALIZAREA GRAFICELOR
Cele mai utilizate funcții utilizate pentru manipularea și personalizarea graficelor sunt:
hold Adăugarea succesivă a reprezentărilor grafice într-un sistem de axe existent

subplot Divizarea ferestrei grafice
figure Crearea obiectelor grafice de tip figură
box Frontierele axelor
axis Scalarea și aspectul axelor
title Precizează titlul graficului
xlabel Precizează eticheta axei X
ylabel Precizează eticheta axei Y
text Plasează un text pe grafic la o poziție impusă
gtext Plasează un text pe grafic la poziția selectabilă cu mouse-ul
grid Trasează o rețea de linii "grid" pe grafic
1. Adăugarea succesivă a reprezentărilor grafice într-un sistem de axe existent (suprapunerea

succesivă)
Utilizând funcția hold se pot adăuga grafice alături de altele, în același sistem de axe.
Sintaxe:
hold determină adăugarea graficelor următoare peste cel curent, fără a-l șterge,
on
producându-se o rescalare a axelor dacă este cazul
hold off determină revenirea la setarea inițială, conform căreia, la apelul unei funcții de
reprezentare grafică, graficul anterior este șters
hold all pe lângă grafic, reține și stilul și culoarea liniei
Exemplu:
x=0:0.01:30;
y1=200*exp(-0.05*x).*sin(x);
y2=100*exp(-0.5*x).*sin(10*x);
plot(x,y1);hold on;
plot(x,y2);
200
150
100
50
-50
-100
-150
-200
0 5 10 15 20 25 30
2. Divizarea ferestrei grafice

MATLAB-ul permite împărțirea ferestrei figură în mai multe ferestre grafice și afișarea în fiecare
fereastră a câte unui sistem de axe. Crearea acestor ferestre și controlul lor este realizat de funcția
subplot.
Sintaxe:
subplot(m,n,s) împarte fereastra figură în m × n zone dreptunghiulare de afișare (analog
unui tabel cu m linii și n coloane) și specifică fereastra (celula tabelului) în care se va face
reprezentare grafică curentă prin numărul (scalarul) s; zonele de afișare sunt numerotate de la
stânga la dreapta, începând cu linia de sus. Dacă fereastra figură a fost împărțită anterior,
apelul funcției face numai specificarea subferestrei curente în care se va crea noul sistem de
axe
subplot(m,n,v) împarte fereastra figură în m × n zone dreptunghiulare de afișare (analog

unui tabel cu m linii și n coloane) și specifică ferestrele (celulele tabelului) în care se va face
reprezentare grafică curentă prin vectorul v
subplot(m,n,v,'replace') ștergerea sistemul de ferestre grafice există deja axe și crearea
unuia nou
h=subplot(...) salvează identificatorul noului sistem de axe în variabila h
subplot(h) permite ca sistemul de axe cu identificatorul h să fie cel curent
În cazul în care apelul unei funcții subplot determină suprapunerea noului sistem de axe peste unul
existent, are loc ștergerea primului.
Exemplul 1: Reprezentarea grafică în cadrane a liniilor matricei Y=[1 5 3 4;3 2 7 6;1 5 3 7;2 6
1 9].
Y=[1 5 3 4;3 2 7 6;1 5 3 7;2 6 1 9];
subplot(2,2,1);plot(Y(1,:));
Exemplul 2: Reprezentarea grafică a primelor 2 linii ale matricei Y=[1 5 3 4;3 2 7 6;1 5 3 7;2 6
1 9] în grafice separate în cadranele 1 și 3, respectiv liniile 3 și 4 în același grafic care să ocupe
cadranul 2 și 4.
Y=[1 5 3 4;3 2 7 6;1 5 3 7;2 6 1 9];
subplot(2,2,[2 4]);plot(Y(3,:));hold on;plot(Y(4,:));
3. Crearea obiectelor grafice de tip figură

Funcția figure creează obiecte grafice de tip figură. Obiectele grafice de tip figură sunt ferestre
individuale de pe ecran în care MATLAB-ul afișează ieșiri grafice.
Exemplu: Reprezentarea în obiecte grafice separate a liniilor matricei Y=[1 5 3 4;3 2 7 6;1 5 3
7;2 6 1 9].
Y=[1 5 3 4;3 2 7 6;1 5 3 7;2 6 1 9];
figure;plot(Y(1,:));
4. Frontierele axelor
Frontierele axelor sunt manipulate cu funcția box.
Sintaxe:
box on sunt reprezentate frontierele axelor
box off nu sunt reprezentate frontierele axelor
Exemplu: Reprezentarea primelor 2 linii ale matricei Y=[1 5 3 4;3 2 7 6;1 5 3 7;2 6 1 9] în
grafice cu, respectiv fără reprezentarea frontierele axelor.
Y=[1 5 3 4;3 2 7 6;1 5 3 7;2 6 1 9];
figure;plot(Y(1,:));box on;
figure;plot(Y(2,:));box off;
5. Scalarea și aspectul axelor

Se realizează cu funcția axis, utilizând următoarele sintaxe:
axis([xmin xmax ymin ymax]) stabilește limitele pentru axele x,y (2D)
axis([xmin xmax ymin ymax zmin zmax]) stabilește limitele pentru axele x,y,z (3D)
v=axis returnează vectorul linie v care conține factorii de scalare pentru axele x,y,z; v
poate avea patru (2D) sau șase componente (3D)
axis auto reprezintă setarea implicită; limitele axelor x,y,z sunt calculate automat pe baza
valorilor minime și maxime ale domeniului datelor
axis tight stabilește limitele axelor x,y,z strict la domeniul datelor
axis ij plasează originea sistemului de coordonate în colțul din stânga sus: i este axa
verticală cu valori care cresc de sus în jos, iar j este axa orizontală, cu valori care
cresc de la stânga la dreapta
axis xy formatul axelor este cel cartezian (implicit)
axis equal stabilește raportul de aspect, astfel ca unitățile să fie aceleași în fiecare direcție.
Raportul de aspect ale axelor x,y,z este ajustat automat în raport de domeniul
datelor
axis square realizează un grafic de formă pătrată (2D) sau cubică (3D); această opțiune ajustează
axele x,y,z astfel încât acestea au lungimi egale și ajustează unitățile de date în
mod corespunzător
axis normal reglează automat raportul de aspect al axelor x,y,z și scalarea relativă a unităților
de date, astfel încât graficul să se potrivească cât mai bine formei figurii
axis off dezactivează toate axele, gradațiile și etichetele
axis on activează toate axele, gradațiile și etichetele
Exemplul 1:
x=0:10;
y=0:2:20;
subplot(1,2,1);plot(x,y);axis equal;
subplot(1,2,2);plot(x,y);axis square;
Exemplul 2:
subplot(1,2,1);plot(0:pi/20:2*pi,sin(0:pi/20:2*pi));
subplot(1,2,2);plot(0:pi/20:2*pi,sin(0:pi/20:2*pi));axis tight
6. Înserarea de caractere speciale și expresii simple în obiectele grafice

Putem utiliza caractere speciale (ex. litere grecești) sau expresii simple în instrucțiuni care afișează
șiruri.
În tabelul următor sunt prezentate definițiile acestora:
Caracter Definiție Caracter Definiție Caracter Definiție

q \theta £ \leq ß \leftarrow
Q \Theta ³ \geq à \rightarrow
Π \Pi ≠ \neq \uparrow

a \alpha ' \prime ¯ \downarrow
± \pm ∂ \partial ßà \leftrightarrow
¥ \infty º \equiv
ò \int
× \times ÷ \div \surd

└ \lfloor ┘ \rfloor
Í \subseteq Ê \supseteq
Definiția literelor grecești mari începe cu literă mare, a celor mici cu literă mică, de exemplu \Omega
pentru Ω și respectiv \omega pentru ω.
Expresiile se definesc după următoarele reguli:
¦ expresii cu exponenți; expresia ab se definește ca a^b
¦ expresii cu indici; expresia xi se definește ca x_i
¦ dacă este cazul, expresiile se pot grupa între acolade, { }
Expresia eat se definește astfel:

e^a^t
sau:
e^{at}
Expresia ai se definește ca:

a_i
iar expresia xi+j se definește ca:

x_{i+j}
Pentru a afișa un text inclinat (italic), vom defini acel text ca:
\ittextul dorit
iar pentru afișare cu litere groase (bold) vom defini textul ca:
\bftextul dorit
7. Precizarea titlului graficului

Titlul graficului curent se plasează deasupra acestuia cu funcția title.
title('text')
unde 'text' este un șir de caractere care reprezintă titlul graficului.

Instrucțiunea:
title(date)
plasează data în care se face graficul în partea superioară a acestuia.
Exemplul 1: Să se reprezinte distribuția normală, graficul având titlul DISTRIBUTIA GAUSSIANA.

y=randn(1000,1);
hist(y,16);title('\it\bfDISTRIBUTIA GAUSSIANA')%italic+bold
Exemplul 2: Includerea variabilelor în titlu.

a=2;t=0:.1:4.5;v=a*t;
plot(t,v);title(['Variatia vitezei pentru acc=',num2str(a),'m/s^2'])
8. Precizarea etichetei axelor

Precizarea numelui mărimilor reprezentate pe fiecare axă, precum și a unităților de măsură folosite,
se face cu funcțiile xlabel (pentru axa x), ylabel (pentru axa y).
xlabel('text')
ylabel('text')
unde 'text' este un șir de caractere care reprezintă numele axei, unitatea de măsură etc. ale
graficului curent. Repetarea instrucțiunii cu alt text conduce la înlocuirea textului anterior, fără a fi
necesară refacerea reprezentării grafice.
Exemplu:
a=2;t=0:.1:4.5;v=a*t;
plot(t,v);
xlabel('timpul,[s]','FontSize',14);
ylabel('viteza,[m/s]','FontSize',14);
title(['Variatia vitezei pentru acc=',num2str(a),'m/s^2'],'FontSize',18)
9. Plasarea unui text pe grafic

Plasarea unui text în câmpul grafic se face cu funcțiile text sau gtext.
text(x,y,'text')
gtext('text')
Funcția text scrie șirul de caractere 'text' în poziția specificată de coordonatele (x,y). Dacă x
și y sunt vectori, funcția text scrie șirul de caractere 'text' în toate pozițiile date de perechile
(x,y).
Exemplu:
plot(0:pi/20:2*pi,sin(0:pi/20:2*pi));
text(pi,0,'\leftarrow sin(\pi)','FontSize',18)
Funcția gtext afișează șirul de caractere 'text' în fereastra grafică și așteaptă plasarea acestuia
pe grafic cu mouse-ul sau oricare tastă.
Exemplu:
plot(0:pi/20:2*pi,sin(0:pi/20:2*pi));
gtext('\leftarrow sin(\omega)','FontSize',18)
10. Trasarea unei rețele pe grafic

Grid-ul este o rețea de linii verticale și orizontale pe un grafic care ușurează citirea datelor. O astfel de
rețea se trasează cu funcția grid.
Se apelează cu una din sintaxele:
grid on
grid off
grid
grid minor
Dacă funcția grid este setată on, pe grafic sunt reprezentate liniile grid, iar dacă este off,
acestea sunt eliminate. Funcția grid stabilește proprietățile obiectului “axe curente”.
Exemplu:
a=2;t=0:.1:4.5;v=a*t;
plot(t,v);grid minor
xlabel('timpul,[s]','FontSize',14);ylabel('viteza,[m/s]','FontSize',14);
title(['Variatia vitezei pentru acc=',num2str(a),'m/s^2'],'FontSize',18);
text(t(20),v(20),['\leftarrow v=',num2str(v(20)),'m/s'],'FontSize',18);
Bibliografie
CURS 7
TRANSFORMAREA SISTEMELOR DE COORDONATE
1. Transformarea coordonatelor carteziene în/din coordonate polare (2D) și cilindrice (3D)

Sintaxe:
[theta,rho]=cart2pol(x,y) [theta,rho,z]=cart2pol(x,y,z)
[x,y]=pol2cart(theta,rho) [x,y,z]=pol2cart(theta,rho,z)
unde x, y, z sunt vectorii coordonatelor carteziene.
2. Transformarea coordonatelor carteziene în/din coordonate sferice

Sintaxă:
[theta,phi,r]=cart2sph(x,y,z) [x,y,z]=sph2cart(theta,phi,r)
Exemplu: Să se transforme coordonatele carteziene (3,4,5) în coordonate cilindrice, respectiv

sferice:
[theta,rho,z]=cart2pol(3,4,5)
[theta,phi,r]=cart2sph(3,4,5)
theta =
0.9273
rho =
5
z =
5
theta =
0.9273
phi =
0.7854
r =
7.0711
ÎMBUNĂTĂȚIREA PERFORMANȚELOR DE CALCUL
Există două metode importante de a îmbunătăți viteza de execuție și gestiunea memoriei în codurile
sursă scrise în MATLAB:
✓ vectorizarea ciclurilor
✓ prealocarea dimensiunilor
Vectorizarea ciclului
MATLAB-ul optimizează operațiile cu vectori și matrice și în unele situații folosește algoritmi mai rapizi
decât cei uzuali. Din acest motiv atunci când este posibil, ciclurile for sau while se recomandă a fi
înlocuite cu operații vectoriale sau matriciale.
Exemplu:
tic %start cronometru
x1=0.01;
for k=1:10000
y1(k)=log10(x1);
x1=x1+0.01;
end
toc %stop cronometru
Elapsed time is 0.029637 seconds.
Versiunea vectorizată a codului anterior este:

tic
x2=0.01:0.01:100;
y2=log10(x2);
toc
Prealocarea dimensiunilor
Când ciclurile for sau while nu pot fi evitate, prealocarea dimensiunilor duce la o creștere a vitezei
de calcul și o îmbunătățire a utilizării memoriei.
Exemplu:
tic
for n=1:320
r(n)=rank(ones(n)); %functia rank calculează rangul unei matrice
end
toc
Versiunea cu prealocare a aceluiași cod este:

tic
r=zeros(1,320);
for n=1:320
r(n)=rank(ones(n));
end
toc
Explicație: fără prealocare, MATLAB-ul mărește dimensiunea tabloului r la fiecare execuție a ciclului,
ceea ce duce la micșorarea vitezei, la fragmentarea și utilizarea irațională a memoriei. Prealocarea
dimensiunii elimină acest pas de creștere a dimensiunii.
PRELUCRAREA DATELOR ȘI CALCULE STATISTICE
Funcțiile MATLAB pentru prelucrarea datelor și calcule statistice sunt următoarele:
sum Calculează suma elementelor

cumsum Calculează suma cumulată a elementelor
prod Calculează produsul elementelor
cumprod Calculează produsul cumulat al elementelor
diff Calculează diferențele dintre elementele succesive
sort Sortează elementele în ordine crescătoare sau descrescătoare
max Determină cea mai mare componentă
min Determină cea mai mică componentă
mean Calculează media aritmetică
median Returnează valoarea mediană
mode Returnează modulul
std Calculează abaterea standard (abaterea medie pătratică)
var Calculează dispersia
1. Sume și produse
Suma elementelor unui vector, matrice sau tablou se realizează cu funcția sum.
Sintaxe:
Y=sum(X) dacă argumentul X este un vector funcția sum returnează un scalar egal cu suma
elementelor vectorului, iar dacă argumentul este o matrice, funcția returnează un vector linie
care conține suma elementelor pe fiecare coloană
Y=sum(X,dim) returnează suma elementelor după dimensiunea specificată (1-suma pe fiecare
coloană rezultând un vector linie care conține suma elementelor pe fiecare coloană; 2-suma pe
fiecare linie rezultând un vector coloană care conține suma elementelor pe fiecare linie; 3-suma
după dimensiunea 3 etc.)
j
Suma cumulată a elementelor unui vector, matrice sau tablou este dată de relația s j =  xk ,
k =1
j = 1, 2, ..., N . Pentru calculul sumei cumulate se folosește funcția cumsum.
Sintaxe:
Y=cumsum(X) dacă argumentul X este un vector, funcția cumsum returnează un vector care
conține suma cumulată a elementelor vectorului, iar dacă argumentul este o matrice, funcția
returnează o matrice care pe fiecare coloană conține suma cumulată a elementelor din coloana
respectivă
Y=cumsum(X,dim) returnează suma cumulată a elementelor după dimensiunea specificată (1-

suma cumulată pe fiecare coloană, 2-suma cumulată pe fiecare linie, 3-suma cumulată după
dimensiunea 3 etc.)
Produsul elementelor unui vector, matrice sau tablou se realizează cu funcția prod.
Sintaxe:
Y=prod(X) dacă argumentul X este un vector, funcția prod returnează un scalar egal cu
produsul elementelor vectorului, iar dacă argumentul este o matrice funcția returnează un vector
linie care conține produsul elementelor pe fiecare coloană
Y=prod(X,dim) returnează produsul elementelor după dimensiunea specificată (1-produsul pe
fiecare coloană, 2-produsul pe fiecare linie, 3-produsul după dimensiunea 3 etc.)
j
Produsul cumulat al elementelor este dat de relația p j =  xk , j = 1, 2, ..., N . Pentru calculul
k =1
produsului cumulat se folosește funcția cumprod.

Sintaxe:
Y=cumprod(X) dacă argumentul X este un vector, funcția cumprod returnează un vector care
conține produsul cumulat al elementelor vectorului, iar dacă argumentul este o matrice funcția
returnează o matrice care pe fiecare coloană, conține produsul cumulat al elementelor din
coloana respectivă
Y=cumprod(X,dim) returnează produsul cumulat al elementelor după dimensiunea specificată
(1-produsul cumulat pe fiecare coloană, 2-produsul cumulat pe fiecare linie, 3-produsul cumulat
2. Calculul diferențelor dintre elementele succesive

Calculul diferențelor dintre elementele adiacente dintr-un vector, matrice sau tablou se realizează cu
funcția diff.
Sintaxe:
Y=diff(X) dacă X este un vector, diff returnează un vector format de diferențele dintre
elementele adiacente (Y are cu un element mai puțin decât X); dacă X este o matrice, diff
returnează o matrice formată de diferențele succesive ale elementelor coloanelor (Y are cu o
linie mai puțin decât X)
Y=diff(X,n) aplică recursiv diff(X) de n ori
Y=diff(X,n,dim) returnează o matrice formată de diferențele succesive ale elementelor după
cele dimensiunea specificată recursiv de n ori (1-diferențele succesive ale elementelor pe fiecare
coloană, 2-diferențele succesive ale elementelor pe fiecare linie, 3-diferențele succesive ale
elementelor după dimensiunea 3 etc.)
Exemplul 1: Să se calculeze suma, suma cumulată, produsul, produsul cumulat și diferențele succesive
ale elementelor unei matrice după dimensiunea 1.
A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
S=sum(A,1)
S =
14 9 15 16
P=prod(A,1)
P =
70 16 0 108
SC=cumsum(A,1)
SC =
2 4 7 3
7 5 7 7
14 9 15 16
PC=cumprod(A,1)
PC =
2 4 7 3
10 4 0 12
70 16 0 108
DS=diff(A,1)
DS =
3 -3 -7 1
2 3 8 5
Exemplul 2: Să se calculeze vitezele medii ale unui atlet pe baza următoarelor date experimentale:
distanțele considerate: 0, 100, 300, 600, 1000, 1500, 2000, 2500, 3000 [m], la timpii:
0, 16, 47, 96, 160, 239, 319, 398, 476 [s].
d=[0 100 300 600 1000 1500 2000 2500 3000];
t=[0 16 47 96 160 239 319 398 476];
vMed=diff(d)./diff(t)
vMed =
6.2500 6.4516 6.1224 6.2500 6.3291 6.2500 6.3291
6.4103
3. Sortarea elementelor
Sortarea elementelor unui vector, matrice sau tablou se face cu funcția sort.
Sintaxe:
Y=sort(X) dacă argumentul X este vector, funcția sortează crescător elementele sale; dacă
argumentul X este matrice, funcția sortează crescător fiecare coloană a acesteia
Y=sort(X,dim) sortează elementele crescător după dimensiunea specificată (1-sortează
elementele crescător pe fiecare coloană, 2-sortează elementele crescător pe fiecare linie, 3-
sortează după dimensiunea 3 etc.)
Y=sort(...,'tip_sortare') sortează elementele în direcția specificată, în funcție de
'tip_sortare': 'ascend' sau 'descend'
[Y,I]=sort(X...) returnează în matricea Y elementele coloanelor sortate și în matricea I
indicii elementelor sortate ale matricei X. Dacă elementele coloanei matricei se repetă (au valori
egale), indicii acestora sunt returnați în ordinea în care au fost întâlniți în matricea argument.
Obs. Pentru matrice cu elemente numere complexe, sortarea se face după valoarea modulului.
Exemplu: Să se sorteze elementele unei matrice, cu precizarea indicelui fiecărui element.

A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
[Y,I]=sort(A,2,'descend')
Y =
7 4 3 2
5 4 1 0
9 8 7 4
I =
3 2 4 1
1 4 2 3
4 3 1 2
4. Maximul și minimul
Funcțiile max și min determină maximul și minimul valorilor unui vector, matrice sau tablou.
Sintaxe:
M=max(X) dacă X este vector, aceste funcții returnează un scalar egal cu cel mai mare element,
iar dacă X este matrice, funcțiile returnează un vector linie care conține elementele maxime din
fiecare coloană
m=min(X) dacă X este vector, aceste funcții returnează un scalar egal cu cel mai mic element,
iar dacă X este matrice, funcțiile returnează un vector linie care conține elementele minime din
fiecare coloană
[M,I]=max(X) determină elementele maxime și a indicelui (poziției) acestora; în vectorul M se
memorează valorile maxime, iar în vectorul I indicii acestor valori; dacă există mai multe valori
maxime identice, se reține indicele primului element maxim
[m,I]=min(X) determină elementele minime, precum și a indicelui (poziției) acestora; în
vectorul m se memorează valorile minime, iar în vectorul I indicii acestor valori; dacă există
mai multe valori minime identice, se reține indicele primului element minim
[M,I]=max(X,[],dim) determină elementele maxime, precum și a indicelui (poziției) acestora
după dimensiunea specificată (1-maximul de pe fiecare coloană, 2-maximul de pe fiecare linie, 3-
maximul după dimensiunea 3 etc.)
[m,I]=min(X,[],dim) determină elementele minime, precum și a indicelui (poziției) acestora
după dimensiunea specificată (1-minimul de pe fiecare coloană, 2-minimul de pe fiecare linie, 3-
minimul după dimensiunea 3 etc.)
C=max(A,B) creează o matrice C care conține elementele maxime din două matrice A și B,
de aceeași dimensiune
C=min(A,B) creează o matrice C care conține elementele minime din două matrice A și B, de
aceeași dimensiune
Exemplul 1: Să se determine valorile maxime și indicii acestora în cazul unui vector și ale unei matrice.
a=[2 4 7 3 5 1 0 4 7 4 8 9]
a =
2 4 7 3 5 1 0 4 7 4 8 9
[M1,I1]=max(a)
M1 =
9
I1 =
12
A=[2 4 7 3;5 1 0 4;7 4 8 9]

A =
2 4 7 3
5 1 0 4
7 4 8 9
[M2,I2]=max(A)
M2 =
7 4 8 9
I2 =
3 1 3 3
[M,I]=max(A,[],2)
M =
7
5
9
I =
3
1
4
Exemplul 2: Crearea a două matrice C și D care conțin elementele maxime, respectiv minime, din
două matrice A și B.
A=[2 4 7 3;5 1 0 4;7 4 8 9]
A =
2 4 7 3
5 1 0 4
7 4 8 9
B=[3 2 3 1;6 1 9 3;8 3 2 2]
B =
3 2 3 1
6 1 9 3
8 3 2 2
C=max(A,B)
C =
3 4 7 3
6 1 9 4
8 4 8 9
D=min(A,B)
D =
2 2 3 1
5 1 0 3
7 3 2 2
5. Media aritmetică
Media aritmetică a unui vector, matrice sau tablou se calculează cu funcția mean.
Sintaxe:
Y=mean(X) dacă argumentul X este un vector, funcția mean returnează un scalar egal cu media
aritmetică a elementelor vectorului, iar dacă argumentul este o matrice funcția returnează un
vector linie care conține media aritmetică a elementelor pe fiecare coloană
Y=mean(X,dim) dacă argumentul X este un tablou, funcția returnează media aritmetică a
elementelor după dimensiunea specificată (1-media pe fiecare coloană, 2-media pe fiecare linie,
3-media după dimensiunea 3 etc.)
6. Mediana
Mediana este elementul de la mijlocul unul set de date ordonat crescător sau descrescător. Dacă
numărul N al valorilor setului este impar, valoarea mediană este cea din poziția (N+1)/2, iar dacă acesta
este par, valoarea mediană este media elementelor din pozițiile (N/2) și (N/2) + 1. Se determină cu
funcția median.
Sintaxe:
Y=median(X) dacă argumentul X este un vector, funcția returnează un scalar egal cu mediana
elementelor vectorului
Y=median(X,dim) dacă argumentul X este un tablou, funcția returnează mediana elementelor
după dimensiunea specificată (1-mediana pe fiecare coloană, 2-mediana pe fiecare linie, 3-
mediana după dimensiunea 3 etc.)
7. Modulul
Modulul reprezintă valoarea termenului dintr-o serie de date care are frecvența maximă. Există serii
de date care au mai multe module. Se determină cu funcția mode.
Sintaxe:
Y=mode(X) dacă argumentul X este un vector, funcția returnează un scalar egal cu modulul
elementelor vectorului. Atunci când există mai multe valori care au aceeași frecvență absolută,
funcția returnează cea mai mică valoare
Y=mode(X,dim) dacă argumentul X este un tablou, funcția returnează mediana elementelor

după dimensiunea specificată (1-pe fiecare coloană, 2-pe fiecare linie, 3-după dimensiunea 3
etc.). Atunci când există mai multe valori care au aceeași frecvență absolută, funcția returnează
cea mai mică valoare
[M,F]=mode(X,dim) returnează în matricea M modulul elementelor și în matricea F numărul
de apariții a modulului după dimensiunea specificată (1-pe fiecare coloană, 2-pe fiecare linie, 3-
8. Dispersia (varianța) și abaterea medie pătratică (abaterea standard)

Dispersia unei variabile se calculează cu relația:
N
(x − m)
2
k
2 = k =1
unde termenul ( xk − m ) reprezintă diferența sau abaterea lui xk față de valoarea medie a variabilei,
notată cu m (dacă N > 40).
Abaterea medie pătratică (abaterea standard) a unei variabile este definită ca radicalul dispersiei
variabilei respective:
N
(x − m)
2
k
= k =1
N
Dispersia de selecție se calculează cu relația:
N
(x − x)
2
k
s2 = k =1
N−1
unde termenul ( xk − x ) reprezintă diferența sau abaterea lui xk față de valoarea medie a selecției,
notată cu x (N < 40).
Abaterea medie pătratică de selecție (abaterea standard de selecție):
N
(x − x)
2
k
s= k =1
N−1
Dispersia (varianța) se calculează cu funcția var.
Sintaxe:
v=var(x,tip_dispersie) dacă argumentul x este un vector, funcția returnează un scalar care
reprezintă dispersia elementelor vectorului (dacă tip_dispersie este 1), respectiv dispersia
de selecție (dacă tip_dispersie este 0)
v=var(X,tip_dispersie,dim) dacă argumentul X este un tablou, funcția returnează un scalar

care reprezintă dispersia (dacă tip_dispersie este 1), respectiv dispersia de selecție (dacă
tip_dispersie este 0) după dimensiunea specificată (1-pe fiecare coloană, 2-pe fiecare linie,
3-dimensiunea 3 etc.)
Abaterea standard (abaterea medie pătratică) se calculează cu funcția std.

Sintaxe:
a=std(x,tip_abatere) dacă argumentul x este un vector, funcția returnează un scalar care
reprezintă abaterea standard a elementelor vectorului (dacă tip_abatere este 1), respectiv
abaterea standard de selecție (dacă tip_abatere este 0)
a=std(X,tip_abatere,dim) dacă argumentul X este un tablou, funcția returnează un scalar
care reprezintă abaterea standard (dacă tip_abatere este 1), respectiv abaterea standard de
selecție (dacă tip_abatere este 0) după dimensiunea specificată (1-pe fiecare coloană, 2-pe
fiecare linie, 3-după dimensiunea 3 etc.)
Exemplu:
rez=[7.00 7.10 7.05 7.05 6.90 7.20 7.20 7.25 7.05 7.20 7.25 7.15 7.20 6.95 7.20
7.50 7.65 7.40 7.20 6.90 7.10 7.40];
Media=mean(rez,2)
Mediana=median(rez,2)
Modul=mode(rez,2)
dispSel=var(rez,0) %0==disp. de selectie
abStSel=std(rez,0)
Media =
7.1773
Mediana =
7.2000
Modul =
7.2000
dispSel =
0.0352
abStSel =
0.1875
9. Coeficienții de corelație (Pearson)

Se utilizează atunci când se dorește stabilirea existenței unei eventuale corelații (legături) între două
variabile din același eșantion și intensitatea acesteia.
Dacă corelația există, se vor deosebi două tipuri: pozitivă și negativă:
▪ Corelația este pozitivă atunci când creșterea valorilor unei variabile determină creșterea
valorilor celeilalte variabile
▪ Corelație este negativă atunci când creșterea valorilor unei variabile determină scăderea
valorilor pentru a doua variabilă
Felul corelației se exprimă prin semnul coeficientului de corelație Pearson (R), iar intensitatea
legăturii dintre cele două variabile se exprimă prin valoarea acestuia.
Este de reținut faptul că valorile lui r pot varia doar în intervalul [-1, +1]. Cu cât valoarea absolută a lui
R este mai mare (tinde către 1), cu atât legătura dintre variabile este mai puternică:
▪ pentru | R | < 0,3 corelația este foarte slabă
▪ pentru | R | = 0,3÷0,5 corelația este slabă
▪ pentru | R | = 0,5÷0,7 corelația este moderată
▪ pentru | R | = 0,7÷0,9 corelația este puternică
▪ pentru | R | = 0,9÷1 corelația este foarte puternică
Dacă valoarea lui R este nulă, se spune că cele două variabile nu sunt corelate sau că sunt necorelate.
Coeficienții de corelație se calculează cu funcția corrcoef.

Sintaxe:
R=corrcoef(X) returnează matricea r a coeficienților de corelație calculați pe baza matricei de
intrare X, ale cărei rânduri sunt observațiile, iar coloanele sunt variabilele
R=corrcoef(x,y) returnează matricea r a coeficienților de corelație calculați pe baza vectorilor
coloană x și y; dacă x și y nu sunt vectori coloană, corrcoef le transformă în vectori coloană
Exemplu: În tabelul următor sunt date rezultatele obținute de un eșantion de 9 studenți la un test
aplicat pe parcurs, respectiv nota finală la examen.
1. Să se determine media, mediana, modulul, dispersia de selecție și abaterea medie pătratică
de selecție ale variabilei test, respectiv notă finală
2. Să se afle dacă rezultatele obținute de cei 9 studenți la testul aplicat pe parcurs au influențat
notele lor finale la examen
Număr puncte la test Nota la examen

(variabila X) (variabila Y)
230 8
310 10
250 9
310 10
150 7
180 7
80 6
350 10
230 8
REZ=[230 310 250 310 150 180 80 350 230;8 10 9 10 7 7 6 10 8]'

media=mean(REZ,1) %dimensiunea 1==linii
mediana=median(REZ,1) %dimensiunea 1==linii
[modulul,frecventa]=mode(REZ,1) %dimensiunea 1==linii
dispersia=var(REZ,0,1) %0==disp. de selectie, dimensiunea 1==linii
abaterea=std(REZ,0,1) %0==abat.std de selectie, dimensiunea 1==linii
R=corrcoef(REZ)
REZ =
230 8
310 10
250 9
310 10
150 7
180 7
80 6
350 10
230 8
media =
232.2222 8.3333
mediana =
230 8
modulul =
230 10
frecventa =
2 3
dispersia =
1.0e+03 *
7.3694 0.0022
abaterea =
85.8455 1.5000
R =
1.0000 0.9740
0.9740 1.0000
CALCULE NUMERICE CU POLINOAME
Funcțiile MATLAB pentru evaluarea polinoamelor, calculul derivatelor și integralelor polinoamelor,

generarea polinoamelor când se cunosc rădăcinile etc., sunt următoarele:
conv Calculează produsul a două polinoame

deconv Calculează câtul și restul împărțirii a două polinoame
poly Calculează coeficienții unui polinom cu rădăcinile date
polyder Calculează derivata polinoamelor
polyfit Aproximează un set de date cu un polinom de grad n
polyint Calculează analitic integralele polinoamelor
polyval Evaluează un polinom la valorile precizate ale variabilei
roots Calculează rădăcinile unui polinom
Polinomul este o funcție de o singură variabilă, care poate fi exprimat sub următoarea formă generală:
p ( x ) = a1x +a2x
n n-1 2
+...+an-1x +anx +an+1
unde: x este variabila

a1, a2, ... , an+1 sunt coeficienții polinomului
Gradul polinomului este egal cu cea mai mare valoare a exponenților.
În sintaxa MATLAB, polinoamele sunt reprezentate cu un vector linie care conține coeficienții în ordinea
descrescătoare a puterilor variabilei. Coeficienții polinomului au indicii de la 1 la n+1.
De exemplu, reprezentarea în MATLAB a polinomului:
p ( x ) = x +2x +0,5x -6,5

4 2
este dată de vectorul:

p=[1 0 2 0.5 -6.5]
1. Evaluarea polinoamelor
În MATLAB există mai multe metode pentru evaluarea polinoamelor. Vor fi exemplificate, cu
polinomul:
p ( x ) = x +2x +0,5x -6,5

4 2
a) Evaluarea cu scalari, adică pentru o singură valoare a variabilei. În acest caz se efectuează
operațiile cu scalari
Exemplu: Evaluarea polinomului p pentru x=1
x=1;
p=x^4+2*x^2+0.5*x-6.5
p =
-3
b) Evaluarea polinomului în mai multe puncte. În acest caz se efectuează operații cu tablouri
(matrice sau vectori). Programul se execută mai rapid decât ansamblul calculelor pentru fiecare
valoare scalară în parte. Sintaxa evaluării presupune în acest caz plasarea unui punct înaintea
operatorilor înmulțire, împărțire sau ridicare la putere. Dimensiunea matricei în care se
returnează valorile polinomului este identică cu cea a matricei care conține punctele în care se
face evaluarea
Exemplu: Evaluarea polinomului p pentru x=-2, 0, 0.5, 1, 3
x=[-2 0 0.5 1 3];
p=x.^4+2*x.^2+0.5*x-6.5
p =
16.5000 -6.5000 -5.6875 -3.0000 94.0000
c) Evaluarea polinomului în unul sau mai multe puncte utilizând funcția polyval
Y=polyval(p,X)
Funcția polyval evaluează polinomul definit de vectorul p al coeficienților polinomului, în punctul

X. Dacă X este vector sau matrice, polinomul este evaluat pentru fiecare dintre elementele
acestuia.
Exemplu: Evaluarea polinomului p pentru X=[-2 0; 0.5 1].
p=[1 0 2 0.5 -6.5]; X=[-2 0; 0.5 1];
Y=polyval(p,X)
Y =
16.5000 -6.5000
-5.6875 -3.0000
2. Adunarea și scăderea polinoamelor

Fie două polinoame p1(x) și p2(x) ai căror coeficienți sunt înregistrați în vectorii linie g și h.
Operațiile aritmetice de adunare și scădere a polinoamelor presupun adunarea și scăderea
coeficienților de același ordin. Deoarece în MATLAB aceste operații necesită vectori de aceeași
dimensiune, lungimea vectorilor coeficienților este dată de polinomul cu puterea cea mai mare. Odată
stabilită această dimensiune, spre exemplu m, vectorii coeficienților polinoamelor care au puterea
maximă n mai mică decât m vor fi completați la stânga cu coeficienți zero până la m.
p1( x ) = x +2x +0,5x -6,5 ; p2( x ) = 3x -2x +5 .

4 2 2
Exemplu: Se consideră polinoamele: Se cer
polinoamele: g = p1( x ) + p2( x ) ; h = p1( x ) - p2( x )
p1=[1 0 2 0.5 -6.5];
p2=[0 0 3 -2 5];
g=p1+p2
g =
1.0000 0 5.0000 -1.5000 -1.5000
h=p1-p2
h =
1.0000 0 -1.0000 2.5000 -11.5000
3. Înmulțirea și împărțirea polinoamelor

Multiplicarea unui polinom cu un scalar constă în multiplicarea coeficienților acestuia cu acel scalar.
Înmulțirea a două polinoame este echivalentă unei operații de convoluție; este realizată cu
funcția conv, care se apelează cu sintaxa:
d=conv(a,b)
unde: a și b sunt vectorii coeficienților polinoamelor care se înmulțesc

d este vectorul coeficienților polinomului produs d(x) = a(x) ∙ b(x)
Împărțirea a două polinoame este echivalentă unei operații de deconvoluție; este realizată cu
funcția deconv, care se apelează cu sintaxa:
[c,r]=deconv(a,b)
unde: a și b sunt vectorii coeficienților polinoamelor deîmpărțit și împărțitor

c este vectorul coeficienților polinomului cât, r este vectorul coeficienților polinomului rest,
rezultat al operației r(x) = a(x) - c(x) ∙ b(x)
p1( x ) = x +2x +0,5x -6,5 ; p2( x ) = 3x -2x +5 .

4 2 2
Exemplu: Se consideră polinoamele: Se cer
polinoamele: u ( x ) = p1( x )  p2( x ) ; v ( x ) = p1( x ) / p2( x ) și restul r(x).
p1=[1 0 2 0.5 -6.5];
p2=[3 -2 5];
u=conv(p1,p2)
u =
3.0000 -2.0000 11.0000 -2.5000 -10.5000 15.5000 -32.5000
[v,r]=deconv(p1,p2)
v =
0.3333 0.2222 0.2593
r =
0 0 0 -0.0926 -7.7963
4. Calculul derivatei polinoamelor

Problemele de derivare ale polinoamelor sunt rezolvate cu funcția polyder.
Apelată cu sintaxa:
d=polyder(p)
funcția polyder returnează în vectorul d coeficienții derivatei polinomului p:

d(x)= p ( x )
d=polyder(a,b)
funcția polyder returnează în vectorul d coeficienții derivatei polinomului produs a∙b:
d(x)= ( a ( x )  b ( x ) ) = a ( x )  b ( x ) + a ( x )  b ( x )
[m,n]=polyder(a,b)
funcția polyder returnează în vectorii m și n coeficienții numărătorului și numitorului derivatei

raportului polinoamelor a/b:
m (x)  a ( x )  a ( x )  b ( x ) -a ( x )  b ( x )
=  =
n (x)  b(x)  b(x)
2
Exemplu: Se consideră polinoamele: p1( x ) = x4 +2x2 +0,5x -6,5 ; p2( x ) = 3x2 -2x +5 . Să se calculeze
coeficienții derivatelor polinoamelor p1 și p2, ai produsului p1∙p2, respectiv ai numărătorului și
numitorului raportului p1/p2.
p1=[1 0 2 0.5 -6.5]; p2=[3 -2 5];
d1=polyder(p1)
d1 =
4.0000 0 4.0000 0.5000
d2=polyder(p2)
d2 =
6 -2
d3=polyder(p1,p2)
d3 =
18.0000 -10.0000 44.0000 -7.5000 -21.0000 15.5000
[m,n]=polyder(p1,p2)
m =
6.0000 -6.0000 20.0000 -5.5000 59.0000 -10.5000
n =
9 -12 34 -20 25
5. Calculul analitic al integralelor polinomiale

Integrala unui polinom utilizează funcția polyint.
Se apelează cu una din sintaxele:
in=polyint(p)
in=polyint(p,k)
unde: p este vectorul linie al coeficienților polinomului în ordinea descrescătoare a puterilor variabilei
k este constanta de integrare (fără k constanta de integrare este 0)
Exemplu: Să se calculeze integrala polinoamelor p1( x ) = x4 +2x2 +0,5x -6,5 ; p2( x ) = 3x2 -2x +5 .
p1=[1 0 2 0.5 -6.5]; p2=[3 -2 5];
in1=polyint(p1)
in1 =
0.2000 0 0.6667 0.2500 -6.5000 0
in2=polyint(p2,2)
in2 =
1 -1 5 2
6. Calculul rădăcinilor polinoamelor

Dacă funcția f(x) este un polinom de gradul n atunci f(x)=0 are n rădăcini, care pot fi reale sau
complexe. În cazul în care coeficienții polinomului sunt numere reale, rădăcinile complexe sunt în
perechi complex conjugate.
Funcția roots determină rădăcinile polinoamelor.

r=roots(c)
unde: c este un vector linie, care conține coeficienții polinomului

r este un vector coloană care conține rădăcinile polinomului
Exemplu: Să se găsească rădăcinile polinoamelor: p1( x ) = x4 +2x2 +0,5x -6,5 ; p2( x ) = 3x2 -2x +5 .
p1=[1 0 2 0.5 -6.5];p2=[3 -2 5];
r1=roots(p1)
r1 =
0.0456 + 1.9345i
0.0456 - 1.9345i
-1.3640
1.2727
r2=roots(p2)
r2 =
0.3333 + 1.2472i
0.3333 - 1.2472i
7. Calculul coeficienților unui polinom cu rădăcinile date

Funcția poly determină coeficienții unui polinom ale cărui rădăcini sunt cunoscute.
c=poly(r)
unde: r este un vector linie care conține rădăcinile polinomului

c este un vector linie care conține coeficienții polinomului
Exemplu: să se determine polinomul care are rădăcinile -2 și 2
r=[-2 2]
p=poly(r);
p =
1 0 -4
Funcțiile roots și poly sunt funcții reciproce, realizând trecerea de la coeficienți la rădăcini, respectiv
de la rădăcini la coeficienți.
Bibliografie
CURS 8
INTERPOLAREA DATELOR
Interpolarea unui set discret de perechi de date experimentale (xk,yk) presupune determinarea
unei funcții f(x) astfel ca f(xk) = yk, în vederea estimării setului de date în orice alt punct
xi ≠ xk. Interpolarea răspunde la nevoia de a găsi o estimare a valorilor yi în punctele xi pentru
care nu s-a realizat experimentul.
Spre exemplu, fie punctele de coordonate (x1,y1) și (x2,y2) care au fost stabilite experimental; se
cere estimarea valorii f(xi) = yi, unde x1 < xi < x2 (valoarea xi nu a fost inclusă în experiment,
deci valoarea yi nu se cunoaște). Dacă punctele sunt unite printr-o dreaptă, interpolarea se numește
liniară, iar dacă sunt unite printr-un polinom, interpolarea se numesște spline.
Extrapolarea reprezintă estimarea unei valori f(xe) = ye, unde xe se află în afara intervalului
valorilor din experiment (xmin,xmax).
Principalele funcții MATLAB pentru interpolarea datelor sunt:
interp1 Interpolează date din tabele unidimensionale

interp2 Interpolează date din tabele bidimensionale
interp3 Interpolează date din tabele tridimensionale
interpn Interpolează date din tabele N-dimensionale
1. Interpolarea datelor din tabele unidimensionale

Se presupune că există un set de date care reprezintă coordonatele (xk,yk). Obiectivul îl constituie
estimarea valorilor funcției f(x), pentru orice punct x  ( xk, xk + 1 ) printr-o curbă de interpolare
care trece prin toate punctele (xk,yk) care o definesc.
Se realizează cu funcția interp1, care se apelează cu una din sintaxele:
yi=interp1(x,y,xi,'metoda') unde x este vectorul care conține abscisele, respectiv y este
vectorul care conține ordonatele datelor cunoscute (cu pas "mare"); xi este un vector care
conține noile abscise, de regulă cu pas mai "fin"; yi este vectorul returnat, asociat lui xi;
interpolarea se face cu una din următoarele metode:
'nearest' Nearest neighbor interpolation [interpolare de tip cel mai apropiat vecin]
'next' Next neighbor interpolation [interpolare de tip vecinul următor]
'previous' Previous neighbor interpolation [interpolare de tip vecinul anterior]
'linear' Linear interpolation (default) [interpolare liniară (implicită)]
'spline' Cubic spline interpolation [interpolare spline cubică]
'pchip' Shape-preserving piecewise cubic interpolation [interpolare cubică cu păstrarea
formei]
yi=interp1(x,y,xi,'metoda','extrap') interpolează și extrapolează în funcție de metoda

specificată
Atenție!!! Valorile elementelor vectorului x trebuie să fie ordonate crescător.
Exemplul 1: Cunoscând evoluția populației unui oraș între anii 1920 și 2010, din 10 în 10 ani, să se
estimeze prin toate metodele evoluția anuală a populației între anii 1900 și 2030. Să se estimeze
populația din anii 1917 și 2043 prin metoda 'pchip'.
x=1920:10:2010;
y=[75995 91972 105711 123203 131669 150697 179323 203212 226505 249633];
xi=1900:2030;
y1i=interp1(x,y,xi,'nearest','extrap');
y2i=interp1(x,y,xi,'linear','extrap');
y3i=interp1(x,y,xi,'spline','extrap');
y4i=interp1(x,y,xi,'pchip','extrap');
plot(x,y,'o',xi,y1i,xi,y2i,xi,y3i,xi,y4i);grid;
legend('date','nearest','linear','spline','pchip','Location','EastOutside');
y5i=interp1(x,y,[1917,2043],'pchip','extrap')
y5i =
1.0e+005 *
0.7078 3.2477
Exemplul 2: Să se reprezinte grafic o interpolare liniară și spline prin șase puncte date, pe o rețea de 10
ori mai "fină".
x=[0 1 2 3 4 5];
y=[0.0 20.0 60.0 68.0 77.0 110.0];
xi=0:0.1:5;
yil=interp1(x,y,xi,'linear');
yis=interp1(x,y,xi,'spline')
plot(x,y,'o',xi,yil,xi,yis);grid;title('Interpolare liniara vs. spline')
2. Interpolarea datelor din tabele bidimensionale

Funcția interp2 interpolează datele funcțiilor de două variabile și se apelează cu sintaxa:
Zi=interp2(x,y,Z,xi,yi,'metoda') unde x este vector linie, y este vector coloană, cu pași
mai "mari", Z este matricea valorilor F(x,y), matricea Zi conține valorile interpolate
corespunzătoare vectorului linie xi și vectorului coloană yi, cu pași mai "fini"; nu permite
extrapolare, returnând NaN pentru aceste elemente; interpolează utilizând următoarele
metode:
'linear' Bilinear interpolation (default) [interpolare biliniară (implicită)]
'spline' Spline interpolation [interpolare spline cubică]
'cubic' Bicubic interpolation [interpolare bicubică (datele trebuie să fie uniform
distanțate), în caz contrar se realizează tot interpolare 'spline']
Observație: Nu permit extrapolare, returnând NaN pentru aceste elemente!!!
Atenție!!! Valorile vectorilor x și y trebuie să fie ordonate crescător.
Exemplul 1: Să se interpoleze datele din tabelul bidimensional pentru valorile x=1:9, y=1:10. Să se
estimeze valoarea lui z pentru x=3.72 și y=5.68.
x 1 2 5 9
y
1 2 6 7 5
3 3 4 8 6
10 4 6 9 5
x=[1 2 5 9];
y=[1 3 10]';
Z=[2,6,7,5;3,4,8,6;4,6,9,5];
xi=1:9;
yi=[1:10]';
Zil=interp2(x,y,Z,xi,yi,'linear');
surf(x,y,Z);hold on;surf(xi,yi,Zil+25);
Zil=interp2(x,y,Z,3.72,5.68,'linear')
Zil =
6.8395
Zis=interp2(x,y,Z,3.72,5.68,'spline')
Zis =
5.7064
3. Interpolarea datelor din tabele tridimensionale

Funcția interp3 interpolează datele funcțiilor de trei variabile. Se apelează cu sintaxa:
Vi=interp3(x,y,z,V,xi,yi,zi,'metoda') interpolează utilizând următoarele metode:
'linear' Linear interpolation (default) [interpolare liniară (implicită)]
'spline' Spline interpolation [interpolare spline cubică]
'cubic' Cubic interpolation [interpolare cubică (datele trebuie să fie uniform distanțate),
în caz contrar se realizează tot interpolare 'spline']
Atenție!!! Valorile vectorilor x, y și z trebuie să fie ordonate crescător.
4. Interpolarea datelor din tabele N-dimensionale

Funcția interpn interpolează datele funcțiilor de N variabile. Se apelează cu sintaxa:
Vi=interpn(x1,x2,x3,...,V,x1i,x2i,x3i,...,'metoda') interpolează utilizând următoa-
rele metode:
'nearest' Nearest neighbor interpolation [interpolare de tip cel mai apropiat vecin];
'linear' Linear interpolation (default) [interpolare liniară (implicită)];
'spline' Spline interpolation [interpolare spline];
'cubic' Bicubic interpolation [interpolare cubică (datele trebuie să fie uniform
distanțate), în caz contrar se realizează tot interpolare 'spline'].
Atenție!!! Valorile vectorilor x1, x2, x3, ... trebuie să fie ordonate crescător.
APROXIMAREA DATELOR
O altă modalitate de prelucrare a unui set de date este aproximarea cu o funcție care constituie "cea
mai bună aproximare". În acest caz nu este neapărat necesar ca funcția determinată să treacă prin
toate punctele date, însă aceasta trebuie să reprezinte "cea mai bună aproximare într-un anumit
sens” (după un anumit criteriu de eroare impus). De exemplu, metoda celor mai mici pătrate
furnizează cea mai bună aproximare în sensul minimizării pătratului distanțelor dintre punctele date
și funcția de aproximare. Pentru ca aproximarea să fie considerată "cea mai bună", suma pătratelor
distanțelor de la fiecare punct al setului de date la curba de aproximare (linie sau polinom) trebuie
să fie minimă. Cu această condiție este posibil ca nici un punct al setului de date să se găsească pe
curba de aproximare. Acest aspect diferențiază clar aproximarea datelor de interpolarea datelor, în
cazul căreia toate punctele sunt situate pe curba de interpolare.
1. Funcția polyfit pentru aproximarea datelor

Sintaxa:
p=polyfit(x,y,n) unde x este vectorul care conține abscisele; y este vectorul care conține
ordonatele datelor cunoscute; n este gradul polinomului; returnează coeficienții ai, ai
polinomului p(x) de grad n, care în punctele precizate de vectorul x are, în sensul celor mai
mici pătrate, valorile date de vectorul y
Evaluarea polinomului în mai multe puncte se face utilizând funcția polyval.
Sintaxa:
val=polyval(p,X) unde p este vectorul coeficienților polinomului; X este un scalar, vector
sau tablou care conține valoarea/ valorile pentru care polinomul este evaluat
Regresia liniară
Regresia liniară reprezintă aproximarea unui set de date printr-o dependență liniară care minimizează
suma pătratelor dintre dreapta de aproximare și punctele date. Măsura calității unei aproximări
liniare este dată de suma pătratelor erorilor (distanțelor) de la fiecare punct dat la estimația liniară
(distanțe prezentate în figura următoare), mărime dată de expresia:
n
tot =  k2 , unde k = yk − y
k =1
Determinarea coeficienților a1 și a2 ai dreptei de aproximare y1=a1∙x+a2 se face utilizând funcția

polyfit pentru n=1 (polinom de gradul1):
p=polyfit(x,y,1)
Exemplu: Să se aproximeze în sensul celor mai mici pătrate cu o regresie liniară setul de date:
x=[0 1 2 3 4 5];y=[0.0 20.0 60.0 68.0 77.0 110.0];
p=polyfit(x,y,1);
y1=polyval(p,x);
plot(x,y1,x,y,'o');grid
Regresia polinomială
Regresia polinomială reprezintă aproximarea unui set de date cu N valori printr-un polinom de grad n:
p ( x ) = a1xn + a2xn−1 + ... + an−1x 2 + anx + an+1
a) dacă gradul polinomului n = N – 1 (unde N este numărul de valori ale setului de date), toate
valorile setului se vor afla pe curba de "aproximare"
b) pentru n < N – 1, aproximarea este cu atât mai bună cu cât gradul polinomului este mai
apropiat de N – 1
c) pentru n > N – 1, aproximarea poate conduce la erori de aproximare considerabile; în acest
caz Matlab-ul va da un mesaj de eroare
Exemplu: Aproximați în sensul celor mai mici pătrate următorul set de date experimentale:
x=[0 0.5 1 1.5 2 2.5 3 3.5 4];
y=[-4.51 -0.466 1.417 1.046 -1.207 0.342 1.630 2.364 7.035];
p3=polyfit(x,y,3);
xi=0:0.01:4;
p3=polyfit(x,y,3);
poli3=polyval(p3,xi);
p6=polyfit(x,y,6);
p8=polyfit(x,y,8);
plot(x,y,'o',xi,poli3,xi,poli6,xi,poli8);grid;
legend('date','polinom grd.3','polinom grd.6','polinom grd.8',
'Location','NorthEastOutside');
2. Instrumentul MATLAB cftool pentru aproximarea datelor

Sintaxe:
cftool deschide instrumentul pentru aproximarea datelor (Curve Fitting Tool)
cftool(x,y) creează o aproximare a curbei cu intrarea x și ieșirea y. x și y sunt vectori cu
același număr de elemente; se deschide Curve Fitting Tool
cftool(x,y,[],W) creează o aproximare cu greutățile punctelor date în vectorul W. W trebuie
să aibă aceeași lungime ca x și y; se deschide Curve Fitting Tool
cftool(x,y,Z) creează o aproximare a suprafeței cu intrările x și y și ieșirea Z. x și y sunt
vectori, Z este o matrice de dimensiune m x n, unde și m = lungimea vectorului y și
n = lungimea vectorului x; se deschide Curve Fitting Tool
cftool(x,y,Z,W) creează o potrivire a suprafeței cu greutățile punctelor date în matricea W.

W trebuie să aibă aceeași dimensiune ca Z; se deschide Curve Fitting Tool
Exemplu: În urma unui studiu experimental privind influența vitezei de așchiere, v [m/min] și
avansului, s [mm/rot] pentru o adâncime de așchiere de ap = 2mm asupra forței principale de așchiere
Fz [N] au rezultat următoarele rezultate:
Vectorii v și s, respectiv matricea Fz sunt definiți în prealabil într-un fișier de tip script care se
salvează cu numele dateAschiere în care apelăm și instrumentul cftool.
%Fisierul script care contine datele experimentale la aschire
%viteza
v=[10 20 30 40 50 60 80 100 130];
%avansul
s=[0.125 0.195 0.285 0.390 0.490 0.750]';
%forta de aschiere
Fz=10^3*[1.6 1.0 0.9 1.0 1.1 1.0 1.1 1.1 1.1;2.0 1.5 1.3 1.3 1.3 1.4 1.5 1.7
1.8;...
2.8 2.1 2.0 2.2 2.5 2.7 2.5 2.2 2.1;3.2 2.8 2.7 2.9 3.0 3.2 2.9 2.7
2.8;...
4.0 3.5 3.9 4.0 4.1 4.0 3.5 3.6 3.6;5.9 5.2 5.7 5.2 5.1 5.0 4.9 4.8 4.8];
%apelarea instrumentului pentru aproximarea datelor
cftool(v,s,Fz)
Se rulează (Run) fișierul script.

În figura următoare, este prezentată interfața cftool care apare.
Se deschide implicit aproximarea de tip Interpolant. Putem alege din metodele Custom Equation,
Interpolant (default), Lowess și Polynomial.
Alegem metoda Polynomial. Pe baza variației forței principale de așchiere Fz în funcție de viteza
de așchiere v și avansul sculei s, putem încerca aproximarea acesteia cu un polinom de gradul 2 în
cazul ambelor variabile.
Fit name, de exemplu FzAproxPoly22.
Clic pe butonul Contour plot
Apare și graficul 2D al datelor aproximate.

Rezultatul aproximării:
Adică, funcția de aproximare rezultată este:
Fz(v,s) = −16,7 − 2,529  v + 9403  s + 0,03547  v2 − 12,6  v  s − 2339  s2
Acum putem crea o funcție care să aproximeze forța principală de așchiere Fz:
function [Fz]=functieAproxFz(v,s)
%Estimeaza forta principala de aschiere Fz pentru o adancime de aschiere de
2mm
if nargin~=2
error('Numarul de argumente de intrare trebuie sa fie 2')
end
p00=-16.7;
p10=-2.529;
p01=9403;
p20=0.03547;
p11=-12.6;
p02=-2339;
Fz=p00+p10*v+p01*s+p20*v.^2+p11*v.*s+p02*s.^2;
end
Folosirea funcției functieAproxFz(v,s) pentru estimarea forței principale de așchiere Fz pentru

viteza de așchiere v=72 m/min și un avans s=0.6 mm/rot:
[Fz]=functieAproxFz(72,0.6)
Fz =
4.2405e+03
Bibliografie
CURS 9
GĂSIREA VALORILOR MINIME ȘI ZERO ALE FUNCȚIILOR
Funcțiile folosite în problemele de găsire a valorilor minime și zero ale funcțiilor sunt:
fminbnd
Găsește minimul absolut al funcțiilor de o singură variabilă
reală supuse la constrângeri
fminsearch
Găsește un minim local al funcțiilor de mai multe variabile
reale nesupuse la constrângeri
fmincon
Găsește un minim local al funcțiilor de mai multe variabile
reale supuse la constrângeri
fzero Găsește zeroul funcțiilor de o singură variabilă reală
Condiție: funcția trebuie să fie continuă pe intervalul considerat!!!

1. Găsirea minimului absolut al funcțiilor de o variabilă reală supuse la constrângeri
Se utilizează funcția fminbnd
Sintaxe:
[X,Fmin]=fminbnd(@numeFunctie,x1,x2) returnează valoarea X a variabilei pentru care
funcția FUN(x) este minimă în intervalul x1<x<x2 și valoarea minimului absolut al funcției,
Fmin în punctul X. numeFunctie este numele fișierului .m care conține funcția pentru care
se caută minimul absolut
[X,Fmin]=fminbnd(@numeFunctie,x1,x2,optimset('optiuni')); opțiunile disponibile
sunt: Display, FunValCheck, MaxFunEval, MaxIter, OutputFcn, PlotFcns, TolX (vezi
help-ul pentru funcția optimset)
[X,Fmin,exitflag]=fminbnd(...) vezi help-ul

[X,Fmin,exitflag,output]=fminbnd(...) vezi help-ul
Observații:
1. fminbnd se bazează pe metoda secțiunii de aur și pe interpolarea parabolică
2. cu excepția cazului în care x1 este foarte aproape de x2, fminbnd nu evaluează funcția
obiectiv pentru x1 și x2, adică xϵ(x1,x2); dacă minimul are loc pentru x1 sau x2,
fminbnd returnează un punct interior al intervalului (x1,x2), la o distanță nu mai mare de
2×TolX de x1 sau de x2
3. fminbnd prezintă adesea convergență lentă atunci când soluția coincide cu una din limitele
intervalului x1 sau x2
Exemplul 1:
1. definirea funcției pentru care dorim să găsim minimul absolut:
function [f]=functieDeMinimizat(x)
f=0;
for k=-10:10
f=f+(k+1)^2*cos(k*x)*exp(-k^2/2);
end
2. găsirea valorii minime în intervalul xϵ(1,5):

[X,Fmin]=fminbnd(@functieDeMinimizat,1,5)
X =
2.0061
Fmin =
-0.6828
2
1.5
0.5
-0.5
A minim
-1
1 1.5 2 2.5 3 3.5 4 4.5 5
Exemplul 2: Utilizarea funcției anonime

[X,Fmin]=fminbnd(@(x) (x+1)/10+sin(x),0,4*pi)%x=var. formala de intrare
X =
4.6122
Fmin =
-0.4338
1.5
0.5
 minim absolut
-0.5
0 2 4 6 8 10 12 14
Exemplul 3: Funcție dependentă de parametri (trebuie specificată variabila, respectiv parametrii)

a1=2;
a2=3;
[X,Fmin]=fminbnd(@(x) a1*(x+1)/10+a2*sin(x),0,4*pi)
X =
4.6457
Fmin =
-1.8642
5
-1
-2  minim absolut
0 2 4 6 8 10 12 14
Exemplul 4: Utilizarea opțiunilor

[X,Fmin]=fminbnd(@(x) x^2-3*x*sqrt(1+x)+cos(x)*(sin(x)^2)+12,1,10,...
optimset('Display','iter','TolX',1e-12))
Func-count x f(x) Procedure
1 4.43769 0.397239 initial
2 6.56231 0.998498 golden
3 3.12461 2.72546 golden
4 5.26342 0.565627 parabolic

5 3.93614 0.901213 golden
6 4.7386 0.426036 parabolic
7 4.35609 0.424957 parabolic
8 4.5461 0.387623 parabolic
9 4.52548 0.387322 parabolic
10 4.52959 0.387308 parabolic
11 4.5291 0.387308 parabolic
12 4.52907 0.387308 parabolic
13 4.52907 0.387308 parabolic
14 4.52907 0.387308 parabolic
15 4.52907 0.387308 parabolic
Optimization terminated:
the current x satisfies the termination criteria using OPTIONS.TolX of
1.000000e-012
X =
4.5291
Fmin =
0.3873
14
12
10
 minim absolut
0
1 2 3 4 5 6 7 8 9 10
2. Găsirea unui minim local al funcțiilor de mai multe variabile reale nesupuse la constrângeri
Se utilizează funcția fminsearch
Sintaxe:
[X,Fmin]=fminsearch(@numeFunctie,X0) returnează valorile xi (i=1...n) în vectorul X,
pentru care funcția numeFunctie(x1,x2,...,xn) prezintă un minim local și valoarea
minimului local al funcției, Fmin; X0 reprezintă valoarea de start a căutării (X0 poate fi
scalar, vector sau matrice); numeFunctie este numele fișierului .m în care a fost definită
funcția pentru care se caută un minim local
[X,Fmin]=fminsearch(@numeFunctie,X0,optimset('optiuni')) opțiuni disponibile:
Display, FunValCheck, MaxFunEval, MaxIter, OutputFcn, PlotFcns, TolFun, TolX,
(vezi help-ul pentru funcția optimset)
[X,Fmin,exitflag]=fminsearch(...) vezi help-ul
[X,Fmin,exitflag,output]=fminsearch(...) vezi help-ul
Observații:
1. fminsearch se bazează pe algoritmul simplex (metodă iterativă în care se pleacă de la o soluție
admisibilă inițială și se construiesc alte soluții până când se găsește un minim local)
2. În Matlab variabilele vor fi notate cu x(1), x(2), x(3), ...
Exemplul 1: găsirea unui minim local pentru o funcție de 1 variabilă

a. pentru valoarea de start X0=2
[X,Fmin]=fminsearch(@(x) (x+1)/10+sin(x),2)
X =
4.6122
Fmin =
-0.4338
b. pentru valoarea de start X0=10

[X,Fmin]=fminsearch(@(x) (x+1)/10+sin(x),10)
X =
10.8954
Fmin =
0.1946
3
2.5
1.5
0.5
 minim local 2
0
-0.5  minim local 1=minim absolut

0 2 4 6 8 10 12 14 16
2
 a 
Exemplul 2: Să se găsească minimul local pentru funcția F ( x,y,z ) =  y - x a1 + 2  + ( z2 + x ) în jurul
2
 z 
punctelor x=0, y=0, z=0 pentru a1=3 și a2=2 (funcția este de 3 variabile și depinde de 2
parametri).
Conform notației din Matlab, vom nota variabila x cu x(1), variabila y cu x(2), respectiv variabila z
cu x(3).
a1=3;
a2=2;
X0=[0,0,0];
[X,Fmin]=fminsearch(@(x) (x(2)-x(1)^a1+a2/x(3))^2+(x(3)^2+x(1))^2,X0)
X =
-1.0658 -3.1480 1.0324
Fmin =
4.4605e-013 → 0
3. Găsirea unui minim local al funcțiilor de mai multe variabile reale supuse la constrângeri
Găsește vectorul X=[x1,x2,…,xn] care definește minimul local al unei funcții de mai multe variabile
f(X) supusă la:
✓ constrângeri de mărginire: xi min  xi  xi max, i = 1,2,…,n
✓ constrângeri de tip inegalitate: gj ( X )  bj, j= 1,2,…,m
✓ constrângeri de tip egalitate: hk ( X ) = beqk, k = 1,2,…,p
Constrângerile de tip inegalitate sau egalitate pot fi liniare sau neliniare.

Definirea constrângerilor
✓ constrângerile de mărginire se definesc prin doi vectori coloană:
LB = x1min;x2min;…;xnmin  (vectorul valorilor minime ale variabilelor)
UB = x1max;x2max;…;xnmax  (vectorul valorilor maxime ale variabilelor)
✓ constrângerile liniare de tip inegalitate sau egalitate se exprimă în format matricial:

- de tip inegalitate: A∙X≤b
- de tip egalitate: Aeq∙X=beq
În aplicație se utilizează matricele A și Aeq, respectiv vectorii coloană b și beq. De exemplu,

o funcție de 3 variabile x1, x2 și x3 cu 2 constrângeri de tip inegalitate:
a11  x1 + a12  x2 + a13  x3  b1
a21  x1 +a22  x2 +a23  x3  b2

În limbaj Matlab se scriu astfel:

A = a11,a12,a13;a21,a22,a23  ; b =  b1;b2 
Analog pentru constrângerile de tip egalitate:

✓ constrângerile neliniare de tip inegalitate sau egalitate se scriu într-o funcție Matlab (de
exemplu constrFunctie.m) care are ca argument de intrare vectorul variabilelor X și
argumente de ieșire vectorii c și ceq:
- inegalitățile neliniare sunt de forma: c≤0
- egalitățile neliniare sunt de forma: ceq=0
Minimul unei funcții de mai multe variabile supuse la constrângeri se găsește cu funcția fmincon.
Sintaxe:
[X,Fmin]=fmincon(@numeFunctie,X0) returnează vectorul care conține valorile X ale
variabilelor pentru care funcția prezintă un minim local și valoarea minimului local Fmin al
funcției numeFunctie nesupusă la restricții; X0 reprezintă valoarea de start a căutării
[X,Fmin]=fmincon(@numeFunctie,X0,A,b) returnează vectorul care conține valorile X ale
variabilelor pentru care funcția prezintă un minim local și valoarea minimului local Fmin al
funcției numeFunctie supusă doar la restricții liniare de tip inegalitate A∙x≤b
[X,Fmin]=fmincon(@numeFunctie,X0,A,b,Aeq,beq) returnează vectorul care conține
valorile X ale variabilelor pentru care funcția prezintă un minim local și valoarea minimului local
Fmin al funcției numeFunctie supusă și la restricții liniare de tip egalitate Aeq∙x=beq (se
setează A=[] și b=[] în cazul în care nu există restricții liniare de tip inegalitate)
[X,Fmin]=fmincon(@numeFunctie,X0,A,b,Aeq,beq,LB,UB) returnează vectorul care conține
valorile X ale variabilelor pentru care funcția prezintă un minim local și valoarea minimului local
Fmin al funcției numeFunctie supusă și la constrângeri de mărginire LB  x  UB (se setează
A=[] și b=[] în cazul în care nu există restricții liniare de tip inegalitate; se setează Aeq=[] și
beq=[] în cazul în care nu există restricții liniare de tip egalitate)
[X,Fmin]=fmincon(@numeFunctie,X0,A,b,Aeq,beq,LB,UB,constrNelFunctie) returnează
vectorul care conține valorile X ale variabilelor pentru care funcția prezintă un minim local și
valoarea minimului local Fmin al funcției numeFunctie supusă și la constrângeri neliniare de
tip inegalitate și/sau egalitate care se scriu într-o funcție constrNelFunctie.m având
argumentul de intrare vectorul variabilelor X și argumente de ieșire vectorii c și ceq (se
setează A=[] și b=[] în cazul în care nu există restricții liniare de tip inegalitate; se setează
Aeq=[] și beq=[] în cazul în care nu există restricții liniare de tip egalitate; se setează LB=[]
și UB=[] în cazul în care nu există constrângeri de mărginire)
[X,Fmin]=fmincon(@numeFunctie,X0,A,b,Aeq,beq,LB,UB,constrNelFunctie,options)
returnează vectorul care conține valorile X ale variabilelor pentru care funcția prezintă un minim
local și valoarea minimului local Fmin al funcției numeFunctie cu parametrii de optimizare
implicite înlocuite cu valorile din structura options; se utilizează optimoptions pentru a seta
aceste opțiuni (se setează A=[] și b=[] în cazul în care nu există restricții liniare de tip
inegalitate; se setează Aeq=[] și beq=[] în cazul în care nu există restricții liniare de tip
egalitate; se setează LB=[] și UB=[] în cazul în care nu există constrângeri de mărginire; se
setează constrNelFunctie=[] în cazul în care nu există constrângeri neliniare de tip inegalitate
sau egalitate)
[X,Fmin,exitflag]=fmincon(...) returnează exitflag (vezi help-ul)
[X,Fmin,exitflag,output]=fmincon(...) vezi help-ul
( )
Exemplu: Să se găsească minimul funcției F ( x,y ) = ex  4  x 2 + 2  y2 + 4  x  y + 2  y + a1 , cu variabilele
x și y reale, supusă la următoarele constrângeri:
1. de mărginire: x   −100, 20  , y   −10, 60 
2. liniare de tip inegalitate:

3  x + 1  y  −5
1 x + 2 y  7
3. neliniare de tip inegalitate:
x  y − x − y + 1,5  0
−x  y − a2  0
Valorile parametrilor sunt: a1 = 1 și a2 = 10

Notăm variabila x cu X(1), respectiv variabila y cu X(2).
Funcția pentru care se caută minimul local:
function [F]=Exemplu(X,a1)
F=exp(X(1))*(4*X(1)^2+2*X(2)^2+4*X(1)*X(2)+2*X(2)+a1);
end
Funcția restricțiilor neliniare:

function [c,ceq]=constrNelExemplu(X,a2)
c=[X(1)*X(2)-X(1)-X(2)+1.5;-X(1)*X(2)-a2];
ceq=[];%nu exista constangeri neliniare de tip egalitate
end
Apelarea funcției fmincon pentru funcția Exemplu:

a1=1;a2=10;
X0=[0,0];
A=[3 1;1 2];b=[-5;7];Aeq=[];beq=[];LB=[-100;-10];UB=[20;60];
[X,Fmin]=fmincon(@(X)Exemplu(X,a1),X0,A,b,Aeq,beq,LB,UB,@(X)constrNelExemplu(
X,a2))
Local minimum found that satisfies the constraints.

Optimization completed because the objective function is non-decreasing in
feasible directions, to within the default value of the optimality tolerance,
and constraints are satisfied to within the default value of the constraint
tolerance.
<stopping criteria details>
X =
-9.5473 1.0474
Fmin =
0.0236
4. Găsirea zeroului funcțiilor de o variabilă reală

Se folosește funcția fzero
Sintaxe:
[x,VALFUN]=fzero(@FUN,x0) returnează cea mai apropiată valoare x de estimația x0 în care
funcția FUN este zero și valoarea funcției VALFUN; @FUN este un șir care conține numele
fișierului .m în care se găsește funcția de minimizat; x0 poate fi scalar, sau vector cu 2 elemente;
dacă x0 este vector cu două elemente, atunci fzero caută zeroul funcției în intervalul
[x0(1), x0(2)], cu condiția ca sign(FUN(x0(1)))≠sign(FUN(x0(2)))
[x,VALFUN]=fzero(@FUN,x0,optimset('optiuni')) opțiuni disponibile: Display,

FunValCheck, OutputFcn, PlotFcns, TolX (vezi help-ul pentru funcția optimset)
[x,VALFUN,exitflag]=fzero(...) vezi help-ul

[x,VALFUN,exitflag,output]=fzero(...) vezi help-ul
x +1
Exemplu: Să se găsească zeroul funcției f ( x ) = + sin ( x ) în jurul valorilor x0=2 și x0=6, respectiv
10
pe intervalul (2, 6).
a. pentru valoarea de start x0=2
[x,F]=fzero(@(x) (x+1)/10+sin(x),2)
x =
3.6221
F =
-5.5511e-017 → 0
1.5
0.5
0  zero
-0.5
0 2 4 6 8 10 12 14
b. pentru valoarea de start x0=6

[x,F]=fzero(@(x) (x+1)/10+sin(x),6)
x =
5.5668
F =
2.9190e-012 → 0
2
1.5
0.5
0  zero
-0.5
0 2 4 6 8 10 12 14
c. pentru intervalul [2,6]

[x,F]=fzero(@(x) (x+1)/10+sin(x),[2,6] )
??? Error using ==> fzero at 283
The function values at the interval endpoints must differ in sign.
d. pentru intervalul [2,4]

[x,F]=fzero(@(x) (x+1)/10+sin(x),[2,4])
x =
3.6221
F =
1.3323e-015 → 0
Limitări ale funcției fzero:

1. Dacă funcția FUN nu este continuă, fzero returnează valoarea punctului în care se produce
discontinuitatea
Exemplul 3:
[x,F]=fzero(@tan,2)
x =
1.5708
F =
1.0533e+015→ inf
2. Comanda fzero definește un zero ca un punct în care funcția traversează axa x. Punctele în care
funcția este doar tangentă la axa x, nu sunt zerouri valabile. Pentru funcții cu zero nevalabil, fzero
rulează până când Inf, Nan, sau o valoare complexă este detectată
Exemplul 4:
x=fzero(@(x) x^2,1)
Exiting fzero: aborting search for an interval containing a sign change because
NaN or Inf function value encountered during search.
(Function value at -1.7162e+154 is Inf.)
Check function or try again with a different starting value.
x =
NaN
9
0  curba este tangenta la axa x

-3 -2 -1 0 1 2 3
5. Instrumentul MATLAB optimtool

Se tastează în Command Window instrucțiunea optimtool.
Bibliografie
CURS 10
CALCUL SIMBOLIC ÎN MATLAB
În calcule inginerești se utilizează frecvent expresii simbolice. MATLAB-ul folosește Symbolic Math
Toolbox care conține un grup de instrumente matematice simbolice folosit pentru crearea și
operarea cu expresii matematice simbolice. Acesta conține sute de funcții simbolice MATLAB
utilizate pentru derivare, integrare, simplificări, transformări, rezolvări de ecuații și sisteme de
ecuații, inclusiv diferențiale etc.
Calculul simbolic operează cu obiecte simbolice: variabile, matrice și expresii simbolice.
1. Definirea variabilelor
Variabilele simbolice pot fi definite în două moduri:
 cu funcția sym este definit un număr, variabilă și obiect simbolic, iar cu funcția syms pot fi
definite mai multe numere, variabile și obiecte simbolice
 orice variabilă care primește ca valoare o expresie simbolică prin folosirea operatorului =
devine o variabilă simbolică
A. Funcția sym poate fi apelată cu una din sintaxele:
Sintaxa v=sym('v') creează variabila simbolică v:
x=sym('x')
Sintaxa v=sym('v','set') creează variabila simbolică v și se stabilește că ea aparține unei

mulțimi (set poate fi real, positive, integer, rational):
y=sym('y','real');
z=sym('z','positive');
u=sym('u','integer');
w=sym('w','rational');
Funcția assumptions verifică mulțimea căreia îi aparține una sau mai multe variabile:
assumptions(z)
ans =
0 < z
assumptions([u w])
ans =
[ in(u, 'integer'), in(w, 'rational')]
Sintaxa sym('v','clear') șterge ipoteza stabilită anterior pentru variabila simbolică v (real,
positive, integer, rational):
sym('y','clear')
Funcția assume(v,'set') setează faptul că variabila simbolică v definită anterior aparține unei
mulțimi (set poate fi real, positive, integer, rational):
y=sym('y');
assume(y,'integer')
assumptions(y)
ans =
in(y, 'integer')
Sintaxa assume(v,'clear') șterge ipoteza stabilită anterior pentru variabila simbolică v (real,
positive, integer, rational):
assume([y,'clear')
Funcția assume, respectiv funcția assumeAlso pot asuma condiții matematice:

assume(COND1) setează condiția COND1 ca fiind adevărată
assumeAlso(COND2) setează condiția COND2 ca fiind adevărată pe lângă ipoteza anterioară
Exemple:
x=sym('x');
assume(x>2)
assumeAlso(x<10)
assumptions(x)
ans =
[ x < 10, 2 < x]
Funcția isAlways(AM) testează (verifică) o afirmație matematică (dacă afirmația este adevărată
returnează 1, dacă este falsă returnează 0):
Exemple:
x=sym('x');
assume(x>2)
assumeAlso(x<10)
isAlways(sqrt(x)<4)
ans =
1
Sintaxa Sim=sym(Num) convertește un scalar sau tablou numeric la forma simbolică:

A=[1 2 3;4 5 6];
A=sym(A)
A =
[ 1, 2, 3]
[ 4, 5, 6]
Sintaxa Sim=sym(Num,'flag') convertește un scalar, vector sau matrice numerică Num la forma
simbolică Sim, argumentul flag specificând tehnica de conversie a numerelor în virgulă mobilă
folosind una dintre următoarele caractere: r, d, f:
a. r vine de la "rațional" care reprezintă opțiunea implicită (default):
a=sym(1/3,'r')
a =
1/3
b=sym(1+sqrt(5),'r')
b =
910872158600853/281474976710656
b. d vine de la "decimal" = zecimală: numărul de cifre este definit de setarea curentă a cifrelor
utilizate de către vpa (Variable-precision arithmetic); utilizarea a mai puțin de 16 cifre
poate duce la o pierdere oarecare a acurateței, în timp ce mai mult de 16 cifre ar putea să fie
nejustificată:
digits(10);
sym(1/3,'d')
ans =
0.3333333333
digits(20);
sym(1/3,'d')
ans =
0.33333333333333331483
c. f vine de la "floating-point":
sym(pi,'f')
ans =
3.141592654
Sintaxa M=sym('M',dim) creează un tablou având elemente de tip simbolic. Numele elementelor
generate ale unui vector utilizează forma vk, iar cele ale unei matrice utilizează forma Mi_j.
a=sym('a',[1 5])
a =
[ a1, a2, a3, a4, a5]
A=sym('A',[2,3])
A =
[ A1_1, A1_2, A1_3]
[ A2_1, A2_2, A2_3]
Sintaxa M=sym('M%d%d',dim) specifică forma Mij pentru numele elementelor unei matrice:
B=sym('B%d%d',[2 3])
B =
[ B11, B12, B13]
[ B21, B22, B23]
Sintaxa M=sym('M',dim,'set') stabilește faptul că toate elementele tabloului M aparțin mulțimii

set (set poate fi real, positive, integer, rational):
a=sym('a',[1 5],'real');
assumptions(a)
ans =
[ in(a1, 'real'), in(a2, 'real'), in(a3, 'real'), in(a4, 'real'), in(a5,
'real')]
B=sym('B%d%d',[2 3],'positive');
assumptions(B)
ans =
[ 0 < B21, 0 < B11, 0 < B22, 0 < B12, 0 < B23, 0 < B13]
Funcția assume(M,'set') stabilește faptul că toate elementele matricei M aparțin mulțimii set
(set poate fi real, positive, integer, rational), unde M este un vector sau o matrice
simbolică definită anterior:
B=sym('B%d%d',[2 3]);
assumptions(B)
ans =
Empty sym: 1-by-0
assume(B,'positive')
assumptions(B)
ans =
[ 0 < B21, 0 < B11, 0 < B22, 0 < B12, 0 < B23, 0 < B13]
Pentru a afișa o expresie simbolică într-un format apropiat de cel din matematică se utilizează funcția
pretty(Sim) al cărei parametru de intrare este chiar expresia simbolică:
pretty(A)
/ 1, 2, 3 \
| |
\ 4, 5, 6 /
Sintaxa f=sym('f(arg1,...,argN)') creează funcția simbolică f și precizează că arg1,...,

argN sunt argumentele de intrare ale funcției f. Această sintaxă nu creează variabile simbolice
arg1,...,argN, acestea trebuind a fi definite anterior:
x=sym('x');
y=sym('y');
f=sym('f(x,y)')
f =
f(x, y)
B. Funcția syms poate fi apelată cu una din sintaxele:

Sintaxa syms v1 ... vN creează variabile simbolice v1 ... vN:
syms x y z
Sintaxa syms v1 ... vN set creează variabile simbolice v1 ... vN și afirmă că acestea aparțin
mulțimii set (set poate fi real, positive, integer, rational):
syms x y z real
Sintaxa syms v1 ... vN clear elimină ipotezele stabilite anterior pentru variabile simbolice
v1 ... vN:
syms x y z clear
2. Definirea expresiilor simbolice

Expresiile simbolice se definesc la fel ca expresiile numerice din Matlab, în care variabilele numerice
sunt înlocuite cu variabile simbolice. Sunt incluse tablourile cu elemente expresii simbolice, asupra
cărora se pot efectua calcule simbolice similare calculelor numerice din Matlab. Expresiile simbolice
au ca termeni variabile simbolice și funcții simbolice, iar ca operatori aritmetici: +, -, *, /, \,
^ . Prioritățile operatorilor aritmetici sunt cele cunoscute. În cadrul expresiilor aritmetice se
utilizează parantezele rotunde () pentru a modifica prioritățile operatorilor.
Exemplul 1. Să se definească variabilele simbolice x, y, cu funcția syms și să se inițializeze
variabila z cu expresia simbolică x∙y, respectiv variabila w cu expresia simbolică w=x+y
syms x y %x, y sunt definite ca variabile simbolice
z=x*y %x, y fiind variabile simbolice => z este variabila simbolica
w=x+y %x, y fiind variabile simbolice => w este variabila simbolica
z =
x*y
w =
x + y
Exemplul 2. Să se definească funcția simbolică f = a∙x3 + b∙x2 + c∙x + d

varianta 1: syms x a b c d
f=a*x^3+b*x^2+c*x+d
f =
a*x^3 + b*x^2 + c*x + d
varianta 2: syms x a b c d
f=sym('a*x^3+b*x^2+c*x+d')
f =
a*x^3 + b*x^2 + c*x + d
3. Definirea variabilelor simbolice complexe

Se folosește funcția syms cu opțiunea real, sau sym cu aceeași opțiune:
varianta 1: syms x y real
z=x+i*y
z =
x + y*i
varianta 2: x=sym('x','real');
y=sym('y','real');
z=x+i*y
z =
x + y*i
În expresiile cu variabile complexe pot fi utilizate funcțiile matematice standard: real, imag,
conj, abs etc.
4. Crearea funcțiilor abstracte

În multe cazuri este avantajos să se creeze o funcție abstractă (nedeterminată) care acționează
asupra obiectelor simbolice, ca mai apoi să poate fi utilizată în alte expresii.
f ( x + delta ) − f ( x )
Pentru a crea expresia simbolică f = scriem următorul cod:
delta
syms x delta
delta_f=(sym('f(x+delta)')-sym('f(x)'))/delta
delta_f =
(f(delta + x) - f(x))/delta
5. Substituții
Există situații când se impune înlocuirea variabilelor simbolice cu altele, sau să atribuim acestora
valori numerice, în acest caz, expresiile simbolice fiind evaluate la valoarea numerică
corespunzătoare.
Aceste substituții ale variabilelor simbolice se fac cu funcția subs.
Sintaxe:
subs(expresie_simbolica,{var_simbolice_substituite},{var_simbolice_noi})
subs(expresie_simbolica,{var_simbolice_substituite},{val_numerice})
Exemple:
syms t y
g=t+y
syms a
h=subs(g,{t},{a})
h =
a + y
syms t y
g=t+y;
syms a b
h=subs(g,{t},{a,b})
h =
[ a + y, b + y]
syms t y
g=t+y+1
h=subs(g,{t},{2,3})
h =
[ y + 3, y + 4]
syms x y z
f=x+y+z;
syms u v
g=subs(f,{x,y},{u,v})
g =
u + v + z
syms x y z
f=x+y+z
g=subs(f,{x,y},{1,[4,5]})
g =
[ z + 5, z + 6]
Exemplu. Fie funcția f(x, y) = x2 – 6 ∙ ln(y) + 7. Să se substituie variabila simbolică x cu valoarea 5,

respectiv y cu 10.
syms x y
f=x^2-6*log(y)+7;
g=subs(f,{x,y},{5,10})
g =
32 - 6*log(10)
6. Conversia valorilor simbolice în valori numerice cu dublă precizie

Se observă că în ultimul exemplu nu a fost realizat calculul numeric al expresiei simbolice
32 - 6*log(10).
Funcția double(S) convertește valoarea simbolică S într-o valoare numerică în dublă precizie.
syms x y
f=x^2-6*log(y)+7;
g=subs(f,{x,y},{5,10})
gNum=double(g)
g =
32 - 6*log(10)
gNum =
18.1845
7. Determinarea variabilelor simbolice din expresii și matrice

Variabilele simbolice dintr-o expresie pot fi determinate cu funcția findsym.
Sintaxa findsym(S) returnează toate variabilele simbolice din expresia simbolică S, în ordine
alfabetică, separate prin virgule. Dacă S nu conține nicio variabilă, findsym returnează un șir gol.
syms x y z u v
f=x+y+z;
g=u/v;
findsym(f)
ans =
x,y,z
8. Dezvoltări și simplificări
Funcția expand aplică dezvoltarea polinoamelor, funcțiilor exponențiale, logaritmice,
trigonometrice.
Sintaxa: E=expand(S)
Tabelul 1. Câteva exemple
S expand(S)
a*(x+y) a*x+a*y
a*(x-y) a*x–a*y
a^(x+y) a^x*a^y
a^(x-y) a^x/a^y
exp(a+b) exp(a)*exp(b)
exp(a-b) exp(a)/exp(b)
log(x*y) log(x)+log(y)
log(x/y) log(x)–log(y)
log(a^y) y*log(a)
sin(a+b) sin(a)*cos(b)+cos(a)*sin(b)
sin(2*asin(a)) 2*a*(1-a^2)^(1/2)
Observație: la dezvoltarea logaritmilor argumentele trebuie să fie pozitive.

Exemplu. Fie funcțiile simbolice f(y, z) = y2 – 6 ∙ ln(z) + 7 și g(y, z, w) = y + z ∙ sin(w). Să se dezvolte
funcția simbolică h(y, z, w) = f(y, z) ∙ g(y, z, w).
syms y z w
f=y^2-6*log(z)+7;
g=y+z*sin(w);
h=expand(f*g)
h =
7*y - 6*y*log(z) + 7*z*sin(w) + y^3 + y^2*z*sin(w) - 6*z*log(z)*sin(w)
Funcția simplify realizează aducerea la o formă mai simplă a polinoamelor, funcțiilor exponențiale
și logaritmice, funcțiilor trigonometrice.
Sintaxa: R=simplify(S)
Tabelul 2. Câteva exemple
S simplify(S)
sin(x)^2+cos(x)^2 1
a^x*a^y a^(x+y)
a^x/a^y a^(x-y)
exp(a)*exp(b) exp(a+b)
exp(a)/exp(b) exp(a–b)
exp(log(x)) x
log(exp(x) x
x 2 + 5x + 6
Exemplu. Să se aducă la o formă mai simplă expresia
x +2
syms x
r=simplify((x^2 + 5*x + 6)/(x + 2))
r =
x + 3
9. Operații cu matrice simbolice

Matricele simbolice au ca elemente obiecte simbolice, constante, variabile sau expresii simbolice.
Operațiile cu matrice se efectuează cu operatorii +, -, *, /, \, ^, .*, ./, .\, .^ .
Semnificația operatorilor +, - este cea de adunare și scădere a matricelor cu dimensiuni
corespunzătoare. Semnificația celorlalți operatori este cea din tabelul 3.
Tabelul 3. Semnificația operatorilor
Operator Exemplu Semnificație
* A*B A*B
/ A/B A*inv(B)
\ A\B inv(A)*B
^ A^B AB
.* C=A.*B Cij=Aij*Bij
./ C=A./B Cij=Aij/Bij
.\ C=A.\B Cij=Bij/Aij
.^ C=A.^B Cij=Aij^Bij
Elementele matricelor simbolice se adresează cu indici în același fel ca elementele matricelor

numerice, iar funcțiile specifice manipulării matricelor numerice sunt aplicate și matricelor simbolice.
Matricele simbolice pot fi definite în două moduri:
 matrice cu elemente simbolice
 convertirea matricelor numerice în matrice simbolice cu funcția sym
Exemplul 1. Să se definească matricea M de dimensiune 2×2, cu elemente simbolice și să se

calculeze determinantul și inversa acesteia.
M=sym('M%d%d',2)
det_M=det(M)
inv_M=inv(M)
pretty(inv_M)
M =
[ M11, M12]
[ M21, M22]
det_M =
M11*M22 - M12*M21
inv_M =
[ M22/(M11*M22 - M12*M21), -M12/(M11*M22 - M12*M21)]
[ -M21/(M11*M22 - M12*M21), M11/(M11*M22 - M12*M21)]
/ M22 M12 \
| -----------------, - ----------------- |
| M11 M22 - M12 M21 M11 M22 - M12 M21 |
| |
| M21 M11 |
| - -----------------, ----------------- |
\ M11 M22 - M12 M21 M11 M22 - M12 M21 /
a 0  a b 
Exemplul 2. Să se definească matricele simbolice  ,   . Să se calculeze suma și produsul
c d  c 0 
lor.
syms a b c d
M1=[a 0;c d]
M2=[a b;c 0]
S=M1+M2
P=M1*M2
M1 =
[ a, 0]
[ c, d]
M2 =
[ a, b]
[ c, 0]
S =
[ 2*a, b]
[ 2*c, d]
P =
[ a^2, a*b]
[ a*c + c*d, b*c]
a + i  b b 
Exemplul 3. Să se definească matricea simbolică cu elemente complexe  și să se
 c d − i  c 
calculeze determinantul, inversa și conjugata acesteia.
syms a b c d real
M=[a+i*b b;c d-i*c]
det_M=det(M)
inv_M=inv(M)
conj_M=conj(M)
M =
[ a + b*i, b]
[ c, d - c*i]
det_M =
a*d - a*c*i + b*d*i
inv_M =
[ -(c*i - d)/(a*d - a*c*i + b*d*i), -b/(a*d - a*c*i + b*d*i)]
[ -c/(a*d - a*c*i + b*d*i), (a + b*i)/(a*d - a*c*i + b*d*i)]
[ a - b*i, b]
[ c, d + c*i]
10. Limite de funcții simbolice

Pentru a calculul limitelor funcțiilor simbolice se utilizează funcția limit.
Sintaxe:
limit(expr,v,a) calculează limita bidirecțională a expresiei simbolice expr atunci când
variabila v tinde către a
limit(expr,v,a,'left') calculează limita expresiei simbolice expr atunci când variabila v
tinde dinspre stânga către a
limit(expr,v,a,'right') calculează limita expresiei simbolice expr atunci când variabila
v tinde dinspre dreapta către a
x x
 a  a
Exemplul 1. Să se calculeze lim  1 +  și lim  1 +  .
x →0
 x x →
 x
syms x a real
f=(1+a/x)^x;
limit(f,x,0) %variabila implicita este x care tinde catre 0
limit(f,x,Inf) %variabila implicita este x care tinde catre Inf
ans =
1
ans =
exp(a)
Exemplul 2. Să se calculeze limita lim

( ) ( ) , adică derivata funcției cos.
cos x + D - cos x
D®0 D
syms x delta real
g=(cos(x+delta)-cos(x))/delta;
lim=limit(g,delta,0)
lim =
-sin(x)
( )
Exemplul 3. Să se calculeze limitele laterale ale funcției h(x) = 1/ x2 + x -2 în punctul x=1.
syms x real
h=1/(x^2+x-2);
[limit(h,x,1,'left'), limit(h,x,1,'right')]
ans =
[ -Inf, Inf]
11. Derivarea funcțiilor simbolice

Calculul derivatei simbolice se face cu funcția diff care poate calcula derivatele funcțiilor simbolice
de una sau mai multe variabile (derivate de ordinul întâi sau de ordin superior).
Sintaxe:
diff(expr,v,n) calculează derivata de ordinul n, respectiv derivata parțială de ordinul n
pentru o funcție de mai multe variabile, a expresiei simbolice expr în raport cu variabila v
diff(expr,v1,v2,...) calculează derivata parțială mixtă în raport cu variabilele v1,v2,...
Exemplul 1. Să se determine derivata de ordinul întâi a funcției f(x) = tg(2∙x).
syms x real
f=tan(2*x);
f_prim=diff(f,x,1)
f_prim =
2*tan(2*x)^2 + 2
Exemplul 2. Să se determine derivatele parțiale de ordinul doi și derivata parțială mixtă a funcției
g(x,y) = x ∙ cos(y) - y ∙ cos(x).
syms x y real
g=x*cos(y)-y*cos(x);
g_sec_x=diff(g,x,2) %derivata partiala de ordinul 2 in raport de x
g_sec_y=diff(g,y,2) %derivata partiala de ordinul 2 in raport de y
g_part_xy=diff(g,x,y) %derivata partiala mixta in raport de x si y
g_sec_x =
y*cos(x)
g_sec_y =
-x*cos(y)
g_part_xy =
sin(x) - sin(y)
 x3 xy 
Exemplul 3. Să se calculeze derivatele parțiale de ordinul 1 ale matricei simbolice M =  
log(x) y 
 x 
(derivata unei matrice simbolice este matricea obținută prin derivarea fiecărui element).
syms x y real
M=[x^3 x^y;log10(x) y/x]
M_prim_x=diff(M,x,1)
M_prim_y=diff(M,y,1)
M =
[ x^3, x^y]
[ log(x)/log(10), y/x]
M_prim_x =
[ 3*x^2, x^(y - 1)*y]
[ 1/(x*log(10)), -y/x^2]
M_prim_y =
[ 0, x^y*log(x)]
[ 0, 1/x]
12. Integrarea funcțiilor simbolice

Integrarea simbolică se face cu funcția int care calculează integrale nedefinite (primitive) și definite.
Sintaxe:
int(expr,v) calculează integrala nedefinită a expresiei simbolice expr în raport cu variabila v
int(expr,v,a,b) calculează integrala definită pe domeniul [a, b] a expresiei simbolice expr
în raport cu variabila v
Exemplul 1. Să se calculeze integrala nedefinită a funcției f ( x ) = 2  x 4 + ln(x) − 5 .

syms x real
f=2*x^4+log(x)-5;
a=int(f,x)
a =
(x*(5*log(x) + 2*x^4 - 30))/5
Exemplul 2. Să se calculeze integrala nedefinită a funcției g ( x,y,z ) = x 4 + 1 / y 2 + ln(z) în raport cu x,

y, respectiv z.
syms x y z real
f=x^4+1/(y^2)+log(z);
a=int(f,x)
b=int(f,y)
c=int(f,z)
a =
x^5/5 + (log(z) + 1/y^2)*x
b =
x^4*y + y*log(z) - 1/y
c =
z/y^2 + z*(x^4 + log(z) - 1)
Exemplul 3. Să se calculeze integrala definită a funcției h ( x ) = x 4 + 1 / x 4 pe domeniul [2, 5].

syms x real
a=int(x^4+1/(x^4),x,2,5)
a =
618639/1000
Exemplul 4. Să se calculeze integrala definită a funcției p ( x ) = x 3 + x + 2 pe domeniul [a, b].

syms x a b real
p=x^3+x+2;
b=int(p,x,a,b)
b =
b*(b*(b^2/4 + 1/2) + 2) - a*(a*(a^2/4 + 1/2) + 2)
Calculul integralelor care depind de un parametru. Fie o funcție care depinde de un parametru. Dacă
parametrul este un număr real, pozitiv sau întreg, el trebuie declarat.

e
− ax2
Exemplul 5. Să se calculeze integrala definită dx , unde a>0.
−
syms x real
syms a positive
f=exp(-a*x^2);
r=int(f,x,-Inf,Inf)
r =
pi^(1/2)/a^(1/2)
13. Calculul sumelor simbolice

Pentru calculul simbolic al sumei se folosește funcția symsum.
Sintaxe:
symsum(expr,v) calculează suma expresiei simbolice expr în raport cu variabila v; variabila
v ia valori de la 0 la v-1
symsum(expr,v,m,n) calculează suma expresiei simbolice expr în raport cu variabila v care

ia valori variabila de la m la n
k −1 n n
Exemplul 1. Să se calculeze sumele s1 =  (k + 1) , s2 =  (k + 1) și s3 =  (k + 1) . Calculați ultimele
2
0 k =1 k =1
două sume și pentru n=100.

syms k n positive
s1=symsum(k+1,k)
pretty(s1)
s2=symsum(k+1,k,1,n)
pretty(s2)
subs(s2,n,100)
s3=symsum((k+1)^2,k,1,n)
pretty(s3)
subs(s3,{n},{100})
s1 =
k^2/2 + k/2
2
k k
-- + -
2 2
s2 =
n + (n*(n + 1))/2
n (n + 1)
n + ---------
2
ans =
5150
s3 =
((2*n + 3)*(n + 1)*(n + 2))/6 - 1
(2 n + 3) (n + 1) (n + 2)
------------------------- - 1
6
ans =
348550
syms k positive
s2=symsum(k+1,k,1,100)
s3=symsum((k+1)^2,k,1,100)
s2 =
5150
s3 =
348550
14. Rezolvarea simbolică a ecuațiilor algebrice

Rezolvarea simbolică a ecuațiilor și sistemelor algebrice se face cu funcția solve.
Sintaxe:
s=solve(eq,v) unde eq este o expresie simbolică (ex. x^2-1==0), apoi solve(eq) rezolvă
eq pentru variabila v
s=solve(eq1,eq2,...,eqn,v1,v2,...,vn) rezolvă sistemul de n ecuații pentru cele n

variabile v1,v2,...,vn
s=solve(...,'IgnoreAnalyticConstraints',val) controlează nivelul de rigoare
matematică pentru a utiliza sau nu constrângerile analitice ale soluției (reduceri de ramură, de
divizare prin zero etc.). Opțiunile pentru val sunt true sau false. Specificați false
pentru a utiliza cel mai înalt nivel de rigoare matematică în găsirea soluțiilor!!!. Modul implicit
este false
Sunt posibile trei moduri de returnare a rezultatelor:
1. Pentru o ecuație liniară (de ordinul I) soluția este o ieșire cu o singură valoare, iar în cazul
unei ecuații neliniare soluția rezultată este o ieșire cu valori multiple
2. Pentru un sistem de ecuații și un număr egal de ieșiri, rezultatele sunt sortate în ordine
alfabetică și alocate la ieșiri
3. Pentru un sistem de ecuații și o singură ieșire este returnată o structură care conține soluțiile
Atât în cazul rezolvării unei singure ecuații, cât și în cazul rezolvării unui sistem de ecuații, sunt
returnate soluții numerice doar dacă nu există soluții simbolice.
Exemplul 1. Să se determine soluțiile ecuației de gradul doi ax 2 + bx + c = 2

syms x a b c
s=solve(a*x^2+b*x+c==2,x)
s =
-(b + (b^2 + 8*a - 4*a*c)^(1/2))/(2*a)
-(b - (b^2 + 8*a - 4*a*c)^(1/2))/(2*a)
Exemplul 2. Să se rezolve ecuația transcendentă (nu are soluții simbolice) cos ( x ) + 2x − 2 = 0, x 

syms x real
r=double(solve(cos(x)+2*x-2==0,x))
r =
0.5824
Observație: funcția double(x) returnează valoarea de precizie dublă pentru x. Dacă x este deja
un scalar, vector sau matrice de precizie dublă, double nu are efect.
3x + y = 2
Exemplul 3. Să se rezolve sistemul neliniar de ecuații  , x,y 
4x + 5xy = 1
syms x y real
s=solve(3*x+y==2,4*x+5*x*y==1,x,y)
s =
x: [2x1 sym]
y: [2x1 sym]
s.x
s.y
ans =
34^(1/2)/15 + 7/15
7/15 - 34^(1/2)/15
ans =
3/5 - 34^(1/2)/5
34^(1/2)/5 + 3/5
x=double(s.x)
y=double(s.y)
x =
0.8554
0.0779
y =
-0.5662
1.7662
x + ay + b = 0
Exemplul 4. Să se rezolve sistemul de ecuații cu parametri:  , x,y,a,b 
y + bx + a = 0
syms x y a b real
s=solve(x+a*y+b==0,y+b*x+a==0,x,y)
x=s.x
y=s.y
s =
x: [1x1 sym]
y: [1x1 sym]
x =
(- a^2 + b)/(a*b - 1)
y =
(- b^2 + a)/(a*b - 1)
 y
x = ln  z  + 1
  
Exemplul 5. Să se rezolve sistemul neliniar de trei ecuații: y = 0,4 + z2 − 2x 2 , x,y,z 
 xy
z = 2 +
 20
syms x y z real
s=solve(x==log(y/z)+1,y==0.4+z^2-2*x^2,z==2+x*y/20,x,y,z)
x=double(s.x)
y=double(s.y)
z=double(s.z)
s =
x: [1x1 sym]
y: [1x1 sym]
z: [1x1 sym]
x =
3.5093
y =
-21.2451
z =
-1.7278
15. Rezolvarea simbolică a ecuațiilor diferențiale ordinare
Fie ecuația diferențială ordinară de ordinul întâi f ( x,y(x),y'(x) ) = 0 , unde x este variabila
independentă, iar y(x) este funcția necunoscută. Soluția generală a acestei ecuații diferențiale
depinde de o singură constantă arbitrară C. Dacă ne interesează o soluție a ecuației diferențiale care
la valoare inițială x0 trece prin punctul y0, constanta C ia valoarea y0.
În continuare vom presupune că soluția ecuației diferențiale există. În funcție de proprietățile
funcției f, soluția poate să fie unică sau nu.
Rezolvarea ecuațiilor diferențiale ordinare se face cu funcția dsolve care poate rezolva ecuații și
sisteme de ecuații diferențiale ordinare de ordinul întâi și de ordin superior.
Notații:
 funcția necunoscută este notată cu y(x)
 derivata este notată cu diff(y,n), unde n este ordinul derivatei funcției y
 condițiile inițiale și/ sau condițiile la limită, dacă există, au forma y(xi), Dy(xi),
D2y(xi),…, D(n-1)y(xi)
Sintaxe:
dsolve(eq) rezolvă simbolic ecuația diferențială ordinară eq fără condiții inițiale
dsolve(eq1,eq2,...) rezolvă simbolic sistemul de ecuații diferențiale ordinare eq1,eq2,...
fără condiții inițiale
dsolve(eq,cond1,cond2,...) rezolvă simbolic ecuația diferențială ordinară eq, cu condițiile
inițiale și/sau condițiile la limită cond1,cond2,...
dsolve(eq1,eq2,...,cond1,cond2,...) rezolvă simbolic ecuațiile diferențiale ordinare
eq1,eq2,..., cu condițiile inițiale și/sau condițiile la limită cond1,cond2,...
dsolve(...,'IgnoreAnalyticConstraints',val) controlează nivelul de rigoare

matematică pentru a utiliza sau nu constrângerile analitice ale soluției (reduceri de ramură, de
divizare prin zero etc.). Opțiunile pentru val sunt true sau false. Modul implicit este
true. Specificați false pentru a utiliza cel mai înalt nivel de rigoare matematică în găsirea
soluțiilor!!!
Notă: Dacă nu setați opțiunea IgnoreAnalyticConstraints la false, verificați întotdeauna
rezultatele returnate de comanda dsolve.
Sunt posibile trei moduri de returnare a rezultatelor:
1. Pentru o ecuație cu o soluție unică, este returnat rezultatul; pentru o ecuație cu mai multe
soluții, rezultatul este returnat într-un vector simbolic
2. Pentru mai multe ecuații și un număr egal de ieșiri, rezultatele sunt sortate în ordine
lexicografică și returnate
3. Pentru mai multe ecuații și o singură ieșire, este returnată o structură care conține soluțiile
În cazul în care nu există o soluție de tip explicit de forma y = g(x, C), Matlab-ul caută o soluție de tip
implicit de forma h(x, y, C) = 0, însoțită de un mesaj de avertisment. Dacă nu este găsită nici soluția
de tip implicit, va fi returnat un obiect simbolic gol, împreună cu un mesaj de avertisment. În unele
cazuri care implică ecuații diferențiale neliniare, rezultatul returnat poate să fie o ecuație
diferențială echivalentă de ordin mai mic sau chiar o integrală.
Exemplul 1. Fie ecuația diferențială y’’ + y = 0, variabila independentă fiind t (timpul).

1. Să se calculeze soluția generală a ecuației
syms y(t)
y=dsolve(diff(y,2)+y==0,'IgnoreAnalyticConstraints',false)
y =
C3*cos(t) + C4*sin(t)
2. Să se găsească soluția particulară care la momentul t=0 îndeplinește condițiile inițiale

y(0)=1 și y’(0)=-1
syms y(t)
Dy=diff(y,1)
y=dsolve(diff(y,2)+y==0,y(0)==1,Dy(0)==-1,'IgnoreAnalyticConstraints',false)
y =
cos(t) - sin(t)
Exemplul 2. Să se rezolve ecuația diferențială: y'' + 2y' + y = e2x + 2x + 1, variabila independentă fiind
x. Condițiile inițiale: y(0)=0, y’(0)=0
syms y(x)
Dy=diff(y,1);
y=dsolve(diff(y,2)+2*diff(y,1)+y==exp(2*x)+2*x+1,y(0)==0,Dy(0)==0,...
'IgnoreAnalyticConstraints',false)
pretty(y)
y =
3*x + 26/(9*exp(x)) + exp(2*x)/9 + (2*x)/(3*exp(x)) - (x*exp(2*x))/3 +
(x*(6*x + exp(2*x) - 3))/3 - 2*x^2 – 3
Exemplul 3. Se consideră arborele elastic din figură.

Să se rezolve:
1. ecuația diferențială a mișcării vibratorii libere y(t) din
figură fără condiții inițiale:
y +p2  y = 0
2. ecuația diferențială a mișcării vibratorii libere cu condițiile inițiale y(0)=1mm, și y’(0)=0m/s
3. să se traseze graficul pentru tЄ[0, 10] secunde, unde: a=0,6m, b=0,4m, d=5mm,
11   d4 3  (a + b)  E  I k
E=2,0 × 10 N/m2, m=10kg, I = , k= , p=
32 a b m
2 2
Rezolvare:
syms y(t) p
%cerinta 1
sol1Sim=dsolve(diff(y,2)+p^2*y==0,'IgnoreAnalyticConstraints',false)
%cerinta 2
Dy=diff(y,1);
sol2Sim=simplify(dsolve(diff(y,2)+p^2*y==0, y(0)==1*10^-3,Dy(0)==0,...
'IgnoreAnalyticConstraints',false))
%cerinta 3
a=0.6;b=0.4;d=5*10^-3;E=2*10^11;m=10;
I=pi*d^4/32;
k=3*(a+b)*E*I/(a^2*b^2);
pNum=sqrt(k/m);
sol3Num=subs(sol2Sim,{p},{pNum})
ezplot(sol3Num,[0,10])
sol1Sim =
C1*exp(p*t*1i) + C2*exp(-p*t*1i)
sol2Sim =
cos(p*t)/1000
sol3Num =
cos((4500638457603595*t)/562949953421312)/1000
16. Reprezentarea grafică a funcțiilor simbolice

Cele mai utilizate funcții pentru reprezentarea funcțiilor simbolice sunt următoarele:
ezplot Utilizarea funcției plot pentru funcțiile simbolice

ezplot3 Utilizarea funcției plot3 pentru funcțiile simbolice
ezmesh Utilizarea funcției mesh pentru funcțiile simbolice
ezsurf Utilizarea funcției surf pentru funcțiile simbolice
fplot Funcția plot între limite specificate
Reprezentarea funcțiilor simbolice folosind funcția ezplot.

Sintaxe:
ezplot(fun,[min,max]) returnează graficul funcției simbolice fun(x) pe domeniul
min<x<max
ezplot(fun2,[xmin,xmax,ymin,ymax]) returnează graficul funcției simbolice implicite de

două variabile fun(x,y)=0 pe domeniul xmin<x<xmax și ymin<y<ymax
ezplot(funx,funy,[tmin,tmax]) returnează graficul curbei parametrice plane definită de
funx(t) și funy(t) pe domeniul [tmin,tmax]
În cazul celorlalte funcții pentru reprezentarea grafică a funcțiilor simbolice folosiți help-ul.
Exemplu. Să se reprezinte funcția implicită f ( x,y ) = x2 − ln(y) = 0 pentru x  1,2 și y  1,10  .

syms x y real
ezplot(x^2-log(y)==0,[1,2,1,10])
x 2 - log(y) == 0
10
6
y
1
1 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2
x
Bibliografie
CURS 11
INTRODUCERE ÎN Python
1. De ce Python?
✓ este un limbaj de programare de nivel înalt (high level programming language)
✓ este un limbaj curat, cu sintaxă simplă și ușor de implementat pe orice calculator
✓ poate realiza aplicații desktop de sine stătătoare precum și proiecte web
2. Anaconda
Anaconda este o distribuție condiționată gratuită și open-source a limbajelor de programare Python
și R pentru calcul științific (știința datelor, aplicații de învățare automată, prelucrarea datelor la scară
largă, analiza predictivă etc.), care are ca scop simplificarea gestionării și implementării pachetelor.
Distribuția include pachete de date științifice potrivite pentru Windows, Linux și MacOS. Este
dezvoltat și întreținut de Anaconda, Inc. Ca produs, Anaconda este cunoscut și sub numele de
Anaconda Distribution sau Anaconda Individual Edition care este gratuit, respectiv Anaconda Team
Edition și Anaconda Enterprise Edition care sunt negratuite.
Anaconda Navigator este o interfață grafica desktop (GUI) inclusa în distribuția Anaconda care
permite utilizatorilor să lanseze aplicații și să gestioneze pachetele implementate. Navigatorul poate
căuta pachete pe Anaconda Cloud sau într-un depozit Local Anaconda, le poate instala într-un mediu,
poate rula pachetele și le poate actualiza. Este disponibil pentru Windows, macOS și Linux.
Următoarele aplicații sunt disponibile în mod implicit în Navigator:
JupyterLab
Jupyter Notebook
QtConsole
Spyder
Glue
Orange
RStudio
Visual Studio Code
2.1. Descărcare și instalare

https://www.anaconda.com/products/individual
Installing on Windows
1. Download the Anaconda installer.

Individual Edition
Your data science toolkit
With over 20 million users worldwide, the open-source Individual Edition (Distribution) is the easiest way to
perform Python/R data science and machine learning on a single machine. Developed for solo practitioners, it is
the toolkit that equips you to work with thousands of open-source packages and libraries.
Download
2. RECOMMENDED: Verify data integrity with SHA-256. For more information on hashes, see What about
cryptographic hash verification?
3. Double click the installer to launch.
Note
To prevent permission errors, do not launch the installer from the Favorites folder.
Note
If you encounter issues during installation, temporarily disable your anti-virus software during install, then re-enable it
after the installation concludes. If you installed for all users, uninstall Anaconda and re-install it for your user only and try
again.
4. Click Next.
5. Read the licensing terms and click “I Agree”.
6. Select an install for “Just Me” unless you’re installing for all users (which requires Windows Administrator
privileges) and click Next.
7. Select a destination folder to install Anaconda and click the Next button. See FAQ.
Note
Install Anaconda to a directory path that does not contain spaces or unicode characters.
Note
Do not install as Administrator unless admin privileges are required.
8. Choose whether to add Anaconda to your PATH environment variable. We recommend not adding Anaconda to
the PATH environment variable, since this can interfere with other software. Instead, use Anaconda software by
opening Anaconda Navigator or the Anaconda Prompt from the Start Menu.
9. Choose whether to register Anaconda as your default Python. Unless you plan on installing and running multiple
versions of Anaconda or multiple versions of Python, accept the default and leave this box checked.
10. Click the Install button. If you want to watch the packages Anaconda is installing, click Show Details.
11. Click the Next button.
12. Optional: To install PyCharm for Anaconda, click on the link to https://www.anaconda.com/pycharm.
Obs. Nu cred că este cazul
Or to install Anaconda without PyCharm, click the Next button.
13. After a successful installation you will see the “Thanks for installing Anaconda” dialog box:
14. If you wish to read more about Anaconda Cloud and how to get started with Anaconda, check the boxes “Learn
more about Anaconda Cloud” and “Learn how to get started with Anaconda”. Click the Finish button.
15. Verify your installation.

Windows: Click Start, search or select Anaconda Navigator from the menu.
Dacă nu doriți tot pachetul Anaconda, se poate descărca și instala doar aplicația Spyder de pe site-ul
https://www.spyder-ide.org/ sau https://www.filehorse.com/download-spyder-python/
3. Primul program în Python

Deschidem aplicația Spyder.
Să scriem un program care să afișeze expresia Hello World!:
#primul meu program in Python
print('Hello World!')
4. Elemente de bază ale unui program Python

Declarațiile (statements) sunt liniile (conținutul) unui program. Toate declarațiile dintr-un
program scrise în modul script și salvate pe hard-ul calculatorului cu extensia .py se cheamă cod
sursă sau pur și simplu cod.
Un script este alcătuit din mai multe linii de cod.
4.1. Comentarii
▪ încep cu # și țin până la sfârșitul liniei:
#primul meu program in Python
▪ încep cu ''' și țin mai multe rânduri, până la un nou '''

'''ce pot face
cu Python'''
analog cu:
#ce pot face
#cu Python
Comentariile sunt folosite ca să arăți ce ai vrut să faci acolo. Dacă peste câtva timp vei redeschide
programul, comentariile îți vor reaminti de ceea ce ai vrut să faci cu linia de cod respectivă din
program. Ele sunt ignorate de interpretorul Python dar nu trebuie ignorate de tine!
4.2. Intrări, procesare, ieșiri, funcția print

Intrarea (Input) care se face de obicei de la tastatură, sunt datele pe care computerul le primește
de la utilizator. Urmează etapa procesării lor. Rezultatul operației de procesare se numește ieșire
(Output) și este afișat pe ecran.
O funcție este un cod prescris care realizează o operație. Python are numeroase funcții
preconstruite. Totuși, dintre toate, fundamentală rămâne funcția print, adică exact aceea care
afișează ieșirea pe ecran.
Când un program execută o funcție, spunem că el cheamă (invocă) funcția.
Afișarea ieșirii cu funcția print
Când invocăm funcția print, scriem cuvântul print urmat de un set de paranteze rotunde ( ).
Înăuntrul parantezelor scriem argumentul care reprezintă datele pe care le dorim afișate pe ecran.
Spre exemplu, la invocarea funcției print în declarația print('Hello World!'), argumentul este
Hello World!. Observăm că apostrofurile (ghilimelele simple) nu sunt afișate la ieșirea programului.
Ele doar arată începutul și sfârșitul textului pe care vrem să-l afișăm. Se poate afirma că print
este una dintre cele mai utilizate funcții.
4.3. Șiruri de date literale

Șirurile de date literale sunt incluse între apostrofuri ' ' (se mai numesc și ghilimele simple).
Exemple:
'Hello World!'
'Centrul Universitar Nord, Victor Babes, 62A, Baia Mare, Maramures’
Pe lângă ghilimele simple (' ') pot fi folosite cele duble ('' '') și triple (''' ''').
print('Centrul Universitar Nord, Victor Babes,62A, Baia Mare, Maramures')
print("Centrul Universitar Nord, Victor Babes,62A, Baia Mare, Maramures")
print('''Centrul Universitar Nord,

Victor Babes, 62A,
Baia Mare, Maramures''')
Răspunsul (în consolă):

Centrul Universitar Nord, Victor Babes,62A, Baia Mare, Maramures
Centrul Universitar Nord, Victor Babes,62A, Baia Mare, Maramures
Centrul Universitar Nord,
Victor Babes, 62A,
Baia Mare, Maramures
Când folosim cele trei tipuri de ghilimele?

De exemplu dacă vrem să tipărim Vino'ncoa!
print('Vino'ncoa!')
Răspunsul este:
SyntaxError: invalid syntax
Corect este:
print("Vino'ncoa!")
sau:
print('''Vino'ncoa!''')
Dacă vrem să tipărim "Python" este un limbaj de programare de nivel înalt

print(""Python" este un limbaj de programare de nivel înalt")
Răspunsul este:
SyntaxError: invalid syntax
Corect este:
print('"Python" este un limbaj de programare de nivel înalt')
sau:
print('''"Python" este un limbaj de programare de nivel înalt''')
4.4. Variabile
Programarea înseamnă înainte de toate a jongla cu noțiuni abstracte.
Variabilele sunt printre cele mai importante elemente din programare, iar ele și manipularea lor
trebuie bine înțeleasă. În Python înțelegerea variabilelor este mulțumitor de ușoară.
Tot ceea ce trebuie să faceți este să vă gândiți la o variabilă ca la o cutie în care depozitați ceva.
O variabilă este un nume (cuvânt) care reprezintă o valoare stocată în memoria calculatorului: este o
secvență de caractere (litere, cifre, _) care încep obligatoriu cu o literă sau cu _
Este indicat ca numele variabilei să înceapă cu literă mică!!!
Variabilele sunt sensibile la litere mici sau mari (case sensitive) așa că de exemplu python nu este
totuna cu Python.
Numele variabilelor nu au voie să conțină cuvintele cheie din Python. De asemenea, variabilele nu
trebuie să înceapă cu un număr sau să conțină caractere speciale precum $ # % ^ & * ș.a.m.d.
Numele (variabila) se scrie întotdeauna în partea stângă:
numarulDeDinti=22
Atenție: Operatorul simplu = nu înseamnă egal ca în matematică, ci reprezintă atribuirea.

Dacă vreau să tipăresc numărul de dinți (adică 22):
print(numarulDeDinti)
Răspuns:
22
Observație: Când se trece o variabilă ca argument al funcției print nu este nevoie de ghilimele!!!
Dacă vreau să tipăresc numarul de dinti este: 22
print('numarul de dinti este:')
print(numarulDeDinti)
Răspuns:
numarul de dinti este:
22
sau:
print('numarul de dinti este:',numarulDeDinti)
Răspuns:
numarul de dinti este: 22
Ce se întâmplă dacă în prima varianta a exemplului anterior am fi cuprins între ghilimele parametrul
numarulDeDinti ca mai jos?
print('numarul de dinti este:','numarulDeDinti')
Răspuns:
numarul de dinti este: numarulDeDinti
În loc să se afișeze valoarea parametrului care este 22, se printează șirul literal numarulDeDinti.
Exemplu de script cu două variabile:
#Se creeaza doua variabile numite modul si numarDinti
modul=3
numarDinti=27
#Afiseaza valorile referite de variabile
print('Modulul este:',modul)
print('Numarul de dinti este:',numarDinti)
Stocarea șirurilor cu tipul de date str

#Creeaza o variabila care refera doua siruri
prenume='Ioan'
nume='Pop'
#Afiseaza valorile referite de variabile
print(prenume,nume)
Run file (F5)

Răspuns:
Ioan Pop
La fel de bine putem să inversăm numele dacă ultima declarație ar arăta astfel:
print(nume,prenume)
Răspuns:
Pop Ioan
Tipuri de date. Reatribuirea variabilelor diferitelor tipuri

În Python există câteva tipuri principale de date:
1. int: număr întreg
2. float: număr în virgulă mobilă
3. complex: număr complex
3. str (string): șir
4. boolean: True, False
Ca să aflăm cu ce fel de date lucrăm (clasa datelor) utilizăm funcția type():

print(type(10))
Răspuns:
<class 'int'>
print(type(2.34))
Răspuns:
<class 'float'>
print(type('modul'))
Răspuns:
<class 'str'>
raspuns=True
print(type(raspuns))
Răspuns:
<class 'bool'>
Ce se întâmplă însă dacă unui întreg (int) îi adăugăm zero după virgulă? Pentru noi el rămâne un
întreg, nu însă și pentru calculator. Astfel, el devine un număr în virgulă mobilă (float):
print(type(10))
Răspuns:
<class 'int'>
print(type(10.0))
Răspuns:
<class 'float'>
În Python, o variabilă poate să refere orice tip de date: șir, întreg, în virgulă mobilă, complex,
boolean. După ce o variabilă a fost atribuită unui anumit tip, ea poate fi reatribuită altui tip de date.
x=12 #aici avem o variabila int (intreg)
print(x)
Răspuns:
12
str:
x='Sa invatam Python' #aici avem o variabila str (sir)
print(x)
Răspuns:
Sa invatam Python
float:
x=0.20 #aici avem o variabila float (virgula mobila)
print(x)
Răspuns:
0.20
Putem să renunțăm la 0 și să lăsăm doar punctul . urmat de valorile semnificative:

x=.20 #am renunțat la 0 in declararea variabilei subunitare
print(x)
Răspuns:
0.20
Obținerea inputului de la user

Obținerea informațiilor de la user este extrem de importantă și se face foarte ușor cu ajutorul
funcției input()
#Preia prenumele
prenume=input('Introdu prenumele: ')
#Preia numele de familie
nume=input('Introdu numele de familie: ')
#Afiseaza numele
print('Domnul/doamna',nume,prenume,'este invitat(a) la ghiseu')
Run file (F5)

În consolă:
Introdu prenumele: Marius
Introdu numele de familie: Pop
Răspuns:
Domnul/doamna Pop Marius este invitat(a) la ghiseu
Citirea numerelor cu funcția input

De exemplu, dacă în fereastra interactivă se tastează numărul 65 și se apasă Enter, valoarea
returnată de funcția input este șirul (str) '65'. Aceasta poate fi o problemă dacă se dorește
folosirea unor operații matematice ulterioare folosind valoarea 65.
Atenție. Operațiile matematice pot fi făcute doar cu valori numerice și nu cu șiruri!!
Exemplul următor folosește funcția input ca să citească un șir (str), un număr întreg (int) și
unul în virgulă mobilă (float).
#Preia numele, varsta si venitul financiar ale userului
nume=input('Care este numele dumneavoastra? ')
varsta=int(input('Cati ani aveti? '))
venit=float(input('Care este venitul dumneavoastra? '))
#Afiseaza datele
print('Iata datele pe care le-ai introdus: ')
print('Numele',nume)
print('Varsta',varsta)
print('Venitul declarat',venit)
Run file (F5)

În consolă:
Care este numele dumneavoastra? Pop Ioan
Cati ani aveti? 40
Care este venitul dumneavoastra? 3076.98
Răspuns:
Iata datele pe care le-ai introdus:
Numele Pop Ioan
Varsta 40
Venitul declarat 3076.98
Concluzia este următoarea: atunci când se introduc nume sau alte date literale se scrie simplu
input('……'). Când însă se introduc numere (întregi sau în virgulă mobilă) este obligatoriu să
definim tipul lor, int sau float.
int și float funcționează doar dacă itemul ce urmează să fie introdus conține o valoare numerică.
Altfel, va apărea o eroare numită excepție.
Dacă nu este obligatoriu ca numărul introdus să fie de un anumit tip (int sau float) putem
utiliza instrucțiunea eval care va evalua tipul numărului (eval ține loc de int sau float):
numar=eval(input('Introduceti numarul: '))
print(type(numar))
În consolă:
Introduceti numarul: 34
Răspuns:
<class 'int'>
În consolă:
Introduceti numarul: 34.5
Răspuns:
<class 'float'>
4.5. Specificarea unui item separator

Când argumentele sunt trecute funcției print, ele sunt automat separate de un spațiu care este
afișat pe ecran.
print('Centrul','Universitar','Nord')
Răspuns:
Centrul Universitar Nord
Dacă se doresc împreunate, se folosește argumentul sep='' plasat după declarației:

print('Centrul','Universitar','Nord',sep='')
Răspuns:
CentrulUniversitarNord
4.6. Caracterul \ (backslash)

Caracterul \ este unul special ce apare înăuntrul unui șir.
Cu el se poate realiza ”spargerea” declarațiilor lungi în linii multiple. Atunci când se sparge o
declarație considerată prea lungă, indentarea (vom vedea puțin mai târziu ce înseamnă acest lucru)
este obligatorie!!!
print('Distanta parcursa este egala cu ',format(valoarea,'.3f'),'m',sep='')
print('Distanta parcursa este egala cu ',\

format(valoarea,'.3f'),'m',sep='')
Dup caracterul \ pot să urmeze anumite instrucțiuni: de exemplu, \n înseamnă linie nouă, \t tab
orizontal, \v tab vertical etc.
print('Centrul\nUniversitar\nNord')
Răspuns:
Centrul
Universitar
Nord
FUNCȚII
O funcție reprezintă un grup de declarații pentru a realiza o anumită sarcină. Funcțiile ne ajută să
împărțim programul în bucăți mai mici și modulare. Pe măsură ce programul nostru crește din ce în
ce mai mult, funcțiile îl fac mai organizat și mai ușor de gestionat. În plus, evită repetarea și face
codul reutilizabil.
Pot fi utilizate atât funcții predefinite, disponibile la nivelul limbajului Python, de exemplu
print(), type(), id(), cât și funcții definite de utilizator.
1. Sintaxa unei funcții

def numeFunctie(argumente):
#comentarii
corpul functiei
return expresie
O funcției constă din următoarele componente:

1. def cuvânt cheie care marchează începutul antetului funcției. Este obligatoriu
2. numeFunctie pentru a identifica în mod unic funcția. Este obligatoriu
Denumirea funcției urmează aceleași reguli de scriere a identificatorilor în Python, adică:
✓ nu se pot folosi cuvintele cheie din Python
✓ nu pot exista spații între cuvintele care alcătuiesc numele funcției
✓ primul caracter trebuie să fie o literă de la a la z, de la A la Z sau underscore _
✓ literele mici sunt tratate diferit de cele mari (case sensitive)
Recomandare: pentru că funcțiile realizează acțiuni, este indicat să folosim verbe atunci când le
alegem numele. De exemplu, o funcție care calculează venitul poate fi denumită pur și simplu
calculeaza_venitul. Unii programatori folosesc pentru notarea funcțiilor metoda numită
”cocoașă de cămilă” (camelCase), adică calculeazaVenitul
3. argumente prin care trecem valori către o funcție. Sunt opționale
4. semnul : pentru a marca sfârșitul antetului funcției. Este obligatoriu

5. comentarii (docstring) pentru a descrie ce face funcția. Sunt opționale
6. corpul funcției format din una sau mai multe declaratii valide care alcătuiesc
declaratiile trebuie să aibă același nivel de indentare (4 spații). Este obligatoriu
7. instrucțiunea return pentru a returna o valoare din funcție. Este opțională
1.1. Indentarea (Important!!!)

În corpul funcției indentarea se face cu același număr de spații!!! De obicei se folosește tab-ul sau
patru spații. Dacă în același program folosim o dată patru spații, altădată tab-ul sau trei, cinci ori “n”
spații, programul va da eroare de indentare. În Spyder indentarea se face automat cu 4 spații!!!
Indentarea în Python este obligatorie și se face pentru ca blocurile de cod din program să fie
perfect stabilite (arătând unde începe și se termină un bloc de declarații), ceea ce duce la o lizibilitate
mai bună a programului. Indentarea ține locul acoladelor din celelalte limbaje de programare din
familia limbajului C. Totodată ține loc și de semnul punct și virgulă cu care se sfârșesc obligatoriu
declarațiile din limbajele de programare din familia C sau Matlab.
1.2. Instrucțiunea return

Instrucțiunea return este folosită pentru a încheia execuția apelului funcției și returnează
rezultatul (valoarea expresiei care urmează cuvântului cheie return) apelantului.
Sintaxa:
return expresie
Observații: 1. Eventualele declarații de după instrucțiunea return nu sunt executate

2. Instrucțiunea return nu poate fi utilizată în afara unei funcții
3. Dacă nu există nicio expresie în instrucțiune sau dacă instrucțiunea return în sine
nu este prezentă în interiorul unei funcții, atunci va fi returnat obiectul None
2. Invocarea unei funcții

Definiția unei funcții specifică ce face funcția, dar nu o execută. Ca să se execute o funcție, ea trebuie
invocată (chemată). Când funcția este chemată, interpretorul sare la acea funcție și execută
declarațiile din blocul ei. Apoi, când blocul s-a terminat, interpretorul sare înapoi la partea de
program care a chemat funcția și programul rezumă execuția în acel punct. Când se întâmplă asta,
spunem că funcția returnează.
Exemplu: o funcție fără argumente de intrare numită mesaj și instrucțiunea return
def mesaj():
#un mesaj din pandemie
return print('Va rugam sa respectati distantarea fizica!')
Run file (F5)

În consolă invocăm funcția:
mesaj()
Răspuns:
Va rugam sa respectati distantarea fizica!
În cazul funcțiilor care nu au argumente de intrare este mai util să invocăm funcția chiar în fișier,
astfel că nu vom mai fi nevoiți să invocăm funcția în consolă:
def mesaj():
#un mesaj din pandemie
return print('Va rugam sa respectati distantarea fizica!')
mesaj()
Run file (F5)

Răspuns:
Va rugam sa respectati distantarea fizica!
Exemplu: funcția urare cu un argument de intrare și instrucțiunea return

def urare(nume):
#functia urare de buna dimineata
return print('Buna dimineata',nume,'!')
Run file (F5)

În consolă:
urare('Ionel')
Răspuns:
Buna dimineata Ionel !
Exemplu: funcția dublare cu un argument de intrare și instrucțiunea return

def dublare(x):
#functia dubleaza valoarea introdusa
return x+x
Run file (F5)

În consolă:
dublare(6)
Răspuns:
12
În consolă:
dublare('Hello')
Răspuns:
'HelloHello'
Exemplu: o funcție care calculează aria pătratului:

def ariaPatratului(latura):
#Functia care calculeaza aria patratului; latura se introduce in [m]
aria=latura**2
return print('Aria patratului este egala cu ',aria,'mp',sep='')
Run file (F5)

În consolă:
ariaPatratului(5)
Răspuns:
Aria patratului este egala cu 25mp
Exemplu: o funcție cu două argumente de intrare:

def ariaDreptunghiului(lungimea,latimea):
#Functia care calculeaza aria dreprunghiului
aria=lungimea*latimea
return print('Aria dreptunghiului este egala cu ',aria,'mp',sep='')
Run file (F5)

În consolă:
ariaDreptunghiului(10,5)
Răspuns:
Aria dreptunghiului este egala cu 50mp
3. Variabile locale
O variabilă locală este creată în interiorul unei funcții și nu poate fi accesată din afara ei.
Funcții diferite pot avea variabile locale cu același nume pentru că ele nu se pot vedea una pe
cealaltă. De fiecare dată când se atribuie o valoare unei variabile în interiorul unei funcții, se
creează o variabilă locală.
Exemplu: Putem să scriem cele două funcții scrise anterior într-un sigur fișier .py pe care să-l
denumim calculArii; ambele funcții au câte o variabilă cu același nume, aria:
#Doua functii scrise in acelasi fisier .py si care

#au variabile locale cu acelasi nume
#Fisierul script contine 2 functii: ariaPatratului si ariaDreptunghiului
def ariaPatratului(latura):
#Functia care calculeaza aria patratului; latura se introduce in [m]
aria=latura**2
return print('Aria patratului este egala cu ',aria,'mp',sep='')
def ariaDreptunghiului(lungimea,latimea):
#Functia care calculeaza aria dreprunghiului
aria=lungimea*latimea
return print('Aria dreptunghiului este egala cu ',aria,'mp',sep='')
Run file (F5)

În consolă:
ariaPatratului(10)
Răspuns:
Aria patratului este egala cu 100mp
În consolă:
ariaDreptunghiului(8,9)
Răspuns:
Aria dreptunghiului este egala cu 72mp
4. Constante globale
O constantă globală referă o valoare care nu poate fi modificată.
Prin convenție, constantele globale se scriu cu majuscule și sunt așezate la începutul programului,
înaintea oricăror alte declarații, ca în exemplul următor (funcția cadereLibera2):
#Definirea unei constante globale: acceleratia gravitationala

ACC_GRAV=9.81
#Definesc functia principala cadereLibera2

def cadereLibera2(timp):
#Chem functia viteza
viteza(timp)
#Chem functia distanta
distanta(timp)
def viteza(timp):
valoarea=ACC_GRAV*timp
print('Viteza finala este egala cu ',format(valoarea,'.3f'),'m/s',sep='')
def distanta(timp):
valoarea=ACC_GRAV/2*timp**2
print('Distanta parcursa este egala cu ',format(valoarea,'.3f'),'m',sep='')
Run file (F5)

În consolă:
cadereLibera2(30)
Răspuns:
Viteza finala este egala cu 294.300m/s
Distanta parcursa este egala cu 4414.500m
5. Funcția lambda
Python permite crearea unei funcții anonime folosind cuvântul cheie lambda.
O funcție anonimă poate să conțină doar o singură expresie care neapărat trebuie să returneze o
valoare. Altfel ca la crearea unei funcții comune care folosește def, o funcție creată cu lambda
returnează un obiect funcție. Acesta poate fi atribuit unei variabile care poate fi folosită în orice
moment ca să execute expresia conținută.
Funcției lambda putem chiar să nu îi atribuim nicio variabilă.
Sintaxe:
variabila=lambda argumente:expresie
variabila=(lambda argumente:expresie)(valori)
Exemple:
1. Ca funcție obișnuită:
def dublare(x):
#functia dubleaza valoarea introdusa
return x+x
Run file (F5)

În consolă:
dublare(5)
Răspuns:
10
2. Cu funcția lambda:
dublu=lambda x:2*x
În consolă:
dublu(5)
Răspuns:
10
sau:
În consolă:
dublu=(lambda x:2*x)(7)
print(dublu)
Răspuns:
14
Bibliografie
1. Mircea Prodan, Cum să programezi în Python (Manual în limba română), 2014
2. Marian Bucos, PROGRAMARE. PYTHON, https://uncoded.ro
3. Adriana Drăghici, Introducere în limbajul Python, 2018
4. Czibula Istvan, Fundamentele Programării. Limbajul de programare PYTHON
5. Mark Lutz, Learning Python, 5th Edition
6. https://docs.anaconda.com/
7. https://opentechschool.github.io/python-beginners/ro/
8. https://python-course.eu/
CURS 12
TIPURI DE DATE ÎN Python
Tipurile de date standard în Python sunt:

✓ Număr
✓ Șir
✓ Listă
✓ Tuplu
✓ Dicționar
✓ Set
În Python toate tipurile de date sunt obiecte!!!
1. Date de tip număr

1.1. Definirea numerelor
Numerele sunt obiecte imutabile: orice modificare a valorii determină schimbarea adresei de
memorie (referinței). Obiectele de tip numeric sunt create atunci când li se atribuie o valoare!!!
Putem privi procesul de creare a obiectelor drept un proces de denumire a unei adrese în memorie
(imaginați-vă aceste adrese drept zone de formă dreptunghiulară unde se găsesc aceste obiecte).
Obiectului de tip variabilă a i se atribuie (=) obiectul de tip număr 5. Să ne imaginăm o
”săgeată” care reprezintă referința de la obiectul a la adresa obiectului 5. Dacă obiectului a i se
atribuie o altă valoare, de exemplu 6, adresa de memorie (referința) se schimbă. Din acest motiv,
obiectele de tip numeric sunt imutabile.
a referinta 5
a referinta 6
Exemplu:
a=5
print(a)
print(id(a))
print(id(5))
a=6
print(a)
print(id(a))
print(id(6))
Răspuns:
5
140736772908960
140736772908960
6
140736772908992
140736772908992
Observație: funcția id() returnează id-ul unic pentru obiectul specificat, adică adresa de memorie a
obiectului; id-ul va fi diferit de fiecare dată când se rulează programul.
Python oferă suport pentru 3 tipuri de numere: int (numere întregi), float (numere reale, cu
virgulă) și complex (numere complexe). Mai mult, Python ne permite să schimbăm tipul de date
oricând ne dorim. Tot ce trebuie să facem este să apelăm una dintre funcțiile built-in
(preinstalate) cu numele specific tipului de date dorit:
a=3.0 #creez variabila a cu valoarea 3.0
print(a)
print(type(a))
Răspuns:
3.0
<class 'float'>
a=int(a) #convertesc valoarea de tip float in int

print(a)
print(type(a))
Răspuns:
3
<class 'int'>
a=complex(a) #convertesc valoarea de tip int in complex

print(a)
print(type(a))
Răspuns:
(3+0j)
<class 'complex'>
Pentru a crea un număr complex se folosește sintaxa complex(a,b), unde argumentul a

reprezintă partea reală, iar b partea imaginară (a,bϵR). În Python unitatea imaginară este
notată cu j:
numCompl=complex(4,5)
print(numCompl)
print(type(numCompl))
Răspuns:
(4+5j)
<class 'complex'>
1.2. Formatarea numerelor

Se folosește funcția format care are două argumente:
• o valoare numerică
• un specificator de format
Specificatorul de format este un șir care conține caractere speciale ce arată formatarea valorilor
numerice.
Formatarea cu număr specificat de zecimale

format(12345.6789,'.3f')
• primul argument, care este un număr în virgulă mobilă (12345.6789), este numărul pe
care vrem să-l formatăm
• al doilea argument este un șir, de exemplu '.3f' și reprezintă specificatorul de format
(în acest caz 3 zecimale):
▪ .3 specifică precizia; el arată că vrem să rotunjim numărul la trei zecimale
▪ f vine de la float și specifică faptul că numărul formatat este în virgulă mobilă
print(format(12345.6789,'.3f'))
Răspuns:
12345.679
print(format(12345.6789,'.1f'))
Răspuns:
12345.7
Formatarea în mod științific: se utilizează literele e sau E în loc de f

print(format(12345.6789,'.3e'))
Răspuns:
1.235e+04
Inserarea separatorului virgulă (separatorul de mii): se folosește caracterul virgulă ,

print(format(12345.6789,',.2f'))
Răspuns:
12,345.68
Specificarea unei lățimi minime de spațiu: se specifică valoarea spațiului

print('Numarul este',format(12345.6789,'10,.2f'))
Răspuns:
Numarul este 12,345.68
Formatarea unui număr în virgulă mobilă ca procent: în loc să folosim litera f folosim simbolul
procent %
print(format(0.5,'%'))
Răspuns:
50.000000%
print(format(0.5,'.1%'))
Răspuns:
50.0%
print(format(0.5,'.0%'))
Răspuns:
50%
Formatarea întregilor: diferențele la formatarea întregilor față de numerele în virgulă mobilă sunt:
• se folosește d în loc de f
• nu se poate specifica precizia
print(format(123456,'d'))
Răspuns:
123456
print(format(123456,',d'))
Răspuns:
123,456
2. Date de tip șir (str)

2.1. Definirea șirurilor
Șirurile sunt obiecte imutabile: orice modificare a șirului determină schimbarea adresei de
memorie (referinței).
Un șir (str) reprezintă orice tip de text inclus între ghilimele simple, duble sau triple. Un șir poate
fi privit drept o listă de caractere aflate într-o anumită ordine:
grupaISFF='Grupa are un numar de 25 de studenti'
print(grupaISFF)
Răspuns:
Grupa are un numar de 25 de studenti
2.2. Operațiile de concatenare și repetare

Concatenarea se realizează cu operatorul +, iar repetarea cu operatorul *
Atenție: pentru concatenare, ambele itemuri trebuie să fie de tip string, iar pentru repetiție este
necesar un string și un număr strict pozitiv întreg (int)!!!
sir1='Anaconda'
sir2='Python'
print(sir1+sir2)
print(sir1*2)
Răspuns:
AnacondaPython
AnacondaAnaconda
nume=input('Introduceti numele dumneavoastra: ')

prenume=input('Introduceti prenumele dumneavoastra: ')
invitatie='Domnul '+nume+' '+prenume+' este invitat la ghiseu'
print(invitatie)
În consolă:
Introduceti numele dumneavoastra: Pop
Introduceti prenumele dumneavoastra: Ioan
Răspuns:
Domnul Pop Ioan este invitat la ghiseu
2.3. Operația de selectare sau feliere (slicing)

Un șir (str) Python poate fi privit drept o listă de caractere aflate într-o anumită ordine. Astfel,
putem selecta (felia) un subșir al șirului nostru folosind paranteze pătrate [ ].
Atenție: în Python numărarea pozițiilor (indecșilor) caracterelor din string începe de la 0!!!
Sintaxe:
sir[i:j:p] i și j sunt indecșii, iar p este pasul (sintaxa completă)
sir[i:j] dacă p=1
sir[::] sau sir[:] selectează tot șirul sir
sir[0:j] sau sir[:j] dacă i=0
sir[i] selectează caracterul cu indexul i din șirul sir
Atenție: intervalul [i:j] este închis la capătul din stânga și deschis la cel din dreapta. Cu alte
cuvinte, itemulul de pe poziția de start a notației va fi inclus în rezultat, iar caracterul indicat de
poziția de final nu va fi inclus!!!
Un index negativ va începe numărătoarea de la capătul din dreapta al șirului!!!
Dacă pasul este negativ se va avansa de la final către început!!!
sir='Anaconda'
print(sir[0:8:1]) #Anaconda
print(sir[0:8]) #Anaconda
print(sir[::]) #Anaconda
print(sir[:]) #Anaconda
print(sir[0:8:2]) #Aaod (Anaconda)

print(sir[::2]) #Aaod (Anaconda)
print(sir[1:8]) #naconda (Anaconda)

print(sir[-7:]) #naconda (Anaconda)
print(sir[-8:-1]) #Anacond (Anaconda)
print(sir[::-1]) #adnocanA (inversează sirul)
print(sir[0]) #A (Anaconda)
print(sir[-8]) #A (Anaconda)
print(sir[3]) #c (Anaconda)
print(sir[-5]) #c (Anaconda)
2.4. Folosirea caracterului %

Caracterul %s indică faptul că pe acea poziție din șir se așteaptă un item de tip string, %d indică
prezența unui item de tip întreg etc.:
invitatie='Domnul %s %s este invitat la ghiseu' %(nume,prenume)
print(invitatie)
Ordinea parametrilor din paranteză contează: dacă parametrii sunt (prenume,nume):

invitatie='Domnul %s %s este invitat la ghiseu' %(prenume,nume)
Răspunsul ar fi:
Domnul Ioan Pop este invitat la ghiseu
2.5. Metode pentru manipularea șirurilor1

Metoda Descriere
sir.capitalize() Convertește primul caracter din șir în majuscule
sir.casefold() Convertește șirul în minuscule
sir.center() Returnează un șir centrat
sir.count() Returnează de câte ori apare o valoare specificată într-un șir
sir.encode() Returnează o versiune codificată a șirului
sir.endswith() Returnează True dacă șirul se termină cu valoarea specificată
sir.expandtabs() Setează dimensiunea tab-ului șirului
Căută în șir o valoare specificată și returnează poziția unde
sir.find()
a fost găsită
sir.format() Formatează valorile specificate într-un șir
sir.format_map() Formatează valorile specificate într-un șir
Căută în șir o valoare specificată și returnează poziția unde
sir.index()
a fost găsită
Returnează True dacă toate caracterele din șir sunt
sir.isalnum()
alfanumerice
sir.isalpha() Returnează True dacă toate caracterele din șir sunt în alfabet
sir.isdecimal() Returnează True dacă toate caracterele din șir sunt zecimale
sir.isdigit() Returnează True dacă toate caracterele din șir sunt cifre
sir.isidentifier() Returnează True dacă șirul este un identificator
sir.islower() Returnează True dacă toate caracterele din șir sunt minuscule
sir.isnumeric() Returnează True dacă toate caracterele din șir sunt numerice
sir.isprintable() Returnează True dacă toate caracterele din șir sunt tipărite
Returnează True dacă toate caracterele din șir sunt spații
sir.isspace()
albe
sir.istitle() Returnează True dacă șirul respectă regulile unui titlu
sir.isupper() Returnează True dacă toate caracterele din șir sunt majuscule
sir.join() Alătură itemurile unui iterabil la sfârșitul șirului
sir.ljust() Returnează o versiune justificată la stânga a șirului
sir.lower() Convertește un șir în minuscule
sir.lstrip() Returnează o versiune de stânga a șirului
Returnează un tabel de traducere pentru a fi utilizat în
sir.maketrans()
traduceri
sir.partition() Returnează o tuplu în care șirul este împărțit în trei părți
1
Există o diferență între funcție și metodă, deși ambele reprezintă subrutine de calcul, adică secvențe de cod ce
prelucrează ceva specific. Metoda este o funcție ce aparține unei clase / tip de date etc.
Returnează un șir în care o valoare specificată este înlocuită

sir.replace()
cu o valoare specificată
Căută în șir o valoare specificată și returnează ultima
sir.rfind()
poziție în care a fost găsită
Căută în șir o valoare specificată și returnează ultima
sir.rindex()
poziție în care a fost găsită
sir.rjust() Returnează o versiune justificată corectă a șirului
sir.rpartition() Returnează o tuplu în care șirul este împărțit în trei părți
sir.rsplit() Împarte șirul la separatorul specificat și returnează o listă
sir.rstrip() Returnează o versiune dreaptă a șirului
sir.split() Împarte șirul la separatorul specificat și returnează o listă
sir.splitlines() Împarte șirul la întreruperile de linie și returnează o listă
sir.startswith() Returnează adevărat dacă șirul începe cu valoarea specificată
sir.strip() Returnează o versiune tăiată a șirului
sir.swapcase() Schimbă majuscule/ minuscule în minuscule/ majuscule
sir.title() Convertește primul caracter al fiecărui cuvânt în majuscule
sir.translate() Returnează un șir tradus
sir.upper() Convertește un șir în majuscule
sir.zfill() Umple șirul cu un număr specificat de 0 valori la început
Metoda format() presupune utilizarea unui șir care reprezintă un șablon

Sintaxa:
sir.format(argument1,argument2,...)
Considerăm următorul șir șablon: Domnul {0} {1} este invitat la ghiseul {2}
Acoladele { } sunt doar substituenți pentru argumentele metodei format care trebuie plasate în șir.
Exemplu:
nrGhiseu=3
print('Domnul {0} {1} este invitat la ghiseul {2}'.format(nume,prenume,nrGhiseu))
În consolă:
Introduceti numele dumneavoastra: Pop
Introduceti prenumele dumneavoastra: Ioan
Răspuns:
Domnul Pop Ioan este invitat la ghiseul 3
Dacă șirul șablon ar fi: Domnul {1} {0} este invitat la ghiseul {2}
print('Domnul {1} {0} este invitat la ghiseul {2}'.format(nume,prenume,ghiseu))
Răspunsul ar fi:
Domnul Ioan Pop este invitat la ghiseul 3
Notă: în Python lista de argumente începe de la 0!!!

Metodele sir.lower(), sir.upper() și sir.split()

nume='Anaconda'
print(nume.lower())
print(nume.upper())
print(nume.split('c')) #delimitatorul c nu va fi in lista
Răspuns:
anaconda
ANACONDA
['Ana', 'onda']
2.6. Funcții de tip built-in pentru șiruri

Funcția Descriere
len() Lungimea șirului (returnează numărul de caractere care îl alcătuiesc)
max() Valoarea maximă (returnează litera din șir cu poziția maximă în alfabet)
min() Valoarea minimă (returnează litera din șir cu poziția minimă în alfabet)
del() Șterge șirul
Lungimea șirului (returnează numărul de caractere care îl alcătuiesc): cu funcția len()

nume='Anaconda'
nrCar=len(nume)
print(nrCar)
Răspuns:
8
Valoarea minimă și maximă (returnează litera din șir cu poziția minimă/maximă în alfabet): cu
funcțiile min(), max()
Observație: toate literele mari vor fi considerate ”mai mici” decât orice literă mică!!!
nume='Anaconda'
minLit=min(nume)
maxLit=max(nume)
print(minLit)
print(maxLit)
Răspuns:
A (observație: A este ”mai mic” decât a)
o
Ștergerea șirului: cu funcția del()

nume='Anaconda'
del(nume)
print(nume)
Răspuns:
NameError: name 'nume' is not defined
3. Date de tip listă

3.1. Definirea listelor
Listele sunt folosite pentru a stoca mai multe itemuri într-o singură variabilă. Listele sunt obiecte
mutabile: modificarea itemurilor nu schimbă adresa din memorie (referința).
Observație: în Python, vectorii (array) vor fi definiți ca liste cu itemuri de același tip!!!
Listele se definesc cu ajutorul parantezelor pătrate [ ], iar elementele sunt separate prin virgulă ,
Exemple:
#lista cu itemuri de tip numeric (vector)
x=[1,2,4,6,9,10]
print(x)
print(type(x))
[1, 2, 4, 6, 9, 10]
<class 'list'>
#lista cu itemuri de tip sir

y=['un sir','alt sir']
print(y)
print(type(y))
['un sir', 'alt sir']
<class 'list'>
#lista mixta (eterogena)

z=[1,'un sir',3,4,'alt sir']
print(z)
print(type(z))
[1, 'un sir', 3, 4, 'alt sir']
<class 'list'>
#lista imbricata (lista in lista)

w=[[4,5],[7,'un sir']]
print(w)
print(type(w))
[[4, 5], [7, 'un sir']]
<class 'list'>
3.2. Operațiile de concatenare și repetare (analoage cu cele de la șiruri):

x=[1,2,4,6,9,10]
y=['un sir','alt sir']
print(x+y)
print(x*2)
print(y*2)
Răspuns:
[1, 2, 4, 6, 9, 10, 'un sir', 'alt sir']
[1, 2, 4, 6, 9, 10, 1, 2, 4, 6, 9, 10]
['un sir', 'alt sir', 'un sir', 'alt sir']
3.3. Operația de selectare (slicing) (analoagă cu cea de la șiruri):

x=[1,2,4,6,9,10]
print(x[0:6:1]) #[1, 2, 4, 6, 9, 10]
print(x[0:6]) #[1, 2, 4, 6, 9, 10]
print(x[::]) #[1, 2, 4, 6, 9, 10]
print(x[:]) #[1, 2, 4, 6, 9, 10]
print(x[0:6:2]) #[1, 4, 9] ([1,2,4,6,9,10])

print(x[::2]) #[1, 4, 9] ([1,2,4,6,9,10])
print(x[1:6]) #[2, 4, 6, 9, 10] ([1,2,4,6,9,10])

print(x[-5:]) #[2, 4, 6, 9, 10] ([1,2,4,6,9,10])
print(x[-6:-1]) #[1, 2, 4, 6, 9] ([1,2,4,6,9,10])
print(x[::-1]) #[10, 9, 6, 4, 2, 1] (inverseaza ordinea elem. din lista)
print(x[0]) #1 ([1,2,4,6,9,10])
print(x[-6]) #1 ([1,2,4,6,9,10])
print(x[3]) #6 ([1,2,4,6,9,10])
print(x[-3]) #6 ([1,2,4,6,9,10])
3.4. Mutabilitatea listelor

Listele sunt mutabile ceea ce înseamnă că itemurile ei pot fi modificate fără a schimba și adresa de
memorie (referința).
Să presupunem că avem listă inițială numită listaInit. Cu operația de atribuire = se creează o
copie mutabilă a listei inițiale, numită listaNoua:
listaNoua=listaInit
Operația de atribuire atribuie întreg obiectul, adică valoare și adresa de memorie!!!

#definesc listaInit
listaInit=[10,20]
print('Lista initiala este:',listaInit)
print('Adresa de memorie a listei initiale este:',id(listaInit))
#creez copia listaNoua

listaNoua=listaInit
print('Copia este:',listaNoua)
print('Adresa de memorie a copiei este:',id(listaNoua))
#inlocuiesc itemul 20 având indexul 1 cu itemul 30

listaInit[1]=30
#afisez cele doua liste si adresele lor

print('Lista initiala modificata este:',listaInit)
print('Adresa de memorie a listei initiale modificata este:',id(listaInit))
print('Copia este:',listaNoua)
print('Adresa de memorie a copiei este:',id(listaNoua))
Răspuns:
Lista initiala este: [10, 20]
Adresa de memorie a listei initiale este: 2674068808000
Copia este: [10, 20]
Adresa de memorie a copiei este: 2674068808000
Lista initiala modificata este: [10, 30]
Adresa de memorie a listei initiale modificata este: 2674068808000
Copia este: [10, 30]
Adresa de memorie a copiei este: 2674068808000
Chiar dacă am modificat doar lista inițială (listaInit) se modifică și copia acesteia
(listaNoua). Același lucru s-ar întâmpla cu listaInit dacă am modifica listaNoua!!!
Explicație: obiectului de tip variabilă listaInit îi atribuim obiectul de tip listă [10,20]. Prin
atribuire creăm obiectul de tip variabilă listaNoua. Atât listaInit, cât și listaNoua vor indica
același obiect listă și aceeași adresă de memorie. Din acest motiv, modificarea obiectului de tip listă
prin oricare din obiectele listaInit sau listaNoua, rezultă și modificarea celuilalt obiect listă.
listaInit
=
[10,20]
listaNoua
listaInit
[10,30]
listaNoua
3.5. Metodele pentru manipularea listelor

Metoda Descriere
lista.append() Adaugă un item la finalul listei
lista.insert() Inserează un item la poziția specificată
lista.extend() Adaugă la finalul listei itemurile listei furnizate
lista.remove() Șterge prima apariție a itemului specificat
lista.pop() Șterge item de la poziția specificata și îl returnează
lista.copy() Returnează o copie a listei
lista.clear() Șterge toate itemurile din listă
lista.count() Numărul de apariții al unui item în lista
lista.index() Indexul primului item din lista care deține valoarea specificata
lista.sort() Sortează itemurile listei
lista.reverse() Inversează ordinea itemurilor din listă
Metoda copy() returnează o listă nouă cu aceleași itemuri ca cea originală, dar cu propria
adresă!!!; se mai spune că se creează o copie superficială (shallow copy)
listaInit=[10,20] #definesc listaInit
print('Lista initiala este:',listaInit)
print('Adresa de memorie a listei initiale este:',id(listaInit))
listaNoua=listaInit.copy() #creez copia superficiala listaNoua

print('Copia superficiala este:',listaNoua)
print('Adresa de memorie a copiei superficiale este:',id(listaNoua))
listaInit[1]=30 #inlocuiesc itemul 20 având indexul 1 cu itemul 30
#afisez cele doua liste si adresele lor

print('Lista initiala modificata este:',listaInit)
print('Adresa de memorie a listei initiale modificata este:',id(listaInit))
print('Copia superficiala este:',listaNoua)
print('Adresa de memorie a copiei superficiale este:',id(listaNoua))
Răspuns:
Lista initiala este: [10, 20]
Adresa de memorie a listei initiale este: 1900055746112
Copia superficiala este: [10, 20]
Adresa de memorie a copiei superficiale este: 1900068560640
Lista initiala modificata este: [10, 30]
Adresa de memorie a listei initiale modificata este: 1900055746112
Copia superficiala este: [10, 20]
Adresa de memorie a copiei superficiale este: 1900068560640
listaInit referinta [10,20]

copy
listaNoua referinta [10,20]
listaInit referinta [10,30]
listaNoua referinta [10,20]
Metoda index() returnează indexul primului item din listă care conține itemul căutat; dacă
itemul căutat nu există în listă, programul va ridica o excepție ValueError
x=[1,5,-7,3,0,9,-7]
print(x.index(-7)) #afisez indexul itemului -7
print(z.index('un sir')) #afisez indexul itemului 'un sir'
print(z.index('sir')) #afisez indexul itemului 'sir' (nu exista)
Răspuns:
2
1
ValueError: 'sir' is not in list
Metoda count() returnează de câte ori apare itemul specificat în listă

x=[1,5,-7,3,0,9,-7]
nrApar=x.count(-7)
print(nrApar) #afisez de cate ori apare itemul -7 in lista x
Răspuns:
2
Metoda sort() sortează itemurile unei liste în ordine ascendentă sau descendentă; metoda sort
nu returnează, ci actualizează lista existentă!!!
Sintaxe:
lista.sort(reverse=True|False)
lista.sort() #sortare in ordine ascendenta
Exemplu:
x=[1,5,-7,3,0,9,-2]
print('Ordinea originala:',x)
x.sort(reverse=True) #sortarea descendenta a listei x
print('In ordine descendenta:',x) #afisez lista x actualizata
x.sort(reverse=False) #sau x.sort();sortarea ascendenta a listei x
print('In ordine ascendenta:',x) #afisez lista x actualizata
Răspuns:
Ordinea originala: [1, 5, -7, 3, 0, 9, -2]
In ordine descendenta: [9, 5, 3, 1, 0, -2, -7]
In ordine ascendenta: [-7, -2, 0, 1, 3, 5, 9]
Observație: sortarea itemurilor unei liste se poate face și cu funcția sorted()
Metoda reverse() inversează ordinea itemilor din listă; metoda reverse nu returnează, ci
actualizează lista existentă!!!
x=[1,5,-7,3,0,9,-2]
print('Ordinea originala:',x) #afisez lista x originala
x.reverse()
print('Ordinea inversata:',x) #afisez lista x actualizata (inversata)
Răspuns:
Ordinea inversata: [-2, 9, 0, 3, -7, 5, 1]
Metoda append() este folosită pentru adăugarea unui item listei. Itemul se adaugă întotdeauna la
sfârșitul listei!!!; metoda append nu returnează, ci actualizează lista existentă!!!
x=[1,5,-7,3,0,9,-2]
x.append(246) #adaug un item, 246, care este de tip numar
z.append([45,98]) #adaug un item, [45,98], care este de tip lista
print(x) #afisez lista x actualizata
print(z) #afisez lista z actualizata
Răspuns:
[1, 5, -7, 3, 0, 9, -2, 246]
[1, 'un sir', 3, 4, 'alt sir', [45, 98]]
Metoda extend() este folosită pentru adăugarea unor itemi listei. Itemii se adaugă întotdeauna la
sfârșitul listei!!!; metoda extend nu returnează, ci actualizează lista existentă!!!
x=[1,5,-7,3,0,9,-2]
x.extend([246]) #adaug un singur item, 246, care este de tip numar
z.extend([45,98]) #adaug doi itemi, 45 si 98, care sunt de tip numar
Răspuns:
[1, 5, -7, 3, 0, 9, -2, 246]
[1, 'un sir', 3, 4, 'alt sir', 45, 98]
Metoda insert() este folosită pentru adăugarea unui item într-o listă pe o poziție specificată;
metoda insert nu returnează, ci actualizează lista existentă!!!
x=[1,5,-7,3,0,9,-2]
x.insert(3,246) #itemul 246 este adaugat pe pozitia cu indexul 3
z.insert(4,[45,98]) #itemul [45,98] este adaugat pe pozitia cu indexul 4
Răspuns:
[1, 5, -7, 246, 3, 0, 9, -2]
[1, 'un sir', 3, 4, [45, 98], 'alt sir']
Metoda remove() elimină din listă primul item identic cu itemul căutat. Dacă itemul nu există în
listă, programul va ridica o excepție ValueError; metoda remove nu returnează, ci actualizează
lista existentă!!!
x=[1,5,-7,3,0,9,-2]
x.remove(0) #elimin itemul 0
z.remove('alt sir') #elimin itemul 'alt sir'
Răspuns:
[1, 5, -7, 3, 9, -2]
[1, 'un sir', 3, 4]
Metoda pop() elimină din listă itemul având indexul dat, returnează itemul eliminat și
actualizează lista existentă
valElim=z.pop(1) #elimin itemul cu indexul 1, adica itemul 'un sir'
print(valElim) #afisez itemul eliminat
Răspuns:
un sir
[1, 3, 4, 'alt sir']
Ștergerea itemurilor pe baza indexului se poate realiza și utilizând funcția del()
Metoda clear() elimină toate itemurile din listă, fără a șterge și lista!!!
x=[1,5,-7,3,0,9,-2]
x.clear()
z.clear()
print(x) #afisez lista x actualizata (golita)
print(z) #afisez lista z actualizata (golita)
Răspuns:
[]
[]
3.6. Funcții de tip built-in pentru liste

Funcția Descriere
len() Numărul de itemuri de la nivelul listei
max() Valoarea maximă de la nivelul listei
min() Valoarea minimă de la nivelul listei
sum() Suma valorilor itemurilor de la nivelul listei
sorted() Returnează o nouă lista ordonată crescător
any() True dacă cel puțin un item din listă are valoarea True
all() True dacă toate itemurile listei se evaluează la True
tuple() Transformarea unei liste în tuplu
del() Șterge lista sau un item pe baza indexului
Lungimea listei (returnează numărul de itemuri care o alcătuiesc): cu funcția len()

x=[1,5,-7,3,0,9,-2]
nrElem=len(x)
print(nrElem)
Răspuns:
7
Valoarea minimă și maximă (returnează itemul minim/ maxim din listă): cu funcțiile min(), max()
Atenție: lucrează doar cu liste omogene. În cazul celor mixte (eterogene) dă eroare!!!
x=[1,5,-7,3,0,9,-2] #lista cu itemuri de tip numeric (vector)
minList=min(x)
maxList=max(x)
print(minList)
print(maxList)
Răspuns:
-7
9
y=['acbd','aefg','abc'] #lista cu itemuri de tip sir

print(min(y))
print(max(y))
Răspuns:
abc
aefg
z=[1,'un sir',3,4,'alt sir'] #lista mixta

print(min(z))
print(max(z))
Răspuns:
TypeError: '<' not supported between instances of 'str' and 'int'
w=[[4,5],[3,'un sir']] #lista imbricata

print(min(w))
print(max(w))
Răspuns:
[3, 'un sir']
[4, 5]
Sortarea listei (returnează lista sortată): cu funcția sorted()

Sintaxe:
ascList=sorted(lista) #sortare ascendenta
desList=sorted(lista,reverse=True) #sortare descendenta
Exemplu:
x=[1,5,-7,3,0,9,-2]
xDesc=sorted(x,reverse=True) #sortarea descendenta a listei x
print('In ordine descendenta:',xDesc) #afisez lista x actualizata
xAsc=sorted(x) #sau x.sort();sortarea ascendenta a listei x
print('In ordine ascendenta:',xAsc) #afisez lista x actualizata
Răspuns:
Ștergerea itemurilor pe baza indexului sau a întregii liste: cu funcția del()

Observație: del() nu returnează itemul eliminat, ci doar actualizează lista!!!
Sintaxe:
del(lista(index))
del(lista)
Exemplu:
del(z[1])
Răspuns:
[1, 3, 4, 'alt sir']
x=[1,5,-7,3,0,9,-2]
del(x) #dupa stergere obiectul x nu mai exista
print(x) #obiectul x ne mai existand, primim un mesaj de eroare
Răspuns:
NameError: name 'x' is not defined
Transformarea unei liste în tuplu: cu funcția tuple()

w=tuple(z)
print(w)
print(type(w))
Răspuns:
(1, 'un sir', 3, 4, 'alt sir')
<class 'tuple'>
4. Date de tip tuplu

4.1. Definirea tuplurilor
Tuplurile sunt obiecte imutabile: modificarea itemurilor schimbă adresa din memorie (referința),
reprezentând diferența fundamentală față de liste, care sunt mutabile.
Tuplu seamănă foarte mult cu o listă cu diferența că o dată creată, itemurile sale nu se pot modifica.
Tuplurile se definesc folosind parantezele rotunde ( ), iar elementele sunt separate prin virgulă ,
x=(1,2,4,6,9,10) #tuplu cu itemuri de tip numeric (vector)
print(x)
print(type(x))
(1, 2, 4, 6, 9, 10)
<class 'tuple'>
y=('un sir','alt sir') #tuplu cu itemuri de tip sir

print(y)
print(type(y))
('un sir', 'alt sir')
<class 'tuple'>
z=(1,'un sir',3,4,[1,6]) #tuplu mixt format din numere, sir, lista
print(z)
print(type(z))
(1, 'un sir', 3, 4, [1, 6])
<class 'tuple'>
w=((4,5),(7,'un sir')) #tuplu imbricat (tuplu in tuplu)

print(w)
print(type(w))
((4, 5), (7, 'un sir'))
<class 'tuple'>
Observație: pentru a crea o tuplu cu un singur item trebuie să adăugăm o virgulă după acel item,
altfel va ignora parantezele și va trata itemul drept o simplă instanță a tipului corespunzător; astfel
(2,) este tuplu, iar (2) este numărul 2!!!
x=(2,)
print('Variabila x este:',x)
print('Tipul variabilei x este:',type(x))
y=(2)
print('Variabila y este:',y)
print('Tipul variabilei y este:',type(y))
Răspuns:
Variabila x este: (2,)
Tipul variabilei x este: <class 'tuple'>
Variabila y este: 2
Tipul variabilei y este: <class 'int'>
4.2. Metodele pentru manipularea tuplelor

Metoda Descriere
index() Indexul primului item din tuplu care deține valoarea specificată
count() Numărul de apariții al unui item în tuplu
Tuplurile nu suportă metoda copy și metodele care presupun actualizarea conținutului: sort,
reverse, append, extend, insert, remove, pop, clear.
Dintre metodele prezentate la obiectele de tip listă, tuplurile suportă doar cele care nu presupun
actualizarea conținutului: index și count.
Metoda index() returnează indexul primului item din tuplu care conține itemul căutat. Dacă
itemul căutat nu există în tuplu, programul va ridica o excepție ValueError
x=(1,5,-7,3,0,9,-7)
z=(1,'un sir',3,4,'alt sir')
print(x.index(-7)) #afisez indexul itemului -7
print(z.index('un sir')) #afisez indexul itemului 'un sir'
Răspuns:
2
1
Metoda count() returnează de câte ori apare itemul specificat în tuplu

x=(1,5,-7,3,0,9,-7)
nrApar=x.count(-7)
print(nrApar) #afisez de cate ori apare itemul -7 in tuplul x
Răspuns:
2
4.3. Funcții de tip built-in pentru tupluri

Funcția Descriere
len() Numărul de itemuri de la nivelul tuplului
max() Valoarea maximă de la nivelul tuplului
min() Valoarea minimă de la nivelul tuplului
sum() Suma valorilor itemurilor de la nivelul tuplului
sorted() Returnează o listă care conține itemurilor tuplului ordonate crescător
any() True dacă cel puțin un item din tuplu are valoarea True
all() True dacă toate itemurile tuplului se evaluează la True
list() Transformarea unei tuplu în listă
del() Șterge tuplul
Lungimea tuplului (returnează numărul de itemuri din tuplu): cu funcția len()

x=(1,5,-7,3,0,9,-2)
nrElem=len(x)
print(nrElem)
Răspuns:
7
Valoarea minimă și maximă (returnează itemul minim/maxim din tuplu): cu funcțiile min(), max()
Atenție: lucrează doar cu tupluri omogene. În cazul celor mixte (eterogene) dă eroare!!!
x=(1,5,-7,3,0,9,-2) #tuplu cu itemuri de tip numeric (vector)
minTup=min(x)
maxTup=max(x)
print(minTup)
print(maxTup)
Răspuns:
-7
9
y=('acbd','aefg','abc') #tuplu cu itemuri de tip sir

print(min(y))
print(max(y))
Răspuns:
abc
aefg
z=(1,'un sir',3,4,'alt sir') #tuplu mixt

print(min(z))
print(max(z))
Răspuns:
TypeError: '<' not supported between instances of 'str' and 'int'
w=((4,5),(3,'un sir')) #tuplu imbricat

print(min(w))
print(max(w))
Răspuns:
(3, 'un sir')
(4, 5)
Sortarea tuplului (Atenție: deoarece tuplul este imutabil returnează o listă sortată): cu funcția
sorted()
Sintaxa:
ascList=sorted(lista) #sortare ascendenta
desList=sorted(lista,reverse=True) #sortare descendenta
Exemplu:
x=(1,5,-7,3,0,9,-2)
xDesc=sorted(x,reverse=True) #sortarea descendenta a tuplului x
print('In ordine descendenta:',xDesc) #afisez tuplul x actualizat
xAsc=sorted(x) #sau x.sort();sortarea ascendenta a tuplului x
print('In ordine ascendenta:',xAsc) #afisez tuplul x actualizat
Răspuns:
Ordinea originala: (1, 5, -7, 3, 0, 9, -2)
Transformarea unui tuplu în listă: cu funcția list()

z=(1,'un sir',3,4,'alt sir')
w=list(z)
print(w)
print(type(w))
Răspuns:
[1, 'un sir', 3, 4, 'alt sir']
<class 'list'>
Ștergerea tuplului: cu funcția del()

x=(1,5,-7,3,0,9,-2)
del(x) #dupa stergere obiectul x acesta nu mai exista
print(x) #obiectul x ne mai existand, primim un mesaj de eroare
Răspuns:
NameError: name 'x' is not defined
Comparație între tuplu și listă

Tuplu Lista
Este format din obiecte imutabile (obiecte care nu pot Este formată din obiecte mutabile (obiecte care pot fi
fi modificate după crearea lor) modificate după creare)
Are date stocate în paranteze ( ). Exemplu (1,2,3) Are date stocate în paranteze [ ]. Exemplu [1,2,3]
Consumă mai puțină memorie Consumă mai multă memorie
Un item dintr-o tuplu nu poate fi eliminat sau înlocuit Un item dintr-o listă poate fi eliminat sau înlocuit
Suportă mai puține metode de tip built-in Suportă mai multe metode de tip built-in
Este adecvată pentru efectuarea operațiilor, cum ar fi
Este adecvat pentru accesarea itemurilor
inserarea și ștergerea
Se utilizează când este puțin probabil să apară Se utilizează când este mai probabil să apară
modificări: stocarea informațiilor privitoare la modificări: stocarea informațiilor privitoare la
studenții unei facultăți; pentru ca aceste informații să produsele dintr-o magazie : pentru ca aceste
rămână imuabile, acestea trebuie stocate într-un informații să poată fi modificate în permanență,
tuplu acestea trebuie stocate într-o listă
5. Date de tip dicționar

5.1. Definirea dicționarelor
Dicționarele sunt obiecte care stochează colecții de date. Fiecare item dintr-un dicționar are două
părți: o cheie și o valoare. Folosim cheia ca să localizăm valoarea. Cheia trebuie să fie unică!!!
Analogie: în dicționarul numit DEX, cheia este cuvântul pe care-l căutăm în dicționar ca să aflăm ce
semnificație are. Să considerăm cheia student, care conform dicționarului numit DEX, are
valoarea persoana care urmeaza cursurile unei universitati.
Dicționarele se definesc cu acolade { }; în interiorul lor, perechile cheie-valoare sunt despărțite prin
două puncte : ; perechea cheie-valoare este despărțită de următoare pereche prin virgulă ,
Proprietăți ale dicționarelor:
1. Dicționarul este un obiect mutabil, însă cheile sale trebuie să fie de tip imutabil (număr,
string sau tuplu, dar nu listă)
2. Nu pot exista chei duplicat
3. Valorile pot fi de orice tip de date (număr, string, listă sau tuplu)
4. Într-un dicționar putem avea chei și valori de diferite tipuri
Exemplu: un dicționar numit calificare care conține ca și chei prenumele angajatului, iar valorile
reprezintă nivelul de calificare al fiecărui angajat (de la 1 la 5)
calificare={'Ioana':1,'Costel':2,'Liviu':5,'Maricica':3,'Ionel':4,'Petrica':1,
'Stelica':4}
print(calificare)
print(type(calificare))
Răspuns:
{'Ioana': 1, 'Costel': 2, 'Liviu': 5, 'Maricica': 3, 'Ionel': 4, 'Petrica': 1,
'Stelica': 4}
<class 'dict'>
Extragerea unei valori din dicționar

Itemurile dintr-un dicționar nu sunt stocate într-o anumită ordine. Înseamnă că dicționarele nu sunt
secvențe ordonate de date precum listele, tuplele sau șirurile. Prin urmare, pentru extragerea
valorilor nu pot fi folosite indexuri numerice, ci se vor folosi cheile valorilor între paranteze drepte
[ ], punând înaintea lor numele dicționarului:
print(calificare['Ionel'])
4
Dacă solicităm o cheie care nu există, va apărea o eroare:

print(calificare['Lucian'])
KeyError: 'Lucian'
Adăugarea unei chei. Modificarea valorii asociată unei chei

Se folosește operația de atribuire =
Dacă dicționarul nu conține cheia specificată, aceasta va fi adăugată cu valoarea indicată.
Dacă dicționarul conține cheia specificată, îi va fi modificată valoarea.
Exemplu: după întocmirea dicționarului calificare, în firmă a fost angajat Cornel care are nivelul
de calificare 5; trebuie să-l introducem
calificare['Cornel']=5 #introduc cheia 'Cornel cu valoarea 5
print(calificare)
Răspuns:
{'Ioana': 1, 'Costel': 2, 'Liviu': 5, 'Maricica': 3, 'Ionel': 4, 'Petrica':
1, 'Stelica': 4, 'Cornel': 5}
Exemplu: Maricica a terminat facultatea; în acest caz ea trece de la nivelul 3 la 4

calificare['Maricica']=4 #modific valoarea cheii 'Maricica'
print(calificare)
Răspuns:
{'Ioana': 1, 'Costel': 2, 'Liviu': 5, 'Maricica': 4, 'Ionel': 4, 'Petrica':
1, 'Stelica': 4, 'Cornel': 5}
5.2. Metodele pentru manipularea dicționarelor

Metoda Descriere
dictionar.keys() Returnează o listă care cuprinde cheile dicționarului
dictionar.values() Returnează o listă care cuprinde valorile dicționarului
dictionar.items() Returnează o listă care cuprinde perechile cheie-valoare
Returnează valoarea corespunzătoare cheii precizate ca și
dictionar.get()
argument
Șterge perechea de tip cheie-valoare din dicționar pe baza
dictionar.pop()
cheii specificate
dictionar.popitem() Șterge ultima pereche de tip cheie-valoare din dicționar

dictionar.copy() Returnează o copie a dicționarului
dictionar.update() Actualizează un dicționar cu itemurile unui alt dicționar
dictionar.clear() Șterge toate perechile cheie-valoare din dicționar
Returnează un dicționar: primul argument este lista cheilor,
dict.fromkeys() definită anterior, iar al doilea argument este valoarea
comună atribuită cheilor
Metoda dictionar.keys() returnează o listă care cuprinde cheile dicționarului

calificare={'Ioana':1,'Costel':2,'Liviu':5,'Maricica':3,'Ionel':4,'Petrica':1,
'Stelica':4}
print(calificare.keys())
Răspuns:
dict_keys(['Ioana', 'Costel', 'Liviu', 'Maricica', 'Ionel', 'Petrica',
'Stelica'])
Metoda dictionar.values() returnează o listă care cuprinde valorile dicționarului

print(calificare.values())
Răspuns:
dict_values([1, 2, 5, 3, 4, 1, 4])
Metoda dictionar.items() returnează o listă care cuprinde perechile cheie-valoare

print(calificare.items())
Răspuns:
dict_items([('Ioana', 1), ('Costel', 2), ('Liviu', 5), ('Maricica', 3),
('Ionel', 4), ('Petrica', 1), ('Stelica', 4)])
Metoda dictionar.get() returnează valoarea corespunzătoare cheii precizate ca și argument

print(calificare.get('Petrica'))
Răspuns:
1
Metoda dictionar.pop() șterge perechea de tip cheie-valoare din dicționar pe baza cheii
specificate
calificare.pop('Costel')
print(calificare)
Răspuns:
{'Ioana': 1, 'Liviu': 5, 'Maricica': 4, 'Ionel': 4, 'Petrica': 1, 'Stelica':
4, 'Cornel': 5}
Metoda dictionar.popitem() șterge ultima pereche de tip cheie-valoare din dicționar

calificare.popitem()
print(calificare)
Răspuns:
{'Ioana': 1, 'Liviu': 5, 'Maricica': 4, 'Ionel': 4, 'Petrica': 1, 'Stelica': 4}
Metoda dictionar.copy() returnează o copie a dicționarului:

copieCalificare=calificare.copy()
print(copieCalificare)
Răspuns:
{'Ioana': 1, 'Liviu': 5, 'Maricica': 4, 'Ionel': 4, 'Petrica': 1, 'Stelica': 4}
Metoda dictionar.update() actualizează un dicționar cu itemurile unui alt dicționar

actualizareCalificare={'Ioana':2,'Lucian':5,'Raluca':1}
calificare.update(actualizareCalificare)
print(calificare)
Răspuns:
{'Ioana': 2, 'Liviu': 5, 'Maricica': 4, 'Ionel': 4, 'Petrica': 1, 'Stelica':
4, 'Lucian': 5, 'Raluca': 1}
Metoda dictionar.clear() șterge toate perechile cheie-valoare din dicționar

calificare.clear()
print(calificare)
Răspuns:
{}
Metoda dict.fromkeys() returnează un dicționar: primul argument este lista cheilor, definită
anterior, iar al doilea argument este valoarea comună atribuită cheilor
chei=('Rosii','Ardei','Castraveti') #definesc cheile
legume=dict.fromkeys(chei,0) #definesc numele dictionarului si stabilesc
valoarea comuna a cheilor ca fiind 0
print(legume)
Răspuns:
{'Rosii': 0, 'Ardei': 0, 'Castraveti': 0}
5.3. Funcții de tip built-in pentru dicționare

Funcția Descriere
len() Numărul de perechi cheie-valoare ale dicționarului
max() Valoare maximă a cheilor dicționarului
min() Valoarea minimă a cheilor dicționarului
sum() Suma cheilor dicționarului
sorted() Returnează o listă care conține cheile dicționarului ordonate crescător
any() True dacă cel puțin o cheie a dicționarului are valoarea True
all() True dacă toate cheile dicționarului se evaluează la True
del() Șterge dicționarul
Numărul de perechi cheie-valoare de la nivelul dicționarului: cu funcția len()

capitale={2:'Bucuresti',5:'Londra',3:'Budapesta',15:'New York',11:'Paris'}
nrPerechi=len(capitale)
print(nrPerechi)
Răspuns:
5
Valoare minimă și minimă de la nivelul cheilor dicționarului: cu funcțiile min(), max()

minChei=min(capitale)
maxChei=max(capitale)
print(minChei)
print(maxChei)
Răspuns:
2
15
Suma valorilor cheilor de la nivelul dicționarului: cu funcția sum()

sumaValChei=sum(capitale)
print(sumaValChei)
Răspuns:
36
Returnarea unei liste care conține cheile ordonate crescător: cu funcția sorted()
cheiSortate=sorted(capitale)
print(cheiSortate)
Răspuns:
[2, 3, 5, 11, 15]
Funcția any() returnează True dacă cel puțin o cheie de la nivelul dicționarului are valoarea True
(diferită de 0), respectiv funcția all() returnează True dacă toate cheile de la nivelul
dicționarului se evaluează la True
Ștergerea dicționarului: cu funcția del()

del(capitale) #dupa stergere, dictionarul nu mai exista
print(capitale)
Răspuns:
Traceback (most recent call last):
File " untitled3.py", line 13, in <module>
print(capitale)
NameError: name 'capitale' is not defined
6. Date de tip mulțime (set)

6.1. Definirea mulțimilor
Mulțimile reprezintă colecții neordonate de itemuri care nu permit duplicate. La nivelul unei
structuri de tip mulțime putem interveni cu operații de ștergere și adăugare, motiv pentru care
spunem că mulțimile sunt structuri de date de tip mutabil, dar nu pot conține elemente care au
caracter mutabil, precum liste, dicționare sau alte mulțimi. Prin urmare, în cazul mulțimilor nu există
posibilitatea imbricării lor.
Declararea mulțimilor se realizează prin intermediul acoladelor { }. Despărțirea elementelor în
mulțime se face prin virgulă ,
Mulțimile mai pot fi definite și cu funcția set().
Exemplu: o mulțime numită oraseROU care conține cele mai mari 4 orașe din România
oraseROU={'Bucuresti','Iasi','Cluj','Timisoara'}
print(oraseROU)
print(type(oraseROU))
Răspuns:
{'Bucuresti', 'Iasi', 'Timisoara', 'Cluj'}
<class 'set'>
Folosind funcția set():

oraseROU=set(['Bucuresti','Iasi','Cluj','Timisoara'])
multimeNumere=set([1, 3, 5, 7, 9])
În cazul în care nu sunt precizate elemente ale mulțimii, adică set(), se creează o mulțime goală:
multimeGoala=set()
În cazul unei mulțimi, elementele pot să fie de tip diferit (elemente eterogene):
MultimeEterogena={'Cerc', 3.14, 'Putere', 1024}
print(MultimeEterogena)
print(type(MultimeEterogena))
Răspuns:
{'Cerc', 1024, 3.14, 'Putere'}
<class 'set'>
Accesarea elementelor unei mulțimi

Elementele unei mulțimi nu sunt indexate numeric, prin urmare nu exista posibilitatea accesării
individuale. Accesarea se poate face doar global, prin intermediul întregii mulțimi
print(oraseROU)
Răspuns:
print(oraseROU[1])
Răspuns:
File "Orase.py", line 3, in <module>
print(oraseROU[1])
TypeError: 'set' object is not subscriptable
Ștergerea unei mulțimi

Este necesară precizarea cuvântului cheie del înaintea numelui mulțimii ce urmează a fi șterse
del oraseROU
print(oraseROU)
Răspuns:
print(oraseROU)
NameError: name 'oraseROU' is not defined
6.2. Metodele pentru manipularea mulțimilor

Metoda Descriere
add() Adaugă un element la mulțime
update() Adaugă mai multe elemente le mulțime
remove() Șterge elementul specificat de la nivelul mulțimii
discard() Șterge elementul specificat de la nivelul mulțimii
pop() Șterge aleator un element de la nivelul mulțimii
copy() Returnează o copie a mulțimii
clear() Șterge toate elementele din mulțime și returnează mulțimea goală
union() Returnează reuniunea a două mulțimi
intersection() Returnează intersecția a două mulțimi
difference() Returnează diferența a două mulțimi
Metoda add() permite adăugarea unei singure valori la o mulțime

oraseROU.add('Baia Mare')
print(oraseROU)
Răspuns:
{'Baia Mare', 'Bucuresti', 'Iasi', 'Timisoara', 'Cluj'}
Metoda update() permite adăugarea mai multor elemente la o mulțime prin intermediul unei
singure operații. Elementele care sunt deja prezente la nivelul mulțimii nu vor mai fi adăugate!!!
multimeNumere={1, 3, 5, 7, 9}
multimeNumere.update({1, 2, 4, 6, 8})
print(multimeNumere)
Răspuns:
{1, 2, 3, 4, 5, 6, 7, 8, 9}
Metoda remove() șterge elementul precizat ca și argument. Dacă valoarea precizată ca și argument
nu este prezentă la nivelul mulțimii, metoda returnează o eroare de tip KeyError
oraseROU.remove('Iasi')
print(oraseROU)
Răspuns:
{'Bucuresti', 'Cluj', 'Timisoara'}
oraseROU.remove('Deva')
Răspuns:
oraseROU.remove('Deva')
KeyError: 'Deva'
Metoda discard() șterge elementul precizat ca și argument. Dacă valoarea precizată ca și

argument nu este prezentă la nivelul mulțimii, metoda nu returnează niciun mesaj
oraseROU.discard('Iasi')
oraseROU.discard('Deva')
print(oraseROU)
Răspuns:
{'Cluj', 'Bucuresti', 'Timisoara'}
Metoda pop() șterge aleator un element de la nivelul mulțimii

oraseROU.pop()
print(oraseROU)
Răspuns:
{'Timisoara', 'Bucuresti', 'Iasi'} #a sters aleator elementul 'Cluj'
Metoda copy() returnează o copie a mulțimii

print(oraseROU)
Răspuns:
copieOraseROU=oraseROU.copy()
print(copieOraseROU)
Răspuns:
Metoda clear() șterge toate elementele din mulțime și returnează set() (o mulțime goală)
oraseROU.clear()
print(oraseROU)
Răspuns:
set()
Metoda union() returnează reuniunea a două mulțimi

multimea1={1, 3, 5, 7, 9}
multimea2={1, 2, 3, 4}
multimea3=multimea1.union(multimea2)
print(multimea3)
Răspuns:
{1, 2, 3, 4, 5, 7, 9}
Metoda intersection() returnează intersecția a două mulțimi

multimea1={1, 3, 5, 7, 9}
multimea2={1, 2, 3, 4}
multimea3=multimea1.intersection(multimea2)
print(multimea3)
Răspuns:
{1, 3}
Metoda difference() returnează diferența a două mulțimi

multimea1={1, 3, 5, 7, 9}
multimea2={1, 2, 3, 4}
multimea3=multimea1.difference(multimea2)
multimea4=multimea2.difference(multimea1)
print(multimea3)
print(multimea4)
Răspuns:
{9, 5, 7}
{2, 4}
6.3. Funcții de tip built-in pentru mulțimi

Funcția Descriere
len() Numărul de elemente de la nivelul mulțimii
max() Valoare maximă de la nivelul mulțimii
min() Valoarea minimă de la nivelul mulțimii
sum() Suma valorilor elementelor de la nivelul mulțimii
sorted() Returnează o listă care conține elementele mulțimii ordonate crescător
any() True dacă cel puțin un element din mulțime are valoarea True
all() True dacă toate elementelor mulțimii se evaluează la True
Numărul de elemente de la nivelul mulțimii: cu funcția len()

multimeNum={10, 7, 0, 5, 3, 9}
nrElem=len(multimeNum)
print(nrElem)
Răspuns:
6
Valoarea minimă și maximă de la nivelul mulțimii: cu funcțiile min(), max()

multimeNum={10, 7, 0, 5, 3, 9}
minVal=min(multimeNum)
maxVal=max(multimeNum)
print(minVal)
print(maxVal)
Răspuns:
0
10
Suma valorilor elementelor de la nivelul mulțimii: cu funcția sum()

multimeNum={10, 7, 0, 5, 3, 9}
sumaVal=sum(multimeNum)
print(sumaVal)
Răspuns:
34
Returnarea unei liste care conține elementele mulțimii ordonate crescător: cu funcția sorted()
multimeNum={10, 7, 0, 5, 3, 9}
listaSortata=sorted(multimeNum)
print(listaSortata)
Răspuns:
[0, 3, 5, 7, 9, 10]
Funcția any() returnează True dacă cel puțin un element se evaluează la True; în caz contrar
returnează False
multimeNum={10, 7, 0, 5, 3, 9}
raspuns=any(multimeNum)
print(raspuns)
Răspuns:
True
Funcția all() returnează True dacă toate elementele se evaluează la True; în caz contrar False
multimeNum={10, 7, 0, 5, 3, 9}
raspuns=all(multimeNum)
print(raspuns)
Răspuns:
False
6.4. Python Set Comprehension

Termenul set comprehension se referă la crearea unei mulțimi noi dintr-o mulțime existentă pe
baza unei expresii urmate de una sau mai multe instrucțiuni for și/ sau if
Exemplu: Dacă se dorește crearea unei mulțimi care conține toate orașele din mulțimea oraseROU
care încep cu litere de la A la M, putem avea în vedere următorul script:
oraseROU={'Bucuresti','Iasi','Cluj','Timisoara','Zalau','Baia Mare','Medias'}
oraseROUnew=set() #creez multimea goala oraseROUnew
for oras in oraseROU:
if oras < 'M':
oraseROUnew.add(oras)
print(oraseROUnew)
Răspuns:
{'Iasi', 'Bucuresti', 'Cluj', 'Baia Mare'}
Scriptul precedent poate fi rescris mult mai compact folosind set comprehension
oraseROU={'Bucuresti','Iasi','Cluj','Timisoara','Zalau','Baia Mare','Medias'}
oraseROUnew={oras for oras in oraseROU if oras < 'M'}
print(oraseROUnew)
Răspuns:
{'Iasi', 'Bucuresti', 'Cluj', 'Baia Mare'}
Bibliografie
7. https://docs.python.org/3/library/
CURS 13
OPERATORI
Operatorii sunt simboluri speciale în Python care efectuează calcule aritmetice sau logice. Valoarea
cu care operează operatorul se numește operand:
Exemplu:
2+3
Out[1]: 5
unde + este operatorul care efectuează însumarea operanzilor 2 și 3, iar 5 este ieșirea
operației.
1. Operatori aritmetici
Operatorii aritmetici sunt utilizați pentru efectuarea operațiilor matematice.
Operator Operația Exemplu
x=5+2
+ adunare print(x)
7
x=5-2
- scădere print(x)
3
x=5*2
* înmulțire print(x)
10
x=5/2
/ împărțire print(x)
2.5
x=5//2
// floor division (cât) print(x)
2
x=5%2
% modulo (rest) print(x)
1
x=5**2
** ridicare la putere print(x)
25
Precedența operatorilor aritmetici:

1. Ridicarea la putere **
2. Înmulțirea, împărțirea, câtul și restul *, /, //, %
3. Adunarea și scăderea +, -
2. Operatori de atribuire augmentată

Așa cum am văzut, operatorul = este operatorul simplu de atribuire (atribuie variabilei o valoare).
Operatorii de atribuire augmentată sunt utilizați în Python pentru a atribui valori variabilelor. Sunt
folosiți pentru a ajuta la prescurtarea și simplificarea codurilor.
Operator Semnificație Echivalent cu
+= x+=2 x=x+2
-= x-=2 x=x-2
*= x*=2 x=x*2
/= x/=2 x=x/2
//= x//=2 x=x//2
%= x%=2 x=x%2
**= x**=2 x=x**2
a=5 #atribui variabilei a valoarea 5

a+=2 #modific valoarea lui a; este echivalent cu a=a+2
print(a)
7
3. Operatori de comparație
Operatorii de comparație sunt folosiți pentru a compara valori, returnând True sau False.
Operator Semnificația Exemplu
x=7
y=9
< Mai mic
print(x<y)
True
print(x>y)
> Mai mare
False
print(x<=y)
<= Mai mic sau egal
True
print(x>=y)
>= Mai mare sau egal
False
print(x==y)
== Egalitate
False
print(x!=y)
!= Diferit
True
4. Operatori logici
Operator Semnificație Exemplu
x=True
Adevărat dacă ambii operanzi y=False
and
sunt adevărați print(x and y)
False
Adevărat dacă oricare dintre print(x or y)
or
operanzi este adevărat True
print(not x)
False
not Neagă operandul
print(not y)
True
5. Operatori speciali
Limbajul Python oferă câteva tipuri speciale de operatori precum operatorii speciali de identitate
și operatorii speciali de membru.
5.1. Operatorii speciali de identitate
is și is not sunt operatorii speciali de identitate din Python. Sunt utilizați pentru a verifica dacă
doi operanzi sunt identici (sunt situați în același loc din memoriei). Două variabile care sunt egale nu
implică faptul că sunt identice!!!
Operator Semnificație
Adevărat dacă operanzii sunt identici (se referă la
is
același obiect)
Adevărat dacă operanzii nu sunt identici (nu se
is not
referă la același obiect)
Exemple:
x1=3 #numar
y1=3 #numar
x2='Hello' #sir
y2='Hello' #sir
x3=[1,2,3] #lista
y3=[1,2,3] #lista
x4=(1,2,3) #tuplu
y4=(1,2,3) #tuplu
x5={'Ioana':1,'Costel':2,'Liviu':5,'Maricica':3,'Ionel':4} #dictionar
y5={'Ioana':1,'Costel':2,'Liviu':5,'Maricica':3,'Ionel':4} #dictionar
x6={'Bucuresti','Iasi','Cluj','Timisoara'} #multime
y6={'Bucuresti','Iasi','Cluj','Timisoara'} #multime
x1 is y1
True
x2 is y2
True
x3 is y3
False
x4 is y4
False
x5 is y5
False
x6 is y6
False
Variabilele (variabilele sunt și ele operanzi) x1 și y1 sunt numere întregi (int) de aceleași valori,
deci sunt egale și identice. Același lucru este cazul cu x2 și y2 care sunt șiruri (str).
Dar operanzii x3 și y3 sunt liste, x4 și y4 sunt tupluri, x5 și y5 sunt dicționare, respectiv x6 și
y6 sunt mulțimi. Sunt egali, dar nu identici deoarece interpretorul le localizează separat în
memorie.
5.2. Operatorii speciali de membru

in și not in sunt operatorii speciali de membru. Sunt folosiți pentru a testa dacă o valoare sau o
variabilă se găsește într-o secvență (șir, listă, tuplu, mulțime). Într-un dicționar putem testa doar
prezența cheii (key), nu și valoarea.
Operator Semnificație
Adevărat dacă valoarea/ variabila se găsește în
in
secvență
Adevărat dacă valoarea/ variabila nu se găsește în
not in
secvență
Exemple:
x='Hello world' #sir
y=[1,2,3,4] #lista
z=(1,2,3,4) #tuplu
w={'Ioana':1,'Costel':2,'Liviu':5,'Maricica':3,'Ionel':4} #dictionar
u={'Bucuresti','Iasi','Cluj','Timisoara'} #multime
'Hel' in x
True
2 in y
True
'Costel' in w
True
'Iasi' in u
True
STRUCTURI DE DECIZIE
1. Declarațiile if, elif, else

1.1. Declarația if
O declarație if execută un bloc de declarații dacă condiția
este adevărată.
Forma generală:
if conditie:
codul ulterior
Atenție: indentarea corectă face ca blocul de cod aferent declarației if să fie stabilit corect!!! În
Python nu există instrucțiunea end !!!!
Exemplu:
temperatura=eval(input('Introduceti temperatura masurata: '))
if temperatura>=20 and temperatura<=22:
print('Temperatura de',temperatura,'grade Celsius este \
corespunzatoare efectuarii masuratorilor')
if temperatura<20 or temperatura>22:
print('Temperatura de',temperatura,'grade Celsius nu este \
1.2. Declarația if-else

O declarație if-else execută un bloc de declarații
dacă condiția blocului if este adevărată sau un alt
bloc dacă condiția este falsă (else).
Forma generală:
if conditie:
else:
codul ulterior
Exemplu:
temperatura=eval(input('Introduceti temperatura masurata: '))
if temperatura>=20 and temperatura<=22:
print('Temperatura de',temperatura,'grade Celsius este \
else:
print('Temperatura de',temperatura,'grade Celsius nu este \
Reguli de indentare a clauzei if-else:

• if și else trebuie să fie aliniate
• declarațiile care urmează după if și else trebuie indentate corespunzător
Compararea șirurilor cu ajutorul declarației if-else

#compararea a doua denumiri de produs (2 siruri)
produs1=input('Scrieti denumirea primului produs: ')
produs2=input('Scrieti denumirea celui de-al doilea produs: ')
if produs1==produs2:
print('Denumirea produselor este identica')
else:
print('Denumirea produselor este diferita')
1.3. Declarația if-elif-else

Forma generală:
if conditie:
elif conditie:
blocul de cod al lui elif
else:
codul ulterior
Exemplu: un script pentru calculul prețului de vânzare aplicând un discount variabil

#calculul pretului de vanzare aplicand un discount variabil
#daca pretul la raft este mai mic de 100 lei, discount-ul este 0%
#daca pretul la raft este mai mare de 100 lei, discount-ul este 5%
pretRaft=eval(input('Introduceti pretul la raft: '))
if pretRaft>2000:
discount=20/100
elif pretRaft>1000:
discount=15/100
elif pretRaft>500:
discount=10/100
elif pretRaft>100:
discount=5/100
else:
discount=0/100
print('Discount-ul este',format(discount,'.0%'))
pretVanzare=pretRaft*(1-discount)
TVA=pretVanzare-pretVanzare/(1+0.19)
print('Pretul final este',format(pretVanzare,'.2f'),'lei,\ndin care TVA-ul\
reprezinta',format(TVA,'.2f'),'lei.')
În consolă:
Introduceti pretul la raft: 1245.89
Răspuns:
Discount-ul este 15%
Pretul final este 1059.01 lei,
din care TVA-ul reprezinta 169.09 lei.
1.4. Declarații imbricate

Exemplu: un script pentru decizia de acordare a ratelor într-un magazin (if în if)
#indeplinire conditii pentru acordare rate cumparare produs
#conditii: vechimea in munca minima 3 ani, salariul net minim 2000 lei
vechimeMunca=eval(input('Vechimea in munca: '))
if vechimeMunca>=3:
salariulNet=eval(input('Salariul net: '))
if salariulNet>=2000:
print('Puteti cumpara produsul in rate')
else:
print('Nu indepliniti conditia ca salariul net sa fie de minim \
2.000 lei')
else:
print('Nu indepliniti conditia vechimii in munca minime de 3 ani')
2. Bucla for
Bucla for iterează de un număr specificat de ori.
Forma generală:
for variabila in secventa:
blocul de cod al lui of
codul ulterior
Exemplu:
#Lista contine 4 itemuri, indicii incep cu 0 si
#se termina cu 3
def culori():
listaDeCulori={'Rosu','Albastu','Verde','Negru'}
for culoare in listaDeCulori:
print(culoare)
culori()
Răspuns:
Rosu
Albastru
Verde
Negru
Folosirea funcției range cu bucla for

Funcția range creează un tip de obiect numit iterabil.
Sintaxe ale funcției range:
range(m): generează o succesiune de numere de la 0 la m-1, incrementul fiind egal cu 1
range(m,n): generează o succesiune de numere de la m la n-1, incrementul fiind egal cu 1
range(m,n,p): generează o succesiune de numere de la m la n-1, incrementul fiind egal cu p
Exemple:
for x in range(7):
print(x)
Răspuns:
0
1
2
3
4
5
6
for x in range(1,7):
print(x)
Răspuns:
1
2
3
4
5
6
for x in range(1,7,2):
print(x)
Răspuns:
1
3
5
Exemplu: calculul sumei unor valori numerice introduse de la tastatură

#Acest script calculeaza suma unei serii de n
#valori numerice introduse de utilizator
#Se foloseste bucla FOR
#Numarul de valori numerice din serie

n=int(input('Introduceti numarul de valori din serie: '))
print('Numarul de valori insumate va fi',n)
#Initializez variabila suma
suma=0.0 #acumulatorul se intializează intotdeauna cu 0.0
for i in range(n):
numar=eval(input('Introduceti un numar: '))
suma=suma+numar
#Afisez suma
print('nSuma celor',n,'valori este',suma)
3. Bucla while
Bucla while face ca o declarație sau un bloc de declarații să se repete
atâta timp cât o condiție e adevărată.
Formatul general:
while(conditie):
blocul de cod al lui while
codul ulterior
Exemplu: calculul sumei unor valori numerice introduse de la tastatură

#valori numerice introduse de utilizator
#Se foloseste bucla WHILE

#Initializez variabila de control i
i=1
while(i<=n):

suma=suma+numar
i=i+1
#Afisez suma
print('Suma celor',n,'valori este',suma)
Exemplu: transformarea temperaturii măsurate în grade Celsius în grade Fahrenheit

#Programul cels2fahr.py pentru transformarea gradelor Celsius in Fahrenheit
#Formula de transformare: F=32+9/5*C
def cels2fahr():
raspuns=input('Continuati? (da/nu): ')
while(raspuns=='da'):
C=eval(input('Temperatura in grade Celsius= '))
F=32+9/5*C
print('Temperatura in grade Fahrenheit=',F)
raspuns=input('Continuati? (da/nu): ')
cels2fahr()
Exemplu: Validarea intrărilor folosind bucla while. Validarea intrărilor (input-ului) este procesul de
verificare a datelor care sunt introduse într-un program ca să fim siguri că sunt corecte înainte de a fi
folosite în calcule. Dacă un user introduce date greșite, programul va returna răspunsuri eronate sau
erori logice care sunt cel mai greu de depanat. Calculatorul nu poate să facă diferența între datele
corecte și cele incorecte.
#Acest program afiseaza salariul brut saptamanal pentru orele lucrate
def calculSalariuBrut():
#Se introduce numele angajatului
nume=input('Introdu numele angajatului:')
#Se introduce numarul orelor lucrate intr-o saptamana
ore=int(input('Introdu numarul orelor lucrate:'))
#Ia salariul orar
salOrar=float(input('Introdu salariul orar:'))
#Calculeaza salariul brut
salariu=ore*salOrar
#Afiseaza salariul
print('Sal. brut al angajatului',nume,'este:',format(salariu,',.2f'),'lei')
calculSalariuBrut()
Ce s-ar întâmpla dacă la orele lucrate într-o săptămână, operatorul în loc de 50 de ore ar introduce
500 de ore? Rezultatul ar fi aberant. Același lucru se poate întâmpla și cu salariul orar.
Cum prevenim o astfel de greșeală? Simplu! Adăugăm o buclă while.
#Acest program afiseaza salariul brut saptamanal pentru orele lucrate
def calculSalariuBrut():
#Se introduce numele angajatului
nume=input('Introdu numele angajatului:')
#Se introduce numarul orelor lucrate intr-o saptamana
ore=int(input('Introdu numarul orelor lucrate:'))
#Asigura-te ca userul nu introduce o valoare absurda
while ore>60:
print('Eroare! Nu pot fi mai mult de 60 de ore!')
ore=int(input('Introdu orele corecte:'))
#Ia salariul orar
salOrar=float(input('Introdu salariul orar:'))
#Asigura-te ca userul nu introduce o valoare absurda
while salOrar>60:
print('Eroare! Salariul orar nu poate fi mai mare de 60 lei!')
salOrar=float(input('Introdu salariul orar corect:'))
#Calculeaza salariul brut
salariu=ore*salOrar
#Afiseaza salariul
print('Sal. brut al angajatului',nume,'este:',format(salariu,',.2f'),'lei')
calculSalariuBrut()
4. Instrucțiunea break
Instrucțiunea break termină bucla care o conține și dă
controlul instrucțiunii imediat următoare corpului buclei for
sau while. Dacă instrucțiunea break se află într-o buclă
imbricată, aceasta va termina bucla cea mai interioară.
Forma generală:
bloc de cod al lui for
if condition:
break
codul ulterior
while(conditie):
bloc de cod al lui while
if condition:
break
codul ulterior
Exemplu:
#valori numerice pozitive introduse de utilizator
#Daca se introduce un numar negativ, acesta nu este luat in considerare
#si se calculeaza suma valorilor pozitive introduse pana la acesta

i=1
while(i<=n):
if numar<0:
print('Numarul nu este considerat pentru calculul sumei')
break #dacă numar<0 bucla while este intrerupta
suma=suma+numar
i=i+1
#Afisez suma valorilor pozitive introduse
print('Suma celor',i-1,'valori pozitive introduse corect este',suma)
5. Instrucțiunea continue
Instrucțiunea continue se folosește de obicei împreună cu if; este utilizată într-o buclă for sau
while pentru a sări la următoarea iterație.
Forma generală:
if condition:
continue
codul ulterior
while(conditie):
if condition:
continue
codul ulterior
Exemplu:
#valori numerice pozitive introduse de utilizator
#Daca se introduce un numar negativ, acesta nu este luat in considerare

i=1
while(i<=n):
if numar<0:
print('Numarul nu este considerat pentru calculul sumei')
continue #dacă numar<0 bucla while sare la urmatoarea iteratie
suma=suma+numar
i=i+1
#Afisez suma valorilor pozitive introduse
print('Suma celor',n,'valori pozitive este',suma)
6. Declarația pass
Instrucțiunea pass este o instrucțiune nulă. În timp ce interpretorul ignoră în totalitate
comentariul #, declarația pass nu este ignorată, dar nici nu se întâmplă nimic, rezultând
no operation (NOP).
În general, îl folosim ca substitut: să presupunem că avem o buclă sau o funcție care nu este încă
implementată, dar vrem să o implementăm în viitor. Nu putem avea un corp gol, deoarece
interpretorul ar da o eroare; folosim declarația pass pentru a construi un corp care nu face nimic.
Exemplu:
#pass este doar un substitut pentru functionalitatea care
#va fi adaugata ulterior
codul anterior
for val in sequence:
pass
............................
codul ulterior
MODULE
Modulele sunt fișiere care conțin instrucțiuni și definiții Python (variabile, funcții, clase). Rolul
modulelor este acela de a împarți programele în unități care pot fi gestionate mult mai ușor.
Câteva dintre funcțiile Python sunt construite în interpretorul lui. Dacă vrem să le folosim, trebuie
să le invocăm. Așa este cazul cu input, print, range.
Majoritatea funcțiilor sunt însă stocate în biblioteci numite module. Aceste module care sunt copiate
în computer în momentul instalării Python ajută la organizarea bibliotecilor standard.
De exemplu, putem defini un modul care poate conține funcții utilizate frecvent, funcții ce pot fi
astfel incluse în diverse aplicații în locul copierii codului de definire.
1. Module standard
Python Standard Library conține un număr mare de module utile ce sunt disponibile la instalarea
Python. Lista completă a acestor module standard poate fi consultată în directorul Lib din
directorul de instalare.
În plus, lista modulelor (modules) este disponibilă și prin intermediul interpretorului interactiv
folosind funcția help().
>>>help('modules')
Please wait a moment while I gather a list of all available modules...
__future__ _tracemalloc glob secrets

_abc _warnings gzip select
_ast _weakref hashlib selectors
_asyncio _weakrefset heapq setuptools
_bisect _winapi hmac shelve
_blake2 abc html shlex
_bootlocale aifc http shutil
_bz2 antigravity idlelib signal
_codecs argparse imaplib site
_codecs_cn array imghdr smtpd
_codecs_hk ast imp smtplib
_codecs_iso2022 asynchat importlib sndhdr
_codecs_jp asyncio inspect socket
_codecs_kr asyncore io socketserver
_codecs_tw atexit ipaddress sqlite3
_collections audioop itertools sre_compile
_collections_abc base64 json sre_constants
_compat_pickle bdb keyword sre_parse
_compression binascii lib2to3 ssl
_contextvars binhex linecache stat
_csv bisect locale statistics
_ctypes builtins logging string
_ctypes_test bz2 lzma stringprep
_datetime cProfile macpath struct
_decimal calendar mailbox subprocess
_dummy_thread cgi mailcap sunau
_elementtree cgitb marshal symbol
_functools chunk math symtable
_hashlib cmath mimetypes sys
_heapq cmd mmap sysconfig
_imp code modulefinder tabnanny
_io codecs msilib tarfile
_json codeop msvcrt telnetlib
_locale collections multiprocessing tempfile
_lsprof colorsys netrc test
_lzma compileall nntplib textwrap
_markupbase concurrent nt this
_md5 configparser ntpath threading
_msi contextlib nturl2path time
_multibytecodec contextvars numbers timeit
_multiprocessing copy opcode tkinter
_opcode copyreg operator token
_operator crypt optparse tokenize
_osx_support csv os trace
_overlapped ctypes parser traceback
_pickle curses pathlib tracemalloc
_py_abc dataclasses pdb tty
_pydecimal datetime pickle turtle
_pyio dbm pickletools turtledemo
_queue decimal pip types
_random difflib pipes typing
_sha1 dis pkg_resources unicodedata
_sha256 distutils pkgutil unittest
_sha3 doctest platform urllib
_sha512 dummy_threading plistlib uu
_signal easy_install poplib uuid
_sitebuiltins email posixpath venv
_socket encodings pprint warnings
_sqlite3 ensurepip profile wave
_sre enum pstats weakref
_ssl errno pty webbrowser
_stat faulthandler py_compile winreg
_string filecmp pyclbr winsound
_strptime fileinput pydoc wsgiref
_struct fnmatch pydoc_data xdrlib
_symtable formatter pyexpat xml
_testbuffer fractions queue xmlrpc
_testcapi ftplib quopri xxsubtype
_testconsole functools random zipapp
_testimportmultiple gc re zipfile
_testmultiphase genericpath reprlib zipimport
_thread getopt rlcompleter zlib
_threading_local getpass runpy
_tkinter gettext sched
Enter any module name to get more help. Or, type "modules spam" to search
for modules whose name or summary contain the string "spam".
Pentru a invoca o funcție stocată într-un modul, trebuie scrisă o declarație de import a modulului
respectiv în partea cea mai de sus a programului:
import modul
Pentru a simplifica sintaxa funcțiilor din modul:

import modul as acronim
Mai există și varianta de a importa din modul doar funcția dorită:

from modul import functia
2. Modulul math
Metodele modulului math sunt prezentate în tabelul următor.
Metoda Descriere
math.acos() Returns the arc cosine of a number
math.acosh() Returns the inverse hyperbolic cosine of a number
math.asin() Returns the arc sine of a number
math.asinh() Returns the inverse hyperbolic sine of a number
math.atan() Returns the arc tangent of a number in radians
math.atan2() Returns the arc tangent of y/x in radians
math.atanh() Returns the inverse hyperbolic tangent of a number
math.ceil() Rounds a number up to the nearest integer
Returns the number of ways to choose k items from n items
math.comb()
without repetition and order
Returns a float consisting of the value of the first parameter
math.copysign()
and the sign of the second parameter
math.cos() Returns the cosine of a number
math.cosh() Returns the hyperbolic cosine of a number
math.degrees() Converts an angle from radians to degrees
Returns the Euclidean distance between two points (p and q),
math.dist()
where p and q are the coordinates of that point
math.erf() Returns the error function of a number
math.erfc() Returns the complementary error function of a number
math.exp() Returns E raised to the power of x
math.expm1() Returns Ex - 1
math.fabs() Returns the absolute value of a number
math.factorial() Returns the factorial of a number
math.floor() Rounds a number down to the nearest integer
math.fmod() Returns the remainder of x/y
math.frexp() Returns the mantissa and the exponent, of a specified number
Returns the sum of all items in any iterable (tuples, arrays,
math.fsum()
lists, etc.)
math.gamma() Returns the gamma function at x
math.gcd() Returns the greatest common divisor of two integers
math.hypot() Returns the Euclidean norm
math.isclose() Checks whether two values are close to each other, or not
math.isfinite() Checks whether a number is finite or not
math.isinf() Checks whether a number is infinite or not
math.isnan() Checks whether a value is NaN (not a number) or not
math.isqrt() Rounds a square root number downwards to the nearest integer
Returns the inverse of math.frexp() which is x * (2**i) of the
math.ldexp()
given numbers x and i
math.lgamma() Returns the log gamma value of x
Returns the natural logarithm of a number, or the logarithm of
math.log()
number to base
math.log10() Returns the base-10 logarithm of x
math.log1p() Returns the natural logarithm of 1+x
math.log2() Returns the base-2 logarithm of x
Returns the number of ways to choose k items from n items with
math.perm()
order and without repetition
math.pow() Returns the value of x to the power of y

math.prod() Returns the product of all the elements in an iterable
math.radians() Converts a degree value into radians
Returns the closest value that can make numerator completely
math.remainder()
divisible by the denominator
math.sin() Returns the sine of a number
math.sinh() Returns the hyperbolic sine of a number
math.sqrt() Returns the square root of a number
math.tan() Returns the tangent of a number
math.tanh() Returns the hyperbolic tangent of a number
math.trunc() Returns the truncated integer parts of a number
Constantele modulului math

Constanta Descriere
math.e Returns Euler's number (2.7182...)
math.inf Returns a floating-point positive infinity
math.nan Returns a floating-point NaN (Not a Number) value
math.pi Returns PI (3.1415...)
math.tau Returns tau (6.2831...)
Exemplu: o funcție pentru calculul produsului scalar al doi vectori.

Varianta1:
#Calculul produsului scalar al doi vectori
#Primele doua argumente de intrare sunt modulele vectorilor
#iar cel de-al treilea este unghiul dintre vectori in grade
def produsScalar(x,y,alfa):
import math
return x*y*math.cos(math.radians(alfa))
Varianta 2:
import math as m #de obicei pentru math se foloseste acronimul m
return x*y*m.cos(m.radians(alfa))
Varianta 3:
from math import cos
from math import radians
return x*y*cos(radians(alfa))
3. Modulul statistics
Acest modul oferă metode pentru calcularea statisticilor matematice ale datelor numerice cu valori
reale. Modulul statistics nu este destinat să concureze bibliotecilor terțe Python-ului, cum ar fi
NumPy, SciPy, sau pachetelor de statistică cu funcții complete destinate statisticienilor
profesioniști, cum ar fi Minitab, SAS și Matlab. Se adresează la nivelul calculatoarelor grafice și
științifice.
Dacă nu este menționat în mod explicit, funcțiile modulului acceptă doar date de tip int, float,
Decimal și Fraction.
Metoda Descriere
mean() Arithmetic mean (“average”) of data
fmean() Fast, floating point arithmetic mean
geometric_mean() Geometric mean of data
harmonic_mean() Harmonic mean of data
median() Median (middle value) of data
median_low() Low median of data
median_high() High median of data
median_grouped() Median, or 50th percentile, of grouped data
mode() Single mode of discrete or nominal data
multimode() List of modes of discrete or nominal data
quantiles() Divide data into intervals with equal probability
pstdev() Population standard deviation of data
pvariance() Population variance of data
stdev() Sample standard deviation of data
variance() Sample variance of data
covariance() Sample covariance for two variables
correlation() Pearson’s correlation coefficient for two variables
linear_regression() Slope and intercept for simple linear regression
Exemplu: În scopul cercetării stabilității statice a procesului de prelucrare a diametrului  = 400,16

0 mm
pe o mașină unealtă, au fost măsurate primele 25 de piese prelucrate, rezultând următorul eșantion:
40.06, 40.11, 40.05, 40.12, 40.10, 40.08, 40.06, 40.09, 40.10, 40.10, 40.07, 40.10, 40.15, 40.04, 40.01,
40.07, 40.07, 40.08, 40.11, 40.11, 40.06, 40.07, 40.09, 40.06, 40.06
Să se scrie un fișier script care să calculeze media de selecție, modulele, mediana, dispersia de
selecție și abaterea standard de selecție.
import statistics as st
valori=[40.06, 40.11, 40.05, 40.12, 40.10, 40.08, 40.06, 40.09, 40.10,\
40.10, 40.07, 40.10, 40.15, 40.04, 40.01, 40.07, 40.07, 40.08,\
40.11, 40.11, 40.06, 40.07, 40.09, 40.06, 40.06]
print('media=',format(st.fmean(valori),'.3f'))
print('module=',st.multimode(valori))
print('mediana=',st.median(valori))
print('disp.Sel=',format(st.variance(valori),'.3f'))
print('abSt.Sel=',format(st.stdev(valori),'.3f'))
Răspuns:
media= 40.081
module= [40.06]
mediana= 40.08
disp.Sel= 0.001
abSt.Sel= 0.029
MODULE THIRD-PARTY
Python-ulpur fără module third-party nu poate fi folosit pentru sarcini rezolvabile de limbajele
Matlab, R etc. Dacă folosim Python în combinație cu module third-party ale sale. NumPy,
SciPy, Matplotlib, Pandas, acesta va aparține limbajelor de programare numerică de top
precum Matlab sau R.
Numpy este modulul third-party care oferă structurile de date de bază, implementând tablouri
(array). Modulul furnizează funcționalitățile necesare pentru a crea și manipula aceste structuri de
date.
SciPy se bazează pe Numpy, utilizând structurile de date furnizate de acesta. SciPy extinde
capacitățile NumPy cu funcții utile suplimentare pentru minimizare, regresie, transformare Fourier și
multe altele.
Matplotlib este un modul third-party de plotare pentru limbajul de programare Python și
modulele third-party NumPy și SciPy.
Pandas folosește toate modulele third-party

menționate anterior. Este construit pe
deasupra lor pentru a oferi un modul pentru
limbajul Python, care este, de asemenea,
capabil de manipulare și analiză a datelor.
Accentul special al Pandas constă în oferirea
de structuri de date și operații pentru
manipularea tabelelor numerice și a seriilor
temporale. Pandas este potrivit pentru lucrul
cu date din tabele, așa cum este cunoscut din
programarea foilor de calcul precum Excel.
Bibliografie
7. https://docs.python.org/3/library/
10. https://numpy.org/doc/stable/reference/
11. https://www.tutorialspoint.com/numpy/index.htm
12. https://matplotlib.org

Pdf24 Merged

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Pdf24 Merged

Încărcat de

Drepturi de autor:

Formate disponibile

Software de analiza numerica si simbolica 1

MATLAB®=Limbaj de înaltă performanță pentru proiectarea asistată de calculator.

Sistemul MATLAB constă în cinci părți principale:

general General purpose commands (Comenzi de uz general)

Graph2d Two-dimensional graphs (Grafice bidimensionale)

Biblioteca de funcții matematice a MATLAB-ului: Reprezintă o colecție complexă de algoritmi de

FUNDAMENTELE PROGRAMĂRII ÎN MATLAB (partea 1)

➢ Pentru a vedea lista funcțiilor avansate se poate tasta:

Funcția originală este reconstituită prin comanda:

nr_prea_mare = pi* nr_foarte_mare

2. Help on-line, formatul datelor, opțiuni de salvare

See also asin, sind.

Reference page in Help browser

See also expm1, log, log10, expm, expint.

Reference page in Help browser

PLOT(Y) plots the columns of Y versus their index.

b blue . point - solid

PLOT(X1,Y1,S1,X2,Y2,S2,X3,Y3,S3,...) combines the plots defined by

For example, PLOT(X,Y,'y-',X,Y,'go') plots the data twice, with a

solid yellow line interpolating green circles at the data points.

The PLOT command, if no color is specified, makes automatic use of

If you do not specify a marker type, PLOT uses no marker.

PLOT(AX,...) plots into the axes with handle AX.

PLOT returns a column vector of handles to lineseries objects, one

The X,Y pairs, or X,Y,S triples, can be followed by

See also plottools, semilogx, semilogy, loglog, plotyy, plot3, grid,

FORMAT may be used to switch between different output display formats

FORMAT may be used to switch between different output display formats

for positive, negative and zero elements.

FORMAT may be used to affect the spacing in the display of all

format, intmax('uint64'), realmax

See also disp, display, isnumeric, isfloat, isinteger.

Reference page in Help browser

Opțiuni de salvare ale variabilelor

realizează salvarea datelor c, determ și A într-un fișier date.mat

A 2x2 32 double array

Grand total is 6 elements using 48 bytes

FUNDAMENTELE PROGRAMĂRII ÎN MATLAB (partea 2)

3. Crearea fișierelor MATLAB (.m files)

Pentru a vedea conținutul unui fișier de tip .m se folosește comanda:

Caracteristicile celor două tipuri de fișiere sunt prezentate în tabelul următor:

Fișiere script Fișiere function

În Command Window tastăm:

La tastarea numelui fișierului script (fără extensia .m):

MATLAB-ul execută comenzile:

Exemplu: funcția pitagoraGen

În Command Window tastăm:

Se poate vizualiza fișierul cu comanda:

Se introduc în Command Window, în mod interactiv liniile:

MATLAB-ul va afișa matricea:

O dată introdusă, matricea este memorată în workspace și poate fi apelată simplu, ca A.

5. Operațiuni elementare cu matrice

PROGRAMAREA ÎN LIMBAJUL MATLAB (partea 1)

1. Operatori și funcții logice

+ Adunare + Plus unar (B = uplus(A))

Cu excepția operatorilor matriceali, operatorii aritmetici lucrează cu elementele corespondente ale

< Mai mic

Funcție Descriere Exemple

A=[0 1 2;3 5 0];

Operator Nivel de prioritate

PROGRAMAREA ÎN LIMBAJUL MATLAB (partea 2)

Instrucțiunile if, if-else, if-elseif, if-elseif-else

Sintaxa Schema logică

temperatura=input('Introduceti temperatura masurata: ');