Metoda Elementelor Finite. Indrumator [PDF]

Zitiervorschau

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: [email protected] 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 Oferă sprijin și-ajutor Studenților Masteranzi Ai Facultății de Construcții, În lupta lor fără egal De-a modela cât mai real Comportamentul structural. Elementele Finite Domină nestingherite Analiza structurală. Inginerii proiectanți Folosesc noapte și zi, Programe pe calculator Bazate pe Metoda lor. Lucrez corect? Lucrez cu spor? Se-ntreabă orice începător În Sap, Consteel, Axis, Robot... Îndrumătorul face tot!

...posibilul să îndeplinească Aceste clare obiective: 1. Noțiuni introductive În teoria liniară (care-i plăcută și ușoară); 2. Studenții vor crea Într-un limbaj de programare, Aplicații ce rezolvă O bară comprimată, O grindă cu zăbrele, Un cadru plan, o șaibă... Vedeți, simple probleme, Dar care programate Pun bine în relief Cum funcționează un software Complex bazat pe MEF.

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 pl pl 2 2 1 3 2 R 1 u1 3 u3 4 u4 2 u2 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 2 e x j uj i ui 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

(I.2)

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 U e  u i  1 0   A    A1U e (I.5) 1 l  j Din Ec. (I.1) și (I.4), deplasarea curentă poate fi scrisă în funcție de deplasările nodale: u ( x)  ui 

u j  ui l

(I.6)

x

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  (I.7)  U e   i  j U e   l l  l l  Se introduce matricea de interpolare a deplasărilor (denumită și matricea funcțiilor de formă) 1

   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: x 

du dx

(I.9)

și poate fi determinat în funcție de deplasările nodale utilizând Ec. (I.7): u j  ui  d i d j   1 1  U e   Ue  dx  l  l l  dx

  x  

 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

(I.10)

  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): u j  ui  l   1 1 (I.13) Ue  E  E  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:

   x  E 

  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:





V



 We   U eT    T CBdV  U e   U eT keU e

(I.18)

ș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   Ae  dx  1 l  1 1 V l    l l l  l T

T

3

(I.21)

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 V

S

(I.22)

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 l 

(I.24)

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   Le  p  1   dx  l  l 

x



 l dx  U

 pl pl  T    U e  Pe  U e 2 2

e

l

(I.25)

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)

ke = ReT ke Re

(I.33)

matricea de rigiditate a EF

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 T 1 1 1 1 1 1 2

T

(I.37)

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    

   ken 

(I.38)

Pentru cazul studiat expresia de mai sus devine (vezi Ec.(I.21)):  1  1 EAe  0 ktot  l 0 0  0

1 1 0 0 0 0

0 0 0 (I.39) 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: 0 0 1 1 0 0

0 0 1 1 0 0

Ptot  ktotUtot

5

0 0 0 0 1 1

(I.40)

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): P  P1 P2 P3 P4   T

pl T 1 2 2 1 2

(I.44)

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 u2  0 u   LU   2   0 u 0 u3  0 u3  0  4 

0 0   u1  0  u2  U tot (I.46) 0  u3    0  u4  1  Se poate observa cum matricea L satisface transformarea vectorului încărcărilor echivalente din Ec. (I.45): 0 1 1 0 0 0

0 0 0 1 1 0

1 0  1 0  1 pl (I.47) 0  1 2   1  1 1  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: 1   1 pl 2  0 T P = L Ptot     2 2  0 1  0

0 1 0 0

0 1 0 0

0 0 1 0

0 0 1 0

Ptot  ktotUtot  P  LT Ptot  LT ktotUtot  LT ktot LU Se introduce matricea de rigiditate a structurii (în coordonate globale):

6

(I.48)

K  LT ktot L

(I.49)

P  KU

(I.50)

iar ecuația de echilibru devine: 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:  u1   pl  1   EAe  1 1 0   2   1 2  1 u   (I.54)    2 2  l   2 0  1 2 u        3 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  EAe R 0 0 1 1 uu2   P (4) l  03   

unde P(4) = pl/2. 7

(I.57)

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

8

(I.59)

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

u  U e

  A1Ue

  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

V

Pe   X dV   t F dS

T e

t

S

V

S

We   Le  Pe  keU e U e  ReT U e Utot  U e1 U e2

Pe = ReT Pe U en 

ke = ReT ke Re Ptot   Pe1 Pe2

T

 ke1  ke2 ktot     U  u1 u2

P   P1 P2

T

Ptot  ktotUtot

P  KU

T

   ken 

um 

P = LT Ptot

Pen 

Pm 

T

Utot  LU

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; %număr GL nrGL=nrnod; %lungime EF l=lungime_bara/nrEF; %se construiește matricea Elementelor Finite %inițializare M_EF=zeros(nrEF,nrGL_EF+1); %prima coloană conține denumirea EF M_EF(:,1)=1:nrEF; %a doua coloană conține primul nod al EF M_EF(:,2)=1:nrEF; %a treia coloană conține al doilea nod al EF M_EF(:,3)=2:nrEF+1; %se construiește matricea Gradelor de Libertate (pentru această aplicație, este identică cu matricea M_EF) M_GL=M_EF; %matricea de rigiditate a EF

nrnod=4 nrGL=4 l=333.33 (credeți-mă ce spun eu până aici a fost mai greu)

M_EF = 0 0 0

0 0 0

0 0 0 (trageți cu ochiul și la Fig.I.2, așa... șmecherește)

M_EF = 1 2 3

1 2 3

2 3 4

(atenție mai jos la semne! Nu de circulație...)

ke =

ke=E*Ae/l*[1 -1;-1 1;];

300 -300 -300 300

%se construiește matricea de 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 0 0

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

12

0 1 1 0 0 0

0 0 0 1 1 0

0 0 0 0 0 1

%matricea k_tot conține pe diagonală nrEF matrice de rigiditate ke ktot=ke; for i=1:nrEF-1 ktot=blkdiag(ktot,ke) end

ktot = 300 -300 0 0 0 0 -300 300 0 0 0 0 0 0 300 -300 0 0 0 0 -300 300 0 0 0 0 0 0 300 -300 0 0 0 0 -300 300

%matricea de rigiditate a structurii (o splendoare a naturii)

K=L'*ktot*L;

K=

%introducerea încărcărilor echivalente în noduri

300 -300 0 0 -300 600 -300 0 0 -300 600 -300 0 0 -300 300

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

%vectorul încărcărilor pe EF

Pe =

Pe=[p*l/2;p*l/2;];

166.67 166.67 Ptot =

%vectorul încărcărilor pe toate EF Ptot=zeros(nrGL_EF*nrEF,1);

166.67 166.67 166.67 166.67 166.67 166.67

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

%vectorul încărcărilor asamblat

P=

P=L'*Ptot;

166.67 333.33 333.33 166.67

%vectorul GL GLtot=zeros(1,nrGL); %se blochează nodul rezemat GLtot(nrGL)=1; %1 = blocat %0 = liber %se caută GL blocate GLbl=find(GLtot);

(4 forțe pentru 4 noduri, armonie!)

13

GLtot =

0

GLbl =

4

0

0

1

%se caută GL libere (Grade de Libertate libere...știu)

GLlib=find(GLtot==0);

GLlib =

%se construiește matricea de rigiditate redusă Kredus=K; %se elimină liniile GL blocate Kredus(GLbl,:)=[]; %se elimină coloanele GL blocate Kredus(:,GLbl)=[];

1

2

3

Kredus = 300 -300 0 -300 600 -300 0 -300 600

%se construiește vectorul redus al încărcărilor echivalente Predus=P; %se elimină elementele GL blocate Predus(GLbl,:)=[];

Predus = 166.67 333.33 333.33

%se determină deplasările GL libere (necunoscutele misterioase ale problemei)

Uliber =

Uliber=Kredus\Predus;

5.00 4.44 2.78

% vectorul deplasărilor totale U=zeros(nrGL,1); % deplasările GL blocate sunt 0 U(GLbl)=0; %deplasările GL libere au fost deja calculate U(GLlib)=Uliber;

(am aflat deplasările, URAAA!)

U= 5.00 4.44 2.78 0

%matricea de rigiditate corespunzătoare GL blocate KR=K(GLbl,:);

KR =

%calcul reacțiuni. Atenție, la reacțiunea rezultată din deplasările nodale, se scade încărcarea echivalentă din nodul blocat.

0

0 -300 300

(încercați să aflați reacțiunea și printr-un elaborat 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 2.78 2.78 0

%altă matrice în care fiecare coloană conține deplasările unui EF U0tot=reshape(Utot,[],nrEF); %matricea de rigiditate a materialului (pentru elemente 1D are un singur element) C=E; %matricea deformațiilor B=[-1/l 1/l];

U0tot = 5.00 4.44

B= %calcul tensiuni pe fiecare EF sigma_ctEF=C*B*U0tot;

4.44 2.78

-0.03

2.78 0

0.03

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) sigma_ctEF(1))/l;

panta_sigma =

sigma(1)=sigma_ctEF(1)panta_sigma*l/2; sigma(nrnod)=sigma_ctEF(nrEF) + panta_sigma*l/2;

-0.0100

sigma = 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

a)

b) x p(x)=p L

P

P 2L/3

L/2

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 p1

8

2 1

y

4 3

6

5

2

10

6

1

3

p2

9 11

7 Δ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

yi O

α

l

ui

xi

xj

x

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    x2  x1 

  arctan 

(II.1)

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 j  u j  ui  l   d i 1   1 0 0  U e   0 0 U e  (II.3)   dx l  l  l   l  dx  Se observă cum deplasările nodale vi și vj nu contribuie la deformațiile specifice. Matricea 1   1 0 , matricea de rigiditate a materialului C conține tot un deformațiilor devine B   0 l   l

  x  

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 EAe  0 ke    CBdV  l  1 V  0 T

1 0 1 0

0 0 0 0

0 0 0 0 

(II.4)

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

j uj

y

e α

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  u j  u j cos   v j sin 

(II.5)

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 e e e 0 cos  sin   u j  v   0   0  sin  cos    v j   j 

(II.6)

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

a

5 6

7

6 A2

8

1

R2

7 9

10 3

2

1 R1

A1

2

11

3

4 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=???; %număr noduri nrnod=size(noduri,1); %număr EF nrEF=size(M_EF,1); %număr noduri încărcate nrnod_inc=???; %număr GL nrGL=???;

nrGL_EF = nrnod=

7

nrEF=

11

nrnod_inc= nrGL=

%se adaugă lungimea și înclinarea fiecărei bare la matricea "EF" for i=1:nrEF 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);

4

2

14

M_EF = 1 2 3 4 5 6 7 8 9 10 11

M_EF(i,5)=sqrt((x2-x1)^2+(y2-y1)^2); M_EF(i,6)= atand((y2-y1)/(x2-x1)); end %se construiește matricea Gradelor de Libertate M_GL=zeros(nrEF, 1+nrnodEF*nrGL_nod); %prima coloană conține denumirea EF M_GL(:,1)=1:nrEF; %următoarele 4 coloane conțin GL pentru fiecare EF %Obs: numărul GL pe verticală este (numărul nodului)*2, %numărul GL pe orizontală este (numărul nodului)*2-1 for i=1:nrEF for j=1:nrnodEF M_GL(i,2*j)=M_EF(i,j+1)*2-1; M_GL(i,2*j+1)=M_EF(i,j+1)*2; end end

1 2 3 5 6 1 5 2 6 3 7

2 3 4 6 7 5 2 6 3 7 4

200 200 200 200 200 100 100 100 100 100 100

2000 2000 2000 2000 2000 1414.21 1414.21 1414.21 1414.21 1414.21 1414.21

2 4 6 10 12 2 10 4 12 6 14

3 5 7 11 13 9 3 11 5 13 7

M_GL = 1 2 3 4 5 6 7 8 9 10 11

22

1 3 5 9 11 1 9 3 11 5 13

4 6 8 12 14 10 4 12 6 14 8

0 0 0 0 0 45 -45 45 -45 45 -45

%se construiește matricea de localizare L

L=

(GPS-ul MEF-ului)

1 0 0 0 0 ...

??? %matricea ktot conține pe diagonală nrEF matrice de rigiditate pe EF în coordonate globale kg_e ktot=[]; for i=1:nrEF A=M_EF(i,4); %arie bară l=M_EF(i,5); %lungime alfa=M_EF(i,6); %înclinare %matricea de rigiditate a EF în coordonate locale ke=E*A/l*[1 0 -1 0;0 0 0 0;-1 0 1 0;0 0 0 0]; %se construiește matricea de rotație Re Re0=[cosd(alfa) sind(alfa); sind(alfa) cosd(alfa);]; Re=blkdiag(Re0, Re0); %matricea de rigiditate în coordonate globale kg_e kg_e =Re'*ke*Re; ktot=blkdiag(ktot,kg_e); end

0 1 0 0 0 ...

0 0 1 0 1 ...

0 0 0 1 0 ...

... ... ... ... ... ...

(...mai sunt multe-multe elemente)

(diferă de la o bară la alta) ke= E*A/l* 1 0 -1 0 0 0 0 0 -1 0 1 0 0 0 0 0 ktot = 21000 0 0 0 -21000 0 0 0 0 0 ... ...

-21000 0 0 0 21000 0 0 0 0 0 ... ...

0 0 0 0 21000 ...

... ... ... ... ... ...

(...chiar multe)

K= 1.0e+04 * 2.84 0.74 0.74 0.74 -2.10 0 ... ...

%matricea de rigiditate a structurii (o minune a naturii)

K=???;

%se construiește vectorul încărcărilor P=zeros(nrGL,1); for i=1:nrnod_inc P(Pinc(i,1)*2)=Pinc(i,3); P(Pinc(i,1)*2-1)=Pinc(i,2); end

-2.10 0 5.68 ...

0 0 0 ...

0 ... 0 ... -2.10 ... ... ...

PT = 1.0e+05 * 0 0 0 0 0 0 0 0 0 -1 0 -1 0 -1

23

%se construiește vectorul GL pe baza vectorului nodrez. Obs: analog cu formarea M_GL GL=zeros(1,nrGL); for i=1: length (nodrez) GL(2*nodrez(i)-1)=nodrez(i,2); GL(2*nodrez(i))=nodrez(i,3); end %se caută GL blocate GLbl=???; %se caută GL libere GLlib=???;

GL = 1 1 0 0 0 0 0 1 0 0 0 0 0 0 GLbl = 1

2

8

GLlib = 3 4 5 6 7 9 10 11 12 13 14

%se construiește matricea de rigiditate redusă Kredus=K; %se elimină liniile GL blocate ???; %se elimină coloanele GL blocate ???;

Kredus = 1.0e+04 * 5.68 0 0 1.49 -2.10 0 0 0 ... ...

%se construiește vectorul redus al încărcărilor Predus=P; %se elimină elementele GL blocate ???;

-2.10 0 5.68 0 ...

0 0 0 1.48 ...

... ... ... ... ...

PredusT = 1.0e+05 * 0 0 0 0 0 0 -1 0 -1 0 -1

%se determină deplasările GL libere Uliber=???;

Uliber = 7.14 -65.03 19.05 -65.03 26.19 22.62 ...

%vectorul deplasărilor totale U=zeros(nrGL,1); %se introduc deplasările GL libere deja calculate ???;

(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 echivalente în nodurile rezemate R=???;

1.0e+05 * 0.00 1.50 1.50 (ce bine a dat! Bravo MEF!)

%vectorul deplasărilor pentru toate EF Utot=L*U; %altă matrice în care fiecare coloană conține deplasările unui EF U0tot=reshape(Utot,[],nrEF);

U0tot = 0 7.14 19.05 0 -65.03 -65.03 7.14 19.05 26.19 -65.03 -65.03 0

%matricea de rigiditate a materialului (pentru elemente 1D are un singur element) C=E; %se calculează produsul matricelor C, B si Re pentru fiecare EF CBRe=zeros(nrEF,nrGL_EF); for i=1:nrEF l=M_EF(i,5); %lungimea barei alfa=M_EF(i,6); %înclinarea %se construiește din nou matricea de rotație Re Re0=???; Re=???; %matricea deformațiilor B=[-1/l 0 1/l 0]; %produsul matricelor C, B si Re CBRe(i,:)=C*B*Re; end %calcul tensiuni pentru fiecare bară sigma=diag(CBRe*U0tot);

22.62 13.10 ... -42.82 -77.72 ... 13.10 3.57 ... -77.72 -42.82 ...

CBRe = -105.00 -105.00 -105.00 ... sigma = 750.00 1250.00 750.00 ... N= 1.0e+05 * 1.50 2.50 1.50 ...

%calcul forțe axiale (sigma x aria) N=sigma.*M_EF(:,4);

25

0 0 0 ...

105.00 105.00 105.00 ...

0 ... 0 ... 0 ... ...

%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)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> 𝐴 = [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

8 1 8 1

1 8 1 8

8 1 8 1

1 8 1 8

8 1 8 1

1 8 1 8

8 1 8 1

Pentru a şterge linii şi coloane dintr-o matrice se poate folosi o pereche de paranteze pătrate. Exemplu 3 Se cere să se şteargă linia a doua a matricei 𝑋 = [11 24 a matricei X. 

≫ 𝑋 = [3 5 7;

11

15 19;

24

29 33];

≫ 𝐴 = 𝑋; ≫ 𝐴(2, : ) = [] 𝐴= 3 24

5 7 29 33 75

5 7 15 19]. Să se şteargă ultima coloană 29 33

≫ 𝑋(: ,3) = [] 𝑋= 3 11 24

5 15 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 3 1 2 3 1 2 3

𝑐𝑜𝑙 = 1 1 2 2 2 3 3 3

𝑣= 2 1 9 7 3 10 8 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 Pentru matricele 𝐴 = [ 3



1 −1 −2 ], 𝐵 = [ ] şi scalarul 𝑠 = 4, să se calculeze: 2 4 0

𝐶 = 𝐴 + 𝐵, 𝐶1 = 𝐴 + 𝑠, 𝐷 = 𝐴 − 𝐵, 𝐷1 = 𝐴 − 𝑠, 𝐸 = 𝐴 ∗ 𝐵, 𝐸1 = 𝐴 ∗ 𝑠, 𝐸2 = 𝐴.∗ 𝐵, 𝐹 = 𝐴/𝐵, 𝐹1 = 𝐴/𝑠, 𝐹2 = 𝐴./𝐵, 𝐺 = 𝐴\𝐵, 𝐺1 = 𝐴.\𝐵, 𝐻 = 𝐴^𝑠, 𝐻1 = 𝐴. ^𝐵, 𝐼 = 𝐴′. ≫ 𝐴 = [0 1;

3 2];

≫ 𝐵 = [−1 −2;

≫ 𝐸2 = 𝐴.∗ 𝐵

4 0];

𝐸2 = 0 12

≫ 𝑠 = 4; ≫𝐶 = 𝐴+𝐵

≫ 𝐹 = 𝐴/𝐵

𝐶=

𝐹=

−1 −1 7 2

−0.5000 −1.0000

≫ 𝐶1 = 𝐴 + 𝑠

−0.1250 0.5000

≫ 𝐹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.0000

≫ 𝐸 =𝐴∗𝐵

1.3333 −2.0000

≫ 𝐺1 = 𝐴.\𝐵

𝐸=

𝐺1 =

4 0 5 −6

0 −0.5000 0.7500 𝐼𝑛𝑓

≫ 𝐸1 = 𝐴 ∗ 𝑠

≫ 𝐻 = 𝐴^s

𝐸1 = 0 12

−2 0

𝐻=

4 8

21 60 79

20 61

≫ 𝐻1 = 𝐴. ^𝐵

≫ 𝐼 = 𝐴′

𝐻1 =

𝐼= 0 3 1 2

𝐼𝑛𝑓 1 81 1 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


=

Primii doi operatori compară atât partea reală cât şi imaginară a operanzilor, iar ceilalţi doi doar partea reală. Exemple 

32 Pentru matricele 𝐴 = [ 17

9 3 74 ], 𝐵 = [ ] şi scalarul 𝑠 = 9, să se calculeze: 24 52 89

𝐶 = 𝐴 == 𝐵, 𝐶1 = 𝐴 == 𝑠, 𝐷 = 𝐴~ = 𝐵, 𝐷1 = 𝐴~ = 𝑠, 𝐸 = 𝐴 ≥ 𝐵, 𝐸1 = 𝐴 >= 𝑠. ≫ 𝐴 = [32 9; 17 24];

≫ 𝐶 = 𝐴 == 𝐵

≫ 𝐵 = [3 74; 52 89];

𝐶=

𝑠 = 9; 80

0 0 0 0

𝐷1 = 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 Pentru matricele 𝐴 = [ 17



9 3 9 ], 𝐵 = [ ] şi scalarul 𝑠 = 9, să se calculeze: 24 52 89

𝐶 = ~𝐴, 𝐶1 = ~𝐵, 𝐶2 = ~𝑠, 𝐷 = 𝐴&𝐵, 𝐷1 = 𝐴&𝑠, 𝐸 = 𝐴|B, 𝐸1 = 𝐴|s, 𝐹 = 𝑥𝑜𝑟(𝐴, 𝐵), 𝐹1 = 𝑥𝑜𝑟(𝐴, 𝑠) ≫ 𝐴 = [32 9; 17 24];

𝐷1 = 1 1 1 1

≫ 𝐵 = [3 74; 52 89]; ≫ 𝑠 = 9;

≫ 𝐸 = 𝐴|B

𝐶 = ~𝐴

𝐸=

𝐶=

1 1 1 1

0 0 0 0

≫ 𝐸1 = 𝐴|s

≫ 𝐶1 = ~𝐵

𝐸1 =

𝐶1 =

1 1 1 1

0 0 0 0

≫ 𝐹 = 𝑥𝑜𝑟(𝐴, 𝐵)

≫ 𝐶2 = ~𝑠

𝐹=

𝐶2 =

0 0 0 0

0 ≫ 𝐷 = 𝐴&𝐵

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

𝐷=

𝐹1 = 0 0 0 0

1 1 1 1 ≫ 𝐷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

1.5625

4.0000

≫ 𝐷 = (𝐴./𝐵). ^2 𝐷= 0.1322 0.0865

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.0778 −0.0263

−0.00186 −0.0013 0.0157

0.1164 −0.0343 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. ≫𝐴= [15 10

≫ 𝑀2 = 𝑚𝑎𝑥 (𝐴, [],2 ) 80;

2 135

32;

18

76 29];

𝑀2 =

≫ 𝑀 = 𝑚𝑎𝑥 (𝐴)

80 135 76

𝑀= 18

135 80

≫ 𝑀3 = 𝑚𝑖𝑛(𝐴, [],2)

≫ 𝑀1 = 𝑚𝑖𝑛(𝐴)

𝑀3 =

𝑀1 = 2 10

10 2 18

29 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 5 18

10 80 135 32 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

≫ 𝐴 = [7 0 −4 5

2]; 88

0 −4 5 2].

≫ 𝐵 = 𝑠𝑜𝑟𝑡(𝐴) 𝐵= −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 15 18

10 29 76 32 135 80

≫ 𝐵1 = 𝑠𝑜𝑟𝑡(𝐴, ′𝑑𝑒𝑠𝑐𝑒𝑛𝑑′) 𝐵1 = 18 15 2

135 80 76 32 10 29

≫ 𝐵2 = 𝑠𝑜𝑟𝑡(𝐴, 2) 𝐵2 = 2 15 18

10 29 32 76 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𝑗 ⋯ ⋯ ⋯ 𝑎𝑖𝑗 ⋯ ⋯ ⋯ 𝑎𝑛𝑗

⋯ ⋯ ⋯ ⋯ ⋯

𝑎1𝑛 ⋯ 𝑎𝑖𝑛 - matricea coeficienţilor necunoscutelor; ⋯ 𝑎𝑛𝑛 ] 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; ≫ 𝐵 = [9;

1 −6];

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 ], exprimate în grade. Să se calculeze sinusul, cosinusul, tangenta şi matricei 𝑋1 = [ 15 80 𝑝𝑖/6 𝑝𝑖/4 ], exprimate în radiani. cotangenta pentru fiecare din elementele matricei 𝑋2 = [ 𝑝𝑖/2.4 𝑝𝑖/3 ≫ 𝑋1 = [30 ≫ 𝑋2 = [𝑝𝑖 ⁄6

45;

0.8660 0.7071 0.2588 0.5000

15 80];

𝑝𝑖 ⁄4;

𝑝𝑖 ⁄2.4 𝑝𝑖 ⁄3];

≫ 𝐶1 = 𝑡𝑎𝑛𝑑 (𝑋1)

≫ 𝐴1 = 𝑠𝑖𝑛𝑑 (𝑋1)

𝐶1 =

𝐴1 =

0.5774 1.0000 0.2679 5.6713

0.5000 0.7071 0.2588 0.9848

≫ 𝐶2 = 𝑡𝑎𝑛(𝑋2)

≫ 𝐴2 = 𝑠𝑖𝑛(𝑋2)

𝐶2 =

𝐴2 =

0.5774 1.0000 3.7321 1.7321

0.5000 0.7071 0.9659 0.8660

≫ 𝐷1 = 𝑐𝑜𝑡𝑑(𝑋)

≫ 𝐵1 = 𝑐𝑜𝑠𝑑(𝑋)

𝐷1 =

𝐵1 =

1.7321 1.0000 3.7321 0.1763

0.8660 0.7071 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 30.0000

≫ 𝑋 = [0.5 𝑠𝑞𝑟𝑡(3)/2; 0.5 1]; ≫ 𝐴 = 𝑎𝑠𝑖𝑛𝑑 (𝑋)

60.0000 90.0000

≫ 𝐴1 = 𝑎𝑠𝑖𝑛(𝑋)

𝐴=

𝐴1 = 94

0 1.0472 0.5236 1.5708

≫ 𝐶1 = 𝑎𝑡𝑎𝑛(𝑋) 𝐶1 =

≫ 𝐵 = 𝑎𝑐𝑜𝑠𝑑 (𝑋)

0 0.7137 0.4636 0.7854

𝐵= 90 60

30 0

≫ 𝐷 = 𝑎𝑐𝑜𝑡𝑑(𝑋) 𝐷=

≫ 𝐵1 = 𝑎𝑐𝑜𝑠(𝑋)

90 63.4349

𝐵= 1.5708 0.5236 1.0472 0

≫ 𝐷1 = 𝑎𝑐𝑜𝑡(𝑋) 𝐷1 =

≫ 𝐶 = 𝑎𝑡𝑎𝑛𝑑 (𝑋)

1.5708 0.8571 1.1071 0.7854

𝐶= 0 26.5651

49.1066 45.0000

40.8934 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 MATLAB -: -.

Tipuri de marker-e MATLAB Semnificaţie o cerc + plus

Semnificaţie linie continuă linie întreruptă linie din * puncte linie punct . x s d ^ v

>

Culori MATLAB y m

asterisc

c

punct cruce pătrat romb triunghi cu vârful în jos triunghi cu vârful în sus triunghi cu vârful spre stânga

r g b w k

96

Semnificaţie galben mov albastru deschis roşu verde albastru alb negru


> 𝑦𝑙𝑎𝑏𝑒𝑙 (′𝑦′) ≫ 𝑡𝑖𝑡𝑙𝑒(′𝐺𝑟𝑎𝑓𝑖𝑐𝑒𝑙𝑒 𝑓𝑢𝑛𝑐ț𝑖𝑖𝑙𝑜𝑟 𝑥 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 −5 10 −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

9

27

81

9

27

81

𝑥= 3 𝑥= 3

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  for:

Programul care ridică numărul 3 la puterile primelor cinci numere naturale utilizând ciclul

𝑓𝑜𝑟 𝑛 = 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