Mihai Nedelcu Horațiu Mociran

METODA ELEMENTELOR FINITE

- îndrumător de laborator –

U.T.PRESS
CLUJ-NAPOCA, 2016
ISBN 978-606-737-202-1
 Editura U.T.PRESS
Str. Observatorului nr. 34
C.P. 42, O.P. 2, 400775 Cluj-Napoca
Tel.:0264-401999; Fax: 0264 - 430408
e-mail: utpress@biblio.utcluj.ro
http://www.utcluj.ro/editura

Director: Ing. Călin D. Câmpean

Referent științific: Prof. dr.ing. Cosmin G. Chiorean

Pregătire format electronic: Ing. Călin D. Câmpean

Copyright © 2016 Editura U.T.PRESS

Reproducerea integrală sau parţială a textului sau ilustraţiilor din această carte este posibilă numai cu
acordul prealabil scris al editurii U.T.PRESS.
Multiplicarea executată la editura U.T.PRESS.

ISBN 978-606-737-202-1
Bun de tipar: 14.12.2016
Tiraj: 100 exemplare
 Cu-vânt înainte!

Prezentul îndrumător ...posibilul să îndeplinească

Oferă sprijin și-ajutor Aceste clare obiective:
Studenților Masteranzi 1. Noțiuni introductive
Ai Facultății de Construcții, În teoria liniară
În lupta lor fără egal (care-i plăcută și ușoară);
De-a modela cât mai real 2. Studenții vor crea
Comportamentul structural. Într-un limbaj de programare,
Elementele Finite Aplicații ce rezolvă
Domină nestingherite O bară comprimată,
Analiza structurală. O grindă cu zăbrele,
Inginerii proiectanți Un cadru plan, o șaibă...
Folosesc noapte și zi, Vedeți, simple probleme,
Programe pe calculator Dar care programate
Bazate pe Metoda lor. Pun bine în relief
Lucrez corect? Lucrez cu spor? Cum funcționează un software
Se-ntreabă orice începător Complex bazat pe
În Sap, Consteel, Axis, Robot... MEF.
Îndrumătorul face tot!

Autorii mulțumesc
Referentului științific,
Vă urează să aveți
Studiu vesel și prolific,
Iar ca ultim comentariu:
Știința este esențială!
Exprimarea ei în versuri
La examen – opțională.
 Cuprins

Algoritmul MEF pentru calculul structural liniar ...................................................................... 1

Lucrările I și II - Noțiuni Introductive în Mediul de Programare Matlab ................................ 10
Lucrarea III – Aplicație MEF pentru o bară simplă ................................................................. 11
Lucrarea IV – Grinzi cu zăbrele............................................................................................... 18
IV.1. Noțiuni teoretice .................................................................................................................... 18
IV.2. Exemplu: grindă cu zăbrele plană .......................................................................................... 21
Lucrarea V – Cadre plane ........................................................................................................ 29
V.1. Noțiuni teoretice ...................................................................................................................... 29
V.2. Exemplu: cadru plan ............................................................................................................... 33
Lucrarea VI – elemente 2D aflate în starea plană de tensiune ................................................. 43
VI.1. Noțiuni teoretice .................................................................................................................... 43
VI.2. Exemplu: șaibă în consolă ..................................................................................................... 47
Lucrarea VII – utilizarea programului de calcul avansat Abaqus ............................................ 58
Bibliografie .............................................................................................................................. 60
APPENDIX – Noțiuni introductive în mediul de programare MATLAB ............................... 61
1. Generalități ............................................................................................................................. 61
2. Variabile ................................................................................................................................. 61
3. Matrice și Vectori ................................................................................................................... 62
3.1. Definirea matricelor ........................................................................................................ 62
3.2. Generarea vectorilor şi a matricelor uzuale ..................................................................... 67
3.3. Generarea unei reţele (mesh) ........................................................................................... 71
3.4. Manipularea matricelor ................................................................................................... 72
3.5. Operatori MATLAB........................................................................................................ 78
3.6. Calcul matriceal .............................................................................................................. 84
3.7. Prelucrarea datelor .......................................................................................................... 85
4. Rezolvarea Sistemelor de Ecuaţii Liniare ............................................................................... 89
5. Funcţii Matematice Uzuale ..................................................................................................... 90
6. Reprezentări Grafice ............................................................................................................... 95
7. Elemente de Programare MATLAB ...................................................................................... 106
7.1. Tipuri de fişiere MATLAB ........................................................................................... 106
7.2. Instrucţiuni de calcul logic ............................................................................................ 107
7.3. Vectorizarea calculelor .................................................................................................. 112
Algoritmul MEF pentru calculul structural liniar
Teoria e plăcere
Lapte cald cu stropi de miere
Dar nu tăbărâți din prima!
Aprindeți treptat lumina,
Fără maximă prudență
Cauzează dependență...
Principiul Metodei Elementelor Finite (MEF) constă în aproximarea oricărei mărimi continue
printr-un model discret, realizat din compunerea unor funcții continue, definite local pe un
număr finit de subdomenii (Elemente Finite).
MEF poate fi formulată alegând ca necunoscute deplasările, eforturile (tensiunile), sau o
combinație a acestora. În această lucrare se utilizează formularea în deplasări, cea mai utilizată
în calculul structural.
Pentru prezentarea algoritmului de calcul, se studiază cazul simplu al unei bare drepte (Fig.
I.1), acționată de o forță p uniform distribuită în lungul barei. Se consideră numai deplasarea
u(x) paralelă cu axa barei.
p x, x
O
L
Fig. I.1: Bara acționată de încărcare axială

Fig. I.2 prezintă discretizarea domeniului și anume împărțirea barei în 3 subdomenii (segmente)
de lungime l denumite Elemente Finite (EF), iar punctele care împart domeniul se vor numi
noduri.
pl pl
2 1 pl 2 pl 3 2 R
1 u1 2 u2 3 u3 4 u4
l l l
L
Fig. I.2: Discretizarea în Elemente Finite

Fig. I.3 prezintă un singur EF cu sistemul local de coordonate Ox care în cazul analizat este
paralel cu sistemul global de coordonate Ox (originea O coincide cu nodul i).
pl pl
2 e 2 x
i ui j uj
l
Fig. I.3: Elementul Finit
Deplasarea u(x) a unui punct curent pe un EF (unde x  ( xi , x j ) ), se poate aproxima prin
interpolare între deplasările nodale ui și uj utilizând frecvent funcții polinomiale. Cea mai
simplă interpolare este cea liniară:

1
 u( x)  1   2 x (I.1)
Ecuația anterioară poate fi rescrisă în formulare matriceală după cum urmează:

u  1 x  1
2
(I.2)

sau introducând notațiile U x  1 x și   1  2 

T

u  U x (I.3)
Obs: Relațiile subliniate prezintă caracter general putând fi aplicate oricărui tip de EF
destinat calculului structural.

Scriind condițiile la limită, coeficienții polinomului de interpolare pot fi exprimați în funcție

de deplasările pe direcțiile Gradelor de Liberate (GL) nodale care devin necunoscutele
problemei. Gradele de Libertate ale unui sistem reprezinta numărul de parametri independenți
care definesc poziția nodurilor în configurația deformată (deplasată).
ui  1
u j  1   2l  
1  ui
 2   u j  ui  l (I.4)

sau introducând vectorul deplasărilor nodale U e  ui u j 

T


U e  u i  1 0   A
u
j 1 l 
   A1U e (I.5)

Din Ec. (I.1) și (I.4), deplasarea curentă poate fi scrisă în funcție de deplasările nodale:
u j  ui
u ( x)  ui  x (I.6)
l
Aceeași relație se obține în formulare matriceală din Ec. (I.3) și (I.5) care au caracter general:
 1 0  x x
u  U x A U e  1 x  1 1  U e  1   U e   i  j U e
1
 (I.7)
 l l   l l
Se introduce matricea de interpolare a deplasărilor (denumită și matricea funcțiilor de formă)
   i  j  , iar relația anterioară devine:

u  U e (I.8)
Vectorul deformație  pe EF, conține în cazul de față doar deformația specifică liniară  x și cu
ajutorul relațiilor de deformații (ecuațiile lui Cauchy) este definit prin:
du
x  (I.9)
dx
și poate fi determinat în funcție de deplasările nodale utilizând Ec. (I.7):
 d i d j   1 1 u j  ui  l 
  x    U e   Ue    (I.10)
 dx dx   l l l  l 
unde la expresia finală se putea ajunge prin derivare directă a Ec. (I.6).
 1 1
Introducând matricea deformațiilor B    , relația anterioară devine:
 l l

2
   BU e (I.11)
Vectorul tensiune  pe EF, conține în cazul de față doar tensiunea normală  x și cu ajutorul
relațiilor constitutive (pentru această aplicație s-a utilizat legea lui Hooke simplă) este definit
prin:
 x  E x (I.12)
și poate fi determinat în funcție de deplasările nodale utilizând Ec. (I.10):
 1 1 u j  ui  l 
   x  E  Ue  E  E  (I.13)
 l l l  l 
Introducând matricea de rigiditate a materialului C (care pentru această aplicație se reduce la
modulul lui Young: C = E), relația anterioară devine:
  CBU e (I.14)
Pentru determinarea deplasărilor nodale Ue, se utilizează Principiul Lucrului Mecanic Virtual
(al deplasărilor virtuale) care se enunță după cum urmează: dacă un corp este în echilibru sub
acțiunea forțelor exterioare și se introduc deplasări virtuale compatibile cu legăturile δu,
variația energiei de deformație δW este egală cu variația lucrului mecanic al forțelor
exterioare δL, adică
W   L (I.15)
Deoarece  și B sunt pentru calculul liniar, independente de deplasări, rezultă că deplasarea
virtuală δu și deformația specifică virtuală  se obțin prin deplasări virtuale nodale δUe:
 u  Ue    Ue (I.16)
Variația energiei de deformație pe EF se scrie:
 We    T  ε e dV    ε e T  dV    U eT  T CBU e dV
V V V
(I.17)
Deoarece δUe și Ue sunt independeți de variabila de integrare, expresia devine:
 
 We   U eT    T CBdV  U e   U eT keU e (I.18)
V 
și introducând matricea de rigiditate a EF în coordonate locale ke :
ke    T CBdV
V
(I.19)
rezultă expresia finală a variației energiei de deformație:
 We   U eT keU e (I.20)
Pentru cazul analizat dV = Aedx (Ae fiind aria secțiunii transversale a barei) și ke se calculează:

 1
 l   1 1  EAe  1 1
ke    CBdV    CBAe dx    E 
T T
 Ae  dx  (I.21)
V l
1
   l l l l  1 1
 l

3
Se analizează acum variația lucrului mecanic al forțelor exterioare pe EF δL e. Pe caz general
EF este acționat de componente ale vectorului forțelor masice X   X Y Z  și de
componente ale vectorului încărcărilor de suprafață F   px p y pz  , acționând pe suprafața
corpului S. Expresia generală se scrie:
 Le   X t udV   F t udS (I.22)
V S

Pentru cazul analizat (element de tip bară 1D, solicitat axial) încărcarea se reduce la px = p.
Expresia variației lucrului al forțelor exterioare pe EF devine:
 Le   F t udx (I.23)
l

Utilizând Ec. (I.8), expresia de mai sus se scrie în funcție de deplasările nodale:
 
 Le    F t dx   U e (I.24)
l 
Introducând expresiile vectorului F   p și a matricei de interpolare a deplasărilor
   i  j  cu componentele date de Ec. (I.7), expresia anterioară devine:

  x  x   pl pl 
 Le  p  1   dx  l dx  U e    U e  Pe  U e
T
(I.25)
 l  l  l 2 2
sau
 Le   U eT Pe (I.26)
unde s-a introdus vectorul forțelor nodale echivalente pe EF în coordonate locale:
Pe   t F dx (I.27)
l

pe caz general acesta având expresia:

Pe   t X dV   t F dS
V S
(I.28)
Obs. Pe cazul analizat, expresia lui Pe poate fi aflată direct prin calculul rezultantei încărcării
p pe EF și împărțirea ei la cele două noduri.

Pe baza PLMV descris de Ec. (I.15) și a expresiilor din Ec. (I.20) și (I.25) rezultă:
 UeT keUe   UeT Pe (I.29)
și cum δUe este ales arbitrar, se deduce:
Pe  keU e (I.30)
Etapele următoare constau în analiza în ansamblu a corpului discretizat în elemente finite.
Primul pas este trecerea din sistemul local în sistemul global de coordonate. Procedura
presupune transformarea din coordonate locale în coordonate globale cu ajutorul matricei de
rotație Re a următoarelor mărimi:
- deplasările nodale

4
 U e  ReT U e (I.31)
- vectorul forțelor nodale echivalente pe EF
Pe = ReT Pe (I.32)
- matricea de rigiditate a EF
ke = ReT ke Re (I.33)
Această procedură care va fi descrisă în detaliu la aplicația următoare. De menționat doar că
matricea de rotație Re este ortogonală, i.e. ReT Re  I (transpusa este egală cu inversa).
Având în vedere că pentru cazul analizat sistemele de coordonate local și global sunt paralele,
toate mărimile mai sus menționate sunt identice i.e. U e  U e , ke  ke și Pe  Pe .
Al doilea pas constă în “însumarea” celor trei mărimi mai sus menționate pentru toate
elementele finite ale structurii studiate. Se introduce vectorul deplasărilor totale (obținut prin
“însumarea” deplasărilor tuturor elementelor finite):

Utot  U e1 U e2 U en 
T
(I.34)
unde n este numărul de EF. Pentru cazul studiat (n = 3), expresia de mai sus se scrie (vezi Fig.
I.2):
Utot  U e1 U e2 U e3   u1 u2 u2 u3 u3 u4 
T T
(I.35)
Analog se formează vectorul forțelor nodale echivalente totale:
Ptot   Pe1 Pe2 Pen 
T
(I.36)
care pentru cazul studiat devine (vezi Ec.(I.25)):

Ptot   Pe1 Pe2 Pe3  

pl
1 1 1 1 1 1
T T
(I.37)
2
Matricea de rigiditate pentru toate EF se obține prin însumarea pe diagonală a matricelor de
rigiditate pe EF, după cum urmează:
 ke1 
 ke2 
ktot    (I.38)
 ken 

Pentru cazul studiat expresia de mai sus devine (vezi Ec.(I.21)):
 1 1 0 00 0
 1 1 0 00 0
EAe  0 0 1 0
1 0
ktot  (I.39)
l 0 0 1 0
1 0
0 0 0 01  1
 0 0 0 01 1
Se trece acum la rescrierea ecuației de echilibru dată de PLMV pentru toate elementele finite
“însumate” pe structură. Ec. (I.30) devine:
Ptot  ktotUtot (I.40)

5
Cum elementele acestor matrice nu sunt ordonate (elemente cu aceeași semnificație apar în
poziții diferite), cu ele nu se poate opera. Se definește vectorul deplasărilor nodale ale
structurii:
U  u1 u2 um 
T
(I.41)
unde m este numărul de noduri ale structurii. Pentru cazul studiat (m = 3), expresia de mai sus
se scrie (vezi Fig.2):
U  u1 u2 u3 u4 
T
(I.42)
Analog se definește vectorul forțelor nodale echivalente pe structură:
P   P1 P2 Pm 
T
(I.43)
care pentru cazul studiat devine (a se vedea Fig. I.2):
pl
P  P1 P2 P3 P4   1 2 2 1
T T
(I.44)
2
Ultima expresie din ecuația anterioară s-a obținut prin distribuirea directă a încărcării p la
nodurile barei, pe caz general ea se obține după cum urmează.
Pentru a face legătura între vectorii U și Utot, respectiv P și Ptot, se introduce matricea de
localizare L, după cum urmează:
a) Utot  LU b) P = LT Ptot (I.45)
Matricea L conține pe fiecare linie un singur element egal cu 1, celelalte fiind nule, fiecare
coloană definind un câmp de deplasări geometric admisibil pentru deplasarea unitară
corespunzătoare, acest element poziționând un anumit element al matricei Utot în U. Matricea
L are numărul de linii egal cu numărul de GL pe EF înmulțit cu n (numărul de EF pe structură)
și numărul de coloane egal cu n.
Pentru cazul studiat se construiește L după cum urmează:
 u1  1 0 0 0
u2  0 0   u1 
1 0
u  0  u2 
 LU   2   0 1 0
0  u3 
U tot (I.46)
u 0 0 1
u3  0 
0  u4 
0 1
u3  0 1 
 4  0 0
Se poate observa cum matricea L satisface transformarea vectorului încărcărilor echivalente
din Ec. (I.45):
1
1   1 0 0 0  1
0 0
pl 2  0 1 1 0  1 pl
0 0
P = L Ptot    
T

2 2  0 0 0 0  1 2
1 1 (I.47)
 
1  0 0 0 1  1
0
1
0

aceasta fiind și modalitatea de calcul a lui P pe caz general.
Se trece acum la rescrierea ecuației de echilibru dată de PLMV pe structură. Ec. (I.40) devine:
Ptot  ktotUtot  P  LT Ptot  LT ktotUtot  LT ktot LU (I.48)
Se introduce matricea de rigiditate a structurii (în coordonate globale):

6
 K  LT ktot L (I.49)
iar ecuația de echilibru devine:
P  KU (I.50)
unde singurele necunoscute sunt deplasările U.
Pentru cazul studiat expresia lui K devine:
 1 1 0 0 
EAe  1 2 1 0 
K (I.51)
l  0 1 2 1
 0 0 1 1
Fiecare element al matricei K reprezintă o reacțiune într-un nod produsă de o creștere unitară a
deplasării unuia dintre nodurile structurii, celelalte fiind blocate, relația de mai sus constituind
condiția de echilibru caracteristică metodei deplasărilor. Dar vectorul P conține atât încărcările
exterioare, cât și reacțiunile din reazeme, ceea ce înseamnă că sistemul de ecuații dat de Ec.
(I.50) admite ca soluție deplasările structurii considerate ca și corp rigid. Pentru ca matricea K
să poată fi inversată (nesingulară), structura se fixează impunând deplasări nule pe gradele de
libertate blocate prin rezemări). Suprimând liniile și coloanele corespunzătoare deplasărilor
anulate, se obține matricea de rigiditate redusă Kredus. Corespunzător se elimină și liniile lui P,
rezultând vectorul redus al încărcărilor echivalente, rezultând Predus. Ec. (I.50) devine:
Predus  K redusUliber (I.52)
unde Uliber este vectorul deplasărilor libere (neblocate de rezemări). Deplasările libere se află
obțin prin rezolvarea sistemului de ecuații liniare de mai sus:
1
Uliber  K redus Predus (I.53)
Pentru cazul studiat, nodul 4 este blocat, în consecință Ec. (I.53) se scrie:

pl 
1  EAe  1 1 0    u1 

 
2   1 2 1   2
u (I.54)
2  
2  l 
 0  1 2  
 3
u 
Vectorul deplasărilor U se obține prin introducerea în Uliber a deplasărilor nule.
Cu liniile extrase din matricea K se construiește KR, care permite determinarea reacțiunilor din
reazeme pe baza deplasărilor nodurilor libere:
R  K RU (I.55)
Forțele echivalente din nodurile rezemate PR produc reacțiuni care nu pot fi calculate pe baza
deplasărilor nodurilor libere, dar care rezultă din echilibrul forțelor pe nod. În consecință PR se
adaugă cu semn schimbat la reacțiunile deja calculate RU, rezultând reacțiunile finale:
R  K RU - PR (I.56)
Pentru cazul studiat, reacțiunea din nodul 4 rezultă:
 u1 
0 0 1 1 uu2   P (4)
EAe
R (I.57)
l  03 
 
unde P(4) = pl/2.

7
Mai departe are loc revenirea de la structură la elementele finite în care a fost discretizată. Se
calculează deplasările pe fiecare EF (Utot) utilizând (I.45a), după care se revine la sistemul de
coordonate local prin utilizarea Ec.(I.31):
U e  ReU e (I.58)
Adaptând Ec.(I.11) și (I.14) se pot calcula deformațiile specifice, respectiv tensiunile pe fiecare
EF (pe baza cărora se ajunge la eforturi):
 tot  BReUtot  tot  CBReUtot (I.59)

8
 A fost mult? A fost cumplit?
A durut atât de tare?
Șapte pagini - mai nimic,
Și-acum...
Recapitulare
Relațiile subliniate din acest capitol au caracter absolut general, putând fi aplicate oricărui tip
de EF destinat calculului liniar al structurilor, în consecință se rescriu mai jos pentru a oferi o
vedere de ansamblu a MEF:

u  U x   A1Ue u  U e
  BUe   CBUe
W   L
 u  Ue    Ue
 We    T  dV   U eT keU e ke    T CBdV
V V

 Le   X  udV   F  udS   U Pe
t t T
e Pe   X dV   t F dS
t

V S V S

We   Le  Pe  keU e
U e  ReT U e Pe = ReT Pe ke = ReT ke Re
Utot  U e1 U e2 U en  Ptot   Pe1 Pe2 Pen 
T T

 ke1 
 ke2 
ktot   
 ken 

U  u1 u2 um  P   P1 P2 Pm 
T T

P = LT Ptot Ptot  ktotUtot Utot  LU

P  KU K  LT ktot L
Predus  K redusUliber 1
Uliber  K redus Predus
R  K RU - PR
 tot  BReUtot  tot  CBReUtot

Sfatul doctorului inginer: A se citi de trei ori pe zi, înainte (sau în loc) de fiecare masă!

9
Lucrările I și II - Noțiuni Introductive în Mediul de Programare Matlab
Se poate înțelege un vals fără să-l dansăm?
Se poate înțelege fotbalul fără să-l jucăm?
Se poate înțelege MEF fără să programăm?
Teoretic da.
Practic...
OBIECTIVELE LUCRĂRILOR

- familiarizarea cu mediul de programare MATLAB

- definirea și manipularea matricelor și vectorilor;

- calcule cu matrice și vectori;

- rezolvarea sistemelor de ecuații liniare;

- însușirea funcțiilor matematice uzuale (utilizate în cadrul disciplinei);
- elemente de grafică 2D și 3D;
- elemente de programare MATLAB.

Pentru îndeplinirea obiectivelor, se vor parcurge noțiunile de sintaxă și semantică MATLAB,

precum și exemplele date în APPENDIX.

10
Lucrarea III – Aplicație MEF pentru o bară simplă
Viața vi se va schimba
Dacă-n MEF veți programa.
Fără alte explicații
Hai să scriem aplicații!
Să se afle deplasările nodale, reacțiunea și tensiunile normale longitudinale pentru bara descrisă
în Fig. I.1. Caracteristicile structurii: interval a = 1000mm, modulul lui Young E = 1000MPa,
aria secțiunii transversale A = 100mm2, forța uniform distribuită p = 1N/ mm.

%Se șterg toate variabilele din memorie (… am uitat tot!)

clear all;
%Se introduc datele de intrare:
%lungimea barei [mm]
lungime_bara=1000;
%Aria secțiunii transversale [mm^2]
Ae=100;
%modulul lui Young [N/mm^2]
E=1000;
%încărcarea axială uniform distribuită [N/mm]
p=1;
%număr EF pe bară
nrEF=3; (la început cât mai puține, ca să pricepem mai bine...)
%număr GL pe EF
nrGL_EF=2; (gradele de libertare, egalitate, fraternitate...)

11
%număr noduri
nrnod=nrEF+1; nrnod=4
%număr GL
nrGL=nrnod; nrGL=4
%lungime EF
l=lungime_bara/nrEF; l=333.33
%se construiește matricea (credeți-mă ce spun eu
până aici a fost mai greu)
Elementelor Finite
%inițializare
M_EF =
M_EF=zeros(nrEF,nrGL_EF+1);
%prima coloană conține denumirea EF
0 0 0
M_EF(:,1)=1:nrEF;
0 0 0
%a doua coloană conține primul nod al
0 0 0
EF
(trageți cu ochiul și la Fig.I.2,
M_EF(:,2)=1:nrEF; așa... șmecherește)
%a treia coloană conține al doilea nod
al EF M_EF =
M_EF(:,3)=2:nrEF+1;
%se construiește matricea Gradelor de 1 1 2
Libertate (pentru această aplicație, 2 2 3
este identică cu matricea M_EF) 3 3 4
M_GL=M_EF;
%matricea de rigiditate a EF
(atenție mai jos la semne!
Nu de circulație...)

ke =
ke=E*Ae/l*[1 -1;-1 1;];
300 -300
%se construiește matricea de -300 300
localizare L
(cine înțelege ce urmează acum
va fii un programator extrem de bun)

L=
L=zeros(nrGL_EF*nrEF,nrGL);

1 0 0 0
for i=1:nrEF
0 1 0 0
for j=1:nrGL_EF
0 1 0 0
L(j+(i-1)* nrGL_EF, M_GL(i,j+1))=1;
0 0 1 0
end
0 0 1 0
end
0 0 0 1

12
%matricea k_tot conține pe diagonală
nrEF matrice de rigiditate ke ktot =
ktot=ke;
for i=1:nrEF-1 300 -300 0 0 0 0
ktot=blkdiag(ktot,ke) -300 300 0 0 0 0
end 0 0 300 -300 0 0
0 0 -300 300 0 0
%matricea de rigiditate a structurii 0 0 0 0 300 -300
(o splendoare a naturii) 0 0 0 0 -300 300

K=L'*ktot*L; K=

%introducerea încărcărilor echivalente 300 -300 0 0

în noduri -300 600 -300 0
(algoritmul nu admite
0 -300 600 -300
încărcări distribuite
dar noi le echivalăm 0 0 -300 300
și-n noduri le concentrăm)

%vectorul încărcărilor pe EF Pe =

Pe=[p*l/2;p*l/2;]; 166.67
166.67
%vectorul încărcărilor pe toate EF Ptot =

Ptot=zeros(nrGL_EF*nrEF,1); 166.67
166.67
for i=1:nrGL_EF:nrGL_EF*nrEF 166.67
Ptot(i:i+nrGL_EF-1)=Pe; 166.67
end 166.67
166.67

%vectorul încărcărilor asamblat P=

P=L'*Ptot; 166.67
333.33
%vectorul GL 333.33
GLtot=zeros(1,nrGL); 166.67
%se blochează nodul rezemat (4 forțe pentru 4 noduri, armonie!)
GLtot(nrGL)=1; %1 = blocat GLtot = 0 0 0 1
%0 = liber
%se caută GL blocate
GLbl=find(GLtot); GLbl = 4

13
%se caută GL libere
(Grade de Libertate libere...știu)
GLlib=find(GLtot==0); GLlib = 1 2 3

%se construiește matricea de rigiditate

redusă
Kredus=K; Kredus =
%se elimină liniile GL blocate
Kredus(GLbl,:)=[]; 300 -300 0
%se elimină coloanele GL blocate -300 600 -300
Kredus(:,GLbl)=[]; 0 -300 600

%se construiește vectorul redus al

încărcărilor echivalente
Predus=P; Predus =
%se elimină elementele GL blocate
Predus(GLbl,:)=[]; 166.67
333.33
%se determină deplasările GL libere 333.33
(necunoscutele misterioase ale problemei)

Uliber =
Uliber=Kredus\Predus;
5.00
4.44
% vectorul deplasărilor totale
2.78
U=zeros(nrGL,1); (am aflat deplasările, URAAA!)
% deplasările GL blocate sunt 0
U(GLbl)=0; U=
%deplasările GL libere au fost deja
calculate 5.00
U(GLlib)=Uliber; 4.44
2.78
%matricea de rigiditate 0
corespunzătoare GL blocate
KR=K(GLbl,:);
KR = 0 0 -300 300
%calcul reacțiuni. Atenție, la
reacțiunea rezultată din deplasările
nodale, se scade încărcarea
(încercați să aflați reacțiunea și printr-un elaborat
echivalentă din nodul blocat. calcul manual)

R=KR*U-P(nrnod); R = -1000

14
%vectorul deplasărilor pentru toate EF
Utot=L*U; Utot =

5.00
4.44
4.44
%altă matrice în care fiecare coloană 2.78
conține deplasările unui EF 2.78
U0tot=reshape(Utot,[],nrEF); 0

%matricea de rigiditate a materialului U0tot =

(pentru elemente 1D are un singur
element) 5.00 4.44 2.78
C=E; 4.44 2.78 0
%matricea deformațiilor
B=[-1/l 1/l];
B= -0.03 0.03
%calcul tensiuni pe fiecare EF
sigma_ctEF=C*B*U0tot; sigma_ctEF =

-1.67 -5.00 -8.33

% Dar tensiunile nu sunt constante ci variază liniar. Se mediază valorile pe noduri,

rezultând diagrama reală a tensiunilor.

%vector tensiuni sigma pentru toate

nodurile
sigma=zeros(1,nrnod);
for i=2:nrnod-1
sigma(i)=(sigma_ctEF(i-1) +
sigma_ctEF(i))/2;
end
%pentru primul și ultimul nod se
extrapolează în funcție de panta
diagramei
panta_sigma=(sigma_ctEF(2) - panta_sigma = -0.0100
sigma_ctEF(1))/l;

sigma(1)=sigma_ctEF(1)-
panta_sigma*l/2;
sigma(nrnod)=sigma_ctEF(nrEF) + sigma =
panta_sigma*l/2; 0.00 -3.33 -6.67 -10.00

15
%afișare rezultate
(Aproape am terminat/Domnul fie lăudat!)
%coordonatele nodurilor în lungul barei
x=0:l:l*nrEF;
%afișare deplasări
subplot(1,2,1);
bar(x,U,1,'r');
axis tight; title('deplasari);
%afișare tensiuni sigma
subplot(1,2,2);
bar(x(1:nrEF)+l/2,sigma_ctEF,1);
axis tight; title('sigma');
hold on
plot(x,sigma,'color','r','Linewidth',2); (roșu am ales nuanța / să-i pricepem importanța)

axis tight; title('sigma');

legend('sigma pe EF,'sigma mediat',2);
%Sfârșit!

%Epilog: Rulați aplicația anterioară de mai multe ori mărind de fiecare dată numărul
de Elemente Finite. Comparați rezultatele!

Fig. III.4: Deplasări nodale și tensiuni normale longitudinale

16
Temă!!! (Acum se separă adulții de copii...)
Adaptați aplicația anterioară pentru cazurile de încărcare și rezemare date mai jos (P = 1kN):
p p

L L/2 L/2
a) b)
x
p(x)=p L
P
P
2L/3 L/3 L
c) d)
Fig. III.5: Temă 1 – bare încărcate axial

17
Lucrarea IV – Grinzi cu zăbrele

IV.1. Noțiuni teoretice

Pentru sănătatea d-voastră consumați zilnic trei pagini de teorie!

P1 P2 P3
4 8

p1 2 4 6 p2
1 3 5 7 9 11
y 2 6 10
1 3 ΔT(ºC) 5 7

x
Fig. IV.1: Grinda cu zăbrele și 3 tipuri de încărcări

Mare parte din relațiile prezentate în primul capitol se aplică direct, după definirea elementului
finit considerat în analiză. Pentru acest tip de structură, elementul finit este bara dublu articulată
la capete prezentată în Fig. IV.2 împreună cu Gradele de Libertate.
x
y vj uj

e
y
yj vi α l
ui
yi

O xi x
xj

Fig. IV.2: Bara dublu articulată - GL

Fiecare bară este definită geometric de lungimea l și unghiul de înclinare  , care se calculează
pe baza coordonatelor nodurilor ( xi , yi și x j , y j ) în sistemul global de axe:

l  ( x2  x1 ) 2  ( y2  y1 ) 2
 y2  y1  (II.1)
  arctan  
 x2  x1 
Se observă cum sistemul local Oxy al barei nu este paralel cu sistemul global Oxy ci este rotit
cu unghiul de înclinare al barei  .

18
În acest îndrumător se analizează numai cazul grinzilor cu zăbrele plane. În consecință gradele
de libertate pe nodul i sunt date de deplasările nodale ui și vi după axele locale Ox și respectiv
Oy, rezultând vectorul deplasărilor nodale pe EF :

U e  ui vi u j v j 
T
(II.2)
Pentru exprimarea deplasării u(x) și v(x) a unui punct curent pe un EF, se utilizează același
polinom de interpolare liniară definit în primul capitol și dat de Ec. (I.1) ( u( x)  1   2 x ),
rezultând că bara rămâne dreaptă în urma acțiunilor exterioare, iar deformația specifică este
constantă pe toată bara. Deformația specifică se scrie analog cu Ec. (I.7):
 d i d j   1 1  u j  ui  l 
  x   0 0  U e   0 0 U e    (II.3)
 dx dx   l l  l  l 
Se observă cum deplasările nodale vi și vj nu contribuie la deformațiile specifice. Matricea
 1 1 
deformațiilor devine B   0 0 , matricea de rigiditate a materialului C conține tot un
 l l 
singur element (modulul lui Young), iar matricea de rigiditate a EF în coordonate locale se
determină pe baza Ec. (I.19) (vezi și Ec. (I.21)):
1 0 1 0
EAe  0 0 0 0
ke    CBdV 
T
(II.4)
l  1 0 1 0
 0 0 
V
0 0
Vectorul forțelor nodale echivalente pe EF în coordonate locale Pe conține 4 componente, unul
pentru fiecare GL, și se calculează cu Ec.(I.27) dacă există încărcări distribuite pe bară (cazul
încărcării p sau a acționării termice prezentate în Fig. IV.2). În cazul acționării numai cu forțe
concentrate în noduri, vectorii forțelor nodale Pe și P se denumesc simplu vectorii încărcărilor
pe EF, respectiv, pe structură.
Se trece acum la transformarea din coordonate locale în coordonate globale cu ajutorul matricei
de rotație Re a mărimilor Ue, ke și Pe.
y
x
vj
v j
u j

y j
e uj

vi α
vi
i ui x
ui

Fig. IV.3: Transformarea din sistemul local în sistemul global de coordonate

Din Fig. IV.3 se determină următoarele relații între deplasările nodale în cele două sisteme de
coordonate, pentru bara dublu articulată:

19
 ui  ui cos   vi sin 
vi  ui sin   vi cos 
(II.5)
u j  u j cos   v j sin 
v j  u j sin   v j cos 
care se scriu matriceal după cum urmează:
 ui   cos  sin  0 0   ui 
 vi    sin  cos  0 0   vi   U = R U
u j    0 0 cos  sin   u j  e e e (II.6)
v   0  
0  sin  cos    v j 
 j 
S-a demonstrat la curs că matricea de rotație Re este întotdeauna ortogonală, i.e. ReT Re  I , în
consecință ecuația anterioară poate fi rescrisă sub forma Ec. (I.31) ( U e  ReT U e ) care duce la
transformarea gradelor de libertate din coordonate locale în coordonate globale. Analog se
obține relația de transformare pentru vectorii încărcărilor dată de Ec. (I.32) ( Pe = ReT Pe ) sau
invers:
Pe = Re Pe (II.7)
Ecuația de echilibru a PLMV pe EF în coordonate locale a fost dată de Ec. (I.30) ( Pe  keU e ).
Utilizând ecuațiile de transformare (II.6) și (II.7) rezultă:
Pe  keUe  Re Pe = ke ReUe  Pe = ReT ke ReU e  keU e (II.8)
de unde s-a obținut expresia matricei de rigiditate a EF în coordonate globale ke dată de
Ec.(I.33) ( ke = ReT ke Re ), astfel încât ecuația de echilibru a PLMV pe EF se poate scrie în
coordonate globale:
Pe = keU e (II.9)
În continuare se aplică relațiile date la finalul capitolului anterior, acest fapt demonstrând
caracterul general al algoritmului MEF pentru calculul liniar al structurilor.

20
 IV.2. Exemplu: grindă cu zăbrele plană
Hai că ne-a venit un chef
Să mai programăm în MEF!
Să se determine deplasările nodale, reacțiunile și forțele axiale din bare pentru grinda cu zăbrele
acționată de forțe concentrate în noduri (Fig. IV.4). Caracteristicile structurii: interval a = 1m,
modulul lui Young E = 2.1e05MPa, aria tălpilor A1 = 200mm2, aria diagonalelor A2 = 100mm2,
forța concentrată P = 100kN.
P P P
4 A1 5

5 6 7
A2
a

6 7 8 9 10 11
R2 1 2 3
1 2 A1 3 4
R1 R3
a a a a a a

Fig. IV.4: a) Grindă cu zăbrele; b) Grade de Libertate

%Se șterg toate variabilele din memorie

??? Semnele de întrebare
Înseamnă că fiecare
Completează cu ce știe.
Mila Domnului să fie!
%Se introduc datele de intrare
%modulul lui Young [N/mm^2]
E=210000;
%se introduc coordonatele nodurilor [mm]
noduri=[1 0 0;2 2000 0;3 4000 0;4 6000 0;5 1000 1000;6 3000 1000;7 5000 1000;];
%ariile barelor (A1 - talpi, A2 - diagonale) [mm^2]
A1=200;
A2=100;
%se introduce matricea Elementelor Finite
%se introduc barele cu nodurile de capăt și aria fiecărei bare
M_EF=[1 1 2 A1;2 2 3 A1;3 3 4 A1;4 5 6 A1;5 6 7 A1;6 1 5 A2;7 5 2 A2;8 2 6 A2;9 6
3 A2;10 3 7 A2;11 7 4 A2;];
%se introduc încărcările concentrate în noduri pe x si y [N]
Pinc=[5 0 -100000;6 0 -100000;7 0 -100000;];
%se introduc deplasări nule în reazeme
nodrez=[1 1 1; 4 0 1;]; %nod 1 - GL blocat, 0 - GL liber
%număr GL pe nod
nrGL_nod=???; % deplasare pe x și deplasare pe y
%număr noduri pe EF
nrnodEF=???;

21
%număr GL pe EF
nrGL_EF=???; nrGL_EF = 4
%număr noduri
nrnod=size(noduri,1); nrnod= 7
%număr EF
nrEF=size(M_EF,1); nrEF= 11
%număr noduri încărcate
nrnod_inc=???; nrnod_inc= 2
%număr GL
nrGL=???; nrGL= 14

%se adaugă lungimea și înclinarea

fiecărei bare la matricea "EF" M_EF =
for i=1:nrEF
x1= noduri(M_EF(i,2),2); 1 1 2 200 2000 0
y1= noduri(M_EF(i,2),3); 2 2 3 200 2000 0
x2= noduri(M_EF(i,3),2); 3 3 4 200 2000 0
y2= noduri(M_EF(i,3),3); 4 5 6 200 2000 0
5 6 7 200 2000 0
M_EF(i,5)=sqrt((x2-x1)^2+(y2-y1)^2); 6 1 5 100 1414.21 45
M_EF(i,6)= atand((y2-y1)/(x2-x1)); 7 5 2 100 1414.21 -45
end 8 2 6 100 1414.21 45
%se construiește matricea Gradelor de 9 6 3 100 1414.21 -45
Libertate 10 3 7 100 1414.21 45
M_GL=zeros(nrEF, 11 7 4 100 1414.21 -45
1+nrnodEF*nrGL_nod);
%prima coloană conține denumirea EF
M_GL(:,1)=1:nrEF; M_GL =
%următoarele 4 coloane conțin GL
pentru fiecare EF 1 1 2 3 4
%Obs: numărul GL pe verticală este 2 3 4 5 6
(numărul nodului)*2, 3 5 6 7 8
%numărul GL pe orizontală este 4 9 10 11 12
(numărul nodului)*2-1 5 11 12 13 14
for i=1:nrEF 6 1 2 9 10
for j=1:nrnodEF 7 9 10 3 4
M_GL(i,2*j)=M_EF(i,j+1)*2-1; 8 3 4 11 12
M_GL(i,2*j+1)=M_EF(i,j+1)*2; 9 11 12 5 6
end 10 5 6 13 14
end 11 13 14 7 8

22
%se construiește matricea de L=
localizare L
(GPS-ul MEF-ului) 1 0 0 0 ...
??? 0 1 0 0 ...
0 0 1 0 ...
%matricea ktot conține pe diagonală 0 0 0 1 ...
nrEF matrice de rigiditate pe EF în 0 0 1 0 ...
coordonate globale kg_e ... ... ... ... ...
ktot=[]; (...mai sunt multe-multe elemente)
for i=1:nrEF
A=M_EF(i,4); %arie bară (diferă de la o bară la alta)
l=M_EF(i,5); %lungime ke= E*A/l*
alfa=M_EF(i,6); %înclinare 1 0 -1 0
%matricea de rigiditate a EF în 0 0 0 0
coordonate locale -1 0 1 0
ke=E*A/l*[1 0 -1 0;0 0 0 0;-1 0 1 0;0 0 0 0 0
0 0 0];
%se construiește matricea de rotație ktot =
Re
Re0=[cosd(alfa) sind(alfa); - 21000 0 -21000 0 0 ...
sind(alfa) cosd(alfa);]; 0 0 0 0 0 ...
Re=blkdiag(Re0, Re0); -21000 0 21000 0 0 ...
%matricea de rigiditate în 0 0 0 0 0 ...
coordonate globale kg_e 0 0 0 0 21000 ...
kg_e =Re'*ke*Re; ... ... ... ... ... ...
ktot=blkdiag(ktot,kg_e); (...chiar multe)
end K=

%matricea de rigiditate a structurii 1.0e+04 *

(o minune a naturii) 2.84 0.74 -2.10 0 0 ...
K=???; 0.74 0.74 0 0 0 ...
-2.10 0 5.68 0 -2.10 ...
... ... ... ... ... ...

%se construiește vectorul încărcărilor PT =

P=zeros(nrGL,1);
for i=1:nrnod_inc 1.0e+05 *
P(Pinc(i,1)*2)=Pinc(i,3); 0 0 0 0 0 0 0 0 0 -1 0 -1 0 -1
P(Pinc(i,1)*2-1)=Pinc(i,2);
end

23
%se construiește vectorul GL pe baza
vectorului nodrez. Obs: analog cu
formarea M_GL GL =
GL=zeros(1,nrGL);
for i=1: length (nodrez) 1 1 0 0 0 0 0 1 0 0 0 0 0 0
GL(2*nodrez(i)-1)=nodrez(i,2);
GL(2*nodrez(i))=nodrez(i,3); GLbl =
end
%se caută GL blocate 1 2 8
GLbl=???;
%se caută GL libere GLlib =
GLlib=???;
3 4 5 6 7 9 10 11 12 13 14
%se construiește matricea de rigiditate
redusă Kredus =
Kredus=K;
%se elimină liniile GL blocate 1.0e+04 *
???; 5.68 0 -2.10 0 ...
%se elimină coloanele GL blocate 0 1.49 0 0 ...
???; -2.10 0 5.68 0 ...
0 0 0 1.48 ...
... ... ... ... ...
%se construiește vectorul redus al
încărcărilor PredusT =
Predus=P;
%se elimină elementele GL blocate 1.0e+05 *
???; 0 0 0 0 0 0 -1 0 -1 0 -1

%se determină deplasările GL libere Uliber =

Uliber=???;
7.14
%vectorul deplasărilor totale -65.03
U=zeros(nrGL,1); 19.05
-65.03
%se introduc deplasările GL libere 26.19
deja calculate 22.62
???; ...
(problema e ca și rezolvată!
și totuși...)

24
%matricea de rigiditate
corespunzătoare GL blocate
KR=???; R=

%calcul reacțiuni. Obs: nu exista forte 1.0e+05 *

echivalente în nodurile rezemate 0.00
R=???; 1.50
1.50
%vectorul deplasărilor pentru toate EF (ce bine a dat! Bravo MEF!)
Utot=L*U;
%altă matrice în care fiecare coloană U0tot =
conține deplasările unui EF
U0tot=reshape(Utot,[],nrEF); 0 7.14 19.05 22.62 13.10 ...
0 -65.03 -65.03 -42.82 -77.72 ...
%matricea de rigiditate a materialului 7.14 19.05 26.19 13.10 3.57 ...
(pentru elemente 1D are un singur -65.03 -65.03 0 -77.72 -42.82 ...
element)
C=E;
%se calculează produsul matricelor C, CBRe =
B si Re pentru fiecare EF
CBRe=zeros(nrEF,nrGL_EF); -105.00 0 105.00 0 ...
for i=1:nrEF -105.00 0 105.00 0 ...
l=M_EF(i,5); %lungimea barei -105.00 0 105.00 0 ...
alfa=M_EF(i,6); %înclinarea ... ... ... ...
%se construiește din nou matricea
de rotație Re sigma =
Re0=???;
Re=???; 750.00
%matricea deformațiilor 1250.00
B=[-1/l 0 1/l 0]; 750.00
%produsul matricelor C, B si Re ...
CBRe(i,:)=C*B*Re; N=
end
%calcul tensiuni pentru fiecare bară 1.0e+05 *
sigma=diag(CBRe*U0tot); 1.50
2.50
%calcul forțe axiale (sigma x aria) 1.50
N=sigma.*M_EF(:,4); ...

25
%afișare rezultate (greul de-abia acum începe)

%afișare deformată
%factor scalare deformată (10% din raportul dintre lungimea maximă de bară și
%deplasarea maximă)
f_scalare=0.1*max(M_EF(:,5))/max(max(abs(U0tot)));
(Fără-o magică scalare / nu vedem nicio schimbare)
subplot(2,1,1);
for i=1:nrEF
%coordonate noduri pentru bara i
x1=noduri(M_EF(i,2),2); y1=noduri(M_EF(i,2),3);
x2=noduri(M_EF(i,3),2); y2=noduri(M_EF(i,3),3);
%afișare structură inițială
line([x1 x2],[y1 y2]);
%coordonate noduri pentru bara i + deplasări
x1_def=x1+U0tot(1,i)*f_scalare; y1_def=y1+U0tot(2,i)*f_scalare;
x2_def=x2+U0tot(3,i)*f_scalare; y2_def=y2+U0tot(4,i)*f_scalare;
%afișare deformată
line([x1_def x2_def],[y1_def y2_def],'Linewidth',2,'color', 'r');
hold on;
end
%titlul figurii
title('Deformata','FontSize',12);
axis equal;

%afișare valori forțe axiale

subplot(2,1,2);
for i=1:nrEF
%coordonate noduri pentru bara i (a se vedea puțin mai sus)
???
%coordonate nod centru pentru bara i
x_mijloc=(x1+x2)/2;
y_mijloc=(y1+y2)/2;
%culoare albastru pentru compresiune, magenta pentru întindere
if N(i)<0
culoare='b';
else
culoare='m';
end
%afișare structură inițială
line([x1 x2],[y1 y2],'Linewidth',2,'color',culoare);
%afișare valori forțe axiale
text(x_mijloc,y_mijloc,num2str(N(i)/1000,'%10.2f'),'FontSize',12,'color', culoare);

26
 hold on;
end
%titlul figurii
title('Forte axiale [kN]','FontSize',12);
axis equal;

% Sfârșit!

Fig. IV.5: Deformata și forțele axiale în bare

27
Temă!!! (este clar că avem ceva cu voi)
Adaptați aplicația anterioară pentru grinzile cu zăbrele de mai jos (p = 10kN/m, ΔT =
+30ºC) și verificați rezultatele utilizând un program de calcul comercial (ex.
Sap2000):
P
P P
P A1 P
P/2 P/2 P P

a
A2
2P 2P

a
6x(2a) A1 A1
a a
a) b)

A1
1,5a

A2
A2
3a

A2
ΔT(ºC)

4x(2a)
p A1 A1
3a
3a

3a 4x(2a)
c) d)
Fig. IV.6: Temă 2 – grinzi cu zăbrele

Obs: La curs s-au prezentat particularitățile încărcării distribuite pe bară și ale acționării
prin diferență de temperatură.

28
Lucrarea V – Cadre plane

V.1. Noțiuni teoretice

Încă o călătorie
Prin superba teorie.
Dacă la grinzile cu zăbrele toate nodurile sunt considerate articulații, iar barele sunt supuse
numai la forțe axiale, cadrele (plane sau spațiale) conțin legături continue între bare,
considerate (într-o analiză simplificată) noduri rigide, iar barele pot fi supuse la toate eforturile
secționale (forțe axiale, momente încovoietoare și de torsiune). În lucrarea de față se prezintă
aplicarea MEF numai pentru cadrele plane, analiza având un grad de complexitate mai scăzut,
dar formulările pot fi cu ușurință adaptate pentru cadrele spațiale.
Fig. V.1 prezintă un exemplu de cadru plan cu sistemele de coordonate global și local, și
discretizarea în elemente finite (barele cadrului).
y
p x y y
P x
2 2 3 2 2 2 3 3

3 3

1 4 1 4
x

1 1
x y
Fig. V.1: Cadru plan

Fig. V.2 prezintă Gradele de Libertate și eforturile considerate în nodurile unui EF.

vi vj Ti Tj
θi θj Mi Mj

ui i e j uj Ni e Nj
l l
Fig. V.2: Elementul Finit – GL și eforturi nodale

Așadar, pentru cadre plane, vectorul deplasărilor nodale pe EF se scrie:

U e  ui vi i u j v j  j 
T
(III.1)
Obs: Față de cazul grinzilor cu zăbrele (Ec. (II.2)) se adaugă la GL rotirea nodului.

Vectorul eforturilor nodale pe EF se scrie:

29
 Se   Ni Ti M i N j T j M j 
T
(III.2)
Pentru deplasările curente u(x) și v(x) se utilizează următoarele polinoame de interpolare:
u ( x)  1   2 x
(III.3)
v( x)   3   4 x   5 x 2   6 x 3
Rotirea curentă θ(x) se obține ca derivata deplasării transversale, în consecință nu este necesar
un polinom independent, iar expresia ei rezultă:
dv
 ( x)    4  2 5 x  3 6 x 2 (III.4)
dx
Alegerea gradelor polinoamelor nu este aleatoare (polinom de gradul I pentru u asociat unui
efort axial constant pe bară, respectiv polinom de gradul III pentru deplasarea transversală v
asociat unei variații liniare a momentului încovoietor în lungul barei în absența unor încărcări
aplicate în cuprinsul barei), iar determinarea lor s-a discutat în detaliu la curs. Ec. (III.3) se
rescrie:
u ( x)  1 x 0 0 0 0 
u  3   U x (III.5)
2

v ( x )   0 0 1 x x x 
unde   1  2 3  4 5  6  . Se observă că numărul coeficienților α coincide cu cel al
T

deplasările nodale, în consecință coeficienții pot fi exprimați în funcție de GL, utilizând Ec.
(I.5) (   A1U e ) în care matricea A se determină pe baza scrierii condițiilor la limită. Matricea
de interpolare a deplasărilor  se determină cu Ec. (I.7) ( u  U x A1U e  U e ).
Vectorul deformație  pe EF, conține doar deformația specifică liniară longitudinală  x (în
analiza prezentată se neglijează tensiunile transversale), dar datorită efectului de încovoiere,
expresia devine:
du d 2v
x  y 2 (III.6)
dx dx
Introducând vectorul deplasărilor curente u în expresia de mai sus, se obține matricea
deformațiilor B. Matricea de rigiditate a materialului C conține și pentru această aplicație un
singur element (C = E). În continuare se parcurg etapele MEF (procedura s-a explicat în detaliu
la curs) și rezultă următoarele matrice de rigiditate a EF în coordonate locale în funcție de tipul
de rezemare a barei:
- pentru bară dublu – încastrată:

30
  EA EA 
 l 0 0  0 0 
l
 12 EI 6 EI 12 EI 6 EI 
 0 0  
 l3 l2 l3 l2 
 0 6 EI 4 EI 6 EI 2 EI 
0  2
ke   l 
2
l l l (III.7)
  EA 0 0
EA
0 0 
 l l 
 12 EI 6 EI 12 EI 6 EI 
 0  3  2 0 3
 2 
 l l l l
6 EI 2 EI 6 EI 4 EI 
 0 0  2 
 l2 l l l 
- pentru bară încastrată în nodul i și articulată în nodul j:
 EA EA 
 l 0 0  0 0
l
 3EI 3EI 3EI 
 0 3 2
0  3 0
 3
l
EI 3
l
EI 3
l
EI 
 0 0  0
ke   l 2
l l2  (III.8)
  EA 0 0
EA
0 0
 l l 
 3EI 3EI 3EI 
 0  3  2 0 0
 0 l l l3
 0 0 0 0 0 

- pentru bară articulată în nodul i și încastrată în nodul j:

 EA EA 
 l 0 0  0 0 
l
 3EI 3EI 3EI 
 0 3
0 0  3 
 0 l l l2 
 0 0 0 0 0 
ke   EA EA
 0 0 0 0  (III.9)
 l l 
 0  3EI 0 0 3EI 3EI 
 2 
 l3 l3 l
 3EI 3EI 3EI 
 0 0 0  2 
 l2 l l 
Obs: Rezemarea de tip “încastrare” se referă la o legătură de tip continuu între bare, nu la
anularea gradelor de libertate.

Matricele de rigiditate de mai sus satisfac Ec. (I.30) ( Pe  keU e ) dar și relația dintre eforturi
secționale și deplasările nodale:
Se  keU e (III.10)
Pentru transformarea mărimilor Ue, ke și Pe din coordonate locale în coordonate globale, se
utilizează matricea de rotație Re adaptată pentru bara cu trei GL pe nod. Adaptarea se face
extrem de ușor având în vedere că rotirea nodului θ este aceeași indiferent de sistemul de
coordonate. Fig. V.3 prezintă bara în starea inițială și după deformare, în cele două sisteme de
31
coordonate. Deplasările nodale u și v se transformă cu relațiile prezentate pentru bara dublu
articulată (Ec. (II.5))
y vj
x
vj
θi
θj uj
y j
e uj

vi α
vi
i x
ui
ui

Fig. V.3: Transformarea din sistemul local în sistemul global de coordonate

Rezultă matricea de rotație Re pentru bara cadrului plan:

 ui   cos  sin  0 0 0 0   ui 
 vi    sin  cos  0 0 0 0   vi 
 i   0
 0 1 0 0 0  i 
 U e = ReU e
u j   0 0 0 cos  sin  0  u  (III.11)
v   0  
j
0 0  sin  cos  0  v j
 j  0 0 1   
 j    j 
0 0 0  

În continuare se parcurg etapele MEF fără nici o modificare.

32
 V.2. Exemplu: cadru plan
Cu adevărat e șef
Cel ce stăpânește MEF!
Să se determine deplasările, reacțiunile și eforturile secționale în noduri pentru cadrul plan
prezentat în Fig. V.4. Caracteristicile structurii: interval a = 6m, modulul lui Young E =
30000MPa, barele au secțiune dreptunghiulară 40x60cm, forța concentrată P = 40kN, forța
uniform distribuită p = 20kN/m.
p u5 u u8
6 u9
P
u4 2 2 3 u7
R8

1
a u3
R1 u1
1
R3 u2
R2
a
a) b)

Fig. V.4: a) Cadru plan; b) Grade de Libertate

Datorită încărcării uniform distribuite pe bara 2, se calculează în prealabil încărcările nodale

echivalente, prezentate în Fig. V.5 atât pe capăt de bară cât și pe nod (cu sens opus).
p=20

5pl 3pl
8 =75 8 =45

pl2
8 =90
l=6
[kN, m]

Fig. V.5: Încărcările nodale echivalente pentru bara 2

%Se șterg toate variabilele din memorie

???
%Se introduc datele de intrare
%modulul lui Young [kN/m^2]
E=3*10^7;
%aria barelor [m^2]
A=0.24;
%momentul de inerție al barelor [m^4]

33
Iy=72*10^(-4);
% se introduc coordonatele nodurilor [m]
noduri=[1 0 0; 2 0 6; 3 6 6;];
%se introduce matricea Elementelor Finite M_EF
%se introduc barele cu nodurile de capăt, aria, momentul de inerție și tipul de
rezemare
%tip de rezemare: 0 – dublă încastrare, 1 – încastrare - articulație,
% 2 – articulație - încastrare
M_EF=[1 1 2 A Iy 0; 2 2 3 A Iy 1;];
%se introduc încărcările concentrate (reale și echivalente) în noduri pe x si y [kN]
P_inc=[2 40 -75 -90;3 0 -45 0];
%se introduc forțele echivalente pe fiecare bară
Pech_EF=[1 0 0 0 0 0 0; 2 0 75 90 0 45 0;];
(cine programează calculul încărcărilor echivalente, va fi răsplătit generos la examen;
asta nu e glumă!)
%se introduc deplasări nule în reazeme
nodrez=[1 1 1 1; 3 0 1 0;]; % nod, 1 - GL blocat, 0 - GL liber
%număr GL pe nod
nrGL_nod=???;
%număr noduri pe EF
nrnodEF=???;

34
%număr GL pe EF
nrGL_EF=???; nrGL_EF = 6
%număr noduri
nrnod=???; nrnod = 3
%număr EF
nrEF=???; nrEF = 2
%număr noduri încărcate
nrnod_inc=???; nrnod_inc = 2
%număr GL
nrGL=???; nrGL = 9

% se adaugă lungimea și înclinarea M_EF =

fiecărei bare la matricea M_EF în
coloana 7, respectiv 8. 1 1 2 0.24 0.0072 0 6 90
2 2 3 0.24 0.0072 1 6 0
???

%se construiește matricea Gradelor de M_GL =

Libertate M_GL
1 1 2 3 4 5 6
??? 2 4 5 6 7 8 9

%se construiește matricea de L=

localizare L
1 0 0 0 ...
??? 0 1 0 0 ...
(câte semne de întrebare... 0 0 1 0 ...
ne vom descurca noi oare?)
0 0 0 1 ...
0 0 0 0 ...
%inițializare matrice de rigiditate
0 0 0 0 ...
%matricea kg_tot conține pe diagonală
0 0 0 1 ...
nrEF matrice de rigiditate pe EF în
... ... ... ... ...
coordonate globale kg_e
kg_tot=[];
%matricea kl_tot conține pe diagonală
nrEF matrice de rigiditate pe EF în
coordonate locale kl_e
kl_tot=[];

35
%matricea R_tot conține pe diagonală
nrEF matrice de rotație pe EF
R_tot=[];

%se construiesc matricele de rigiditate

și de rotație
for i=1:nrEF pentru prima bară (i = 1):
A=M_EF(i,4); %arie bară
Iy=M_EF(i,5); %moment de inerție A = 0.24
tip=M_EF(i,6); %tip rezemare Iy = 0.0072
l=M_EF(i,7); %lungime tip = 0
alfa=M_EF(i,8); %înclinare l=6
%matricea de rigiditate a EF în alfa = 90
coordonate locale

if tip==0 %dublă încastrare kl_e =

kl_e=E*[A/l 0 0 -A/l 0 0;
0 12*Iy/l^3 6*Iy/l^2 0 -12*Iy/l^3 6*Iy/l^2;
1.0e+05 *
0 6*Iy/l^2 4*Iy/l 0 -6*Iy/l^2 2*Iy/l;
-A/l 0 0 A/l 0 0; 12 0 0 -12 0 0
0 -12*Iy/l^3 -6*Iy/l^2 0 12*Iy/l^3 - 0 0.12 0.36 0 -0.12 0.36
6*Iy/l^2; 0 0.36 1.44 0 -0.36 0.72
0 6*Iy/l^2 2*Iy/l 0 -6*Iy/l^2 4*Iy/l]; -12 0 0 12 0 0
else 0 -0.12 -0.36 0 0.12 -0.36
if tip==1 %încastrare-articulație 0 0.36 0.72 0 -0.36 1.44
kl_e=???%a se vedea teoria
else %articulație-încastrare
kl_e=???%a se vedea teoria Re0 =
end
end 0 1
-1 0
%matricea de rotație a EF
Re0=[cosd(alfa) sind(alfa); kg_e=
-sind(alfa) cosd(alfa);];
R_e=blkdiag(Re0,1,Re0,1);
1.0e+05 *
%matricea de rigiditate a EF în 0.12 0 -0.36 -0.12 0 -0.36
coordonate globale 0 12.00 0 0 -12.00 0
kg_e=R_e'*kl_e*R_e; -0.36 0 1.44 0.36 0 0.72
-0.12 0 0.36 0.12 0 0.36
kg_tot=blkdiag(kg_tot,kg_e); 0 -12.00 0 0 12.00 0
kl_tot=blkdiag(kl_tot,kl_e); -0.36 0 0.72 0.36 0 1.44
R_tot=blkdiag(R_tot,R_e);
end

36
%matricea de rigiditate a structurii K=
(un miracol al naturii)
1.0e+04 *
K=???; 1.2 0.0 -3.6 -1.2 0.0 ...
0 120.0 0.0 0.0 -120.0 ...
%se construiește vectorul încărcărilor -3.6 0.0 14.4 3.6 0.0 ...
P=zeros(nrGL,1); ... ... ... ... ... ...
for i=1:nrnod_inc
P(P_inc(i,1)*nrGL_nod)=P_inc(i,4); PT =
???
end 0 0 0 40 -75 -90 0 -45 0

%se construiește vectorul GL pe baza GL =

vectorului nodrez. Obs: analog cu
formarea M_GL 1 1 1 0 0 0 0 1 0

??? GLbl =

%se caută GL blocate 1 2 3 8

GLbl=???;
%se caută GL libere GLlib =
GLlib=???;
4 5 6 7 9
%se construiește matricea de rigiditate
redusă Kredus =
Kredus=K;
%se elimină liniile GL blocate 1.0e+03 *
???; 1212 0 36 -1200 0
%se elimină coloanele GL blocate 0 1203 18 0 0
???; 36 18 252 0 0
-1200 0 0 1200 0
% A se observa cum ultima linie și 0 0 0 0 0
coloană din Kredus conține numai
elemente nule, deoarece bara 2 este (elegantă și frumoasă,
articulată în nodul 3. Aceste elemente e o matrice aleasă)
se elimină după cum urmează.
% Se caută liniile/coloanele cu
elemente nule.
liniecoloana0=[];

37
for i=1:size(Kredus,1)
if all(Kredus(i,:)==0)
liniecoloana0=[liniecoloana0 i]; liniecoloana0 = 5
end
end
%Se elimină GL liber corespunzător
articulației
GLlib(liniecoloana0)=[];
Kredus =

%Se elimină linia/coloana cu elemente

1.0e+03 *
nule.
1212 0 36 -1200
Kredus(liniecoloana0,:)=[];
0 1203 18 0
Kredus(:,liniecoloana0)=[];
36 18 252 0
-1200 0 0 1200
%se construiește vectorul redus al
încărcărilor
Predus=P;
PredusT =
(redus ca dimensiuni, nu ca istețime)

40 -75 -90 0
%se elimină elementele GL blocate
???;
UliberT =
Predus(liniecoloana0,:)=[];

%se determină deplasările GL libere 1.0e-03 *

7.69 -0.04 -1.45 7.69
Uliber=???;

%vectorul deplasărilor totale în UT =

coordonate globale
1.0e-03 *
U=zeros(nrGL,1);
%se introduc deplasările GL libere 0 0 0 7.69 -0.04 -1.45 7.69 0 0
deja calculate
U0_tot =
???;
%deplasările pe fiecare element
1.0e-03 *
U_tot=L*U;
0 7.69
%vectorul deplasărilor la nivel de 0 -0.04
structură 0 -1.45
7.69 7.69
U0_tot=reshape(U_tot,[],nrEF);
%fiecare coloană conține deplasările -0.04 0
unui EF -1.45 0
%deplasările pe fiecare element în
coordonate locale
Ul_tot=R_tot*U_tot

38
%matricea de rigiditate R=
corespunzătoare GL blocate
KR=K(GLbl,:); -40.00 (Rx – nod 1)
48.72 (Ry – nod 1)
%calcul reacțiuni 172.32 (Mz– nod 1)
R=KR*U-P(GLbl); 71.28 (Ry – nod 3)

%se transformă matricea încărcărilor

Pech0 =
echivalente pe bară într-un vector
Pech0=reshape(Pech_EF(:,2:nrGL_EF
0 0 0 0 0 0 0 75 90
+1)',1,nrEF*nrGL_EF)';
0 45 0

%calculul eforturilor
S_EF =
S=kl_tot*Ul_tot+ Pech0;
48.72 -0.00
%se rearanjează vectorul eforturilor
40.00 48.72
pentru a avea pe fiecare coloană
172.32 -67.68
eforturile unei bare
-48.72 0.00
S_EF=reshape(S,[],nrEF);
-40.00 71.28
67.68 0
%A se identifica eforturile obținute în
diagramele de eforturi din Fig. V.6. Unde-i forța axială?
Oare care e momentul?
Avem forță tăietoare?
Ei, acum vedem talentul!

39
% afișare rezultate
??? (pam-param...)
1.45
0.04 7.69 7.69

71.28
Δ ·10-3 R

40
[kN, m, rad] 172.32
48.72
48.72
67.68
71.28

N T M

48.72 40 172.32
Fig. V.6: Deplasări, reacțiuni și diagrame de eforturi

40
Temă!!! (asta e ultima picătură)
Adaptați aplicația anterioară pentru cadrele de mai jos și verificați rezultatele utilizând
un program de calcul comercial (chiar dacă este desigur inferior aplicației scrise):
p E=3·104 MPa
P/2 grinzi

a/2
p

60
[cm]
P

30

a/2
p
P stâlpi

30
[cm]

a/2
30
a

a)
stâlp
E=3.5·104 MPa
[cm]

20
a

p contravântuiri
E=2.1·105 MPa
0.5
1.5a

0.5 [cm]
5

a a
b)

41
 2
p/

a/2
E=2.1·105 MPa
P P rigle, console IPE 300
stâlpi HEB 160
p/2 a/3 a/3

a
2a/3
a a
c)

Fig. V.7: Temă 3 – cadre plane

42
Lucrarea VI – elemente 2D aflate în starea plană de tensiune

VI.1. Noțiuni teoretice

Mamă te iubesc,
Dar nu ca pe MEF!
În cadrul Teoriei Elasticității s-a studiat această stare specială de solicitare, descrisă pe scurt
după cum urmează: un corp deformabil liniar elastic, în echilibru sub acțiunea forțelor
exterioare și de legătură, se află în stare plană de tensiune dacă tabloul tensiunilor este paralel
cu un plan dat și identic în toate planele paralele cu planul respectiv. În această categorie intră
elementele de construcții bidimensionale (2D) acționate pe contur de forțe distribuite uniform
pe grosime, paralele cu suprafața mediană (vezi Fig. VI.1).
y y
p(x,y)

σy
τxy
y
σx σx
τxy
σy y
x x

t
Fig. VI.1: Corp aflat în stare plană de tensiune

Tensorul tensiunilor se reduce la:

  
Tσ   x yx  (IV.1)
 xy y

Relațiile constitutive între tensiuni și deformații specifice (provenite din legea generalizată a
lui Hooke) se scriu:

x 
E
1  2
 x   y 
y 
E
1  2
 y   x  (IV.2)

E
 xy  G xy   xy
2(1   )
Pentru aplicarea MEF la starea plană de tensiune se alege Elementul Finit dreptunghiular, cu
două GL pe nod și anume deplasările u și v din planul xOy (vezi Fig. VI.2). De multe ori este

43
 x y
convenabilă utilizarea unui sistem de coordonate reduse pe EF   ,   , unde a și b sunt
a b
dimensiunile elementului.
y, η
vj uj vk uk
j k
e
b vi vl
ui ul
i l x, ξ
a
Fig. VI.2: EF dreptunghiular cu 2 GL pe nod

Vectorul deplasărilor nodale pe EF se scrie:

U e  ui vi u j v j uk vk ul vl 
T
(IV.3)
Pentru deplasările curente u(x,y) și v(x,y) se utilizează următoarele polinoame de interpolare:
u ( x, y)  1   2 x   3 xy   4 y
(IV.4)
v( x, y )   5   6 x   7 xy  8 y
Ecuația de mai sus se rescrie matriceal:
u ( x, y)  1 x xy y 0 0 0 0 
u    U x (IV.5)
v( x, y)  0 0 0 0 1 x xy y 
unde   1  2 3  4 5 6 7 8  . Se observă că numărul coeficienților α coincide
T

cu cel al deplasările nodale, în consecință coeficienții pot fi exprimați în funcție de GL,

utilizând Ec. (I.5) (   A1U e ) în care matricea A se determină pe baza scrierii condițiilor la
limită. Matricea de interpolare a deplasărilor  se determină cu Ec. (I.7)
( u  U x A1U e  U e ) și devine:

 
   u   01 0 02 0 03 0 04 0  (IV.6)
v   1 2 3 4

Expresiile și deducerea funcțiilor de interpolare s-au prezentat la curs, pentru exemplificare se

dă mai jos doar expresia primei funcții de interpolare:
 x  y 
 1  1  1    1   1    (IV.7)
 
a b 
Vectorul deformație  pe EF se scrie utilizând ecuațiile lui Cauchy:

44
  u   1  u 
   a  
  x   x   
   v   1  v 
   y      U e = BU e (IV.8)
 xy   y   b  
 u  v   1  u  1  v 
 y x   b  a  
în care matricea deformațiilor se scrie utilizând coordonatele reduse:
 
 1   0  0  0 1  0 
1 1  1   
  0  0 0 0   (IV.9)
a r r r r
1  1   
 1      1  
 r r r r 
unde r = b/a reprezintă raportul dintre laturile Elementului Finit. Din legea generalizată a lui
Hooke (Ec. (IV.2)) rezultă vectorul tensiune  pe EF:
 
 x  1  0 
  E
 1
   y   0    C  CBU e (IV.10)
  1  2
 1  
 xy
0 0 
 2 
în care se identifică ușor matricea de rigiditate a materialului C.

Obs: Întreaga teorie se poate aplica cu modificări minore și pentru starea plană de deformație
caracterizată prin faptul că deplasările tuturor punctelor unui corp elastic deformabil se
produc paralel cu un plan dat și sunt constante după direcția normalei la acest plan (ex. ziduri
de sprijin, baraje, tuneluri etc). Se analizează o fâșie din elementul aflat în stare plană de
deformație, egală cu unitatea, iar modificările apar doar la nivelul matricei constitutive C.

În continuare se parcurg etapele MEF (procedura s-a explicat în detaliu la curs) și rezultă
matricea de rigiditate a EF în coordonate locale:
 21 
 4r  r 
 3 4 
 2  21r simetric 
 2 r 
 2r  21  3 3 4r  21 
 r 2 r 
 3 4 3 4 
Et  2 3     1 r   2  2 1 r 
ke  2 
r 2 r
 (IV.11)
 
12(1   ) 2r  1  2 4r  1  3 4r  1
3 3 2 

 3 r 2 r 2 r 
  2  2  1r 3
3
2
 21r
3
2
4
 21r 
 2 r 2 r 2 r 
4r  1 3
3 2r 
1 3
2 2r 
21 3
 3 4r 
21 
 r 2 r 2 r 2 r 
 3 2 3 2 3 4 3 4 
  3  2 1r 2   1r 3   1r  2  21r 
 2 r 2 r 2 r 2 r 

unde s-au folosit notațiile 1  1   , 2  1   , 3  1  3 , iar t este grosimea șaibei.

45
Pentru transformarea mărimilor Ue, ke și Pe din coordonate locale în coordonate globale, se
utilizează matricea de rotație Re adaptată pentru EF dreptunghiular cu două GL pe nod
(deplasările u și v). Proiectând deplasările din coordonate globale în coordonate locale, rezultă
transformarea Gradelor de Libertate analog cu Ec. (II.6):
 ui   cos  sin  0 0 0 0 0 0   ui 
 vi    sin  cos  0 0 0 0 0 0   vi 
u j   0 0 cos  sin  0 0 0 0  u j 
v   0 0  sin  cos  0 0 0 0  v j 
u j    0 0 0 0 cos  sin  0 0  uk 
 k  0 0 0 0  sin  cos  0 0   vk 
(IV.12)
 vk   0 0 0 0 0 0 cos  sin    ul 
 ul   0  sin  cos    
 vl   0 0 0 0 0  vl 
U e = ReU e

Dacă sistemul global este paralel cu cel local, Re = I (matricea unitate).

46
 VI.2. Exemplu: șaibă în consolă
La examen, țineți minte,
Vrednicul student se simte
Binecuvântat să aibă
De analizat o șaibă.
Să se determine deplasările, reacțiunile și tensiunile pentru consola scurtă acționată de o
încărcare uniform distribuită p la partea superioară (Fig. VI.3) [5]. Caracteristicile structurii: L
= 1m, H = 2L, modulul lui Young E = 1000kN/m2, coeficientul lui Poison μ = 0.3, forța uniform
distribuită p = 1kN/m.
pa pa
pa
p 2 2
u1 u7 u13
x u2 u8 u14
1 3 1 3

b
u3 u9 u15
H=2L

u4 u10 u16
2 4 2 4
b

u5 u11 u17

L a a u6 u12 u18
y
a) b) c)
Fig. VI.3: a) Șaibă; b) Discretizare și forțe echivalente; c) Grade de Libertate

Obs: Sistemele de coordonate local și global sunt paralele, în consecință nu mai este necesară
utilizarea matricei de rotație Re.

%Se șterg toate variabilele din memorie

???

%Se introduc datele de intrare

E=1000; %modulul lui Young [kN/m^2]

miu=0.3; %coeficientul lui Poisson
L=1; %lungime consolă [m]
H=2*L; %înălțime consolă [m]
t=1; %grosime consolă [m]
p=1; %încărcare [kN/m]
nrEFx=2; %număr EF pe x
nrEFy=2; %număr EF pe y
nrnodEF=4; %număr noduri pe EF
nrGL_nod=2; %număr GL pe nod

47
%număr noduri pe EF in care se calculează tensiunile (4 noduri și centru)
nrpctsigma=5;

%matricea coordonatelor relative pe EF csi si eta pentru 5 puncte în care se vor

calcula tensiunile (cele 4 noduri plus centrul de EF)
matr_csi_eta=[0 0; 0 1; 1 1; 1 0; 0.5 0.5;];

48
%număr GL pe EF
nrGL_EF=???; nrGL_EF = 8
%număr noduri pe x
nrnodx=nrEFx+1; nrnodx = 3
%număr noduri pe y
nrnody=???; nrnody = 3
%număr total noduri
nrnod=???; nrnod = 9
%număr GL
nrGL=???; nrGL = 18
%latura EF pe x
a=L/nrEFx; a = 0.5
%latura EF pe y
b=H/nrEFy; b=1
%raportul laturilor
r=b/a; r=2

%se construiește rețeaua de puncte cu [X,Y] =

coordonate pe x și y
[X,Y] = 0 0.50 1.00 0 0 0
meshgrid(0:a:nrEFx*a,0:b:nrEFy*b); 0 0.50 1.00 1.00 1.00 1.00
%se construiește matricea 0 0.50 1.00 2.00 2.00 2.00
coordonatelor nodurilor
coord=zeros(nrnod,3); coord =
%coloana 1 conține numărul nodului
coord(:,1)=1:nrnod; 1 0 0
%coloana 2 conține coordonata pe x 2 0 1.00
coord(:,2)=reshape(X,[],1); 3 0 2.00
%coloana 3 conține coordonata pe y 4 0.50 0
coord(:,3)=???; 5 0.50 1.00
6 0.50 2.00
%se construiește matricea 7 1.00 0
Elementelor Finite M_EF 8 1.00 1.00
M_EF=zeros(nrEF,5); 9 1.00 2.00
%coloana 1 conține numărul EF
M_EF(:,1)=???;

49
%următoarele 4 coloane conțin
nodurile Elementului Finit
for i=1:nrEFx
for j=1:nrEFy
%coloana 2 M_EF =
M_EF(j+(i-1)*nrEFy,2)=j+(i-1)*nrnody;
%coloana 3 1 1 2 5 4
M_EF(j+(i-1)*nrEFy,3)=j+1+(i- 2 2 3 6 5
1)*nrnody; 3 4 5 8 7
%coloana 4 4 5 6 9 8
M_EF(j+(i-1)*nrEFy,4)=???;
%coloana 5
M_EF(j+(i-1)*nrEFy,5)=???;
end M_GL =
end
1 1 2 3 4 9 10 7 8
%se construiește matricea Gradelor de 2 3 4 5 6 11 12 9 10
Libertate M_GL 3 7 8 9 10 15 16 13 14
4 9 10 11 12 17 18 15 16
???

%se construiește matricea de

localizare L L=

??? 1 0 0 0 ...
0 1 0 0 ...
%introducerea încărcărilor echivalente 0 0 1 0 ...
în noduri 0 0 0 1 ...
%vectorul încărcărilor echivalente ... ... ... ... ...
P=zeros(nrGL,1);
%se găsesc nodurile încărcate (y =0)
nodinc=find(coord(:,3)==0);
%primul nod încărcat (P=p*a/2)
P(nodinc(1)*2)=p*a/2; nodinc = 1 4 7
%ultimul nod încărcat (P=p*a/2)
P(nodinc(length(nodinc))*2)=p*a/2;
%restul nodurilor (P=p*a)
for i=2:length(nodinc)-1 PT =
P(nodinc(i)*2)=p*a;
end 0 0.25 0 0 0 0 0 0.5 0 0 0 0 0
(cine ajunge aici, primește un BMW din partea 0.25 0 0 0 0
decanatului)

50
%matricea de rigiditate a EF (8 linii x 8
coloane)
k_e=E*t/(12*(1-miu^2))* k_e =
[4*r+2*(1-miu)/r 3/2*(1+miu) ...;
3/2*(1+miu) 4/r+2*(1-miu)*r ...; 796.70 178.57 302.20 13.74 ...
... ... ....;]; 178.57 439.56 -13.74 -54.95 ...
(... = a se vedea teoria, știu că-i dureros, dar altfel 302.20 -13.74 796.70 -178.57 ...
cum să scriem pe k_e frumos?)
... ... ... ... ...

%matricea k_tot conține pe diagonală

nrEF matrice de rigiditate k_e

???

%matricea de rigiditate a structurii K=

(o dovadă a evoluției incontestabile a intelectului
uman... a naturii)
796.70 178.57 302.20 13.74 ...
K=???; 178.57 439.56 -13.74 -54.95 ...
302.20 -13.74 1593.41 0 ...
%se construiește vectorul deplasărilor ... ... ... ... ...
nule din reazeme
%se caută nodurile cu x=0 nodrez = 1 2 3
nodrez=find(coord(:,2)==0);

%se construiește vectorul GL pe baza GL =

vectorului nodrez.
1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
??? 0 0

%se caută GL blocate GLbl = 1 2 3 4 5 6

GLbl=???;

%se caută GL libere GLlib = 7 8 9 10 11 12 13 14

GLlib=???; 15 16 17 18

51
%se construiește matricea de rigiditate Kredus =
redusă
Kredus=K; 1593.68 0 604.40 0 ...
%se elimină liniile GL blocate 0 879.12 0 -109.89 ...
???; 604.40 0 3186.81 0 ...
%se elimină coloanele GL blocate 0 -109.89 0 1758.24 ...
???; ... ... ... ... ...

%se construiește vectorul redus al

încărcărilor echivalente PredusT =
Predus=P;
%se elimină elementele GL blocate 0 0.50 0 0 0 0 0 0.25 0 0 0 0
???;
UliberT =
%se determină deplasările GL libere
Uliber=???; 0.34 1.08 -0.04 0.40 -0.14 0.31
%vectorul deplasărilor totale 0.51 1.50 0.03 0.73 -0.18 0.47
U=zeros(nrGL,1); (am aflat deplasările,
%se introduc deplasările GL libere se cheamă că nu am trăit degeaba.)
deja calculate
???; UT =

%matricea de rigiditate 0 0 0 0 0 0 0.34 1.08 -0.04

corespunzătoare GL blocate 0.40 -0.14 0.31 0.51 1.50 0.03
KR=K(GLbl,:); 0.73 -0.18 0.47

%calcul reacțiuni R=
R=KR*U-P(GLbl);
-0.31 -0.25 0.12 -0.35
% vectorul deplasărilor pentru toate EF 0.19 -0.14
Utot=L*U;
%altă matrice în care fiecare coloană U0tot =
conține deplasările unui EF
0 0 0.34 -0.04
U0tot =reshape(Utot,[],nrEF); 0 0 1.08 0.40
0 0 -0.04 -0.14
0 0 0.40 0.31
-0.04 -0.14 0.03 -0.18
0.40 0.31 0.73 0.47
0.34 -0.04 0.51 0.03
1.08 0.40 1.50 0.73

52
 %matricea de rigiditate a materialului C=
C=E/(1-miu^2)*[1 miu 0; miu 1 0; 0 0
(1-miu)/2]; 1098.90 329.67 0
329.67 1098.90 0
%se construiește produsul matricelor 0 0 384.62
C și B matricea deformațiilor pe EF
CB=[]; matr_csi_eta =
for j=1:nrpctsigma
csi=matr_csi_eta(j,1); 0 0
eta=matr_csi_eta(j,2); 0 1
%matricea deformațiilor pe EF 1 1
B=1/a*[-1+eta 0 -eta 0 eta 0 1-eta 0; 1 0
0 -(1-csi)/r 0 (1-csi)/r 0 csi/r 0 - 0.50 0.50
csi/r;
-(1-csi)/r -1+eta (1-csi)/r -eta csi/r CB =
eta -csi/r 1-eta];
%produsul matricelor C, B -2197.80 -329.67 0 ...
CB=[CB; C*B]; -658.34 -1098.90 0 ...
end -384.62 -769.23 384.62 ...
... ... ... ...
%calcul tensiuni. Matricea sigma (15
linii x 4 coloane) conține pe fiecare sigma =
coloana tensiunile unui EF
sigma=CB* U0tot; 0.75 -0.09 0.14 0.12
%tensiunile extrase separat in 5 0.22 -0.03 -0.64 -0.05
puncte pe fiecare EF 0.83 0.31 0.17 0.22
sigmax5=zeros(5,nrEF); %sigma_x ... ... ... ...
sigmay5=zeros(5,nrEF); %sigma_y
tauxy5=zeros(5,nrEF); %tau_xy sigmax5 =
for i=1:5
sigmax5(i,:)=sigma((i-1)*3+1,:); 0.75 -0.09 0.14 0.12
sigmay5(i,:)=sigma((i-1)*3+2,:); -0.09 -0.31 -0.07 -0.11
tauxy5(i,:)=sigma((i-1)*3+3,:); -0.32 -0.34 -0.10 -0.17
end 0.53 -0.12 0.11 0.07
0.22 -0.22 0.02 -0.02
%tensiunile in 4 puncte (doar noduri)
sigmax4=sigmax5(1:4,:);
sigmay4=???;
tauxy4=???;

53
%se extrag tensiunile pe noduri și se sigmax =
mediază pentru noduri comune ale
elementelor finite 0.75 -0.09 -0.31 0.33 -0.10 -0.23
sigmax=zeros(1,nrnod); 0.11 -0.02 -0.17
sigmay=zeros(1,nrnod);
tauxy=zeros(1,nrnod); sigmay =
for i=1:nrnod
%se caută nodurile care apar de mai 0.22 -0.03 -0.09 -0.58 -0.41 -0.16
multe ori in definirea elementelor finite -0.73 -0.52 -0.31
indice=find(M_EF(:,2:5)'==i);
%se calculează media aritmetică a tauxy =
tensiunilor 0.83 0.31 0.24 0.43 0.19 0.14
sigmax(i)=mean(sigmax4(indice)); 0.14 0.12 0.04
sigmay(i)=mean(sigmay4(indice));
tauxy(i)=mean(tauxy4(indice));
end

54
%Afișare rezultate folosind funcția "patch"
(din păcate interfața
ne complică aprig viața)
%vârfurile functiei patch sunt coordonatele nodurilor pentru șaiba nedeformată
varfuri=coord(:,2:3);
%fețele funcției patch sunt nodurile elementelor finite
elemente=M_EF(:,2:5);

% Vor fi 2x2 figuri. Se afișează prima figura - deformata consolei

subplot(2,2,1);
%rearanjare deplasari: prima coloana - deplasări pe x, a doua coloana - deplasări pe y
Uxy=reshape(U,2,[])';
%factor scalare deformata (20% din deplasarea maxima)
f_scalare=0.2/max(max(abs(Uxy)));
%coordonatele nodurilor după deformare
varfuri_def=varfuri+Uxy*f_scalare;
%afișare șaibă nedeformată
patch('Vertices',varfuri,'Faces',elemente,'LineStyle','--', 'FaceColor', 'none',
'FaceAlpha',0.6,'EdgeColor','k','LineWidth',0.5);
%afișare șaibă deformată
patch('Vertices',varfuri_def,'Faces',elemente,'LineStyle','-','FaceColor','none',
'FaceAlpha',0.6,'EdgeColor','r','LineWidth',1.5);
%titlul figurii
title('Deformata');
%se inversează sensul axei y
set(gca,'YDir','reverse');
%se definește aspectul figurii
axis equal tight;

%a doua figură: sigma_x

subplot(2,2,2);
patch('Vertices',varfuri,'Faces',elemente,'FaceVertexCData',sigmax','FaceColor','interp');
%Obs. Culoarea se introduce pe baza valorilor sigma_x prin interpolare
title('sigma_x');
set(gca,'YDir','reverse');
axis equal tight;
%legenda culorilor poziționată în partea dreaptă
colorbar('location','eastoutside');

%a treia figură: sigma_y

subplot(2,2,3);
patch('Vertices',varfuri,'Faces',elemente,'FaceVertexCData',sigmay','FaceColor','interp');
title('sigma_y'); set(gca,'YDir','reverse'); axis equal tight; colorbar('location','eastoutside');

55
%a patra figură: tau_xy
subplot(2,2,4);
patch('Vertices',varfuri,'Faces',elemente,'FaceVertexCData',tauxy','FaceColor','interp');
title('tau_xy'); set(gca,'YDir','reverse'); axis equal tight;
colorbar('location','eastoutside');

%Sfârșit!

%Epilog: Rulați aplicația anterioară de mai multe ori îndesind de fiecare dată rețeaua de
EF. Comparați rezultatele!

Fig. VI.4: Deformata și distribuția tensiunilor

56
Temă!!!
...ultima, dar nu fiți triști,
și nu mai protestați în cor,
ne vom lupta să vă mai dăm
vreo 10 la laborator.
Adaptați aplicația anterioară pentru șaibele de mai jos:

p p
3L

2L
y y

L/5 L/5 x x

L L L L
a) b)

Fig. VI.5: Temă 4 – a) grindă perete; b) console scurte stâlp

Concluzie: Se poate trăi și fără MEF...

dar nu merită.

57
Lucrarea VII – utilizarea programului de calcul avansat Abaqus

Utilizând programul de calcul Abaqus/Standard, remodelați exemplele date la lucrarea VI (vezi Fig.
VI.3 și Fig. VI.5).

Abaqus - scurtă prezentare

Abaqus este un produs Dassault Systèmes Simulia Corp. [10] care conține 3 module principale:
Abaqus/CAE, Abaqus/Standard și Abaqus/Explicit. Versiunile recente conțin de asemenea
Abaqus/CFD pentru modelări din mecanica fluidelor numerică.
Abaqus/CAE este interfața grafică utilizată pentru “preprocessing” (crearea modelului numeric,
lansare și monitorizare analiză) și „postprocessing” (vizualizarea și manipularea rezultatelor analizei).
Abaqus/Standard și Abaqus/Explicit sunt “motoarele” de analiză ale programului.
Abaqus/Standard este utilizat cu precădere la simularea comportamentului pentru structuri solicitate
de încărcări statice sau dinamice cu viteze reduse.
Abaqus/Explicit este utilizat la structuri solicitate dinamic cu viteze ridicate pe durată scurtă
(evenimente tranzitorii, ex. impact balistic). Cele două module de analiză se pot cupla, astfel încât
Abaqus/Explicit să preia acele porțiuni de analiză în care domină răspunsul dinamic iar
Abaqus/Standard să intervină pe intervalele de timp în care domină răspunsul static și cvasistatic.

Abaqus/CAE generează un fișier INPUT (ex. model.inp) care este preluat de Abaqus/Standard și/sau
Abaqus/Explicit, se execută simularea numerică și se generează fișierele de OUTPUT (ex. model.odb,
model.dat, model.msg, model.log). Abaqus/CAE pune la dispoziție instrumente de procesare a datelor
de ieșire (ex. vizualizare deformații, deplasări, tensiuni, reacțiuni etc.; exportare date numerice în
fișiere cu diferite formate, ex. .xls, .txt etc.).

58
Etapele modelării numerice

1. Se definește geometria modelului prin elementele (părțile) constitutive denumite “parts”

2. Se definesc caracteristicile de material
3. Se definesc secțiuni la care li se atribuie caracteristicile de material
4. Se atribuie secțiunile părților constitutive
5. Se specifică tipurile Elementelor Finite utilizate și se discretizează părțile constitutive
6. Se asamblează părțile constitutive într-un singur model
7. Se definesc etapele analizei
8. Se aplică condițiile de rezemare, încărcare, cuplare GDL și interacțiune între părți
9. Se transmite modelul la “motorul”de analiză (ex. Abaqus/Standard)
10. Se postprocesează rezultatele analizei în Abaqus/CAE sau în alte programe

Obs.1: În Abaqus nu se introduc unități de măsură, acestea sunt stabilite virtual de către utilizator
de la prima etapă a modelării și rezultatele se interpretează în funcție de acestea.

Obs.2: Abaqus beneficiază de o vastă și detaliată documentație de asistență (Help):

ex. HTML documentation Abaqus 6.13: http://129.97.46.200:2080/v6.13/

59
Bibliografie
1. Bia C., Ille V., Soare M.V., Rezistența materialelor și Teoria elasticității, E.D.P. ,1983.
2. Avram C., Bob C., Friedrich R., Stoian V., Structuri din beton armat – Metoda Elementelor
Finite, Teoria Echivalenţelor, Editura Academiei RSR, 1984.
3. Bănuţ V., Popescu H., Stabilitatea structurilor elastice, Editura Academiei RSR, 1975.
4. Bănuţ V., Calculul neliniar al structurilor, Editura Tehnică, Bucureşti, 1981.
5. Marţian I., Teoria elasticităţii şi plasticităţii pentru constructori, Universitatea Tehnică din
Cluj-Napoca, 1999.
6. Panțel E., Bia C., Metode numerice in proiectare - Metoda Elementelor Finite - Litografia UTC-
N, 1992.
7. Smith I.M., Griffiths D.V., Programming the finite element method - John Wiley, 2004.
8. Ziennkievicz O.C.,Taylor R.L., The finite element method: Ist Basis and Fundamentals -
Butterworth-Heinemann, 2005.
9. Matlab Version 7.1.0246 Documentation, The Mathwork Inc., 2005.
10. http://www.3ds.com/products-services/simulia/products/abaqus/

Chiar dacă sunteți copleșiți

De-atâta MEF de calitate,
Nu-i cazul să ne mulțumiți.
Spor la-învățat și sănătate!

60
APPENDIX – Noțiuni introductive în mediul de programare MATLAB

1. Generalități
MATLAB (MATtrix LABoratory) este un limbaj de programare de înaltă performanţă, destinat
calculului matematic, ştiinţific şi ingineresc. MATLAB este un produs al companiei americane The
Mathworks Inc. şi este utilizat în peste 5000 de universităţi. Versiunea cea mai recentă este R2015b.
În Fig. A1 se prezintă interfața programului MATLAB.

Fig. A1. Interfața MATLAB

Principalele ferestre ale MATLAB-ului sunt:
Current Folder (Directorul de lucru) - pemite afișarea și schimbarea directorului de lucru din
sesiunea actuală;
Command Window (Fereastra de comenzi) – permite lansarea comenzilor;
Workspace (Spațiul de lucru) – permite vizualizarea variabilelor utilizate în sesiunea actuală;
Command History (Istoria comenzilor) – permite vizualizarea și relansarea comenzilor utilizate
anterior, atât în sesiunea actuală cât și în cele anterioare;
Editor – permite crearea și editarea fișierelor Matlab.

2. Variabile
Instrucţiunile MATLAB sunt în general de forma:
variabilă=expresie
sau, simplificat:
expresie
Expresiile pot fi alcătuite din operatori sau alte caractere speciale, din funcţii şi nume de variabilă.
61
Dacă expresiei nu i se specifică în mod explicit un nume de variabilă, rezultatul acesteia va fi atribuit
variabilei ans. În variabila ans se memorează valoarea ultimei expresii căreia nu i s-a atribuit un
nume.
Instrucţiunile se termină în mod obişnuit prin apăsarea tastei enter. Dacă se doreşte executarea
instrucţiunii, fără afişarea rezultatului pe ecran, ultimul caracter al acesteia este „ ; ”.
Numele de variabile şi funcţii au ca prim caracter o literă, urmată de cifre, litere sau caracterul „ _ ”.
MATLAB-ul face distincţie între literele mari şi mici.
Exemple
 Să se atribuie variabilei A, rezultatul adunării dintre 5 şi 3.
≫ 𝐴 =5+3
𝐴=
8
 Să se calculeze rezultatul împărţirii dintre 8 şi 10.
≫ 8⁄10
𝑎𝑛𝑠 =
0.8000

3. Matrice și Vectori
3.1. Definirea matricelor
Elementul de bază cu care lucrează MATLAB-ul este matricea. Scalarii sunt matrice de dimensiune
1x1, iar vectorii sunt matrice de dimensiune 1xn sau nx1. Elementele unei matrice pot fi numere reale,
complexe sau orice expresie MATLAB.
Definirea matricelor se face prin una dintre următoarele metode:
- introducerea explicită a elementelor acestora;
- generarea prin instrucţiuni şi funcţii;
- crearea de fişiere MATLAB (extensie mat.);
- încărcarea din fişiere de date externe.
La introducerea unei matrice ca o listă de elemente, trebuie respectate următoarele convenţii:
- elementele unei matrice sunt cuprinse între paranteze drepte „ [ ] ”;
- elementele unei linii se separă prin spaţii sau virgule;
- liniile se separă prin semnul punct şi virgulă „ ; ”.

62
Exemple
2
10 5 3
4
 Pentru a defini matricea 𝐴 = [34 4 11], vectorii 𝐵 = [5 6 7] și 𝐶 = [ ] se tastează
3
7 18 29
5
în linia de comandă din Command Window:
≫ 𝐴 = [10 5 3; 34 4 11; 7 18 29]
sau
≫ 𝐴 = [10 5 3; 34 4 11; 7 …
18 29]
sau
≫ 𝐴 = [10, 5, 3; 34, 4, 11; 7, 18, 29]
sau
≫ 𝐴 = [10 5 3
34 4 11
7 18 29]
≫ 𝐵 = [5 6 7]
≫ 𝐶 = ⌈2; 4; 3; 5⌉
iar MATLAB va afişa:
𝐴=
10 5 3
34 4 11
7 18 29
𝐵=

5 6 7
𝐶=
2
4
3
5
Matricele sunt memorate în “spațiul de lucru” MATLAB workspace. Pentru a le vizualiza ulterior, se
tastează numele lor.
În cazul unei matrice A:
A(i,j) reprezintă elementul matricei situat pe linia i şi coloana j;
A(i) reprezintă elementul i al matricei, numerotarea elementelor făcându-se pe coloane, de sus în jos,
de la stânga la dreapta;
63
A(i,:) reprezintă elementele matricei situate pe linia i;
A(:,j) reprezintă elementele matricei situate pe coloana j;
A(i:j,:) reprezintă elementele matricei situate pe liniile cuprinse între i şi j;
A(:,i:j) reprezintă elementele matricei situate pe coloanele cuprinse între i şi j;
A(i:end,:) reprezintă elementele matricei situate pe liniile cuprinse între i şi ultima linie;
A(:,i:end) reprezintă elementele matricei situate pe coloanele cuprinse între i şi ultima coloană;
A(i:j:k, :) reprezintă elementele matricei situate pe liniile i, i+j, i+2j,…k (se incrementează liniile cu
pasul j);
A(:,i:j:k) reprezintă elementele matricei situate pe coloanele i, i+j, i+2j,…k (se incrementează
coloanele cu pasul j);
A(i:j,k:l) reprezintă submatricea formată cu elementele matricei situate la intersecţia liniilor cuprinse
între i şi j şi a coloanelor cuprinse între k şi l;
A([i,j,k],:) reprezintă elementele matricei situate pe liniile i, j şi k;
A(:, [i,j,k]) reprezintă elementele matricei situate pe coloanele i, j şi k;
A([i, j, k], [l, m, n]) reprezintă submatricea formată cu elementele matricei aflate la intersecţia liniilor
i, j şi k şi a coloanelor l, m şi n;
A(:, :) reprezintă toate elementele matricei;
A(i:j) reprezintă elementele matricei cuprinse între i şi j, prezentate sub forma unui vector linie
(numerotarea elementelor matricei se face pe coloane, de sus în jos, de la stânga la dreapta);
A(:) reprezintă toate elementele matricei, prezentate sub forma unui vector coloană (coloanele
matricei sunt dispuse una sub alta, citirea lor făcându-se de la stânga spre dreapta).
În cazul unui vector B:
B(i:k) reprezintă elementele vectorului situate pe poziţiile i, i+1, i+2, …k (dacă i>k atunci vectorul
rezultat este gol);
B(i:j:k) reprezintă elementele vectorului situate pe poziţiile i, i+j, i+2j, …k (dacă j>0 şi i>k sau j<0
şi i<k atunci vectorul rezultat este gol);
B([i, j, k]) reprezintă elementele vectorului situate pe poziţiile i, j şi k;
B(:) reprezintă toate elementele vectorului (vectorul linie devine coloană, iar vectorul coloană rămâne
la fel).
Exemple
 Se consideră matricea A și vectorii B și C definiți anterior. Să se extragă elementul matricei A
situat pe linia 3, coloana 2; repectiv cel situat pe linia 2, coloana 3. Să se extragă elementul al 3-lea
al vectorului B, elementul al 4-lea și respectiv ultimul al vectorului C.
≫ 𝐴(3,2)
𝑎𝑛𝑠 =

64
 18
≫ 𝐴(2, 𝑒𝑛𝑑 )
𝑎𝑛𝑠 =
11
≫ B(3)
𝑎𝑛𝑠 =
7
≫ 𝑐 = 𝐶 (4)
𝑐=
5
≫ 𝑑 = 𝐵(𝑒𝑛𝑑 )
𝑑=
7
 Se consideră matricea A și vectorul B definiți anterior. Să se înlocuiască elementul matricei A
situat pe linia a 2-a, coloana a 2-a cu 34. Să se adauge numărul 52 pe linia a 4-a, coloana a 4-a a
matricei A. Să se adauge numărul 11 pe poziția a 4-a a vectorului B.
≫ 𝐴(2,2) = 34
𝐴=
10 5 3
34 34 11
7 18 29
≫ 𝐴(4,4) = 52
𝐴=
10 5 3 0
34 34 11 0
7 18 29 0
0 0 0 52
≫ 𝐵(4) = 11
𝐵=

5 6 7 11
Se pot extrage elemente ale unei matrice utilizând o altă matrice ca argument.
Exemplu
 Să se extragă elementele matricei 𝐴 = [3 7 11 15 19 24 27] situate pe pozițiile
4 5
specificate de vectorul 𝐵 = [1 3 5] și de matricea 𝐶 = [ ].
2 3
65
≫ 𝐴 = [3 7 11 15 19 24 27];
≫ 𝐵 = [1 3 5];
≫ 𝐶 = [4 5; 2 3];
≫ 𝐴 (𝐵 )
𝑎𝑛𝑠 =
3 11 19
≫ 𝐴 (𝐶 )
𝑎𝑛𝑠 =
15 19
7 11
Se pot obține matrice de dimensiuni mai mari pornind de la matrice de dimensiuni mai reduse. Pentru
a fi posibile construcțiile respective, în cazul concatenării (alăturării) pe orizontală, matricele trebuie
să aibă același număr de coloane, iar în cazul concatenării pe verticală, același număr de linii.
Exemplu
 Să se construiască matricea D prin alăturarea pe orizontală a matricei 𝐴 =
10 5 3 0
34 34 11 0
[ ] cu vectorul 𝐵 = [5 6 7 11]. Să se construiască matricea E prin
7 18 29 0
0 0 0 52
2
3
concatenarea matricei A cu vectorul 𝐶 = [ ].
4
5
≫ 𝐴 = [10 5 3 0; 34 34 11 0; 7 18 29 0; 0 0 0 52];
≫ 𝐵 = [5 6 7 11];
≫ 𝐶 = [2; 3; 4; 5];
≫ 𝐷 = [𝐴; 𝐵]
𝐷=
10 5 3 0
34 34 11 0
7 18 29 0
0 0 0 52
5 6 7 11
≫ 𝐸 = [𝐴, 𝐶]
𝐸=
10 5 3 0 2
34 34 11 0 3
7 18 29 0 4
0 0 0 52 5
66
Pentru determinarea dimensiunilor unei matrice se pot utiliza două funcţii: size şi length.
Funcţia size se apelează cu sintaxa:
[m,n]=size(X) - returnează un vector linie cu două componente [m,n], care conţine numărul de linii
m şi numărul de coloane n, ale matricei X.
Funcţia length se apelează cu sintaxa:
a=length(X) - returnează dimensiunea maximă a matricei X, fiind echivalentă cu instrucţiunea
max(size(X)). În cazul unui vector X având dimensiunea 1xn sau nx1, returnează numărul de elemente
ale vectorului, n.
Exemplu
15 4 756
 Să se determine dimensiunile matricei 𝐴 = [ ] şi lungimea vectorului 𝐵 =
4 47 85
[6 45 8].
≫ 𝐴 = [15 4 756; 4 47 85];
≫ 𝐵 = [6 45 8];
[𝑚, 𝑛] = 𝑠𝑖𝑧𝑒(𝐴)

𝑚=
2
𝑛=
3
𝑎 = 𝑙𝑒𝑛𝑔𝑡ℎ(𝐵)
𝑎=
3
3.2. Generarea vectorilor şi a matricelor uzuale
Generarea vectorilor cu pas liniar
Pentru generarea vectorilor cu pas liniar trebuie cunoscute limitele intervalului (amin şi amax) şi a
pasului dintre două elemente (pas), sau numărul de elemente ale vectorului (N).
Generarea vectorilor se face cu sintaxele:
x=amin:pas:amax – dacă nu se precizează pasul, acesta se consideră egal cu unitatea. Dacă pasul
indicat este pozitiv, este necesar ca amin<amax, iar dacă pasul este negativ, amin>amax.
x=linspace(amin, amax, N) –dacă nu se menţionează numărul de elemente ale vectorului, atunci N se
consideră egal cu 100.
Exemple
 Să se genereze următorii vectori cu pas liniar: A, având limitele 1 și 5, iar pasul 1; B, având
limitele 3 și 35, iar pasul 7; C, având limitele 10 și 5, iar pasul -2. Să se genereze vectorul cu pas
liniar D, având 6 elemente, între limitele 5 și 10.

67
≫ 𝐴 = 3: 5
𝐴=

3 4 5
≫ B = 3: 7: 35
B=
3 10 17 24 31
≫ C = 10: −2: 5
C=
10 8 6
≫ D = linspace(5, 10, 6)
D=

5 6 7 8 9 10
Generarea vectorilor cu pas logaritmic

Pentru generarea vectorilor cu pas logaritmic trebuie cunoscute limitele intervalului 10a
min
şi 10amax 
şi numărul de elemente ale vectorului (N).
Generararea vectorilor se face cu sintaxa:
x=logspace(amin, amax, N) – dacă nu se menţionează numărul de elemente ale vectorului, atunci N
se consideră egal cu 50.
Exemplu
Să se genereze vectorul A având 4 elemente distribuite logaritmic pe intervalul [10-3, 102].
≫ 𝐴 = 𝑙𝑜𝑔𝑠𝑝𝑎𝑐𝑒(−3, 2, 4)
𝐴=

0.0010 0.0464 2.1544 100.0000

Generarea matricei goale
Matricea goală are dimensiuni 0x0 şi poate fi creată cu instrucţiunea:
X=[]
Generarea matricei unitate
Matricea unitate este o matrice cu toate elementele egale cu 1:
1 1 ⋯ 1
1 1 ⋯ 1
𝑈=[ ]
⋯ ⋯ ⋯ ⋯
1 1 ⋯ 1

68
Generarea matricei unitate se face cu funcţia ones, care poate fi apelată cu una din următoarele
sintaxe:
U=ones(n), U=ones(m,n), U=ones(size(A))
unde m şi n sunt scalari, iar A este o matrice oarecare.
Dacă funcţia ones este apelată cu un singur argument scalar, matricea generată este o matrice pătratică
de ordinul n.
Exemplu
Pentru n=3, cu instrucţiunea U = ones(3) se obţine:
𝑈=
1 1 1
1 1 1
1 1 1
Dacă funcţia ones este apelată cu două argumente scalare (m,n), matricea generată are m linii şi n
coloane.
Exemplu
Pentru m=3 şi n=2, cu instrucţiunea U = ones(3,2) se obţine:
𝑈=
1 1
1 1
1 1
Dacă funcţia ones este apelată având ca argument o matrice A, matricea unitate generată are aceleaşi
dimensiuni ca A.
Exemplu
Pentru A = [2 4 6 8 10; 1 3 5 7 9], cu instrucţiunea U = ones(size(A)) se obţine:
𝑈=
1 1 1 1 1
1 1 1 1 1
Generarea matricei identitate
Matricea identitate este o matrice care are elementele de pe diagonală principală egale cu 1, celelalte
fiind egale cu 0:
1 0 ⋯ 0
0 1 ⋯ 0
𝐼=[ ]
⋯ ⋯ ⋯ ⋯
0 0 ⋯ 1
Generarea matricei identitate se face cu funcţia eye, care poate fi apelată cu una din următoarele
sintaxe:
I = eye(n), I = eye(m,n), I = eye(size(A))

69
unde m şi n sunt scalari, iar A este o matrice oarecare.
Dacă funcţia eye este apelată cu un singur argument scalar, matricea generată este o matrice pătratică
având dimensiunea argumentului (n).
Exemplu
Pentru n =3, cu instrucţiunea I = eye(3) se obţine:
I=
1 0 0
0 1 0
0 0 1
Dacă funcţia eye este apelată cu două argumente scalare (m,n), matricea generată are m linii şi n
coloane.
Exemplu
Pentru m = 3 şi n = 2, cu instrucţiunea I = eye(3,2) se obţine:
𝐼=
1 0
0 1
0 0
Dacă funcţia eye este apelată având ca argument o matrice A, matricea identică generată are aceleaşi
dimensiuni ca A.
Exemplu
Pentru A = [2 4 6 8 10; 1 3 5 7 9], cu instrucţiunea I = eye(size(A)) se obţine:
𝐼=
1 0 0 0 0
0 1 0 0 0
Generarea matricei nule
Matricea nulă este o matrice care are toate elementele egale cu zero:
0 0 ⋯ 0
0 0 ⋯ 0
𝑂=[ ]
⋯ ⋯ ⋯ ⋯
0 0 ⋯ 0
Generarea matricei nule se face cu funcţia zeros, care poate fi apelată cu una din următoarele sintaxe:
O = zeros(n), O = zeros(m,n), O = zeros(size(A))
unde m şi n sunt scalari, iar A este o matrice oarecare.
Dacă funcţia zeros este apelată cu un singur argument scalar, matricea generată este o matrice
pătratică de ordinul n.
Exemplu

70
Pentru n=3, cu instrucţiunea O = zeros(3) se obţine:
𝑂=
0 0 0
0 0 0
0 0 0
Dacă funcţia zeros este apelată cu două argumente scalare (m,n), matricea generată are m linii şi n
coloane.
Exemplu
Pentru m = 3 şi n = 2, cu instrucţiunea O = zeros(3,2) se obţine:
𝑂=
0 0
0 0
0 0
Dacă funcţia zeros este apelată având ca argument o matrice A, matricea unitate generată are aceleaşi
dimensiuni ca A.
Exemplu
Pentru A = [2 4 6 8 10; 1 3 5 7 9], cu instrucţiunea O = zeros(size(A)) se obţine:
𝑂=
0 0 0 0 0
0 0 0 0 0
3.3. Generarea unei reţele (mesh)
Generarea unei reţele (mesh) se face cu funcţia meshgrid, care transformă un domeniu specificat prin
vectorii x şi y în tablourile X şi Y care pot fi folosite la evaluări ale funcţiilor de două variabile şi
pentru reprezentări grafice în 3D.
Se apelează cu sintaxa [X,Y] = meshgrid(x,y), iar când vectorii x şi y sunt egali se utilizează [X,Y] =
meshgrid(x).
Funcţia meshgrid returnează în tablourile X şi Y perechile de coordonate ale tuturor punctelor din
domeniul definit de vectorii x şi y. Vectorii x şi y sunt de forma:
x = xmin: Δx: xmax, y = ymin: Δy: ymax
Exemplu
 Pentru domeniul -4 ≤ x ≤ 8, -6 ≤ y ≤ 3, cu pasul Δx = 4 şi Δy = 3, generarea tablourilor X şi Y
se face cu instrucţiunea [X, Y] = meshgrid(-4: 4: 8, -6: 3: 3) şi se obţine:
𝑋=
−4 0 4 8
−4 0 4 8
−4 0 4 8
−4 0 4 8
𝑌=
71
 −6 −6 −6 −6
−3 −3 −3 −3
0 0 0 0
3 3 3 3
3.4. Manipularea matricelor
Funcţia reshape transformă o matrice A cu dimensiunea l x p într-o matrice B, cu dimensiunea m x n,
cu condiţia ca cele două matrice să aibă acelaşi număr de elemente (l x p = m x n).
Se apelează cu sintaxa:
B = reshape(A,m,n) - elementele matricei A, citite pe coloane, de sus în jos, de la stânga spre dreapta,
sunt dispuse în matricea B, succesiv, pe n coloane cu m linii.
Exemplu
12 7 2
3 11 27
 Să se transfome matricea 𝐴 = [ ] cu dimensiunea 4x3 într-o matrice B cu
61 5 58
24 18 75
dimensiunea 6x2.
≫ 𝐴 = [12 7 2; 3 11 27; 61 5 58; 24 18 75];
≫ 𝐵 = 𝑟𝑒𝑠ℎ𝑎𝑝𝑒 (𝐴, 6, 2)
𝐵=
12 5
3 18
61 2
24 27
7 58
11 75
Funcţia diag creează matrice diagonale cu elementele unui vector sau extrage elementele situate pe
diagonala unei matrice.
Se apelează cu una dintre sintaxele:
D = diag(v) - returnează o matrice pătratică cu elementele vectorului v amplasate pe diagonala
principală
D = diag(v,k) – amplasează elementele vectorului v pe diagonala k (k = 0, înseamnă diagonala
principală; k > 0, diagonale situate deasupra diagonalei principale; iar k < 0, diagonale dedesubtul
diagonalei principale)
x = diag(A) – returnează un vector coloană conţinând elementele de pe diagonala principală a matricei
A
x = diag(A,k) – returnează un vector coloană conţinând elementele de pe diagonala k a matricei A
Exemple
 În cazul vectorului 𝑣 = [1 6 11], prin comenzile D = diag(v) şi D1 = diag(v,1) se obţine:

72
𝐷=
1 0 0
0 6 0
0 0 11
𝐷1 =
0 1 0 0
0 0 6 0
0 0 0 11
0 0 0 0
 Pentru a extrage diagonala principală a matricei
𝐴 = [10 15 20; 25 30 35; 40 45 50] se utilizează comanda x = diag(A)
𝑥=
10
30
50
 Pentru a obţine o matrice diagonală A1 având aceeaşi diagonală cu matricea A definită anterior
se utilizează A1 = diag(diag(A))
𝐴1 =
10 0 0
0 30 0
0 0 50
Funcţia triu(X) extrage matricea superior triunghiulară din matricea X (elementele situate pe
diagonala principală şi deasupra ei, celelalte elemente fiind zero), iar triu(X,k) extrage toate
elementele matricei X situate pe diagonala a k-a şi deasupra ei, celelalte elemente fiind zero.
Funcţia tril(X) extrage matricea inferior triunghiulară din matricea X (elementele situate pe diagonala
principală şi dedesubtul ei, celelalte elemente fiind zero), iar tril(X,k) extrage toate elementele
matricei X situate pe diagonala a k-a şi dedesubtul ei, celelalte elemente fiind zero.
Exemplu
 În cazul matricei 𝑋 = [3 5 7; 11 15 19; 24 29 33]
𝑡𝑟𝑖𝑢(𝑋) =
3 5 7
0 15 19
0 0 33
𝑡𝑟𝑖𝑙(𝑋, −1) =
0 0 0
11 0 0
24 29 0
Funcţia fliplr(X) inversează ordinea coloanelor în matricea X de la stânga spre dreapta. În urma
aplicării comenzii, ultima coloană a matricei X devine prima.

73
Exemplu
 Dacă 𝑋 = [1 2 3; 1 2 3; 1 2 3] atunci prin comanda fliplr(X) se obţine:
𝑎𝑛𝑠 =
3 2 1
3 2 1
3 2 1
Funcţia flipud(X) inversează ordinea liniilor în matricea X de sus în jos. În urma aplicării comenzii,
ultima linie a matricei X devine prima.
Exemplu
 Pentru 𝑋 = [1 1 1; 2 2 2; 3 3 3], prin comanda flipud(X) se obţine:
𝑎𝑛𝑠 =
3 3 3
2 2 2
1 1 1
Funcţia blkdiag creează o matrice prin amplasarea pe diagonală a matricelor argument în formă de
blocuri. Se apelează cu sintaxa:
out = blkdiag(a,b,c,d…) - matricele a, b, c, d sunt amplasate pe diagonala matricei returnate, out,
care este de tipul:
𝑎 0 0 0 0
0 𝑏 0 0 0
0 0 𝑐 0 0 .
0 0 0 𝑑 0
[0 0 0 0 …]
Matricele a, b, c, d etc. nu trebuie să fie pătratice sau să aibă aceleaşi dimensiuni.
Exemplu
 Să se construiască matricea A care să aibă amplasate pe diagonala principală matricele 𝐵 =
7 7
8 14
[ ] și 𝐶 = [6 6].
5 5
8 8
≫ 𝐵 = [8 14; 5 5];
≫ 𝐶 = [7 7; 6 6; 8 8];
≫ 𝐴 = 𝑏𝑙𝑘𝑑𝑖𝑎𝑔(𝐵, 𝐶 )
𝐴=
8 14 0 0
5 5 0 0
0 0 7 7
0 0 6 6
0 0 8 8

74
Funcţia repmat realizează copii ale unei matrice date, care sunt dispuse într-o nouă matrice. Se
apelează cu sintaxele:
B = repmat(A,n) – returnează o matrice pătratică ce conţine n copii ale argumentului A amplasate pe
direcţia liniilor şi respectiv a coloanelor.
B = repmat(A, r1, r2) – returnează o matrice ce conţine r1 copii ale argumentului A amplasate pe
direcţia liniilor şi respectiv r2 copii ale argumentului A amplasate pe direcţia coloanelor.
Argumentul A poate fi un scalar, un vector sau o matrice.
Exemplu
8 1
 Să se construiască matricea pătratică B care să conţină 3 copii ale matricei 𝐴 = [ ] pe
1 8
direcţia liniilor, respectiv coloanelor. Să se construiască matricea C care să conţină 3 copii ale matricei
A pe direcţia liniilor şi 2 copii pe direcţia coloanelor.
>> 𝐴 = [8 1; 1 8];
≫ 𝐵 = 𝑟𝑒𝑝𝑚𝑎𝑡 (𝐴, 3)
𝐵=
8 1 8 1 8 1
1 8 1 8 1 8
8 1 8 1 8 1
1 8 1 8 1 8
8 1 8 1 8 1
1 8 1 8 1 8
≫ 𝐶 = 𝑟𝑒𝑝𝑚𝑎𝑡 (𝐴, 2,4)
𝐶=
1 8 1 8 1 8 1 8
8 1 8 1 8 1 8 1
1 8 1 8 1 8 1 8
8 1 8 1 8 1 8 1
Pentru a şterge linii şi coloane dintr-o matrice se poate folosi o pereche de paranteze pătrate.
Exemplu
3 5 7
 Se cere să se şteargă linia a doua a matricei 𝑋 = [11 15 19]. Să se şteargă ultima coloană
24 29 33
a matricei X.
≫ 𝑋 = [3 5 7; 11 15 19; 24 29 33];
≫ 𝐴 = 𝑋;
≫ 𝐴(2, : ) = []
𝐴=
3 5 7
24 29 33
75
≫ 𝑋(: ,3) = []
𝑋=
3 5
11 15
24 29
Funcţia find returnează indicii şi valorile elementelor diferite de zero sau care verifică o anumită
condiţie. Se apelează cu una dintre sintaxele:
k = find(X) – returnează un vector conţinând indicii elementelor diferite de zero ale argumentului X.
Dacă argumentul este un vector, funcţia find returnează un vector având aceeaşi orientare cu X. Dacă
argumentul este o matrice, funcţia find returnează o matrice coloană, numerotarea elementelor
făcându-se pe coloane, de sus în jos, de la stânga la dreapta.
k = find(X,n) – returnează indicii primelor n elemente diferite de zero ale argumentului X
k = find(X,n, direcţie) – dacă direcţia este 'first' (direcţia prestabilită) returnează indicii primelor n
elemente diferite de zero; dacă direcţia este 'last' returnează indicii ultimelor elemente diferite de zero
[lin, col]=find(X) – returnează numărul liniei (în vectorul lin) şi al coloanei (în vectorul col) pentru
elementele matricei argument X diferite de zero
[lin, col, v]=find(X) - returnează şi vectorul v, care conţine elementele diferite de zero ale matricei
argument X
Exemple
 Să se găsească indicii elementelor diferite de zero (vectorul k) şi respectiv egale cu zero
7 5 0
(vectorul k1) ale matricei 𝑋 = [0 4 2].
8 0 3
≫ 𝑋 = [7 5 0; 0 4 2; 8 0 3];
≫ 𝑘 = 𝑓𝑖𝑛𝑑(𝑋)
𝑘=
1
3
4
5
8
9
≫ 𝑘1 = 𝑓𝑖𝑛𝑑 (~𝑋)
𝑘1 =
2
6
7

76
 Să se găsească indicii primelor patru elemente mai mici decât 6 (vectorul k) ale matricei 𝑋 =
2 9 10
[0 7 8] şi să se creeze vectorul coloană Y care să conţină acele elemente.
1 3 4
≫ 𝑋 = [2 9 10; 0 7 8; 1 3 4];
≫ 𝑘 = 𝑓𝑖𝑛𝑑 (𝑋 < 6,4)
𝑘=
1
2
3
6
≫ 𝑌 = 𝑋 (𝑘 )
𝑌=
2
0
1
3
 Să se găsească indicii ultimelor trei elemente diferite de zero (vectorul k) ale matricei definite
anterior.
≫ 𝑋 = [2 9 10; 0 7 8; 1 3 4];
≫ 𝑘 = 𝑓𝑖𝑛𝑑 (𝑋, 3, ′last′)
𝑘=
7
8
9
 Să se găsească indicii liniilor (vectorul lin) şi indicii coloanelor (vectorul col) pentru
elementele matricei definite anterior care sunt mai mari decât 1 şi mai mici decât 5.
≫ 𝑋 = [2 9 10; 0 7 8; 1 3 4];
≫ [𝑙𝑖𝑛, 𝑐𝑜𝑙 ] = 𝑓𝑖𝑛𝑑 (𝑋 > 1&𝑋 < 5)
𝑙𝑖𝑛 =
1
3
3
𝑐𝑜𝑙 =
1
2
3
 Să se găsească indicii liniilor (vectorul lin), indicii coloanelor (vectorul col) şi să se afişeze
elementele (vectorul v) diferite de zero ale matricei definite anterior.

77
≫ 𝑋 = [2 9 10; 0 7 8; 1 3 4];
>> [𝑙𝑖𝑛, 𝑐𝑜𝑙, 𝑣 ] = 𝑓𝑖𝑛𝑑 (𝑋)

𝑙𝑖𝑛 = 𝑐𝑜𝑙 = 𝑣=
1 1 2
3 1 1
1 2 9
2 2 7
3 2 3
1 3 10
2 3 8
3 3 4
3.5. Operatori MATLAB
Operatorii MATLAB pot fi clasificaţi în trei categorii:
- Operatori aritmetici;
- Operatori relaţionali;
- Operatori logici.
Operatori aritmetici
Calculele aritmetice asupra tablourilor de date în MATLAB pot fi efectuate după:
- regulile calculului matriceal (operaţii cu matrice);
- regulile calculului scalar (operaţii cu tablouri).
În cazul operaţiilor cu tablouri, care sunt operaţii aritmetice între elementele situate în aceeaşi poziţie
a tablourilor, ambii operanzi trebuie să aibă aceeaşi dimensiune. În situaţia în care unul dintre
operanzi este un scalar, acesta se aplică fiecărui element al tabloului.
Operatorii aritmetici ai MATLAB-ului sunt prezentaţi în Tabelul 1.1.

Tabelul 1.1 Operatorii aritmetici ai MATLAB-ului

Operaţia Scalari Matrice Tablouri
Adunare + + +
Scădere - - -
Înmulţirea * * .*
Împărţirea la dreapta / / ./
Împărţirea la stânga \ \ .\

78
 Ridicarea la putere ^ ^ .^
Transpunerea ’ ‘ .’

Exemple
0 1 −1 −2
 Pentru matricele 𝐴 = [ ], 𝐵 = [ ] şi scalarul 𝑠 = 4, să se calculeze:
3 2 4 0
𝐶 = 𝐴 + 𝐵, 𝐶1 = 𝐴 + 𝑠, 𝐷 = 𝐴 − 𝐵, 𝐷1 = 𝐴 − 𝑠, 𝐸 = 𝐴 ∗ 𝐵, 𝐸1 = 𝐴 ∗ 𝑠, 𝐸2 = 𝐴.∗ 𝐵, 𝐹 = 𝐴/𝐵,
𝐹1 = 𝐴/𝑠, 𝐹2 = 𝐴./𝐵, 𝐺 = 𝐴\𝐵, 𝐺1 = 𝐴.\𝐵, 𝐻 = 𝐴^𝑠, 𝐻1 = 𝐴. ^𝐵, 𝐼 = 𝐴′.
≫ 𝐴 = [0 1; 3 2]; ≫ 𝐸2 = 𝐴.∗ 𝐵
≫ 𝐵 = [−1 −2; 4 0]; 𝐸2 =
≫ 𝑠 = 4; 0 −2
12 0
≫𝐶 = 𝐴+𝐵
≫ 𝐹 = 𝐴/𝐵
𝐶=
𝐹=
−1 −1
7 2 −0.5000 −0.1250
−1.0000 0.5000
≫ 𝐶1 = 𝐴 + 𝑠
≫ 𝐹1 = 𝐴/𝑠
≫ 𝐶1 =
𝐹1 =
4 5
7 6 0 0.2500
0.7500 0.5000
≫𝐷 = 𝐴−𝐵
≫ 𝐹2 = 𝐴./𝐵
𝐷=
𝐹2 =
1 3
−1 2 0 −0.5000
0.7500 𝐼𝑛𝑓
≫ 𝐷1 = 𝐴 − 𝑠
>> 𝐺 = 𝐴\𝐵
𝐷1 =
𝐺=
−4 −3
−1 −2 2.0000 1.3333
−1.0000 −2.0000
≫ 𝐸 =𝐴∗𝐵
≫ 𝐺1 = 𝐴.\𝐵
𝐸=
𝐺1 =
4 0
5 −6 0 −0.5000
0.7500 𝐼𝑛𝑓
≫ 𝐸1 = 𝐴 ∗ 𝑠
≫ 𝐻 = 𝐴^s
𝐸1 =
0 4 𝐻=
12 8 21 20
60 61
79
≫ 𝐻1 = 𝐴. ^𝐵 ≫ 𝐼 = 𝐴′
𝐻1 = 𝐼=
𝐼𝑛𝑓 1 0 3
81 1 1 2
Operatori relaţionali
Operatorii relaţionali, compară element cu element două matrice, care au aceeaşi dimensiune şi
returnează o matrice cu elemente egale cu 1 când relaţia este Adevărată, şi cu elemente egale cu 0
când relaţia este Falsă 0. Dacă se compară doi scalari, rezultatul obţinut este un scalar. În situaţia în
care unul dintre operanzi este un scalar şi celălalt o matrice, scalarul se compară cu fiecare element
al matricei.
Sintaxa instrucţiunii este:
C = A operator relaţional B
unde:
C – matricea în care se returnează rezultatul
A, B – matricele care se compară
Operatorii relaţionali ai MATLAB-ului sunt prezentaţi în Tabelul 1.2.
Tabelul 1.2 Operatori relaţionali ai MATLAB-ului
Semnificaţie Operatori relaţionali
Identic ==
Diferit ~=
Mai mic <
Mai mic sau egal <=
Mai mare >
Mai mare sau egal >=

Primii doi operatori compară atât partea reală cât şi imaginară a operanzilor, iar ceilalţi doi doar partea
reală.
Exemple
32 9 3 74
 Pentru matricele 𝐴 = [ ], 𝐵 = [ ] şi scalarul 𝑠 = 9, să se calculeze:
17 24 52 89
𝐶 = 𝐴 == 𝐵, 𝐶1 = 𝐴 == 𝑠, 𝐷 = 𝐴~ = 𝐵, 𝐷1 = 𝐴~ = 𝑠, 𝐸 = 𝐴 ≥ 𝐵, 𝐸1 = 𝐴 >= 𝑠.
≫ 𝐴 = [32 9; 17 24]; ≫ 𝐶 = 𝐴 == 𝐵
≫ 𝐵 = [3 74; 52 89]; 𝐶=
𝑠 = 9;
80
 0 0 𝐷1 =
0 0
1 0
≫ 𝐶1 = 𝐴 == 𝑠 1 1
𝐶1 = ≫ 𝐸 = 𝐴 >= 𝐵
0 1 𝐸=
0 0
1 0
≫ 𝐷 = 𝐴~ = 𝐵 0 0
𝐷= ≫ 𝐸1 = 𝐴 >= 𝑠
1 1 𝐸1 =
1 1
1 1
≫ 𝐷1 = 𝐴~ = 𝑠 1 1
Operatori logici
Operatorii logici au o prioritate mai mică decât operatorii relaţionali sau aritmetici. Într-o expresie,
se evaluează mai întâi relaţiile care conţin operatori relaţionali şi aritmetici şi apoi cele cu operatori
logici.
În MATLAB orice valoare diferită de zero este considerată adevărată logic, adică 1.
Operatorii logici ai MATLAB-ului sunt prezentaţi în Tabelul 1.3.
Tabelul 1.3 Operatori logici ai MATLAB-ului
Semnificaţia Forma MATLAB
Nu ~
Şi &
Sau |
Sau exclusiv xor

Operatorul Nu neagă operandul şi returnează o matrice cu elemente egale cu 1 (Adevărat) sau 0 (Fals).
Un element al matricei de ieşire este egal cu 1 dacă elementul situat pe aceeaşi poziţie a matricei
iniţiale este zero. Dacă operatorul se aplică unui scalar, rezultatul obţinut va fi tot un scalar.
Sintaxa instrucţiunii este:
C =~ A
unde:
C – matricea în care se returnează rezultatul; A– matricea care se evaluează

Operatorul Şi compară element cu element două matrice, care au aceeaşi dimensiune şi returnează o
matrice cu elemente egale cu 1 (Adevărat) sau 0 (Fals). Un element al matricei de ieşire este egal cu
1 dacă ambele elemente situate pe aceeaşi poziţie a matricelor care se compară sunt diferite de zero.
81
Dacă se compară doi scalari, rezultatul obţinut este un scalar. În situaţia în care unul dintre operanzi
este un scalar şi celălalt o matrice, scalarul se aplică fiecărui element al matricei.
Sintaxa instrucţiunii este:
C=A&B
unde:
C – matricea în care se returnează rezultatul
A, B – matricele care se compară

Operatorul Sau compară element cu element două matrice, care au aceeaşi dimensiune şi returnează
o matrice cu elemente egale cu 1 (Adevărat) sau 0 (Fals). Un element al matricei de ieşire este egal
cu 1 dacă unul din elementele situate pe aceeaşi poziţie a matricelor care se compară este diferit de
zero. Dacă se compară doi scalari, rezultatul obţinut este un scalar. În situaţia în care unul dintre
operanzi este un scalar şi celălalt o matrice, scalarul se aplică fiecărui element al matricei.
Sintaxa instrucţiunii este:
C=A|B
unde:
C – matricea în care se returnează rezultatul; A, B – matricele care se compară

Operatorul Sau exclusiv compară element cu element două matrice, care au aceeaşi dimensiune şi
returnează o matrice cu elemente egale cu 1 (Adevărat) sau 0 (Fals). Un element al matricei de ieşire
este egal cu 1 dacă unul din elementele situate pe aceeaşi poziţie a matricelor care se compară este
diferit de zero, iar celălalt este zero. Dacă se compară doi scalari, rezultatul obţinut este un scalar. În
situaţia în care unul dintre operanzi este un scalar şi celălalt o matrice, scalarul se aplică fiecărui
element al matricei.
Sintaxa instrucţiunii este:
C = xor(A, B)
unde:
C – matricea în care se returnează rezultatul; A, B – matricele care se compară

Ordinea de prioritate a operatorilor logici:

Nu
Şi
Sau ori Sau exclusiv
Rezultatele aplicării operatorilor logici în cazul a doi scalari A şi B sunt prezentate în Tabelul 3.5.1.

82
Tabelul 3.5.1. Tabela de adevăr a operatorilor logici
A B A & B A | B xor(A,B) ~A
0 0 0 0 0 1
0 1 0 1 1 1
1 0 0 1 1 0
1 1 1 1 0 0

Exemplu
32 9 3 9
 Pentru matricele 𝐴 = [ ], 𝐵 = [ ] şi scalarul 𝑠 = 9, să se calculeze:
17 24 52 89
𝐶 = ~𝐴, 𝐶1 = ~𝐵, 𝐶2 = ~𝑠, 𝐷 = 𝐴&𝐵, 𝐷1 = 𝐴&𝑠, 𝐸 = 𝐴|B, 𝐸1 = 𝐴|s, 𝐹 = 𝑥𝑜𝑟(𝐴, 𝐵), 𝐹1 =
𝑥𝑜𝑟(𝐴, 𝑠)
≫ 𝐴 = [32 9; 17 24]; 𝐷1 =
≫ 𝐵 = [3 74; 52 89]; 1 1
1 1
≫ 𝑠 = 9;
≫ 𝐸 = 𝐴|B
𝐶 = ~𝐴
𝐸=
𝐶=
1 1
0 0 1 1
0 0
≫ 𝐸1 = 𝐴|s
≫ 𝐶1 = ~𝐵
𝐸1 =
𝐶1 =
1 1
0 0 1 1
0 0
≫ 𝐹 = 𝑥𝑜𝑟(𝐴, 𝐵)
≫ 𝐶2 = ~𝑠
𝐹=
𝐶2 =
0 0
0 0 0

≫ 𝐷 = 𝐴&𝐵 ≫ 𝐹1 = 𝑥𝑜𝑟(𝐴, 𝑠)

𝐷= 𝐹1 =

1 1 0 0
1 1 0 0

≫ 𝐷1 = 𝐴&𝑠
Prioritatea operatorilor
Prioritatea operatorilor determină ordinea de evaluare a operaţiilor într-o expresie. În funcţie de
prioritate, operatorii MATLAB sunt clasificaţi în 11 nivele de prioritate, prezentate în Tabelul 3.5.2.
83
Operatorii din primul nivel au prioritate maximă. Prioritatea operatorilor descreşte cu numărul
nivelului de care aparţine operatorul. Operatorii din acelaşi nivel au aceeaşi prioritate şi sunt evaluaţi
de la stânga la dreapta.

Tab. 3.5.2. Prioritatea operatorilor

1. ()
2. .’, .^, ’, ^
3. + (plus unar), - (minus unar), ~
4. .*, ./, .\, *, /, \
5. +, -
6. :
7. <, <=, >, >=, ==, ~=
8. &
9. |
10. &&
11. ||

Exemplu
 Pentru matricele 𝐴 = [4 10 15 20] şi 𝐵 = [11 34 12 10], se cere să se compare rezultele
obţinute pentru următooarele operaţii: 𝐶 = 𝐴./𝐵. ^2 şi 𝐷 = (𝐴./𝐵). ^2.

≫ 𝐴 = [4 10 15 20];
≫ 𝐵 = [11 34 12 10];
≫ 𝐶 = 𝐴./𝐵. ^2
𝐶=
0.0331 0.0087 0.1042 0.2000
≫ 𝐷 = (𝐴./𝐵). ^2
𝐷=

0.1322 0.0865 1.5625 4.0000

3.6. Calcul matriceal
Determinantul unei matrice
Determinantului unei matrice A se calculează cu funcţia det, care se apelează cu sintaxa:
d = det(A)

84
Exemplu
4 15 6
 Să se calculeze determinantul matricei 𝐴 = [2 23 68].
9 4 11
≫ 𝐴 = [4 15 6; 2 23 68; 9 4 11];
≫ 𝑑 = 𝑑𝑒𝑡(𝐴)
𝑑=
7850
Inversa unei matrice
Inversa unei matrice X se calculează cu funcţia inv, care se apelează cu sintaxa:
Y = inv(X)
Exemplu
4 15 6
 Să se calculeze inversa matricei 𝐴 = [2 23 68].
9 4 11
≫ 𝐴 = [4 15 6; 2 23 68; 9 4 11];
≫ 𝑌 = 𝑖𝑛𝑣 (𝐴)
𝑌=
−0.0025 −0.00186 0.1164
0.0778 −0.0013 −0.0343
−0.0263 0.0157 0.0082

3.7. Prelucrarea datelor

Maximul şi minimul
Funcţia max identifică elementul maxim al unui vector sau elementele maxime ale unei matrice; se
apelează cu una dintre sintaxele:
M = max(A) – returnează elementul maxim al argumentului A. Dacă argumentul este un vector,
funcţia returnează cel mai mare element al acestuia. Dacă argumentul este o matrice, funcţia
returnează un vector linie, ce conţine elementul maxim al fiecărei coloane.
M = max(A, [], dim) – returnează elementul maxim al argumentului A, pe direcţia dimensiunii dim.
De exemplu, dacă argumentul este o matrice, max(A, [], 2) returnează un vector coloană, ce conţine
elementul maxim al fiecărei linii.
[M, I] = max(A) – găseşte indicii liniilor valorilor maxime ale argumentului A şi îi returnează în
vectorul de ieşire I.
C = max(A,B) – returnează o matrice sau un vector C, având aceeaşi dimensiune cu A şi B, ce conţine
elementele maxime din A şi B. Argumentele A şi B trebuie să aibă aceleaşi dimensiuni în cazul
matricelor şi vectorilor, sau unul dintre ele poate fi un scalar.
85
Funcţia min identifică elementul minim al unui vector sau elementele minime ale unei matrice; se
apelează cu una dintre sintaxele:
M = min(A) – returnează elementul minim al argumentului A. Dacă argumentul este un vector, funcţia
returnează cel mai mic element al acestuia. Dacă argumentul este o matrice, funcţia returnează un
vector linie, ce conţine elementul minim al fiecărei coloane.
M = min(A, [], dim) – returnează elementul minim al argumentului A, pe direcţia dimensiunii dim. De
exemplu, dacă argumentul este o matrice, max(A, [], 2) returnează un vector coloană, ce conţine
elementul minim al fiecărei coloane.
[M, I] = min(A) – găseşte indicii liniilor valorilor minime ale argumentului A şi îi returnează în
vectorul de ieşire I.
C = min(A,B) – returnează o matrice sau un vector C, având aceeaşi dimensiune cu A şi B, ce conţine
elementele minime din A şi B. Argumentele A şi B trebuie să aibă aceleaşi dimensiuni în cazul
matricelor şi vectorilor, sau unul dintre ele poate fi un scalar.
Exemple
 Să se determine cel mai mare (M) şi cel mai mic (M1) element al vectorului 𝐴 =
[14 27 2 19 123].

≫ 𝐴 = [14 27 2 19 123];
≫ 𝑀 = 𝑚𝑎𝑥 (𝐴)
𝑀=
123
≫ 𝑀1 = 𝑚𝑖𝑛(𝐴)
𝑀1 =
2
 Să se determine elementele maxime (M) şi minime (M1) pentru fiecare coloană a matricei
15 10 80
𝐴 = 2 135 32]. Să se determine elementele maxime (M2) şi minime (M3) pentru fiecare linie
[
18 76 29
a matricei A. Să se determine elementul maxim (M4) şi minim (M5) al matricei A.
≫𝐴= ≫ 𝑀2 = 𝑚𝑎𝑥 (𝐴, [],2 )
[15 10 80; 2 135 32; 18 76 29];
𝑀2 =
≫ 𝑀 = 𝑚𝑎𝑥 (𝐴)
80
𝑀= 135
76
18 135 80
≫ 𝑀3 = 𝑚𝑖𝑛(𝐴, [],2)
≫ 𝑀1 = 𝑚𝑖𝑛(𝐴)
𝑀3 =
𝑀1 =
10
2 10 29 2
18
86
≫ 𝑀4 = 𝑚𝑎𝑥(𝑚𝑎𝑥 (𝐴)) ≫ 𝑀5 = 𝑚𝑖𝑛(𝑚𝑖𝑛(𝐴))

𝑀4 = 𝑀5 =
135 2
 Să se determine elementele maxime (M) pentru fiecare coloană a matricei 𝐴 =
15 10 80
[ 2 135 32] şi să se specifice indicii liniilor (vectorul I) pe care apar. Să se determine elementele
18 76 29
minime (M1) pentru fiecare coloană a matricei A şi să se specifice indicii liniilor (vectorul I1) pe care
apar.

≫ 𝐴 = [15 10 80; 2 135 32; 18 76 29];

≫ [𝑀, 𝐼 ] = 𝑚𝑎𝑥 (𝐴)
𝑀=

18 135 80
𝐼=
3 2 1
≫ [𝑀1, 𝐼1] = 𝑚𝑖𝑛(𝐴)
𝑀1 =
2 10 29
𝐼1 =
2 1 3
 Să se determine valoarea maximă ce se obţine comparând fiecare element al matricei 𝐴 =
15 10 80
[ 2 135 32] cu scalarul 𝑝 = 5. Să se determine valoarea minimă ce se obţine comparând fiecare
18 76 29
element al matricei 𝐴 cu scalarul 𝑝 = 5.

≫ 𝐴 = [15 10 80; 2 135 32; 18 76 29];

≫ 𝑝 = 5;
≫ 𝐶 = 𝑚𝑎𝑥 (𝐴, 𝑝)
𝐶=
15 10 80
5 135 32
18 76 29
≫ 𝐶1 = 𝑚𝑖𝑛(𝐴, 𝑝)
𝐶1 =

87
 5 5 5
5 5 5
5 5 5
Media
Funcţia mean calculează valoarea medie a unui set de date; se apelează cu sintaxa:
M = mean(A) – returnează valoarea medie a elementelor argumentului A. Dacă argumentul este un
vector, funcţia returnează valoarea medie a elementelor acestuia. Dacă argumentul este o matrice,
funcţia retunează un vector linie, ce conţine valoarea medie a fiecărei coloane.
M = mean(A, dim) – returnează valoarea medie a elementelor argumentului A, pe direcţia dimensiunii
dim. De exemplu, dacă argumentul este o matrice, mean(A,2) returnează un vector coloană, ce conţine
valoarea medie a fiecărei linii.
Exemplu
4 10 1
 Să se calculeze media elementelor fiecărei coloane (vectorul M) a matricei 𝐴 = [2 10 3].
9 4 5
Să se calculeze media elementelor fiecărei linii (vectorul M1) a matricei A.
≫ 𝐴 = [4 10 1; 2 10 3; 9 4 5];
≫ 𝑀 = 𝑚𝑒𝑎𝑛(𝐴)
𝑀=

5 8 3
≫ 𝑀1 = 𝑚𝑒𝑎𝑛(𝐴, 2)
𝑀1 =
5
5
6
Sortarea elementelor unui vector sau a unei matrice
Funcţia sort sortează elementele unui vector sau a unei matrice; se apelează cu sintaxa:
B = sort(A) – sortează în ordine crescătoare elementele argumentului A. Dacă argumentul este un
vector, funcţia sortează elementele acestuia. Dacă argumentul este o matrice, funcţia sortează
elementele fiecărei coloane.
B = sort(A, dim) – sortează în ordine crescătoare elementele argumentului A, pe direcţia dimensiunii
dim. De exemplu, dacă argumentul este o matrice, sort(A, [], 2) sortează elementele fiecărei linii.
B = sort( A, mod) – sortează elementele argumentului A în ordinea indicată de mod. Dacă se doreşte
în ordine crescătoare, se alege modul ’ascend’ (prestabilit). Dacă se doreşte în ordine descrescătoare,
se alege modul ’descend’.
Exemple
 Să se sorteze în ordine crescătoare elementele vectorului 𝐴 = [7 0 −4 5 2].
≫ 𝐴 = [7 0 −4 5 2];
88
≫ 𝐵 = 𝑠𝑜𝑟𝑡(𝐴)
𝐵=

−4 0 2 5 7
 Să se sorteze în ordine crescătoare elementele fiecărei coloane (matricea B) a matricei 𝐴 =
15 10 80
[ 2 135 32]. Să se sorteze în ordine descrescătoare elementele fiecărei coloane (matricea B1) a
18 76 29
matricei A. Să se sorteze în ordine crescătoare elementele fiecărei linii (matricea B2) a matricei A.

≫ 𝐴 = [15 10 80; 2 135 32; 18 76 29];

≫ 𝐵 = 𝑠𝑜𝑟𝑡(𝐴)
𝐵=
2 10 29
15 76 32
18 135 80
≫ 𝐵1 = 𝑠𝑜𝑟𝑡(𝐴, ′𝑑𝑒𝑠𝑐𝑒𝑛𝑑′)
𝐵1 =
18 135 80
15 76 32
2 10 29
≫ 𝐵2 = 𝑠𝑜𝑟𝑡(𝐴, 2)
𝐵2 =
2 10 29
15 32 76
18 80 135
4. Rezolvarea Sistemelor de Ecuaţii Liniare
Un sistem de n ecuaţii liniare cu n necunoscute:
𝑎11 𝑥1 + … + 𝑎1𝑗 𝑥𝑗 + … + 𝑎1𝑛 𝑥𝑛 = 𝑏1
………………………………………………………
𝑎𝑖1 𝑥1 + … + 𝑎𝑖𝑗 𝑥𝑗 + … + 𝑎𝑖𝑛 𝑥𝑛 = 𝑏𝑖
………………………………………………………
{ 𝑎𝑛1 𝑥1 + … + 𝑎𝑛𝑗 𝑥𝑗 + … + 𝑎𝑛𝑛 𝑥𝑛 = 𝑏𝑛

poate fi scris sub formă matriceală:

𝐴∙𝑋 =𝐵
unde:
𝑎11 ⋯ 𝑎1𝑗 ⋯ 𝑎1𝑛
⋯ ⋯ ⋯ ⋯ ⋯
𝑎
𝐴 = 𝑖1 ⋯ 𝑎𝑖𝑗 ⋯ 𝑎𝑖𝑛 - matricea coeficienţilor necunoscutelor;
⋯ ⋯ ⋯ ⋯ ⋯
𝑎
[ 𝑛1 ⋯ 𝑎𝑛𝑗 ⋯ 𝑎𝑛𝑛 ]
89
 𝑥1
⋯
𝑋 = 𝑥𝑖 - matricea necunoscutelor;
⋯
[𝑥𝑛 ]
𝑏1
⋯
𝐵 = 𝑏𝑖 - matricea termenilor liberi.
⋯
[𝑏𝑛 ]
Soluţiile sistemului pot fi obţinute în MATLAB utilizând una din instrucţiunile:
𝑋 = 𝐵/𝐴 – împărţire la dreapta
𝑋 = 𝐴\𝐵 – împărţire la stânga
𝑋 = 𝑖𝑛𝑣 (𝐴) ∙ 𝐵
Împărţirea la stânga este efectuată de MATLAB mai rapid decât împărţirea la dreapta.
Exemplu
 Să se rezolve sistemul de ecuaţii:
4𝑥 − 3𝑦 = 9
{
𝑥 − 6𝑦 = 4
Se scrie sistemul sub formă matriceală:
𝐴∙𝑋 =𝐵
unde:
4 −3
𝐴=[ ]
1 −6
𝑥
𝑋 = [𝑦 ]

9
𝐵=[ ]
4
≫ 𝐴 = [4 −3; 1 −6];
≫ 𝐵 = [9; 4];
≫ 𝑋 = 𝐴\𝐵
𝑋=
2.0000
−0.3333
5. Funcţii Matematice Uzuale
Funcţii pentru ridicarea la putere, extragerea radicalului, calculul logaritmului şi al
exponenţialei

90
Pentru ridicarea la putere a unui număr se foloseşte funcţia ^, care se apelează cu sintaxa:
x=a^n – ridică un număr a la puterea n.
Exemple
 Să se ridice numărul 3 la puterea a patra.
≫ 𝑥 = 3^4
𝑥=
81
 Să se ridice numărul 5 la puterile 2, 3 şi 4.
𝑎 = [2 3 4]
𝑥 = 5. ^𝑎
𝑥=

25 125 625
Pentru calculul radicalului de ordinul 2 dintr-un număr a se utilizează funcţia sqrt, care se apelează
cu sintaxa:
B = sqrt(X) – extrage radicalul de ordinul 2 din argumentul X.
Exemplu
 Să se extragă radicalul de ordinul 2 din 81, 57 şi 62.
≫ 𝑋 = [81 57 62];
≫ 𝐵 = 𝑠𝑞𝑟𝑡(𝑋)
𝐵=
9 7.5498 7.8740
Dacă se doreşte extragerea radicalului de ordinul n, se utilizează funcţia nthroot, care se apelează cu
sintaxa:
Y = nthroot(X, N) – extrage radicalul de ordinul N din X. X şi N trebuie să fie scalari sau matrice cu
aceeaşi dimensiune.
Exemple
 Să se calculeze rădăcinile de ordinul 5, 3 şi 2 ale numărului 81.
≫ 𝑁 = [5 3 2]; % vectorul rădăcinilor
≫ 𝑌 = 𝑛𝑡ℎ𝑟𝑜𝑜𝑡(81, 𝑁)
𝑌=
2.4082 4.3267 9.0000
 Să se extragă rădăcinile de ordinul 3 din 27, de ordinul 2.5 din 35 şi de ordinul 2 din 49.

91
≫ 𝑋 = [27 35 49];
≫ 𝑁 = [3 2.5 2]; % vectorul rădăcinilor
≫ 𝑌 = 𝑛𝑡ℎ𝑟𝑜𝑜𝑡(𝑋, 𝑁)
𝑌=

3 4.1459 7
Pentru calculul logaritmului se utilizează funcţiile log, log2 şi log10, care se apelează cu sintaxele:
Y = log(X) – calculează logaritmul natural al argumentului X;
Y = log2(X) – calculează logaritmul în baza doi al argumentului X;
Y = log10(X) – calculează logaritmul în baza 10 al argumentului X.
Exemplu
 Să se calculeze logaritmul natural, logaritmul în baza doi şi logaritmul în baza 10 din
4 15
elementele matricei = [ ].
23 7
≫ 𝑋 = [4 15; 23 7];
≫ 𝑌 = 𝑙𝑜𝑔(𝑋)
𝑌=
1.3863 2.7081
3.1355 1.9459
≫ 𝑌1 = 𝑙𝑜𝑔2(𝑋)
𝑌1 =
2.0000 3.9069
4.5236 2.8074
≫ 𝑌2 = 𝑙𝑜𝑔10(𝑋)
𝑌2 =
0.6021 1.1761
1.3617 0.8451
Exponenţiala se calculează cu funcţia exp, care se apelează cu sintaxa:
Y = exp(X) – ridică pe e (e=2.7182…) la puterea X.
Exemplu
 Să se ridice numărul e la puterile 2, 3 şi -1.
≫ 𝑋 = [2 3 −1]; % vectorul puterilor
≫ 𝑌 = 𝑒𝑥𝑝(𝑋)
𝑋=

7.3890 20.0855 0.3678

92
Funcţii trigonometrice
Funcţiile trigonometrice se apelează cu sintaxa:
Y = funcţie_trigonometrică(argument)
unde:
- funcţie_trigonometrică este numele funcţiei;
- argument este valoarea pentru care se calculează funcţia;
- Y este variabila în care se returnează rezultatul.
Argumentul poate fi un scalar, sau o matrice. În cazul matricelor, funcţia se aplică tuturor elementelor.
Principalele funcţii trigonometrice din MATLAB sunt:
sin – calculează sinusul argumentului, exprimat în radiani;
sind – calculează sinusul argumentului, exprimat în grade;
asin – calculează arcsinusul argumentului, exprimat în radiani;
asind – calculează arcsinusul argumentului, exprimat în grade;
sinh – calculează sinusul hiperbolic al argumentului;
asinh – calculează arcsinusul hiperbolic al argumentului;

cos – calculează cosinusul argumentului, exprimat în radiani;

cosd –calculează cosinusul argumentului, exprimat în grade;
acos – calculează arccosinusul argumentului, exprimat în radiani;
acosd – calculează arccosinusul argumentului, exprimat în grade;
cosh –calculează cosinusul hiperbolic al argumentului;
acosh – calculează arccosinusul hiperbolic al argumentului;

tan – calculează tangenta argumentului, exprimat în radiani;

tand – calculează tangenta argumentului, exprimat în grade;
atan – calculează arctangenta argumentului, exprimat în radiani;
atand – calculează arctangenta argumentului, exprimat în grade;
tanh- calculează tangenta hiperbolică a argumentului;
atanh- calculează arctangenta hiperbolică a argumentului;

cot- calculează cotangenta argumentului, exprimat în radiani;

93
cotd- calculează cotangenta argumentului, exprimat în grade;
acot- calculează arccotangenta argumentului, exprimat în radiani;
acotd- calculează arccotangenta argumentului, exprimat în grade;
coth- calculează cotangenta hiperbolică a argumentului;
acoth- calculează arctangenta hiperbolică a argumentului.
Exemple
 Să se calculeze sinusul, cosinusul, tangenta şi cotangenta pentru fiecare din elementele
30 45
matricei 𝑋1 = [ ], exprimate în grade. Să se calculeze sinusul, cosinusul, tangenta şi
15 80
𝑝𝑖/6 𝑝𝑖/4
cotangenta pentru fiecare din elementele matricei 𝑋2 = [ ], exprimate în radiani.
𝑝𝑖/2.4 𝑝𝑖/3
≫ 𝑋1 = [30 45; 15 80]; 0.8660 0.7071
0.2588 0.5000
≫ 𝑋2 = [𝑝𝑖 ⁄6 𝑝𝑖 ⁄4; 𝑝𝑖 ⁄2.4 𝑝𝑖 ⁄3];
≫ 𝐶1 = 𝑡𝑎𝑛𝑑 (𝑋1)
≫ 𝐴1 = 𝑠𝑖𝑛𝑑 (𝑋1)
𝐶1 =
𝐴1 =
0.5774 1.0000
0.5000 0.7071 0.2679 5.6713
0.2588 0.9848
≫ 𝐶2 = 𝑡𝑎𝑛(𝑋2)
≫ 𝐴2 = 𝑠𝑖𝑛(𝑋2)
𝐶2 =
𝐴2 =
0.5774 1.0000
0.5000 0.7071 3.7321 1.7321
0.9659 0.8660
≫ 𝐷1 = 𝑐𝑜𝑡𝑑(𝑋)
≫ 𝐵1 = 𝑐𝑜𝑠𝑑(𝑋)
𝐷1 =
𝐵1 =
1.7321 1.0000
0.8660 0.7071 3.7321 0.1763
0.9659 0.1736
≫ 𝐷2 = 𝑐𝑜𝑡(𝑋2)
≫ 𝐵2 = 𝑐𝑜𝑠(𝑋2)
𝐷2 =
𝐵2 =
1.7321 1.0000
0.2679 0.5774
 Să se calculeze arcsinusul, arccosinusul, arctangenta şi arccotangenta, în grade, pentru fiecare
din elementele matricei 𝑋 = [ 0 √3⁄2]. Să se calculeze arcsinusul, arccosinusul, arctangenta şi
0.5 1
arccotangenta, în radiani, pentru fiecare din elementele matricei X.
≫ 𝑋 = [0.5 𝑠𝑞𝑟𝑡(3)/2; 0.5 1]; 0 60.0000
30.0000 90.0000
≫ 𝐴 = 𝑎𝑠𝑖𝑛𝑑 (𝑋)
≫ 𝐴1 = 𝑎𝑠𝑖𝑛(𝑋)
𝐴=
𝐴1 =

94
 0 1.0472 ≫ 𝐶1 = 𝑎𝑡𝑎𝑛(𝑋)
0.5236 1.5708
𝐶1 =
≫ 𝐵 = 𝑎𝑐𝑜𝑠𝑑 (𝑋)
0 0.7137
𝐵= 0.4636 0.7854
90 30 ≫ 𝐷 = 𝑎𝑐𝑜𝑡𝑑(𝑋)
60 0
𝐷=
≫ 𝐵1 = 𝑎𝑐𝑜𝑠(𝑋)
90 49.1066
𝐵= 63.4349 45.0000
1.5708 0.5236 ≫ 𝐷1 = 𝑎𝑐𝑜𝑡(𝑋)
1.0472 0
𝐷1 =
≫ 𝐶 = 𝑎𝑡𝑎𝑛𝑑 (𝑋)
1.5708 0.8571
𝐶= 1.1071 0.7854
0 40.8934
26.5651 45.0000
6. Reprezentări Grafice
Pentru a deschide o fereastră grafică se utilizează funcţia figure, care se apelează cu una dintre
sintaxele:
figure – deschide o nouă fereastră grafică, cu proprietăţi prestabilite, care devine fereastra curentă.
Titlul figurii create este un număr întreg, cunoscut sub numele de identificator al figurii.
figure(h) – în cazul în care fereastra grafică cu identificatorul h există, ea devine fereastra curentă.
Altfel, se creează fereastra grafică cu identificatorul h, unde h trebuie să fie un număr întreg.
h = figure – deschide o nouă fereastră grafică şi returnează identificatorul acesteia.
Funcţia clf şterge toate elementele grafice din figura curentă. Se apelează cu una dintre sintaxele:
clf – șterge toate elementele grafice ale căror identificatori nu sunt ascunși
clf (‘reset’) – șterge elementele grafice indiferent de starea identficatorilor
Funcţia close se utilizează pentru a închide o fereastră grafică. Se apelează cu una dintre sintaxele:
close – închide fereastra grafică curentă
close(h) – închide fereastra grafică cu identificatorul h
close all – închide toate ferestrele grafice
Pentru reprezentări grafice în coordonate carteziene se utilizează funcţia plot, care se apelează cu una
dintre sintaxele:
plot(X,Y)- reprezintă grafic datele din Y în funcţie de valorile corespunzătoare din X.
Dacă X şi Y sunt vectori, aceştia trebuie să aibă aceeaşi lungime. În acest caz, se reprezintă grafic Y
în funcţie de X.

95
Dacă X şi Y sunt matrice, acestea trebuie să aibă aceeaşi dimensiune. În acest caz se reprezintă grafic
coloanele lui Y în funcţie de coloanele lui X.
Dacă unul dintre X şi Y este un vector şi celălalt o matrice una din dimensiunile matricei trebuie să
coincidă cu lungimea vectorului. În cazul în care numărul de linii ale matricei este egal cu lungimea
vectorului, se reprezintă grafic fiecare coloană a matricei în funcţie de vector. În cazul în care numărul
de coloane ale matricei este egal cu lungimea vectorului, se reprezintă grafic fiecare linie a matricei
în funcţie de vector. În cazul în care matricea este pătratică, se reprezintă grafic fiecare coloană a sa
în funcţie de vector.
Dacă unul dintre X şi Y este un scalar şi celălalt un scalar sau un vector, se reprezintă grafic puncte
distincte.
plot(X, Y, LineSpec) – specifică suplimentar proprietăţile liniei (LineSpec): tipul, marker-ul şi
culoarea. Proprietăţile liniei sunt prezentate în Tabelul 6.1.
plot(X1, Y1, …, Xn,Yn) – reprezintă simultan mai multe grafice în acelaşi sistem de coordonate
plot(X1, Y1, LineSpec1, …,Xn, Yn, LineSpecn)- specifică suplimentar pentru fiecare linie proprietăţile
acesteia (LineSpec). Se pot combina tripletele X, Y, LineSpec, cu perechile X, Y sub forma plot (X1,
Y1, X2, Y2, LineSpec2, X3, Y3).
plot(Y) – reprezintă grafic datele din Y în funcţie de indicii poziţiilor elementelor respective.
Dacă Y este un vector, valorile de pe axa x sunt cuprinse între 1 şi length(Y).
Dacă Y este o matrice, se reprezintă grafic coloanele lui Y în funcţie de numărul liniei lor. Valorile de
pe axa x sunt cuprinse între 1 şi numărul de linii ale lui Y.
plot(Y,LineSpec) – specifică suplimentar proprietăţile liniei (LineSpec)

Tabelul 6.1. Tipuri de linii, marker-e şi culori

Tipuri de linii Tipuri de marker-e Culori
MATLAB Semnificaţie MATLAB Semnificaţie MATLAB Semnificaţie
- linie continuă o cerc y galben
-- linie + plus m mov
întreruptă
: linie din * asterisc c albastru
puncte deschis
-. linie punct . punct r roşu
x cruce g verde
s pătrat b albastru
d romb w alb
^ triunghi cu k negru
vârful în jos
v triunghi cu
vârful în sus
> triunghi cu
vârful spre
stânga

96
 < triunghi cu
vârful spre
dreapta
p pentagramă
h hexagramă

Exemple
 Să se reprezinte graficul funcției sind(x) pe intervalul 0 - 3600, divizat în 100 de puncte egal
depărtate.
≫ 𝑥 = 𝑙𝑖𝑛𝑠𝑝𝑎𝑐𝑒 (0,360,100);
≫ 𝑦 = 𝑠𝑖𝑛𝑑 (𝑥 );
≫ 𝑓𝑖𝑔𝑢𝑟𝑒
≫ 𝑝𝑙𝑜𝑡(𝑥, 𝑦)

 Să se reprezinte grafic coloanele matricei Y în funcție de coloanele matricei X.

≫ 𝑋 = [1 1 1 ; 3 3 3 ; 5 5 5];
≫ 𝑌 = [10 13 16 ; 4 7 10 ; 8 11 14];
≫ 𝑓𝑖𝑔𝑢𝑟𝑒
≫ 𝑝𝑙𝑜𝑡 (𝑋, 𝑌)

97
 Să se reprezinte în același sistem de coordonate graficele funcțiilor sin(x) și cos(x) pe
intervalul 0 - 3600, divizat în 100 de puncte egal depărtate.
≫ 𝑥 = 𝑙𝑖𝑛𝑠𝑝𝑎𝑐𝑒 (0,360,100);
≫ 𝑦1 = 𝑠𝑖𝑛𝑑(𝑥);
≫ 𝑦2 = 𝑐𝑜𝑠𝑑(𝑥 );
≫ 𝑓𝑖𝑔𝑢𝑟𝑒(1)
≫ 𝑝𝑙𝑜𝑡 (𝑥, 𝑦1, 𝑥, 𝑦2)

 Să se reprezinte în același sistem de coordonate graficele funcțiilor sin(x) și sin(x-30) pe

intervalul 0 - 3600, divizat în 100 de puncte egal depărtate. Pentru reprezentarea funcției sin(x) să se
utilizeze linie întreruptă (--), iar pentru cos(x) să se utilizeze linie punct (_.).
≫ 𝑥 = 𝑙𝑖𝑛𝑠𝑝𝑎𝑐𝑒 (0,360,100);
≫ 𝑦1 = 𝑠𝑖𝑛𝑑(𝑥);
≫ 𝑦2 = 𝑠𝑖𝑛𝑑(𝑥 − 30);
98
≫ 𝑓𝑖𝑔𝑢𝑟𝑒(1)
≫ 𝑝𝑙𝑜𝑡 (𝑥, 𝑦1,′− −′ , 𝑥, 𝑦2,′ −. ′)

 Să se reprezinte grafic elementele fiecărei coloane a matricei Y în funcție de numărul liniei pe

care se află.
≫ 𝑌 = [10 13 16 ; 4 7 10 ; 8 11 14];
≫ 𝑓𝑖𝑔𝑢𝑟𝑒
≫ 𝑝𝑙𝑜𝑡 (𝑌)

Pentru reprezentări grafice în coordonate logaritmice sau semilogaritmice se utilizează funcţiile

loglog, semilogx, semilogy.
Funcţia loglog utilizează o scară logaritmică în baza 10 pe axele x şi y.
Funcţia semilogx utilizează o scară logaritmică în baza 10 pe axa x şi o scară liniară pe axa y.
Funcţia semilogy utilizează o scară liniară pe axa x şi o scară logaritmică în baza 10 pe y.
Funcţiile se apelează cu sintaxele:

99
loglog(Y); semilogx(Y); semilogy(Y)
loglog(X,Y); semilogx(X,Y); semilogy(X,Y);
loglog(X1, Y1, LineSpec1,…, Xn, Yn, LineSpecn); semilogx(X1, Y1, LineSpec1,…, Xn, Yn, LineSpecn);
semilogy(X1,Y1,LineSpec1,…,Xn,Yn,LineSpecn).
Modul de operare al acestor funcţii este similar funcţiei plot.
Exemple
 Să se reprezinte graficul funcției exponențiale pe intervalul 10 0 - 103, divizat în 100 de puncte
distribuite logartimic. Să se utilizeze scări logaritmice pe ambele axe.
≫ 𝑥 = 𝑙𝑜𝑔𝑠𝑝𝑎𝑐𝑒(0,3);
≫ 𝑦 = 𝑒𝑥𝑝(𝑥 );
≫ 𝑓𝑖𝑔𝑢𝑟𝑒
≫ 𝑙𝑜𝑔𝑙𝑜𝑔(𝑥, 𝑦)

 Să se reprezinte graficul funcției logartim pe intervalul 10 0 - 105, divizat în 100 de puncte

distribuite logaritmic. Să se utilizeze o scară logaritmică pe x și una liniară pe y.
≫ 𝑥 = 𝑙𝑜𝑔𝑠𝑝𝑎𝑐𝑒(0,5,100)
≫ 𝑦 = 𝑙𝑜𝑔10(𝑥 );
≫ 𝑓𝑖𝑔𝑢𝑟𝑒
≫ 𝑠𝑒𝑚𝑖𝑙𝑜𝑔𝑥(𝑥, 𝑦)

100
Pentru reprezentări grafice cu bare se utilizează funcţia bar, care se apelează cu una dintre sintaxele:
bar(y) – reprezintă cu câte o bară fiecare element al lui y. În cazul în care y este o matrice, în grafic
se grupează barele aferente elementelor fiecărei linii.
bar(x,y) – desenează barele corespunzătoare elementelor lui y în poziţiile specificate de x
bar(y,width); bar(x,y,width) – indică lăţimea (width) relativă a barelor, care controlează distanţa
dintre ele. Lăţimea se introduce sub forma unui scalar.
bar(y,color); bar(x,y,color) – indică culorea barelor, conform tab. ..
Exemple
 Să se reprezinte grafic cu bare elementele vectorului 𝑦 = [25 50 10 50 80].
≫ 𝑦 = [25 50 10 50 80];
≫ 𝑓𝑖𝑔𝑢𝑟𝑒
≫ 𝑏𝑎𝑟 (𝑦)

101
 Să se reprezinte grafic cu bare elementele aceluiași vector y, în pozițiile indicate de vectorul
𝑥 = [30 35 40 45 50]. Fiecare bară se va reprezenta cu o lățime egală cu 35% din cea
prestabilită.
≫ 𝑥 = 30: 5: 50
≫ 𝑦 = [25 50 10 50 80];
≫ 𝑓𝑖𝑔𝑢𝑟𝑒
≫ 𝑏𝑎𝑟 (𝑥, 𝑦, 0.35)

Pentru desenarea liniilor se poate folosi funcţia line, care se apelează cu sintaxa:
line(X, Y) – desenează liniile definite de vectorii X şi Y în sistemul de axe curent. Dacă X şi Y sunt
matrice de aceeaşi dimensiune, se trasează câte o linie pentru fiecare coloană.
Exemplu
 Să se reprezinte grafic triunghiul care are vârfurile de coordonate (4,8), (2,3) și (7,1).
≫ 𝑙𝑖𝑛𝑒 ([4 2 7 4], [8 3 1 8]);

102
Editarea graficelor se poate realiza fie în mod interactiv utilizând meniul ferestrelor grafice ori mouse-
ul, fie folosind funcţii MATLAB.
Pentru a adăuga titlul la graficul curent se utilizează funcţia title, care se apelează cu sintaxa:
title(’str’) – adaugă titlul constând într-un şir de caractere (string) deasupra figurii curente.
Dacă se doreşte includerea valorii numerice a variabilei c în titlu, se foloseşte funcţia num2str.
Exemplu
c = 31;
title([’Temperatura este ’, num2str(c), ’C’].
Pentru a scrie în titlu o variabilă ridicată la o anumită putere se utilizează caracterul ^, iar pentru a
scrie o variabilă urmată de un indice se foloseşte caracterul _.
Exemplu
title(‘a^2 şi b_1)
Mărimile reprezentate pe axele de coordonate ale graficului curent se precizează cu funcţiile xlabel
şi ylabel, care se apelează cu sintaxele:
xlabel(‘str’) – adaugă textul specificat de str pe axa x;
ylabel(‘str’) – adaugă textul specificat de str pe axa y.
Adăugarea unei legende la graficul curent se face cu funcţia legend, care se apelează cu sintaxa:
legend(‘s1’,…’sN’) – utilizează denumirile s1… sN pentru a eticheta fiecare set de date.
Exemplu
legend(‘sin(x)’,’cos(i)’)
Desenarea unui caroiaj pe grafic se face cu funcţia grid, care se apelează cu una dintre sintaxele:
grid on – afişează caroiajul pe grafic

103
grid off – şterge caroiajul de pe grafic.
Exemplu
 Să se reprezinte în același sistem de coordonate graficele funcțiilor sin(x) și cos(x) pe
intervalul 0 - 3600, divizat în 100 de puncte egal depărtate. Pentru reprezentarea funcției sin(x) să se
utilizeze linie întreruptă (--). Să se denumească axele, figura și să se reprezinte caroiajul și legenda.
≫ 𝑥 = 𝑙𝑖𝑛𝑠𝑝𝑎𝑐𝑒 (0,360,100);
≫ 𝑦1 = 𝑠𝑖𝑛𝑑 (𝑥 );
≫ 𝑦2 = 𝑐𝑜𝑠𝑑(𝑥 );
≫ 𝑝𝑙𝑜𝑡 (𝑥, 𝑦1,′− −′ , 𝑥, 𝑦2)
≫ 𝑡𝑖𝑡𝑙𝑒(′𝐺𝑟𝑎𝑓𝑖𝑐𝑒𝑙𝑒 𝑓𝑢𝑛𝑐ț𝑖𝑖𝑙𝑜𝑟 𝑠𝑖𝑛𝑢𝑠 ș𝑖 𝑐𝑜𝑠𝑖𝑛𝑢𝑠 î𝑛𝑡𝑟𝑒 0 ș𝑖 360^0′ )
≫ 𝑥𝑙𝑎𝑏𝑒𝑙 (′𝑥′)
≫ 𝑦𝑙𝑎𝑏𝑒𝑙 (′𝑦′)
≫ 𝑙𝑒𝑔𝑒𝑛𝑑(′𝑦1 = sin(𝑥 )′ ,′ 𝑦2 = cos(𝑥 )′)
≫ 𝑔𝑟𝑖𝑑 𝑜𝑛

Suprapunerea mai multor grafice în sistemul de axe curente se face cu funcţia hold, care se apelează
cu una dintre sintaxele:
hold on – adaugă noile grafice peste cele existente
hold off – noile grafice le înlocuiesc pe cele anterioare.
Exemplu
 Să se reprezinte în același sistem de coordonate graficele funcțiilor x2 și x3 pe intervalul 0 -
10, divizat în 100 de puncte egal depărtate. Pentru reprezentarea funcției x2 să se utilizeze linie
întreruptă (--).

104
≫ 𝑥 = 𝑙𝑖𝑛𝑠𝑝𝑎𝑐𝑒 (0,10,100);
≫ 𝑦 = 𝑥. ^2;
≫ 𝑝𝑙𝑜𝑡 (𝑥, 𝑦)
≫ ℎ𝑜𝑙𝑑 𝑜𝑛
≫ 𝑦1 = 𝑥. ^3;
≫ 𝑝𝑙𝑜𝑡 (𝑥, 𝑦1)
≫ 𝑥𝑙𝑎𝑏𝑒𝑙 (′𝑥′)
>> 𝑦𝑙𝑎𝑏𝑒𝑙 (′𝑦′)
≫ 𝑡𝑖𝑡𝑙𝑒(′𝐺𝑟𝑎𝑓𝑖𝑐𝑒𝑙𝑒 𝑓𝑢𝑛𝑐ț𝑖𝑖𝑙𝑜𝑟 𝑥 2 ș𝑖 𝑥 3 𝑝𝑒 𝑖𝑛𝑡𝑒𝑟𝑣𝑎𝑙𝑢𝑙 [0: 10]′ )
≫ 𝑙𝑒𝑔𝑒𝑛𝑑(′𝑦1 = 𝑥^2′, ′𝑦2 = 𝑥^3′)
≫ 𝑔𝑟𝑖𝑑 𝑜𝑛

Pentru a reprezenta în fereastra curentă mai multe grafice se utilizează funcţia subplot, care se
apelează cu sintaxa:
subplot(m,n,p) – împarte fereastra într-o matrice având dimensiunile m x n (m fiind numărul de linii
şi n numărul de coloane) şi creează sistemul de axe pentru reprezentarea grafică în poziţia p.
Numerotarea poziţiilor în matrice se face de la stânga la dreapta, de sus în jos.
Exemplu
 Să se împartă fereastra grafică într-o matrice având dimensiunea 2x2. Să se reprezinte pe
intervalul 0 - 3600, divizat în 100 de puncte egal depărtate, graficele funcțiilor sin(x) în partea din
stânga sus, sin(2x) în dreapta sus, cos(x) în stânga jos și cos(2x) în dreapta jos.
≫ 𝑥 = 𝑙𝑖𝑛𝑠𝑝𝑎𝑐𝑒 (0,360,100); ≫ 𝑠𝑢𝑏𝑝𝑙𝑜𝑡 (2,2,1)
≫ 𝑦1 = 𝑠𝑖𝑛𝑑 (𝑥 ); ≫ 𝑝𝑙𝑜𝑡 (𝑥, 𝑦1)

105
≫ 𝑡𝑖𝑡𝑙𝑒(′𝐺𝑟𝑎𝑓𝑖𝑐𝑢𝑙 𝑓𝑢𝑛𝑐ț𝑖𝑒𝑖 𝑠𝑖𝑛(𝑥 )′) ≫ 𝑠𝑢𝑏𝑝𝑙𝑜𝑡 (2,2,3)
≫ 𝑥𝑙𝑎𝑏𝑒𝑙 (′𝑥′) ≫ 𝑝𝑙𝑜𝑡 (𝑥, 𝑦3)
≫ 𝑦𝑙𝑎𝑏𝑒𝑙 (′𝑦′) ≫ 𝑡𝑖𝑡𝑙𝑒(′𝐺𝑟𝑎𝑓𝑖𝑐𝑢𝑙 𝑓𝑢𝑛𝑐ț𝑖𝑒𝑖 𝑐𝑜𝑠(𝑥 )′)
≫ 𝑔𝑟𝑖𝑑 𝑜𝑛 ≫ 𝑥𝑙𝑎𝑏𝑒𝑙 (′𝑥′)
≫ 𝑦2 = 𝑠𝑖𝑛𝑑 (2 ∗ 𝑥 ); ≫ 𝑦𝑙𝑎𝑏𝑒𝑙 (′𝑦′)
≫ 𝑠𝑢𝑏𝑝𝑙𝑜𝑡 (2,2,2) ≫ 𝑔𝑟𝑖𝑑 𝑜𝑛
≫ 𝑝𝑙𝑜𝑡 (𝑥, 𝑦2) ≫ 𝑦4 = 𝑐𝑜𝑠𝑑(2 ∗ 𝑥 );
≫ 𝑡𝑖𝑡𝑙𝑒(′𝐺𝑟𝑎𝑓𝑖𝑐𝑢𝑙 𝑓𝑢𝑛𝑐ț𝑖𝑒𝑖 𝑠𝑖𝑛(2𝑥 )′) ≫ 𝑠𝑢𝑏𝑝𝑙𝑜𝑡 (2,2,4)
≫ 𝑥𝑙𝑎𝑏𝑒𝑙 (′𝑥′) ≫ 𝑝𝑙𝑜𝑡 (𝑥, 𝑦4)
≫ 𝑦𝑙𝑎𝑏𝑒𝑙 (′𝑦′) ≫ 𝑡𝑖𝑡𝑙𝑒(′𝐺𝑟𝑎𝑓𝑖𝑐𝑢𝑙 𝑓𝑢𝑛𝑐ț𝑖𝑒𝑖 𝑐𝑜𝑠(2𝑥 )′)
≫ 𝑔𝑟𝑖𝑑 𝑜𝑛 ≫ 𝑥𝑙𝑎𝑏𝑒𝑙 (′𝑥′)
≫ 𝑦3 = 𝑐𝑜𝑠𝑑(𝑥 ); ≫ 𝑦𝑙𝑎𝑏𝑒𝑙 (′𝑦′)
≫ 𝑔𝑟𝑖𝑑 𝑜𝑛

7. Elemente de Programare MATLAB

7.1. Tipuri de fişiere MATLAB
MATLAB-ul operează în modul linie de comandă, caz în care fiecare linie este prelucrată imediat,
sau utilizând programe scrise în fişiere cu extensia .m, numite fişiere M. Aceste fişiere, create folosind
un editor de text (MATLAB Editor, Notepad, Wordpad etc.), conţin instrucţiuni MATLAB, şi sunt
de două tipuri: script sau funcţie.
Fişierele script operează asupra variabilelor din spaţiul de lucru (workspace). Se utilizează de
regulă pentru rezolvarea unor probleme care necesită un număr mare de comenzi. La terminarea
execuţiei unui fişier script, variabilele cu care acesta a operat rămân în memoria calculatorului.
106
Fişierele funcţie acceptă argumente de intrare şi returnează argumente de ieşire. Variabilele
folosite sunt variabile locale ale funcţiei, cu excepţia cazului când sunt declarate globale. La
terminarea execuţiei unei funcţii, doar variabilele de ieşire rămân în memoria calculatorului.
Fişierele funcţie sunt folosite pentru crearea unor noi funcţii MATLAB.
Forma generală a primei linii a unui fişier funcţie este:
function [parametri_ieşire]=nume_funcţie (parametric_intrare)
unde:
function – cuvânt obligatoriu care declară că fişierul este de tip funcţie;
nume_funcţie – numele funcţiei (este identic cu numele fişierului)
parametri_ieşire – lista parametrilor de ieşire care trebuie separaţi prin virgulă şi cuprinşi între
paranteze drepte. Dacă funcţia nu are parametri de ieşire, parantezele drepte şi semnul egal se omit
parametri_intrare – lista parametrilor de intrare care trebuie separaţi prin virgulă şi cuprinşi între
paranteze rotunde. Dacă funcţia nu are parametri de intrare, parantezele rotunde se omit.
Pentru introducerea unui comentariu într-un program se foloseşte semnul procent % la începutul
liniei. Dacă semnul procent % apare într-o linie de program, atunci partea de linie care urmează va fi
ignorată de compilator.
În cazul în care comentariul se introduce imediat după linia de declarare a unui fişier funcţie, atunci
va reprezenta help-ul fişierului funcţie respectiv, adică textul care va fi afişat în linia de comandă în
urma apelării:
help nume_funcţie
7.2. Instrucţiuni de calcul logic
Instrucţiunile if, elseif, else
- execută instrucţiuni dacă expresia logică este adevărată.
Forma generală a instrucţiunilor if, elseif şi else este:
if expresie 1
instrucţiuni 1
elseif expresie 2
instrucţiuni 2
else
instrucţiuni 3
end
Se evaluează expresia 1. Dacă este Adevărată, se execută instrucţiunile 1, sărind peste instrucţiunile
2 şi 3. Dacă este Falsă, se evaluează expresia 2. În situaţia în care aceasta este Adevărată, se execută
instrucţiunile 2, sărind peste instrucţiunile 3 şi 1. Dacă expresia 2 este Falsă, se execută instrucţiunile
3, sărind peste instrucţiunile 1 şi 2.

107
Instrucţiunile elseif şi else sunt opţionale.
Exemplu
 Să se genereze o matrice X având 3 linii şi 6 coloane, ale cărei elemente sunt:
−5, dacă 𝑖 < 𝑗;
𝑋 = { 10, dacă 𝑖 = 𝑗;
5, dacă 𝑖 > 𝑗.
𝑓𝑜𝑟 𝑖 = 1: 3
𝑓𝑜𝑟 𝑗 = 1: 6
𝑖𝑓 𝑖 == 𝑗
𝑋(𝑖, 𝑗) = 10
𝑒𝑙𝑠𝑒𝑖𝑓 𝑖 < 𝑗
𝑋(𝑖, 𝑗) = −5
𝑒𝑙𝑠𝑒
𝑋(𝑖, 𝑗) = 5
𝑒𝑛𝑑
𝑒𝑛𝑑
𝑒𝑛𝑑
𝑋=
10 −5 −5 −5 −5 −5
5 10 −5 −5 −5 −5
5 5 10 −5 −5 −5
Instrucţiunea for
- execută instrucţiuni de un anumit număr de ori.
Forma generală a instrucţiunii for este:
for index = valori
instrucţiuni
end
Se execută instrucţiunile din buclă de un un număr specificat de ori. Valori are una din următoarele
forme:
val_iniţ:val_fin - Se incrementează variabila index de la valoarea iniţială val_iniţ la valoarea finală
val_fin cu pasul 1, şi se repetă execuţia instrucţiunilor până când index este mai mare decât val_fin.
Instrucţiunile se execută o singură dată pentru fiecare valoare a variabilei index;
val_matrice - Se execută instrucţiunile o singură dată pentru fiecare coloană a matricei val_matrice.
În fiecare iteraţie, variabilei index i se atribuie următoarea coloană a matricei val_matrice. De

108
exemplu, în prima iteraţie, index = val_matrice (:,1). În iteraţia i, index=val_matrice(:,i). Bucla se
execută de maximum n ori, unde n reprezintă numărul de coloane din val_matrice.
Exemple
 Să se ridice numărul 3 la puterile 1, 2, 3, 4 și 5.
𝑓𝑜𝑟 𝑛 = 1: 5
𝑥 (𝑛) = 3^𝑛
𝑒𝑛𝑑
Se va afişa:
𝑥=
3
𝑥=
3 9
𝑥=
3 9 27
𝑥=
3 9 27 81
𝑥=
3 9 27 81 243
Dacă se doreşte doar afişarea rezultatului ultimei iteraţii:
𝑓𝑜𝑟 𝑛 = 1: 5
𝑥 (𝑛) = 3^𝑛;
𝑒𝑛𝑑
>> 𝑥
𝑥=
3 9 27 81 243
1 4 7
 Să se ridice la puterea a doua şi să se împartă la 2 fiecare coloană a matricei 𝐴 = [2 5 8].
3 6 9
𝐴 = [1 4 7; 2 5 8; 3 6 9];
𝑓𝑜𝑟 𝑖 = 𝐴
𝐵 = 𝐴. ^2⁄2;
𝑒𝑛𝑑

109
≫𝐵
𝐵=
0.50 8.00 24.50
2.00 12.50 32.00
4.50 18.00 40.50
Instrucţiunea while
- repetă execuţia instrucţiunilor atât timp cât o condiţie specificată este adevărată.
Forma generală a instrucţiunii while este:
while expresie
instrucţiuni
end
Se evaluează expresia logică. Dacă acesta este Adevărată (are toate elementele nenule), se execută
instrucţiunile. După aceea, se reevaluează expresia logică. Dacă aceasta este Adevărată, se execută
instrucţiunile. Când expresia este Falsă, se trece la instrucţiunile care urmează după end. În situaţia
în care expresia este întotdeauna Adevărată, bucla devine infinită. Ieşirea forţată dintr-o buclă infinită
se face prin apăsarea concomitentă a tastelor Ctrl şi C.
Exemplu
 Să se ridice la puterea a treia numerele 1, 2 și 3.
𝑥=1 𝑥=
𝑤ℎ𝑖𝑙𝑒 𝑥 < 4 2
𝑦 = 𝑥^3 𝑦=
𝑥 = 𝑥+1 8
𝑒𝑛𝑑 𝑥=
3
𝑥= 𝑦=
1 27
𝑦= 𝑥=
1 4
Instrucţiunea break
- termină execuţia pentru o buclă for sau while.
În cazul ciclurilor imbricate, instrucţiunea break dispune ieşirea din ciclul cel mai interior. În
continuare se execută instrucţiunile care urmează după acel ciclu.
Exemplu
 De studiat diferența față de varianta fără break.
110
𝑓𝑜𝑟 𝑖 = 1: 10 𝑓𝑜𝑟 𝑖 = 1: 10
𝑎 (𝑖 ) = 𝑖 ∗ 5 − 1 𝑎(𝑖 ) = 𝑖 ∗ 5 − 1;
𝑏𝑟𝑒𝑎𝑘 𝑒𝑛𝑑
𝑒𝑛𝑑 ≫𝑎
𝑎=
𝑎= 4 9 14 19 24 29 34 39 44 49
4
Instrucţiunea continue
- este folosită pentru reluarea ciclurilor for şi while cu următoarea iteraţie, înainte de terminarea
iteraţiei curente. În cazul ciclurilor imbricate, efectul instrucţiunii continue se produce doar pentru
corpul ciclului unde se foloseşte.
Exemplu
 De studiat diferenţa faţă de varianta fără continue. Să se afișeze numerele mai mici decât 3
cuprinse între 1și 8. Dacă un număr este mai mare decât 3 intrucțiunea continue reia ciclul cu
următoarea iterație, sărind peste comanda disp de afișare a numărului respectiv.
𝑓𝑜𝑟 𝑖 = 1: 8
𝑖𝑓 𝑖 > 3
𝑐𝑜𝑛𝑡𝑖𝑛𝑢𝑒
𝑒𝑛𝑑
𝑑𝑖𝑠𝑝(𝑖 )
𝑒𝑛𝑑
care afişează întregii de la 1 la 3:
1
2
3
Instrucţiunea end
- termină un grup de instrucţiuni.
Forma generală a instrucţiunii este:
end
Instrucţiunea end încheie ciclurile for, while şi if. Fiecare end încheie cel mai apropiat ciclu anterior
for, while sau if.
Exemplu
𝑓𝑜𝑟 𝑗 = 1: 𝑛
111
 𝑖𝑓 𝑎(𝑗) == 0
𝑎(𝑗) = 𝑎(𝑗) + 7;
𝑒𝑛𝑑
𝑒𝑛𝑑
Instrucţiunea pause
- întrerupe temporar execuţia programului.
Formele generale ale instrucţiunii pause sunt:
pause - opreşte execuţia programului până la apăsarea oricărei taste;
pause(n) - opreşte întreruperea programului pentru n secunde;
pause on - permite execuţia instrucţiunilor pause şi pause(n);
pause off - nu permite execuţia instrucţiunilor pause şi pause(n).
7.3. Vectorizarea calculelor
Pentru mărirea vitezei de lucru, când este posibil, ciclurile for şi while trebuie înlocuite cu operaţii cu
vectori sau matrice.
Exemplu
 Programul care ridică numărul 3 la puterile primelor cinci numere naturale utilizând ciclul
for:
𝑓𝑜𝑟 𝑛 = 1: 5
𝑥 (𝑛) = 3^𝑛
𝑒𝑛𝑑
se poate scrie sub formă matriceală:
𝑛 = 1: 5
𝑋 = 3. ^𝑛
Atunci când ciclurile for şi while nu pot fi substituite cu operaţii cu vectori şi matrice, se prealocă
vectori sau matrice în care vor fi memorate rezultatele.
Exemplu
 Să se prealoce memorie pentru vectorul rezultat în urma aplicării ciclului for prin crearea unui
vector inițial având dimensiunea celui rezultat și elemente egale cu zero.
𝑦 = 𝑧𝑒𝑟𝑜𝑠(1,100)
𝑓𝑜𝑟 𝑖 = 1: 100
𝑦(𝑖 ) = 𝑖^2 + 1;
𝑒𝑛𝑑

112
A treia lege a lui GREER

Un program pentru calculator face ceea ce îi spui tu să facă, iar nu ceea ce vrei tu să facă.

113