MATLAB Mitu Paleu Final

Nicolae Mitu Viorel Paleu
Introducere în MATLAB
Vol. I
Indrumar de laborator
IAŞI 2008
Autori : Nicolae Mitu şi Viorel Paleu 2
CUPRINS
CUPRINS................................................................................................. 2
LUCRAREA 1 ......................................................................................... 9
1.1. Obiectivele lucrării................................................................... 9
1.2. Ferestrele MATLAB. ............................................................... 9
1.3. Expresii şi calcule .................................................................. 11
1.4. Aplicaţii.................................................................................. 14
1.5. Indicaţii şi soluţii......................................................................... 16
LUCRAREA 2 ....................................................................................... 20
2.1. Obiectivele lucrării...................................................................... 20
2.2. Matrici şi vectori ........................................................................ 20
2.2.1. Matrici şi vectori. Definiţii................................................... 20
2.2.2. Definirea matricilor în MATLAB........................................ 21
2.2.3. Accesarea elementelor unei matrici. Operatorul.................. 22
2.2.4. Operaţii cu matrici şi vectori................................................ 23
2.2.5. Funcţii de matrici. ................................................................ 24
2.3. APLICAŢII ................................................................................. 24
LUCRAREA 3 ....................................................................................... 32
3.1. Obiectivele lucrării..................................................................... 32
3.2 . Elemente de algebră liniară în MATLAB .................................. 32
3.2.1.Ecuaţii matriciale. ................................................................. 32
3.2.2. Sisteme liniare...................................................................... 33
3.2.3. Vectori şi valori proprii........................................................ 34
3.3 APLICAŢII .................................................................................. 37
LUCRAREA 4 ....................................................................................... 44
4.2. Elemente de grafică în MATLAB............................................... 44
4.2.1. Grafice 2D............................................................................ 44
4.2.2. Grafice 3D............................................................................ 49
4.3. Aplicaţii....................................................................................... 52
LUCRAREA 5 ....................................................................................... 63
Introducere în MATLAB- Indrummar de laborator 3

5.2. Polinoame. Funcţii. Ecuaţii ......................................................... 63
5.2.1.Polinoame în MATLAB........................................................ 63
5.2.2.Funcţii utilizator .................................................................... 67
5.3. APLICAŢII ................................................................................. 70
LUCRAREA 6 ....................................................................................... 76
6.2. Calcule simbolice cu expresii şi polinoame ................................ 76
6.3. APLICAŢII ................................................................................. 80
6.4. Indicaţii. ...................................................................................... 82
6.5. Soluţii. ......................................................................................... 84
LUCRAREA 7 ....................................................................................... 86
7.2. Calcule simbolice în algebra liniară............................................ 86
7.3. APLICAŢII ................................................................................. 91
7.4. Indicaţii ....................................................................................... 93
7.5. Soluţii .......................................................................................... 95
LUCRAREA 8 ....................................................................................... 98
8.2. Calcule simbolice cu funcţii........................................................ 98
8.3. APLICAŢII ............................................................................... 104
8.4. Indicaţii ..................................................................................... 106
8.5. Soluţii ........................................................................................ 107
LUCRAREA 9 ..................................................................................... 110
9.1. Obiectivele lucrării.................................................................... 110
9.2. Operatori relaţionali şi logici. ................................................... 110
9.3. APLICAŢII ............................................................................... 116
9.4. Indicaţii ..................................................................................... 119
9.5. Soluţii ........................................................................................ 121
LUCRAREA 10 ................................................................................... 125
10.1. Obiectivele lucrării.................................................................. 125
10.2. Comenzi de control a execuţiei unui program. ....................... 125
10.3. Aplicaţii................................................................................... 134
10.4. Indicaţii ................................................................................... 135
10.5. Soluţii ...................................................................................... 138
LUCRAREA 11 ................................................................................... 144

11.2. Programe m-file. Comenzi de intrare – ieşire. ........................ 144
11.3. Aplicaţii................................................................................... 153
11.4. Indicaţii ................................................................................... 154
11.5. Soluţii ...................................................................................... 155
LUCRAREA 12 ................................................................................... 166
12.2. Exemple de utilizare MATLAB în modelarea şi rezolvarea
problemelor tehnice.......................................................................... 166
12.3. Aplicaţii................................................................................... 174
12.4. Indicaţii ................................................................................... 179
12.5. Soluţii ...................................................................................... 187
LUCRAREA 13 ................................................................................... 190
problemelor tehnice.......................................................................... 190
13.2.1. Calcul vectorial în MATLAB .......................................... 190
13.3. Aplicaţii................................................................................... 194
13.4. Indicaţii ................................................................................... 196
13.5. Soluţii ...................................................................................... 202
LUCRAREA 14 ................................................................................... 204
problemelor tehnice. (Continuare) ................................................... 204
14.3. Aplicaţii................................................................................... 204
14.4. Indicaţii ................................................................................... 207
14.5. Soluţii ...................................................................................... 220
LUCRAREA 15 ................................................................................... 225
15.1. Depanarea şi optimizarea programelor MATLAB. .................... 225
15.2. Aplicaţii................................................................................... 234
15.3. Indicaţii ................................................................................... 236
LUCRAREA 16 ................................................................................... 245
16.1. Sisteme neliniare. .................................................................... 245
16.2. Aplicaţii................................................................................... 250
16.3. Indicaţii ................................................................................... 251
16.5. Soluţii ...................................................................................... 253

LUCRAREA 17 ................................................................................... 255
17.1. Ecuaţii diferenţiale de ordinul I............................................... 255
17.3. Aplicaţii................................................................................... 259
17.4. Indicaţii ................................................................................... 260
17.5. Soluţii ...................................................................................... 261
LUCRAREA 18 ................................................................................... 266
18.2. Aplicaţii................................................................................... 268
18.3. Indicaţii ................................................................................... 268
18.4. Soluţii ...................................................................................... 270
LUCRAREA 19 ................................................................................... 272
problemelor tehnice. Aplicaţii.......................................................... 272
19.2. Indicaţii ................................................................................... 274
19.3. Soluţii ...................................................................................... 284
LUCRAREA 20 ................................................................................... 288
20.1. Simulink. Elemente de bază.................................................... 288
19.4. Aplicaţii................................................................................... 305
19.5. Indicaţii şi soluţii..................................................................... 306
LUCRAREA 21 ................................................................................... 311
21.1. Simulink. Simularea sistemelor dinamice bazate pe ecuaţii
diferenţiale de ordinul 1. .................................................................. 311
21.2. Aplicaţii................................................................................... 315
LUCRAREA 22 ................................................................................... 325
22.1. Simulink. Simularea sistemelor dinamice bazate pe ecuaţii
diferenţiale de ordinul 1I.................................................................. 325
22.2. Aplicaţii................................................................................... 329
LUCRAREA 23 ................................................................................... 336
23.1. Simulink. Subsisteme.............................................................. 336
LUCRAREA 24 ................................................................................... 349
24.1. Simulink. Subsisteme mascate ................................................ 349
BIBLIOGRAFIE .................................................................................. 356
Introducere
Pentru cursul ”Programarea Calculatoarelor şi Limbaje de

Programare”, prevăzut de programa analitică a Facultăţii de Mecanică
anul I, s-a considerat necesară însuşirea de cunoştinţe privind mediul de
programare MATLAB.
Conform site-ului www.thefreedictionay.com, MATLAB este :
’Un program interactiv, produs de firma MathWorks pentru calcule
numerice de înaltă performanţă şi reprezentări grafice. MATLAB
integrează analiza numerică cu calculul matriceal, cu prelucrarea
semnalelor şi cu grafica într-un mediu uşor de utilizat. MATLAB este
construit pe baza unui soft sofisticat de calcul matriceal de analiză a
ecuaţiilor liniare. Componentele livrate pot fi utilizate în următoarele
domenii: matematică aplicată, fizică, chimie, tehnică, finanţe şi în orice
domeniu care utilizează modele ce necesită calcule numerice complexe’.
Definiţia din dicţionar este o definiţie destul de laborioasă şi
descrie, în opinia noastră, destul de corect punctul de vedere al unui
utilizator obişnuit al programului MATLAB. Un specialist în ştiinţa
calculatoarelor va spune că MATLAB este un limbaj de programare, mai
exact un interpretor pentru programarea calculelor numerice complexe.
Mathworks a intitulat manualul de utilizare de la un moment dat (de la
versiunea 5) „MATLAB – The Language of Technical Computing” ceea
ce se traduce prin „MATLAB – Limbajul calculelor tehnice”, fapt ce
vine în sprijinul accepţiunii date de autori mai sus . Surprinzător,
MATLAB este un limbaj ca C++, Fortran, Pascal, făcând parte din
aceeaşi clasă cu BASIC-ul. De asemenea, trebuie subliniat că MATLAB
acceptă majoritatea instrucţiunilor C++ şi practic apare ca o extensie a
acestui limbaj. Prin urmare, cunoscătorii limbajului C++ au un mare
avantaj, pentru aceştia timpul de însuşire al limbajului MATLAB fiind

foarte scurt. În cele ce urmează vom prezenta un număr de lucrări
practice utilizând versiunea 6.5 (R13) a programului MATLAB.
Cunoştinţele necesare pentru parcurgerea lucrărilor practice din
prezentul îndrumar sunt:
cunoştinţe elementare despre calculatoare electronice de tip PC şi
sistemul de operare Windos XP;
matematica şi fizica din liceu (discipline cerute la admitere).
Lucrările de laborator au fost elaborate după următoarea
structură:
O primă parte ce prezintă pe scurt obiectivele dorite de atins ale
lucrării.
O a doua parte în care sunt prezentate şi exemplificate comenzile
MATLAB necesare rezolvării aplicaţiilor. Spre deosebire de curs aici
comenzile sunt prezentate pe scurt, dar cu multe exemple semnificative
şi special alese pentru înţelegerea atât a sintaxei comenzii cât şi a
diverselor efecte pe care executarea comenzii le are.
O a treia parte ce conţine aplicaţiile necesare de rezolvat cu
privire la tema lucrării cuprinsă chiar în titlu. Aceste aplicaţii au fost
concepute încât sa fie semnificative şi să poată fii parcurse de un student
cu cunoştinţe medii asupra temei în o oră şi jumătate.
A patra parte dă indicaţii despre cum s-ar putea rezolva aplicaţia.
Chiar dacă un student a rezolvat independent o anumită aplicaţie,
recomandăm parcurgerea şi a indicaţiilor pentru analizarea altei soluţii şi
mai ales pentru că uneori pentru prezentarea unei soluţii optime sunt
necesare cunoştinţe suplimentare, neprezentate din lipsă se timp la curs.
O ultimă parte prezintă rezultatele rezolvării aplicaţiilor.
Recomandăm parcurgerea acestei părţi după realizarea unei rezolvări
proprii, pentru compararea rezultatelor. Uneori, din motive de claritate,
ultimele două părţi sunt prezentate împreună.
Aceste lucrări de laborator trebuie parcurse în ordinea prezentată

aici, pentru că o lucrare presupune parcurgerea tuturor lucrărilor
anterioare ei. Prezentul îndrumar nu îşi propune să depăşească un anumit
nivel de abordare a limbajului MATLAB. Parcurgerea cu succes a
tuturor aplicaţiilor din primele 12 lucrări va conduce la însuşirea unor
cunoştinţe de bază pentru conceperea de programe în mediul MATLAB.
Partea a doua a lucrărilor, până la 24, va conduce la însuşirea
unor cunoştinţe de nivel mediu privind programarea în MATLAB,
necesare pentru scrierea unor programe pentru aplicaţii inginereşti
concrete. Deasemenea, recomandăm alocarea unui anumit număr de ore
de activitate individuală, constând în încercarea de a rezolva, cu ajutorul
mediului de programare MATLAB, probleme ce apar la celelalte
discipline studiate.
LUCRAREA 1
1.1. Obiectivele lucrării.
Această lucrare îşi propune prezentarea mediului de programare

MATLAB, însuşirea modului de scrierea expresiilor în MATLAB,
efectuarea de calcule aritmetice, prezentarea şi utilizarea funcţiilor
elementare predefinite.
1.2. Ferestrele MATLAB.
Lansarea programului MATLAB se face simplu: fie dând click

de două ori pe iconiţa corespunzătoare de pe desktop, fie din start>all
programs>MATLAB. Se obţine imaginea din figura 1.1 pe desktop.
Pentru închiderea programului MATLAB avem următoarele
posibilităţi:
se apasă butonul 6 din stânga sus al ferestrei principale ;
se tastează CTRL+Q;
se intră în meniul File şi se alege Exit;
se tastează exit în zona de comenzi.
De interes deosebit este zona de comenzi, unde programul
aşteaptă să tastăm comenzi pe care el să le interpreteze şi să le execute.
Vom indica cu caractere italice exemplificările din această zonă.
Zona denumită istorie comenzi va conţine toate comenzile date pe
parcursul unei sesiuni de lucru (adică între deschiderea şi închiderea
programului). Mai mult conţine toate comenzile din mai multe sesiuni,
fiecare sesiune fiind despărţită de precedenta de un rând ce conţine data
şi ora deschiderii sesiunii. Această zonă ne permite să nu scriem

secvenţe de comenzi care au fost date în sesiuni anterioare, ci utilizând
copy-paste să readucem secvenţa dorită în zona de comenzi,
economisind timp. Zona de memorie conţine informaţii despre toate
datele, constante sau variabile existente în memorie lucru ce permite
uşurare construirii programelor mari.
Zona
memorie Zona
comenzi
Istorie
comenzi
Fig.1.1. Ferestrele MATLAB
Mai există o fereastră des utilizată, fereastra grafică. Această

fereastră se deschide numai dacă a fost scrisă în zona de comenzi o
comandă din clasa comenzilor grafice.
1.3. Expresii şi calcule
Ca orice program de modelare matematică MATLAB este

capabil să efectueze calcule matematice simple (la sfârşitul comenzii se
tastează Enter pentru a o transmite programului Matlab):
adunarea
>> 5 + 3
ans =
8
>>
scăderea
>> 5 – 3
ans =
2
>>
înmulţirea
>> 5 * 3
ans =
15
>>
împărţirea
>> 5 / 3
ans =
1.6667
>>
ridicarea la putere
>> 5 ^ 3
ans =
125
>>
Se impun două observaţii: prima este remarcarea faptului că
operaţiile de înmulţire şi împărţire utilizează aceleaşi simboluri, *
respectiv / , care sunt utilizate în celelalte limbaje de programare; a doua
este apariţia variabilei ans, variabilă în care programul introduce automat
rezultatul unei comenzi ce nu defineşte o variabilă proprie în acest scop.
Sigur putem face calcule aritmetice complexe acum utilizând
reguli implicite acceptate în limbajele de programare. Astfel pentru
calculul simplu:
3
5+
7
3
Vom scrie:
>> (5+3/7)/3
ans =
1.8095
>>
Utilizând parantezele corespunzător se pot calcula expresii mai
complicate. În calcule se pot utiliza şi funcţii elementare predefinite în
program. Mai jos prezentăm cele mai utilizate funcţii:
funcţii trigonometrice:
sin – sinus; asin – arcsinus;
cos – cosinus; acos – arccosinus;
tan – tangentă; atan – arctangent;
cot – cotangentă; acot – arccotangent;

sec – secantă; asec – arcsecant;
csc – cosecantă; acsc – arccosecant;
funcţii putere:
exp – funcţia exponenţială;
log – logaritm natural;
log2 – logaritm în baza 2;
log10 – logaritm în baza 10;
sqrt – funcţia radical;
alte funcţii:
abs – valoarea absolută, modul;
min – minimum;
max – maximum;
În manualul de referinţă aflat pe site-ul MathWorks se găsesc

listate în ordine alfabetică toate funcţiile definite implicit de programul
MATLAB (manualul este în limba engleză). Putem utiliza aceste funcţii
în calcule:
π π
sin + cos
4 3
5 + ln(7) − 1.50.17
Se va scrie comanda:
>> (sin(pi/4)+cos(pi/3))/(sqrt(5+log(7))-1.5^0.17)
ans =
0.7717
>>
1.4. Aplicaţii
Care dintre expresii este mai mare?

a) 2π sau π 2 ;
2
b) π + 1 + π 2 sau π 1+ 1+π ;
π π π
⎛ π π⎞ sin + cos
c) ⎜ sin + cos ⎟ sau π 3 4 .
⎝ 3 4⎠
Să se calculeze:
1+ 5
a) =
2
π⎤ 3
⎡
b) ⎢
⎣
( )
2 ⎥
⎦
=
π
c) π 2 − 10icos 2 =
3
Să se afle valoarea fracţiilor:

π
⎛ ⎞ 3
⎜ 3π − π 3 ⎟
a) ⎜ ⎟ =
⎜ 1+ 3 ⎟
⎜ ⎟
⎝ 3 ⎠
ln(56) + sin(cos 44.67)
b) =
3 ln(678) + lg(223.38) − tg (sin
π
)
3
1
c) =
2
1+
3
1+
2
1+
5
1+
1+ 6
Să se efectueze calculele cu constante speciale:

a) realmax + 2 =
b) inf – inf =
c) nan + 2 =
d) realmax – realmin =
e) inf / inf =
f) 0 * inf =
5. De la analiza matematică se ştie că limitele:

f ( x + h) − f ( x) f ( x + h) − f ( x − h)
lim şi lim sunt egale cu derivata
h →0 h h →0 2ih
funcţiei în x, f ' ( x ) . Acest lucru înseamnă că dând o valoare mică
pentru h fracţiile din limitele de mai sus aproximează derivata. Luând
f(x)=sin x să se calculeze eroarea dintre valoarea exactă a derivatei
π
funcţiei în şi aceste aproximări pentru:
4
h=10-6 ;
h=10-8 ;
h=10-10 ;
h=10-15 ;
h=10-20 .
Cum explicaţi rezultatele?
6. Pentru x=0.5 şi t= 2 calculaţi expresiile:

( ) (
a) x 3 + 1 iln 1 + t + t 2 = )
b) e x + t i(1 + x + cos t ) =
cos 2 x + arctg t
c) t =
x + t + ex
1.5. Indicaţii şi soluţii
1.
a) 2^pi-pi^2
ans =
-1.0446 Deci 2π < π 2 . Analog şi punctele b) şi c).
2.
a) (1+sqrt(5))/2
ans =
1.6180
b) 6.5919
c) 7.3696
3.
a) ((3^pi-pi^3)/((1+sqrt(3))/3))^(pi/sqrt(3))
ans =
0.3849
b) 2.4231
c) 0.5576
4.
a) realmax;
b) NaN;
c) NaN;
d) realmax;
e) NaN;
f) NaN;
5. Erorile sunt date de: abs(cos(pi/4)-(sin(pi/4+h)-sin(pi/4))/h) ,

respectiv abs(cos(pi/4)-(sin(pi/4+h)-sin(pi/4-h))/h/2)
a)
h=0.000001
ans=
3.5344e-007
ans=
5.2650e-011
b)
h=0.00000001
ans=
3.0503e-009
ans=
3.0503e-009
c)
h=0.0000000001
ans =
9.2454e-007
ans =
3.6942e-007
d)
h=0.000000000001
ans =
5.7368e-006
ans =
6.1248e-005
e)
ans =
0.0034
ans =
0.0021
π
Este surprinzător dar fracţiile nu tind la derivata în !!? Motivul
4
este, în principal dat erorile de calcul care se acumulează (precizia este
mică la maşinile pe 32 biţi). De remarcat este faptul că şi funcţiile
elementare sin(x) şi cos(x) sunt şi ele calculate şi au erori de aproximare.
0
În plus aici este vorba de o nedeterminare de forma şi deci se
0
împart două numere foarte mici. Ca şi sfat în astfel de calcule utilizaţi
valori pentru h la jumătatea preciziei maxime, deci 10-7 sau 10-8. Se
observă că precizia atinsă atunci este în jur de 10-8, 10--9 o precizie
satisfăcătoare pentru maşinile de 32 biţi. Precizia se va dubla odată cu

trecerea la procesoare pe 64 biţi.
6.
a) (x^3+1)*log(1+t+t^2)= 1.6704
b) exp(x+t)*(1+x+cos(t))= 11.2300
c) ((cos(x))^2+atan(t))/(x+t+exp(x^t))= 0.5121
LUCRAREA 2
Această lucrare îşi propune însuşirea lucrului cu matrici : crearea,

accesarea elementelor sau a grupurilor de elemente, calcule elementare
cu matrici, funcţii de matrici (inversa, determinantul, etc.).
2.2. Matrici şi vectori
2.2.1. Matrici şi vectori. Definiţii.
În teoria informaţiei o matrice este un tablou în care informaţiile

sunt organizate în linii şi coloane. Este cel mai des întâlnit mod de
organizare al informaţiei din această cauză matricea fiind supranumită
mama structurilor de date. În matematică matricile sunt de obicei
tablouri de numere. Pentru notaţii se utilizează paranteze pătrate între
care se scrie tabloul de date.
Exemplu: un tablou numeric de două linii şi două coloane:
⎡ 5 0⎤
⎢ −1 2 ⎥ . În cazul unei matrici mari se folosesc uneori notaţii
⎣ ⎦
simbolice: ⎡⎣ aij ⎤⎦ i = 1,… , n ; j = 1,… , m pentru o matrice cu n linii şi m
coloane.
Numărul de linii şi de coloane reprezintă tipul matricii. Din
exemplele de mai sus prima matrice este de tipul 2X2, iar a doua de tipul
nXm. În cazul când n=m matricea se zice pătrată şi are tipul n. În cazul
matricilor pătrate elementele de pe diagonala ce porneşte din colţul din

stânga sus şi ajung în colţul din dreapta jos formează diagonala
principală. Elementele ce pornesc din colţul din dreapta sus şi ajung în
colţul din stânga jos formează diagonala secundară.
Matricile de tipul 1Xm se numesc vectori linie cu m elemente.
Matricile de tipul nX1 se numesc vectori coloană cu n elemente.
2.2.2. Definirea matricilor în MATLAB.
Pentru definirea matricilor în MATLAB se utilizează operatorul

[]. Astfel în interiorul operatorului elementele matricii se scriu pe linii cu
separatori între elemente (spaţiu, virgula), terminarea unei linii fiind
indicată de separatorul punct-virgula (;). De exemplu matricea:
⎡1 2 3⎤
A=⎢ ⎥
⎣3 2 1 ⎦
Se obţine cu ajutorul comenzii [1,2,3;3,2,1]. Un vector linie [1 2

3] se defineşte în MATLAB exact cum a fost scris mai înainte. Acelaşi
vector dar coloană se va defini cu [1;2;3].
Matrici mai des definite au funcţii predefinite:
zeros(n,m) va genera matricea de tip nXm a cărui elemente sunt toate
zero. Dacă matricea este pătrată de tip n se va scrie zeros(n).
ones(n,m) va genera matricea de tip nXm cu toate elementele 1.
Matricea pătrată de tip n cu elemente 1 este generată de ones(n).
eye(n) va genera matricea unitate de ordin n, adică matricea ce are
elementele egale cu 1 pe diagonala principală şi 0 în rest.
Operatorul [] permite generarea unor noi matrici prin
concatenarea unor matrici deja generate. Pentru concatenarea pe
orizontală a matricilor A cu B vom scrie [A,B] matricile A şi B trebuind

să aibă acelaşi număr de linii. Pentru concatenarea pe verticală vom scrie
[A;B] de data aceasta matricile A şi B trebuind să aibă acelşi număr de
coloane.
Pentru generarea de matrici poate fi utilizată şi funcţia diag(v,k)
unde v este un vector iar k un întreg. Funcţia va genera o matrice în care
vectorul v devine o diagonală paralelă cu diagonala principală aflată la
distanţa k deasupra (dacă k>0) sau dedesubtul (dacă k<0) diagonalei
principale iar restul elementelor matricii sunt nule. Dacă k lipseşte sau
este 0 atunci v va deveni chiar diagonala principală. Funcţia diag este
utilă la definirea matricilor bandă (cum se numesc matricile ale căror
elemente nenule sunt pe diagonale paralele cu diagonala principală,
aflate în apropierea diagonalei principale).
2.2.3. Accesarea elementelor unei matrici.

Operatorul
Accesarea individuală a unui element se face indicând linia şi

coloana lui/ de exemplu pentru matricea A de mai sus elementul din
prima linie şi coloana a treia este A(1,3)=3.
Pentru accesarea multiplă MATLAB are mai multe posibilităţi.
Astfel putem utiliza la indice operatorul : . Astfel dacă vrem să indicăm
elementele liniei 1 din A scriem A(1,1:3). Ţinând cont că elementele
matricii A sunt memorate liniar putem indica toate elementele prin A(:).
Putem accesa mai multe elemente neliniar. Astfel dacă dorim
elementele din linia i dar coloane impare scriem A(i,1:2:end). Se observă
apariţia lui end care este expresia precisă a propoziţiei „până la sfârşit” .
O altă posibilitate este indicarea unei condiţii drept indice. Astfel
dacă dorim accesarea doar a elementelor pozitive ale lui A scriem
A(A>0). Expresia din paranteză trebuie să fie o expresie logică pe care

elementele trebuie să o verifice.
2.2.4. Operaţii cu matrici şi vectori.
Matricile de acelaşi tip se pot aduna obţinându-se o matrice a

cărui elemente sunt suma element cu element a celor două matrici,
matematic cij=aij+bij.
Înmulţirea matricilor A cu B este posibilă dacă A este de tip nXm şi B
de tip mXp rezultând matricea C de tip nXp. Înmulţirea se face „linii pe
coloane”, pentru a obţine elementul cij se face suma produselor dintre
elementele liniei i a lui A cu elementele corespunzătoare ale coloanei j a
m
lui B (matematic cij = ∑ aik ibkj ). Noi vom scrie A*B şi dacă produsul
k =1
este posibil MATLAB va efectua înmulţirea.

Datorită modului special în care este abordată împărţirea de către
MATLAB aceasta va fi abordată separat în lucrarea următoare .
O matrice poate fi ridicată la putere cu operatorul ^. Această
ridicare la putere se face corespunzător operaţiei înmulţire linii pe
coloane prezentate mai înainte.
Pentru efectuarea operaţiilor element cu element există aşa
numitele ‚,operaţii cu punct”. Astfel * este operaţia de înmulţire element
cu element, / operaţia de împărţire element cu element iar ^ este
ridicarea la putere a fiecărui element al matricii. Aceste operaţii sunt
utile în special în formulele ce admit ca variabile matrici sau vectori.
În afara funcţiilor de matrici de mai jos, asupra matricilor se pot
aplica funcţiile matematice uzuale efectul aplicându-se fiecărui element.
De exemplu sin aplicată unei matrici este matricea sinusurilor fiecărui
element.
2.2.5. Funcţii de matrici.
Sunt foarte multe funcţii de matrici. Vom prezenta pe scurt cele

mai utilizate dintre ele:
-size(A) ne dă tipul matricii
-Nume(A) numărul elementelor lui A
-min(A) cel mai mic element al lui A
-max(A) cel mai mare element al lui A
-prod(A) produsul elementelor lui A
-sum(A) suma elementelor lui A
-det(A) determinantul lui A
-inv(A) inversa lui A
2.3. APLICAŢII
1. Definiţi în MATLAB vectorii şi matricile de mai jos:

v = (1, 2,3) ; w = ( 4,5, 6 ) ;
⎛ −1 ⎞ ⎛2⎞
a) ⎜ ⎟ ⎜ ⎟
u = ⎜ 0 ⎟; z = ⎜ 0 ⎟;
⎜1⎟ ⎜ −1 ⎟
⎝ ⎠ ⎝ ⎠
⎡1 0 0 ⎤ ⎡2 0 1⎤
b) A = ⎢⎢0 1 0 ⎥⎥ ; B = ⎢⎢ 1 1 1 ⎥⎥ ;
⎢⎣0 0 1 ⎥⎦ ⎢⎣ −1 2 −2 ⎥⎦
2. Creaţi vectorii va, vb, vc şi vd care să aibă următoarele elemente:

a) 2,4,6,8,…,100;
b) 50,48,46,…,-50;
c) 1,1/2,1/3,…,1/100;
d) 0,1/2,2/3,3/4,…,99/100.
3. Prin concatenarea matricilor şi vectorilor de mai sus, definiţi în

MATLAB:
⎛2⎞
⎜ ⎟
⎜0⎟
⎜ −1 ⎟
a) r = (1, 2,3, 4,5, 6 ) ; t = ⎜ ⎟ ;
⎜ −1 ⎟
⎜0⎟
⎜⎜ ⎟⎟
⎝1⎠
⎡0 0 0 5 0 0⎤
⎢0 0 0 0 5 0 ⎥⎥
⎢
⎢0 0 0 0 0 5⎥
b) C = ⎢ ⎥;
⎢2 0 1 3 3 3⎥
⎢1 1 1 3 3 3⎥
⎢ ⎥
⎣⎢ −1 2 −2 3 3 3⎦⎥
4. Cu ajutorul funcţiei diag(v,n), (unde n este distanţa de la diagonala

principală), definiţi:
⎡0 0 1 0 0 0⎤
⎢0 0 0 1 0 0 ⎥⎥
⎢
⎢0 0 0 0 1 0⎥
a) D = ⎢ ⎥;
⎢ −2 0 0 0 0 1⎥
⎢ 0 −2 0 0 0 0⎥
⎢ ⎥
⎢⎣ 0 0 −2 0 0 0 ⎥⎦
⎡2 1 0 0 0 0⎤
⎢1 2 1 0 0 0 ⎥⎥
⎢
⎢0 1 2 1 0 0⎥
b) E = ⎢ ⎥;
⎢0 0 1 2 1 0⎥
⎢0 0 0 1 2 1⎥
⎢ ⎥
⎣⎢ 0 0 0 0 1 2 ⎦⎥
5. Utilizând matricile şi vectorii definiţi în exerciţiile 1, 2 şi 3, calculaţi:

a) v ⋅ z = ; r ⋅ t = ; b) A ⋅ u − B ⋅ z = ; c) C 3 + D3 − 15 ⋅ E 3 = ; d)
B i B 2 − 5i B −1 = ;
e) D5 = ; f) Di E − E i D = ; g) D. ∗ E − E. ∗ D = ; h)
sin ( D ) − cos ( E ) = ;
6. Utilizând matricile A şi B să se definească matricile:

⎡1 0 0 0 0 0⎤
⎢0 1 0 0 0 0 ⎥⎥
⎢
⎢0 0 1 0 0 0⎥
a) G = ⎢ ⎥ ;
⎢0 0 0 2 0 1⎥
⎢0 0 0 1 1 1⎥
⎢ ⎥
⎢⎣ 0 0 0 −1 2 −2 ⎥⎦
⎡1 0 0 −1 0 0 ⎤
⎢0 1 0 0 −1 0 ⎥⎥
⎢
⎢0 0 1 0 0 −1⎥
b) H = ⎢ ⎥
⎢2 0 1 2 0 1⎥
⎢1 1 1 1 1 1⎥
⎢ ⎥
⎣⎢ −1 2 −2 −1 2 −2 ⎦⎥
7. Să se creeze sau calculeze, după caz :

a) Vectorul elementelor impare ale lui r ;
b) Vectorul elementelor pozitive ale lui H;
c) Suma elementelor lui H;
d) Matricea elementelor lui H aflate la intersecţia liniilor 1.2 şi 3 cu
coloanele 2,4 şi 6;
e) vectorul ri in care elementele lui r sunt în ordine inversă.
8. Utilizând matricea B definită la 1.c) scrieţi comenzile necesare pentru

a obţine:
a) un vector format din elementele primei linii a lui B;
b) o matrice formată cu ultimele două linii ale lui B;
c) un vector a cărui elemente sunt sumele elementelor din coloanele lui
B;
d) un vector a cărui elemente sunt sumele elementelor din liniile lui B;
e) o matrice formată din elementele din colţurile lui B.
1.
c) B=[2 0 1;1 1 1;-1 2 -2]
2.
a) va=2:2:100
b) vb=50:-2:-50
c) vt=1:100; vc=1./vt
d) vt1=0:99; vt2=1:100; vd=vt1./vt2
3.
a) r=[v w]; t=[z;u]
b) C=[zeros(3) 5*eye(3);B 3*ones(3)]
4.
a) D=-2*diag(ones(1,3),-3)+diag(ones(1,4),2)
b) E=diag(ones(1,5),-1)+2*diag(ones(1,6))+diag(ones(1,5),1)
5.
a) v*z= -1 r*t= 1
⎛ −4 ⎞
⎜ ⎟
b) ⎜ −1 ⎟
⎜1 ⎟
⎝ ⎠
⎡ -180 -167 -90 170 135 160 ⎤

⎢ -180 -255 -229 70 145 160 ⎥⎥
⎢
⎢ -60 -180 -300 -117 95 70 ⎥
c) ⎢ ⎥
⎢ 54 1 -225 18 104 198 ⎥
⎢ 68 81 -90 93 33 76 ⎥
⎢ ⎥
⎢⎣ 64 75 10 168 63 18⎥⎦
⎡ -19.0000 -8.0000 -1.0000 ⎤

d) ⎢⎢ -9.0000 -18.0000 -1.0000 ⎥⎥
⎢⎣ -7.0000 6.0000 -23.0000 ⎥⎦
⎡ 4 0 0 0 0 -2⎤
⎢ 0 8 0 0 0 0 ⎥⎥
⎢
⎢ 0 0 8 0 0 0⎥
e) ⎢ ⎥
⎢ 0 0 0 8 0 0⎥
⎢ 0 0 0 0 8 0⎥
⎢ ⎥
⎣⎢ -8 0 0 0 0 4 ⎦⎥
⎡ 0 1 0 0 0 0⎤
⎢ 0 0 0 0 0 0 ⎥⎥
⎢
⎢ 2 0 0 0 0 0⎥
f) ⎢ ⎥
⎢ 0 0 0 0 0 0⎥
⎢ 0 0 0 0 0 -1 ⎥
⎢ ⎥
⎢⎣ 0 0 0 -2 0 0 ⎥⎦
⎡ 0 0 0 0 0 0⎤
⎢ 0 0 0 0 0 0 ⎥⎥
⎢
⎢ 0 0 0 0 0 0⎥
g) ⎢ ⎥
⎢ 0 0 0 0 0 0⎥
⎢ 0 0 0 0 0 0⎥
⎢ ⎥
⎢⎣ 0 0 0 0 0 0 ⎥⎦
⎡ 0.4161 -0.5403 -0.1585 -1.0000 -1.0000 -1.0000 ⎤

⎢ -0.5403 0.4161 -0.5403 -0.1585 -1.0000 -1.0000 ⎥⎥
⎢
⎢ -1.0000 -0.5403 0.4161 -0.5403 -0.1585 -1.0000 ⎥
h) ⎢ ⎥
⎢ -1.9093 -1.0000 -0.5403 0.4161 -0.5403 -0.1585 ⎥
⎢ -1.0000 -1.9093 -1.0000 -0.5403 0.4161 -0.5403 ⎥
⎢ ⎥
⎣⎢ -1.0000 -1.0000 -1.9093 -1.0000 -0.5403 0.4161 ⎦⎥
6.
a) G=[A zeros(3);zeros(3) B]
b) H=[A –A;B B]
7.
a) r(1:2:end)
b) H(H>0)
c) sum(H(:))
d) H(1:3,2:2:end)
e) ri=r(end:-1:1)
8.
a) va=B(1,1:end)
b) Bb=B(end-1:end,1:end)
c) xc=sum(B)
d) xd=sum(B,2)
Observaţie. A doua valoare din sum indică după ce dimensiune se face
suma (implicit are valoarea 1 deci implicit se face suma pe coloane). În
cazul nostru pentru că dorim suma pe linii s-a trecut valoarea 2.
e) Bd=B([1,end],[1,end])
LUCRAREA 3
Această lucrare îşi propune prezentarea principalelor probleme ce

apar în algebra liniară: ecuaţii matriciale, sisteme liniare, vectori şi valori
proprii.
3.2 . Elemente de algebră liniară în MATLAB
3.2.1.Ecuaţii matriciale.
Fie ecuaţiile matriciale Ai X = B , respectiv, Y i A = B . Din

algebra liniară ştim că soluţiile acestor ecuaţii sunt: X = A−1 i B ,
respectiv, Y = B i A−1 . Comenzile MATLAB corespunzătoare sunt:
X=inv(A)*B, respectiv, Y=B*Inv(A). Totuşi pornind de la ecuaţia de
gradul 1 de forma a i x = b , a cărui soluţie este x = b / a în MATLAB a
fost introdus operatorul \ care calculează soluţia ecuaţiei matriciale în alt
mod decât clasica soluţie de mai sus ( cea cu inversa). Testele arată
faptul că soluţia cu operatorul / este obţinută mult mai rapid decât cu
formula clasică, acest fapt devenind observabil atunci când matricile
sunt de mari dimensiuni. Astfel pentru matrici de ordinul 1000 soluţia / a
fost de 400 ori mai rapidă. Pentru soluţia ecuaţiei Y i A = B s-a definit
operatorul /. Deci în MATLAB soluţiile celor două ecuaţii sunt: X=A\B,
respectiv Y=B/A.
3.2.2. Sisteme liniare.
Din algebra liniară se ştie faptul că sistemele liniare sunt de trei

tipuri:
sisteme compatibile unic determinate (care au soluţie unică);
sisteme compatibile nedeterminate (care au o infinitate de soluţii);
sisteme incompatibile (care nu au nici o soluţie).
Să considerăm un sistem liniar de ordin n (adică are n ecuaţii cu
n necunoscute). Să notăm cu A matricea coeficienţilor necunoscutelor,
cu x vectorul coloană al necunoscutelor şi cu b vectorul coloană al
termenilor liberi. Sistemul liniar capătă o formă matricială Ai x = b . Se
numeşte rangul unei matrici ordinul (tipul) determinantului cel mai mare
nenul ce se poate forma cu elementele matricei. În MATLAB există
funcţia rank(A) care ne calculează rangul matricei ((((ă)))). Mai definim
matricea extinsă a lui A, obţinută prin concatenarea orizontală la A cu
vectorul b (în MATLAB Aext=[A b]). Acum putem spune despre un
sistem liniar de ce tip este:
Dacă rank(A)=rank(Aext)=n este vorba despre un sistem
compatibil unic determinat pe care îl rezolvăm cu formula x=A\b;
Dacă rank(A)=rank(Aext)<n este vorba despre un sistem
compatibil nedeterminat a cărui infinitate de soluţii va fi determinată sub
formă simbolică mai târziu.
Dacă rank(A)≠rank(Aext) sistemul este incompatibil şi deci nu
are soluţie.
Din păcate se ştie că soluţiile chiar date de formule exacte sunt
totdeauna aproximative şi de aceea este bine ca înainte de a determina
soluţia să calculăm precizia soluţiei.. Formula preciziei este dată de:
p < C icond ( A)i p (comp)
Unde p este precizia de calcul căutată, C o constantă care verifică
1<C<10 (pentru siguranţă este recomandabil să considerăm C=10),
p(comp) este precizia calculatorului, pentru PC-uri este de aproximativ

2.2i10−16 , iar cond(A) este numărul de condiţie al matricei (în MATLAB
cond(A) este funcţia ce ne dă acest număr. Din cele de mai sus rezultă
faptul că precizia de calcul este în cel mai defavorabil caz dată de
formula: 2.2i10−15 icond ( A) .
3.2.3. Vectori şi valori proprii.
Ne propunem să determinăm vectorul v de tip nx1 şi constanta

λ ∈ R care verifică ecuaţia matricială Av= λv unde A este o matrice
pătrată de ordinul n. Vectorul v soluţie se numeşte vector propriu iar
constanta λ se numeşte valoare proprie. În general această problemă nu
are o infinitate de soluţii dar de la 0 la cel mult n soluţii independente.
MATLAB are o funcţie specială ce rezolvă această problemă, şi anume
funcţia eig cu structura: [v,d]=eig(A), unde A este matricea din ecuaţie,
v este tot o matrice de ordin n ca şi A, dar a cărui coloane sunt vectorii
proprii căutaţi (unii din ei fiind complecşi) iar d este o matrice diagonală
de tip n elementele de pe diagonala principală fiind valorile proprii
căutate. Perechile de soluţii sunt: (d(k,k), v(:,k)) adică elementul de pe
diagonala principală a lui d aflat pe coloana k este valoarea proprie
corespunzătoare vectorului propriu din coloana k a lui v. Vectorii
proprii din coloanele lui v sunt calculaţi în aşa fel încât norma lor să fie
1 (se mai zic vectori unitari), adică norm(v(:,k))=1 (funcţia norm
calculează norma unui vector), de fapt orice alt vector care este soluţie a
problemei se va exprima în funcţie de aceşti vectori unitari din matricea
v. Vom da mai multe exemple pentru diferite situaţii.
Fie matricea
⎡ 3 −2 0 ⎤
A = ⎢⎢ 2 −2 0 ⎥⎥
⎢⎣ 0 1 1 ⎥⎦
Atunci folosind funcţia eig obţinem:
> A=[3,-2,0;2,-2,0;0,1,1]
A=
3 -2 0
2 -2 0
0 1 1
>> [v,d]=eig(A)
v=
0 -0.4082 -0.8165
0 -0.8165 -0.4082
1.0000 0.4082 -0.4082
d=
1 0 0
0 -1 0
0 0 2
S-au obţinut pe diagonală trei numere reale distincte deci avem
trei perechi: [1, (0,0,1)], [-1, (-0.4082,-0.8165, 0.4082)] şi ultima
pereche este [2, (-0.8165,-0.4092,-0.4082)] . Observăm că şi perechea
formată din:
[2,(2,1,1)] este soluţie.
>> A*v-2*v
ans =
0
0
0
Dar vectorul (2,1,1) nu mai este unitar, dar vectorul u este
>> norm(v)
ans =
2.4495
>> u=[-0.8165;-0.4082;-0.4082];
>> norm(u)
ans =
1.0000
Mai prezentăm următorul exemplu:
>> B=[0,-6,-1;6,2,-16;-5,20,-10]
>> [v,d]=eig(B)
v=
-0.8326 0.2003 - 0.1394i 0.2003 + 0.1394i

-0.3553 -0.2110 - 0.6447i -0.2110 + 0.6447i
-0.4248 -0.6930 -0.6930
d=
-3.0710 0 0
0 -2.4645 +17.6008i 0
0 0 -2.4645 -17.6008i
Se observă că avem o singură pereche pentru care valoarea

proprie este număr real [-3.017, (-0.8326,-0.3553,-0.4248)].
3.3 APLICAŢII
Fie matricele A, B, C definite de:
⎡1 1 1 0 0 0 0⎤
⎢0 1 1 1 0 0 0 ⎥⎥
⎢
⎢0 0 1 1 1 0 0⎥
⎢ ⎥
A = ⎢0 0 0 1 1 1 0⎥ ;
⎢0 0 0 0 1 1 1⎥
⎢ ⎥
⎢0 0 0 0 0 1 1⎥
⎢0 0 0 0 0 0 1 ⎥⎦
⎣
⎡3 4 3 1 0 0 0⎤
⎢1 3 4 3 1 0 0 ⎥⎥
⎢
⎢0 1 3 4 3 1 0⎥
⎢ ⎥
B = ⎢0 0 1 3 4 3 1⎥ ;
⎢0 0 0 1 3 4 3⎥
⎢ ⎥
⎢0 0 0 0 1 3 4⎥
⎢0 0 0 0 0 1 2 ⎥⎦
⎣
⎡1 2 2 1 0 0 0⎤
⎢1 2 3 2 1 0 0 ⎥⎥
⎢
⎢0 1 2 3 2 1 0⎥
⎢ ⎥
C = ⎢0 0 1 2 3 2 1⎥
⎢0 0 0 1 2 3 2⎥
⎢ ⎥
⎢0 0 0 0 1 2 3⎥
⎢0 0 0 0 0 1 2 ⎥⎦
⎣
Să se rezolve ecuaţiile matriciale Ai X = B şi Y i A = C
Fie matricele:
⎡5 3 ⎤ ⎡6 2⎤ ⎡ 4 −2 ⎤
A=⎢ ⎥ ; B=⎢ ⎥ ; C=⎢ ⎥
⎣3 2 ⎦ ⎣2 4⎦ ⎣ −6 3 ⎦
Să se rezolve ecuaţiile matriciale:
a) AX+B=C,
b) AX+B=X,
c) XA+B=C,
d) XA+B=X.
Să se rezolve sistemele următoare indicând şi numărul de cifre

exacte:
⎧ x1 + x2 + x3 + x4 = 0
⎪
⎪ 2i x1 − x2 − x3 − 2i x4 = 1
a) ⎨
⎪− x1 + 3i x2 + 2i x3 + 3i x4 = −1
⎪ x1 − 2i x2 + x3 − 2i x4 = −6
⎩
⎧ x1 − x2 + 2i x3 + 3i x4 + 5i x5 = 2
⎪
⎪2i x1 − 2i x2 + x3 − 4i x5 = 0
⎪
b) ⎨−3i x1 + x2 − 2i x3 − 2i x4 = 1
⎪− x + 2i x − 2i x + 3i x + 3i x = 3
⎪ 1 2 3 4 5
⎪⎩ − 2i x2 + x3 + x4 + x5 = −2
⎧ x1 − x2 + 2i x3 + 3i x4 + 5i x5 = 2
⎪
⎪2i x1 − 2i x2 + x3 − 4i x5 = 0
⎪
c) ⎨−3i x1 + x2 − 2i x3 − 2i x4 = 1
⎪− x + 2i x − 2i x + 3i x + 3i x = 3
⎪ 1 2 3 4 5
⎪⎩ − 2i x2 + x3 + x4 + x5 = 3
⎧2i x1 + x2 + … =2
⎪ x +2 x + x + =2
⎪ 1 i 2 3 …
⎪ x2 + 2i x3 + x4 + … =2
⎪
d) ⎨.......................................................................................
⎪ … + 2i x97 + x98 =2
⎪
⎪ … + x97 + 2i x98 + x99 = 2
⎪
⎪⎩ …+ + x98 + 2i x99 = 2
Fiind date matricele A şi B să se stabilească valorile proprii şi

vectorii proprii corespunzători acestor valori.
⎡ 3 7 0 −6 ⎤
⎡7 8 2⎤ ⎢ −2 0 0 0 ⎥
A = ⎢⎢ −5 −6 −2 ⎥⎥ ; B = ⎢ ⎥
⎢ 6 12 −1 −9 ⎥
⎢⎣ −1 −1 1 ⎥⎦ ⎢ ⎥
⎣ −2 2 0 −2 ⎦
Dacă L este matricea pătrată ce are pe diagonala principală
valorile proprii iar V este matricea a cărui coloane sunt vectorii proprii
corespunzători să se calculeze pentru fiecare matrice A respectiv B
matricele V*L*inv(V). Ce observaţi
1.
A=diag(ones(1,7))+diag(ones(1,6),1) +diag(ones(1,5),2)
B=diag(ones(1,6),-1) +3*diag(ones(1,7)) +4*diag(ones(1,6),1)
+3*diag(ones(1,5),2) +diag(ones(1,4),3) şi apoi B(7,7)=2
C=diag(ones(1,6),-1) +2*diag(ones(1,7)) +3*diag(ones(1,6),1)
+2*diag(ones(1,5),2) +diag(ones(1,4),1) şi apoi C(1,1)=1, C(1,2)=2
X=A\B şi Y=C/A soluţiile ecuaţiilor.
⎡ 2 1 0 0 0 0 0⎤
⎢ 1 2 1 0 0 0 -1⎥⎥
⎢
⎢ 0 1 2 1 0 0 1⎥
⎢ ⎥
X =⎢ 0 0 1 2 1 0 0⎥ ;
⎢ 0 0 0 1 2 1 -1⎥
⎢ ⎥
⎢ 0 0 0 0 1 2 2⎥
⎢ 0 0 0 0 0 1 2 ⎥⎦
⎣
⎡1 1 0 0 0 0 0⎤
⎢1 1 1 0 0 0 0 ⎥⎥
⎢
⎢0 1 1 1 0 0 0⎥
⎢ ⎥
Y =⎢0 0 1 1 1 0 0⎥
⎢0 0 0 1 1 1 0⎥
⎢ ⎥
⎢0 0 0 0 1 1 1⎥
⎢0 0 0 0 0 1 1 ⎥⎦
⎣
2.
⎡ 20.0000 -5.0000 ⎤
a) X=A\(C-B); X = ⎢ ⎥
⎣ -34.0000 7.0000 ⎦
⎡ 0 -2 ⎤
b) X=(A-eye(2))\(-B); X = ⎢ ⎥
⎣ -2 2 ⎦
⎡ 8.0000 -14.0000 ⎤
c) X=(C-B)/A; X = ⎢ ⎥
⎣ -13.0000 19.0000 ⎦
⎡ 0 -2 ⎤
d) X=(-B)/(A-eye(2)); X = ⎢ ⎥
⎣ -2 2 ⎦
3.
a) rang(A)=rang(Aext)=4 sistem compatibil determinat;
2.2e − 15 * cond ( A) = 3.7226e-014 deci precizia este cel puţin 10−14
X=A\b; x1=1; x2=0; x3=-3; x4=2
b) rang(A)≠rang(Aext) sistem incompatibil
c) rang(A)=rang(Aext)=3<4 sistem compatibil nedeterminat
d) A=2*diag(ones(1,99))+ diag(ones(1,98),-1)+ diag(ones(1,98),1);
b=2*ones(99,1) rang(A)=rang(Aext)=99 sistem compatibil determinat
2.2e-15*cond(A)=8.9148e-012
deci precizia este cel puţin 10−12 x=A\b
⎧0 daca i este par
Soluţia este: xi = ⎨
⎩1 daca i este impar
4.
⎡ 0.7071 -0.8165 0.5774 ⎤
[V L]=eig(A); V = ⎢⎢-0.7071 0.4082 -0.5774 ⎥⎥ ;
⎢⎣-0.0000 0.4082 0.5774 ⎥⎦
⎡ -1.0000 0 0 ⎤
⎢
L=⎢ 0 2.0000 0 ⎥⎥
⎢⎣ 0 0 1.0000 ⎥⎦
⎛ 1⎞
⎜ ⎟
Valoarea proprie λ1 = −1 este asociată cu vectorul propriu v1 = ⎜ −1 ⎟
⎜ 0⎟
⎝ ⎠
⎛ −2 ⎞
⎜ ⎟
Valoarea proprie λ2 = 2 este asociată cu vectorul propriu v2 = ⎜ 1⎟
⎜ 1⎟
⎝ ⎠
⎛ 1⎞
⎜ ⎟
Valoarea proprie λ3 = 1 este asociată cu vectorul propriu v3 = ⎜ −1⎟
⎜ 1⎟
⎝ ⎠
V*L*inv(V)=A care se numeşte descompunerea cu valori singulare a
matricei A.
Analog pentru matricea B
⎡ 0 0.5000 -0.3333 0.4082 ⎤

⎢ 0 -0.5000 0.6667 0.4082 ⎥⎥
V =⎢ ;
⎢ 1.0000 0.5000 -0.0000 0.0000 ⎥
⎢ ⎥
⎣ 0 -0.5000 0.6667 0.8165 ⎦
⎡-1.0000 0 0 0 ⎤
⎢ 0 2.0000 0 0 ⎥⎥
L= ⎢
⎢ 0 0 1.0000 0 ⎥
⎢ ⎥
⎣ 0 0 0 -2.0000 ⎦
LUCRAREA 4
Această lucrare îşi propune prezentarea unor concepte elementare

de grafică în MATLAB în special grafice de funcţii şi generarea de
suprafeţe.
4.2. Elemente de grafică în MATLAB
4.2.1. Grafice 2D.

Presupunem că am efectuat un experiment în care variind o
mărime x de la -5 la 5 cu pasul 0.5 am obţinut următorul şir de valori: -4,
-7, -5, -3, 0, 2, 5, 8, 6, 2, 0, -4, 2, 4, 7, 9, 6, 0, -3, -1, -3. Putem cu
MATLAB să prezentăm un grafic al variaţiei rezultatelor. Pentru aceasta
vom proceda astfel. Vom construi vectorul x al parametrului cu ajutorul
operatorului „:” .
>> x=-5:0.5:5
Vom defini vectorul y al valorilor obţinute:
>> y=[-4,-7,-5,-3,0,2,5,8,6,2,0,-4,2,4,7,9,6,0,-3,-1,-1]
Vom construi graficul dorit utilizând funcţia plot:
>> plot(x,y)
Într-o fereastră specială (fereastra grafică) apare graficul dorit
(Figura 4.1):
Vom completa acest grafic cu un titlu, cu etichete pentru axa Ox

şi Oy, cu indicarea prin text pe grafic al punctului de minim şi de
maxim:
>> title ('EXEMPLUL 1')
>> xlabel('VARIATIA PARAMETRULUI X')
>> ylabel('REZULTATE')
>> text(-4.5,-7,'minim')
>> text(2.5,9,'maxim')
La comanda text valorile numerice indică punctul (x,y) poziţia
din fereastra graficului de unde va începe scrierea textului. Pentru
informaţii suplimentare recomandăm capitolul corespunzător din
manualul User Guide (Figura 4.2).
Figura 4.1
Figura 4.2
Funcţia plot are următoarea formă sintactică:

plot(x,y,speclinie) unde:
x şi y sunt vectorii ce definesc punctele de reprezentat;
speclinie este un şir de caractere intre ` ` şi reprezintă tipul liniei ce
uneşte punctele definite de x şi y, markerul cu care se reprezintă punctele
definite de x şi y şi culoarea liniei puse în această ordine.
Tipul de linie poate fi:
simbol Tip linie
- Linie continuă (implicit)
-- liniuţe
: puncte
-. Linie-punct
Marcherul poate fi:

simbol Tip marker
+ Semnul +
o cerc
* asterisc
. punct
x cruce
s pătrat
d romb
^ triunghi cu un vârf în sus
v triunghi cu un vârf în jos
> triunghi cu un vârf la dreapta
< triunghi cu un vârf la stânga
p pentagrama stelată
h hexagrama stelată
Culorile pot fi:
simbol culoare
r roşu
g verde
b albastru
c bleu
m mov
y galben
k negru
w alb
Vom reprezenta acum graficul funcţiei f(x)=x*sin(x) pe

intervalul [-π, π]. Pentru aceasta vom construi cei doi vectori x şi y după
care vom utiliza comanda plot. Vom considera raţia ca fiind 0.01.
Întrucât x este un vector iar sin(x) este tot un vector va trebui să utilizăm
la înmulţire operaţia cu punct (.*).
>> x=-pi:0.01:pi;
>> y=x.*sin(x);
>> plot(x,y,’-xr’);
>> title('Graficul funcţiei x*sin(x)');
>> xlabel('x');
>> ylabel('x*sin(x)');
Graficul obţinut este prezentat în figura 4.3.
Remarcaţi faptul că am pus la sfârşitul definirii lui x ; care are
rolul de a anula scrierea pe ecran vectorului x. Am făcut acest lucru
pentru a nu umple inutil ecranul cu elementele lui x (nu mai puţin de 629
de elemente). Am procedat la fel şi la definirea lui y (evident tot 629 de
elemente). Recomandăm utilizarea acestui separator pentru a anula
scrierea inutilă a tot felul de numere pe ecran. Însă este util să nu
utilizăm separatorul „;” dacă dorim să depanăm un program.
Figura 4.3
4.2.2. Grafice 3D
Putem reprezenta şi suprafaţa ce reprezintă graficul unei funcţii

de două variabile z=f(x,y).
xi y
f ( x, y ) = 2 pentru x ∈ [ −2, 2] , y ∈ [ −4, 4]
x + y2 +1
Pentru aceasta trebuie să definim mai întâi matricile ce definesc
domeniul de definiţie şi utilizăm apoi comanda surf (figura 4.4).
>> [x,y]=meshgrid([-2:0.2:2],[-4:0.4:4]);
>> z=x.*y./sqrt(x.^2+y.^2+1);
>> surf(x,y,z)
Figura 4.4
Comanda meshgrid are rolul de a transforma domeniile de tip

vector ale lui x şi y în matrici pentru a putea fi utilizate de surf care cere
ca variabilele de intrare să fie matrici.
În locul comenzii surf se pot utiliza comenzile mesh, surfc,
meshc ultimele două desenând pe planul xOy liniile de contur. Dacă se
doresc doar liniile de contur există comenzile contour(x,y,z) şi
contourf(x,y,z) special pentru acest lucru. Ultima dintre ele umple cu
culoare diferenţele de nivel (vezi figura 4.5).
Pentru a le desena graficele pe acelaşi ecran am folosit comanda
subplot(n,m,k) unde n reprezintă numărul de lini de subferestre, m
numărul de coloane de subferestre, iar k numărul ferestrei ce devine

activă. Comenzile au fost:
>> subplot(1,2,1)
>> contour(x,y,z)
>> subplot(1,2,2)
>> contourf(x,y,z)
Figura 4.5
Pentru desenarea de figuri geometrice în spaţiu avem trei
comenzi:
cylinder(y,n) desenează un corp de rotaţie în jurul axei z generat de o
curbă creată de vectorul y şi având n puncte pe circumferinţă. Daca r
este constant atunci desenează o prismă regulată cu baza având n laturi.
Cu ajutorul ei se pot desena şi piramide sau conuri.
sphere(n) o sferă cu n puncte pe circumferinţă.

ellipsoid(xc,yc,zc,rx,ry,rz) generează un elipsoid de centru (xc,yc,zc) şi
semiaxe rx, ry, rz.
4.3. Aplicaţii
Să se reprezinte graficele funcţiilor următoare:

x
y1 = e 2 isin ( 2i x ) ; y2 =
x +1
x −3
2
; ( )
y3 = xisin x 2 + 1 ; y 4 = x 2 + 1i arctg ( x ) ,
definite pe intervalul x ∈ [ −2 , 2] . Reprezentarea se va face:

toate funcţiile pe aceiaşi figură;
fiecare funcţie în figura ei dar toate pe acelaşi ecran.
sin ⎛⎜ x 2 + y 2 ⎞⎟
2. a) Să se reprezinte graficul funcţiei z = ⎝ ⎠ pe
x2 + y2
domeniul x ∈ [ −8 , 8] , y ∈ [ −8 , 8] . Se vor utiliza toate comenzile de
desenare ( mesh, meshc, surf, surfc ), pe acelaşi ecran în figuri diferite.
Discutaţi diferenţele.
b) Să se traseze suprafaţa definită de z = xisin ( x )icos ( y )
pe domeniul dat de x ∈ [ −π , π ] , y ∈ [ −π , π ] şi să se editeze modul de
colorare al suprafeţei.
c) Să se traseze liniile de contur ale celor două grafice de
mai sus în ambele variante de desenare, cele patru desene fiind
reprezentate pe aceiaşi imagine.
3. Să se deseneze următoarele figuri geometrice:

a) un cilindru;
b) un paralelipiped dreptunghic;
c) o piramidă cu baza pătrată;
d) un trunchi de piramidă cu baza hexagonală:
e) un con;
f) un trunchi de con;
g) o suprafaţă de rotaţie generată de funcţia: y = xisin( x) ;
h) o sferă:
i) un elipsoid cu centrul în punctul (0,0,0) si de raze: rx=1, ry=8
şi rz=3.
4. Să se facă următoarele intersecţii de figuri:

a) un cilindru şi un con;
b) un elipsoid de centru (0,0,0.5) şi raze rx=1.5, ry=1 şi rz=0.75
1
cu conul generat de y = i x − 4; pentru x=0:0.5:8.
2
1. a) x=-2:0.1:2; y1=exp(x/2).*sin(2*x); y2=(x-2)./(x.^2+1);

y3=x.*sin(x.^2+1); y4=sqrt(x.^2+1).*atan(x);
plot(x,y1,’r’,x,y2,’b’,x,y3,’g’,x,y4,’m’)
Fig. 4.6
x=-2:0.1:2; y1=exp(x/2).*sin(2*x); y2=(x-2)./(x.^2+1);
y3=x.*sin(x.^2+1); y4=sqrt(x.^2+1).*atan(x); subplot(2,2,1);
plot(x,y1,’r’); subplot(2,2,2); plot(x,y2,’b’); subplot(2,2,3);
plot(x,y3,’g’); subplot(2,2,4); plot(x,y4,’m’)
Fig. 4.7
2. a) x=-8:0.5:8; y=x; [X,Y]=meshgrid(x,y);
Z=sin(sqrt(X.^2+Y.^2+eps))./sqrt(X.^2+Y.^2+eps); surf(X,Y,Z)
Fig. 4.8
b) x=-pi:pi/10:pi; y=x; [X,Y]=meshgrid(x,y);
Z=X.*sin(X).*cos(Y); surf(X,Y,Z);
Fig. 4.9
c) x=-8:0.5:8; y=x; [X,Y]=meshgrid(x,y);

Z=sin(sqrt(X.^2+Y.^2+eps))./sqrt(X.^2+Y.^2+eps); subplot(2,2,1)
contour(X,Y,Z); subplot(2,2,3); contourf(X,Y,Z)
x=-pi:pi/10:pi; y=x; [X,Y]=meshgrid(x,y); Z=X.*sin(X).*cos(Y);
subplot(2,2,2);contour(X,Y,Z); subplot(2,2,4); contourf(X,Y,Z)
Fig.4.10
3. a) cylinder;
b) cylinder
Fig. 4.11
c)x=0:0.2:2; y=x-2; cylinder(y,4);
Fig. 4.12
d) x=0:0.2:2; y=x-3; cylinder(y,6);
Fig. 4.13
e) x=0:0.2:2; y=x-2; cylinder(y,40);
Fig 4.14
f) x=0:0.2:2; y=x-3; cylinder(y,40);
Fig. 4.15
g) x=-pi/2:pi/10:pi/2; y=x.*sin(x); cylinder(y,40);
Fig. 4.16
h) sphere;
Fig. 4.17
ellipsoid(0,0,0,1,8,3).
Fig. 4.18
a) x=0:0.1:2; y=x-2; cylinder(y,50); hold on; cylinder;
Fig. 4.19
b) ellipsoid(0,0,0.5,1.5,1,0.75); hold on; x=0:0.5:8; y=0.5*x-4;

cylinder(y,40)
Fig, 4.20
LUCRAREA 5
Această lucrare îşi propune prezentarea calculului polinomial în

MATLAB, funcţiilor utilizator precum şi rezolvarea ecuaţiilor
polinomiale şi determinarea zerourilor unei funcţii utilizator.
5.2. Polinoame. Funcţii. Ecuaţii
5.2.1.Polinoame în MATLAB
Notaţia obişnuită utilizată la polinoame este una simbolică.

MATLAB utilizează în calcule doar un vector ce are ca elemente
coeficienţii monoamelor. Numărul acestor elemente este cu 1 mai mare
decât gradul polinomului Astfel pentru polinomul x5 − 5 x + 4 MATLAB
utilizează vectorul obţinut cu comanda [1 0 0 0 -5 4]. Se observă faptul
că avem coeficient zero pentru monoamele care lipsesc (cele de grad 4, 3
şi 2). Numărul elementelor vectorului este 6 adică 5+1(5 fiind gradul
polinomului). Se observă faptul că avem la stânga coeficientul
monomului de grad maxim. Dacă rezultă din diverse calcule (specifice
polinoamelor ) vectorul -2 0 -1 5 0 4 -2 acesta reprezintă polinomul:
−2 x 6 − x 4 + 5 x 3 + 4 x − 2 .
Manipularea polinoamelor în MATLAB se face prin intermediul
mai multor funcţii aplicate asupra vectorilor coeficienţilor, funcţii pe
care le prezentăm în continuare.
Înmulţirea a două polinoame se face cu funcţia conv:

w=conv(u,v)
unde u si v sunt vectorii coeficienţilor polinoamelor care se înmulţesc,
iar w este vectorul coeficienţilor polinomului produs. Astfel dacă p este
vectorul coeficienţilor polinomului x 7 + x 6 − 4 x5 + 6 x 4 − x3 − x 2 + 4 x − 6
adică p=[1 1 -4 6 -1 -1 4 6], iar q vectorul coeficienţilor polinomului
x3 − x 2 − 7 x + 15 . adică q=[1 -1 -7 15] , atunci conv(p,q) va da ca
rezultat vectorul 1 0 -12 18 36 -102 102 -18 -37 102 -90 adică
polinomul produs:
x10 − x8 + 18 x 7 + 36 x 6 − 102 x5 + 102 x 4 − 18 x3 − 37 x 2 + 102 x − 90 .
Împărţirea a două polinoame se face cu funcţia deconv:

[c,r]=deconv(p,q)
unde c este vectorul coeficienţilor câtului, iar r este vectorul
coeficienţilor restului. Astfel dacă vrem să împărţim polinomul p la q
(definite mai sus) trebuie scrisă comanda deconv astfel:
>> [c,r]=deconv(p,q)
c=
1 2 5 10 14
r=
0 0 0 0 0 8 -48 -216
Deci câtul este polinomul x 4 + 2 x3 + 5 x 2 + 10 x + 14 iar restul este
polinomul 8 x 2 − 48 x − 216 .
Determinarea rădăcinilor unui polinom se face cu ajutorul

funcţiei roots. De exemplu putem determina rădăcinile polinoamelor p şi
q de mai sus:
>> roots(p)
ans =
-3.0000
-1.0000
1.0000 + 1.0000i
1.0000 - 1.0000i
-0.0000 + 1.0000i
-0.0000 - 1.0000i
1.0000
>> roots(q)
ans =
-3.0000
2.0000 + 1.0000i
2.0000 - 1.0000i
Determinarea unui polinom ale cărui rădăcini sunt elementele

unui vector v se face cu funcţia w=poly(v). În w se vor afla coeficienţii
polinomului căutat. De exemplu dacă v=[1 1 -2] atunci:
>> poly(v)
ans =
1 0 -3 2
Deci polinomul căutata este x3 − 3x + 2 .
Determinarea valorii polinomului reprezentat de vectorul
coeficienţilor v, într-un punct x0 se face cu funcţia polyval(v,x0). De
exemplu valoarea polinomului p în -2 este:
>> polyval(p,-2)
ans =
162
Derivata unui polinom p este polinomul ai cărui coeficienţi sunt

daţi de funcţia polyder(p), de exemplu:
polyder(p)
ans =
7 6 -20 24 -3 -2 4
Adică polinomul: 7 x 6 + 6 x5 − 20 x 4 + 24 x3 − 3 x 2 − 2 x + 4
Dacă se doreşte determinarea unui polinom de un anumit grad

care să aproximeze un set de date experimentale în sensul metodei celor
mai mici pătrate se utilizează funcţia w=polyfit(x,y,n) unde w este
vectorul coeficienţilor polinomului căutat, vectorii x şi y sunt vectorii
datelor experimentale iar n este gradul polinomului căutat. De exemplu
dacă x=0:pi/10:pi,iar y=sqrtx(x) atunci polinomul de gradul 4 ce
aproximează setul de date este dat de
>> polyfit(x,y,4)
ans =
-0.2969 1.4531 -2.5609 2.3776 0.0183
Adică polinomul:
−0.2969 x 4 + 1.4531x3 − 2.5609 x 2 + 2.3776 x + 0.0183 .
pentru aflarea valorilor prin interpolare polinomială se utilizează funcţia

interp1(x,y,x0, ‚metoda’) unde x,y sunt vectorii datelor experimentale.
X0 este punctul în care vrem să aflăm valoarea, iar metoda este: nearest,
linear, spline şi cubic ultimele două luând mai mult timp de calcul dar
fiind mai precise astfel pentru datele x şi y de la G, utilizând cele 4
metode în punctul 1.1 obţinem:
>> interp1(x,y,1,'nearest')
ans =
1
>> interp1(x,y,1.1,'nearest')
ans =
1.0954
>> interp1(x,y,1.1,'linear')
ans =
1.0477
>> interp1(x,y,1.1,'spline')
ans =
1.0489
>> interp1(x,y,1.1,'cubic')
ans =
1.0488
>> sqrt(1.1)
ans =
1.0488
Ultima valoare este valoarea exactă şi se observă faptul că
ultimele două metode sunt mai precise.
5.2.2.Funcţii utilizator
Pentru definirea funcţiilor utilizator cu expresii mai complexe,

sau mai des utilizate se recomandă definirea cu function lucru cel vom
face într-o lucrare ulterioară. Pentru funcţii mai simple sau utilizate
temporar se recomandă definirea cu funcţia inline. Această funcţie este
specifică pachetului MATLAB negăsindu-se în nici un alt limbaj de
programare. Putem definii astfel funcţia utilizator
sin x
g ( x) = astfel
sin x + cos x + 4
>> g=inline('sin(x)./(sin(x)+cos(x)+4)')
g=
Inline function:
g(x) = sin(x)./(sin(x)+cos(x)+4)
Dacă dorim să facem graficul unei funcţii utilizator utiliză funcţia

fplot(numef,limite,specl) unde limite este un vector cu 2 sau 4 valori
indicând limitele pentru x(2valor) şi eventual y(daca sunt 4 valori),iar
specl este specificatorul de linie acelaşi ca la comanda plot(vezi
laboratorul 4). Exemplu pentru g definit anterior
>> fplot(g,[-pi,pi],'r')
Fig.5.1
Pentru determinarea valorii minime a unei funcţii pe un interval
utilizăm funcţia fminbnd(numef,xmin,xmax) unde [xmin,xmax] indică
intervalul în care căutăm valoarea minimă. Pentru g de mai sus pe
intervalul [-2,2]:
>> fminbnd(g,-2,2)
ans =
-1.8235
C. Pentru calculul integralei definite se utilizează funcţia

quad(numef,a,b), unde a şi b sunt limitele între care se integrează. Pentru
g de mai sus:
>> quad(g,-pi/4,pi)
ans =
0.3589
π
sin x
Adică ∫π sin x + cos x + 4 dx ≈ 0.3589 . Putem calcula integrale duble sau
−
4
triple cu funcţiile dblquad(numef,ax,bx,ay,by) sau

triplequad(numef,ax,bx,ay,by,az,bz). De exemplu:
>> gdbl=inline('(x+5*y)./(x.^2+y.^2+0.1)')
gdbl =
Inline function:
gdbl(x,y) = (x+5*y)./(x.^2+y.^2+0.1)
>> dblquad(gdbl,0,1,-2,2)
ans =
1.8241
>> gtriple=inline('x.*y.*z./(x.^2+2*y.^2+3*z.^2+0.1)')
gtriple =
Inline function:
gtriple(x,y,z) = x.*y.*z./(x.^2+2*y.^2+3*z.^2+0.1)
>> triplequad(gtriple,0,3,0,2,0,1)
ans =
0.5371
x + 5y
Deci: ∫∫ 2 dx dy ≈ 1.8241 pentru xmin=0, xmax=1, ymin=-2,
x + y 2 + 0.1
xyz
ymax=2 şi ∫∫∫ x 2
+ 2 y + 3 z 2 + 0.1
2
dxdydz ≈ 0.5371 pentru
xmin=0,xmax=3,ymin=0,ymax=2,zmin=0,zmax=1.
Pentru calculul zerourilor(rădăcinilor) unei funcţii putem utiliza

funcţia fzero(numef, x0) această funcţie calculează o rădăcină a funcţiei
cea mai aproape de x0. De exemplu:
>> gx=inline('(x.^2-1).*sin(3*x)')
gx =
Inline function:
gx(x) = (x.^2-1).*sin(3*x)
>> fzero(gx,1.5)
ans =
1.0472
>> fzero(gx,0.9)
ans =
1.0000
5.3. APLICAŢII
Fie polinoamele:
P[ x] = x5 − 7 x3 − 8 x 2 + 2 x + 12 ;
Q [ x] = x4 − 5x2 + 4 ;
T [ x ] = x6 + 4 x 4 − x 2 − 4
Să se determine produsul P[x]*T[x]*Q[x] ;
Să se determine câtul şi restul împărţirii P[x]:Q[x] şi T[x]:Q[x];
Să se determine rădăcinile polinoamelor P[x], Q[x] şi T[x].
2.a) Să se determine polinomul S[x] ale cărui rădăcini sunt:

x1=1, x2=-2, x3=3, x4=-4, x5=5.;
b) Să se afle valorile S(2), S(0) şi S(-7);
c) Să se afle valorile S’(1), S’(0) şi S’(-1).
Fie x = 0 : π 10 : π şi y=sin(x).
a) Să se determine polinomul P4[x] de gradul 4 care aproximează datele
din vectorii x şi y.
b) Să se compare valorile P4 [π 2] cu valoarea exactă sin(π 2) );
c) Să se calculeze utilând toate tipurile de interpolare valoarea în
π 2.
a) Să se reprezinte graficele funcţiilor f(x)=x*sin(x) şi g=ln(1+sin(x)) pe

[ −π , π ] utilizând funcţia fplot.
x 4 − 5i x 2 + 4
b) Să se determine minimumul funcţiei f ( x) = pe
x6 + 4
intervalul [-3, 0];
c) Să se determine maximumul aceleiaşi funcţii pe intervalul [-1,
1];
π
1 3
d) Să se calculeze ∫ f ( x) dx şi ∫ sin( x) * g ( x) dx ;
−1 π
−
3
x2
e) Să se calculeze ∫∫ y 2 + 1 dxdy pentru xmin=0, xmax=1,
ymin=0, ymax=1;
dxdydz
f) Să se calculeze ∫∫∫ x + y + z +1
pentru xmin=ymin=zmin=0,
xmax=ymax=zmax=1.
5. Să se rezolve ecuaţiile:
a) xisin( x) + cos( x) = 0 pentru valoarea iniţială x=1;
( )
b) x 2 i x 2 + 3 + xiln x 2 + 1 − 2 − ln 2 = 0 , x=0.5;
c) Să se reprezinte grafic funcţia f ( x ) = ( x − 1)ie x isin( x) + x3 − x şi apoi

să se determine toate rădăcinile pe intervalul [-2, 2].
5.4. Indicaţii şi soluţii.
P=[1 0 -7 -8 2 12]; q=[1 0 -5 0 4]; t=[1 0 4 0 -1 0 -4];

conv(conv(p,t),q);
x15 − 8i x13 − 8i x12 − 8i x11 + 20i x10 + 134i x9 + 124i x8 − 137i x7 − 340 ⋅ x6 −
−94i x5 + 76i x 4 + 144i x3 + 320i x 2 − 32i x − 192
[c,r]=deconv(p,q)
c=x; r = −2 ⋅ x3 − 8i x 2 − 2i x + 12 ;
[c1,r1]=deconv(t,q);
c1 = x 2 + 9 ; r1 = 40i x 2 − 40
c) roots(p); x1=3, x2=-2, x3=-1+i, x4=-1-i, x5=1
roots(q); x1=1, x2=-1, x3=2, x4=-2
roots(t); x1=2i, x2=-2i, x3=1, x4=-1, x5=i, x6=-i
2.
a) v=[1 2 3 -4 -5]; s=poly(v);
s ( x ) = x5 + 3i x 4 − 23i x3 − 27 ⋅ x 2 + 166i x − 120
polyval(s,2)=0, polyval(s,0)=-120; polyval(s,-7)=-4320
c) polyval(polyder(s),1)=60; polyval(polyder(s),0)=166,
polyval(polyder(s),-1)=144
3.x=0:pi/10:pi; y=sin(x);
a) p4=polyfit(x,y,4);
P4 ( x ) = 0.0368i x 4 -0.2309i x 3 + 0.0485i x 2 + 0.9874i x+ 0.0002
b) polyval(p4,pi/2)-sin(pi/2)=0.00053993<10-3
c) interp1(x,y,pi/2,’nearest’); 1
interp1(x,y,pi/2,’linear’); 1
interp1(x,y,pi/2,’spline’); 1
interp1(x,y,pi/2,’cubic’); 1
4.
a) fplot(inline(‚x.*sin(x)’),[-pi pi],’r’);
Fig.5.2
fplot(inline('log(1+sin(x))'),[-pi pi],'m');
Fig.5.3
b) fminbnd(inline('(x.^4-5*x.^2+4)./(x.^6+4)'),-3,0) -
1.3072;
c) fminbnd(inline('-(x.^4-5*x.^2+4)./(x.^6+4)'),-1,1) 0;
d) quad(inline('x.*sin(x)'),-1,1); 0.6023
quad(inline('sin(x).*log(1+sin(x))'),-1,1); 0.6750
e) dblquad(inline('x.^2./(y.^2+1)'),0,1,0,1); 0.2618
f) triplequad(inline('1./sqrt(x+y+z+1)'),0,1,0,1,0,1);
0.6428
5.
a) fzero(inline('x.*sin(x)+cos(x)'),1); 2.7984
b) fzero(inline('x.^2.*sqrt(x.^2+3)+x.*log(x.^2+1)-2-
log(2)'),0.5); 1
c) fzero(inline('(x-1).*exp(x).*sin(x)+x.^3-x'),-1); -
1.2255
fzero(inline('(x-1).*exp(x).*sin(x)+x.^3-x'),0.1); 0
fzero(inline('(x-1).*exp(x).*sin(x)+x.^3-x'),0.9); 1
Fig.5.4
Se observă pe grafic faptul că avem rădăcini în apropierea

punctelor -1, 0.1 şi 0.9 pe care le-am utilizat apoi în funcţia fzero.
LUCRAREA 6
Această lucrare îşi propune prezentarea noţiunii de dată simbolică,

definirea variabilelor simbolice,a expresiilor simbolice şi polinoame
simbolice. Apoi sunt prezentate principalele operaţii ce se pot efectua cu
acestea.
6.2. Calcule simbolice cu expresii şi polinoame
În această lucrare introducem un nou tip de date şi anume date de

tip simbolic. Aceste date se declară cu comanda syms sau cu funcţia
sym.
Exemple.
syms x y z
d=sym(2)
În exemplul de mai sus x,y,z sunt declarate ca simboluri, iar d are

valoarea 2 dar este simbol nu număr. Pentru a înţelege deosebirea dintre
2 ca simbol şi doi ca număr prezentăm exemplul următor:
>> 1/2+1/3
ans
0.8333
>> sym(1)/sym(2)+sym(1)/sym(3)
ans =
5/6
Se remarcă faptul că datele numerice duc la rezultate efective, iar

datele simbolice dau un rezultat simbolic(aici o fracţie). Interesant aici
este că forma simbolică este un rezultat exact în timp ce forma numerică
este un rezultat aproximativ deoarece reprezentarea numerică a fracţiei
5/6 are un număr infinit de zecimale după virgulă.
Funcţia collect(p,v) ne ajută să ordonăm în raport cu puterile lui
v o expresie p. Dacă variabila v lipseşte se consideră implicit x.
Exemple:
>> syms x y
>> collect((x+y)*(x^2+y^2+1))
ans =
x^3+y*x^2+(y^2+1)*x+y*(y^2+1)
>> collect((x+y)*(x^2+y^2+1), y)
ans =
y^3+x*y^2+(x^2+1)*y+x*(x^2+1)
Funcţia expand((p) conduce la scrierea expresiei p cu elementele
ei constitutive. Exemple:
>> expand((x-2)*(x-4))
ans =
x^2-6*x+8
>> expand(cos(x+y))
ans =
cos(x)*cos(y)-sin(x)*sin(y)
Se observă că această funcţie calculează produse de

polinoame,dar şi desface expresii trigonometrice,exponenţiale sau
logaritmice.
Funcţia factor(p) factorizează expresia p. Dacă p este un număr
întreg face descompunerea lui p în numere prime. Exemple:
>> factor(x^3-y^3+x^2-y^2)
ans =
(x-y)*(x^2+x+y*x+y+y^2)
>> factor(13482
ans
2 3 3 7 10
>> factor(sym(13482))
ans =
(2)*(3)^2*(7)*(107)
Se remarcă deosebirea de formă a răspunsului dacă se utilizează

funcţia sym sau nu.
Funcţia simplify(p) simplifică expresia p. Exemple:
>> simplify((x^2+x-2)/(x-1))
ans =
x+2
>> simplify(sin(x)^2 + cos(x)^2)
ans
1
Funcţia [n1,n2]=numden(p) calculează p ca o expresie raţională

şi calculează numărătorul n1 şi numitorul n2. Nu face însă şi simplificări
de aceea pentru a afla valoare finală trebuie să utiliză şi funcţia

simplify(n1/n2). Exemple:
>> [n1,n2]=numden(x/(x*y-y^2)-y/(x^2-x*y))
n1 =
x^2-y^2
n2 =
y*(x-y)*x
>> simplify(n1/n2)
ans =
(x+y)/y/x
x2 − y2
Se observă faptul că numden ne dă fracţia: i numai
xy ( x − y )
x+ y
prin simplificare obţinem răspunsul final .
xy
Funcţia [r,cum]=simple(p) caută să determine cea mai simplă
(mai scurtă) formă a unei expresii. În r fa fi această formă simplă găsită
iar în cum metoda,funcţia cu care a fost găsită această formă simplă.
Exemple:
>> [r,cum]=simple(cos(x)^2-sin(x)^2)
r=
cos(2*x)
cum =
combine(trig)
Putem rezolva simbolic o ecuaţie cu ajutorul funcţiei solve. Se
va indica doar eq din ecuaţia eq=0. Acest lucru înseamnă faptul că
trebuie să ducem toţii termenii ecuaţiei în stânga pentru a forma expresia
eq. In funcţia solve se indică doar expresia eq presupunându-se că dorim
să rezolvăm ecuaţia eq=0. Exemplu:
>> solve('x^3-2*t*x^2+t^3')
ans =
t
(1/2*5^(1/2)+1/2)*t
(1/2-1/2*5^(1/2))*t
Dacă dorim să rezolvăm ecuaţia în raport cu altă variabilă decât
cea implicită (adică altă variabilă decât x) trebuie să indicăm acest lucru.
Exemplu:
>> solve('x^3-2*t*x^2+t^3',t)
ans =
x
(1/2*5^(1/2)-1/2)*x
(-1/2-1/2*5^(1/2))*x
6.3. APLICAŢII
1. Să se calculeze simbolic expresiile:
2 4 1
a) + + =
3 5 7
1 1
+
b) 2 3=
1 1
+
5 7
1
c) 1 + =
1
1+
1
1+
1
1+
2
2. a) Să se dezvolte după puterile lui x expresia:

( x − y )i( x 2 + y 2 )i( x 4 − x 2 i y 2 + y 4 ) ;
b) Să se determine polinomul care are rădăcina triplă 2 şi rădăcina
dublă -1;
c) Să se descompună în factori ireductibili polinomul:
( a2 + b2 )i x4 + ( −a3 − aib2 + a2 + b2 − aib )i x3 +

( −a3 − aib2 + a2 * b − 2ia2 − 2ib2 − aib )i x2 +
+ ( 2ia3 + 2iaib 2 + a 2 ib + 2i aib ) • x − 2i a 2 ib
d) Să se reprezinte în funcţie de sin(x) şi cos(x) expresia : sin(6*x)-

cos(6*x)
e) Să se descompună în produse de numere prime întregii 354600 şi
12345678901234567890.
f) Să se descompună în factori ireductibili expresia:
a 6 − a5 ib + a 4 ib 2 − a 2 ib4 + aib5 − b6
3, Să se calculeze expresiile:
1 1
1−
a a + 1− a =
a) +
1 1 a
1−
a 1− a
x3 − y 3 x 2 − y 2 ⎛ 1 1 ⎞
i i⎜ + ⎟
x 2 + y 2 x3 + y 3 ⎜⎝ x 2 y 2 ⎟⎠
b) =
2
( x + y ) − xi y i⎛ 1 − 1 ⎞
⎜ ⎟
( x − y )2 + xi y ⎝ y x ⎠
1 ⎛ 1 1 ⎞ 3 ⎛ 1 1 ⎞ 6 ⎛1 1⎞
c) i + ⎟+ i + ⎟+ i⎜ + ⎟ =
3 ⎜ 3 2 4 ⎜ 2 2
(a + b) ⎝a b ⎠ (a + b) ⎝a b ⎠ ( a + b )5 ⎝ a b ⎠
4. Să se simplifice expresiile:
a) 8icos 4 ( x ) + 8isin( x)icos3 ( x ) − 8icos 2 ( x ) − 4isin( x)icos ( x ) + 1 ;

b) cos(3 i acos(x));
c) a icos(a )icos(b) − a isin(a )isin(b) + bicos(a )icos(b) − bisin(a )isin(b) .
5. Să se rezolve ecuaţiile:
a) x3 + 2iai x 2 − a 2 i x − 2i a3 = 0
b) x 4 − 6ia i x 2 + 8iai a i x − 3i a 2 = 0
( a2 + b2 )i x4 + ( −a3 − aib2 + a2 + b2 − aib )i x3 +

c) + ( − a3 − aib2 + a 2 * b − 2ia 2 − 2ib 2 − aib )i x 2 +
+ ( 2ia3 + 2iaib 2 + a 2 ib + 2i aib ) • x − 2i a 2 ib = 0
6.4. Indicaţii.
1.
a) sym(2)/sym(3)+sym(4)/sym(5)+sym(1)/sym(7)
b) u=sym(1);d=sym(2);t=sym(3);c=sym(5);s=sym(7)
(u/d+u/t)/(u/c+u/s)
c) u+u/(u+u/(u+u/(u+u/d)))
2.
a) expand((x-y)*(x^2+y^2)*(x^4-x^2*y^2+y^4)) sau
collect((x-y)*(x^2+y^2)*(x^4-x^2*y^2+y^4))
b) collect((x-2)^3*(x+1)^2) sau
expand((x-2)^3*(x+1)^2)
c) factor((a^2+b^2)*x^4+(-a*b-(a^2+b^2)*a+a^2+b^2)*x^3+(a^2*b-
a*b-(a^2+b^2)*a-2*a^2-2*b^2)*x^2+(a^2*b+2*a*b+2*(a^2+b^2)*a)*x-
2*a^2*b)
d) expand(sin(6*x)-cos(6*x))
e) factor(sym('354600'))
factor(sym('12345678901234567890'))
f) factor(a^6-a^5*b+a^4*b^2-b^4*a^2+b^5*a-b^6)
(-b+a)*(b+a)*(b^2+a^2)*(b^2-a*b+a^2)
3.
a) [sus,jos]=numden(a/(1-1/a)+(1-1/a)/(1/(1-a))+(1/(1-a))/a)
simplify(sus/jos)
b) [sus,jos]=numden(((x^3-y^3)/(x^2+y^2)*(x^2-
y^2)/(x^3+y^3)*(1/x^2+1/y^2))/(((x+y)^2-x*y)/((x-y)^2+x*y)*(1/y-
1/x)))
simplify (sus/jos)
c)
[sus,jos]=numden(1/(a+b)^3*(1/a^3+1/b^3)+3/(a+b)^4*(1/a^2+1/b^2)+6
/(a+b)^5*(1/a+1/b))
simplify(sus/jos)
4.
a) [r,how]=simple(8*cos(x)^4+8*sin(x)*cos(x)^3-8*cos(x)^2-
4*sin(x)*cos(x)+1)
b) [r,how]=simple(cos(3*acos(x)))
c) simple(simple(a*cos(a)*cos(b)-a*sin(a)*sin(b)+b*cos(a)*cos(b)-
b*sin(a)*sin(b)))
5
a) solve(x^3+2*a*x^2-a^2*x-2*a^3)
b) solve(x^4-6*a*x^2+8*a*sqrt(a)*x-3*a^2)
c) solve((a^2+b^2)*x^4+(-a^3-a*b^2+a^2+b^2-a*b)*x^3+(-a^3-
a*b^2+a^2*b-2*a^2-2*b^2-
a*b)*x^2+(2*a^3+2*a*b^2+a^2*b+2*a*b)*x-2*a^2*b)
6.5. Soluţii.
1.
a) 169/105
b) 175/72
c) 13/8
2.
a) x^7+x*y^6-y*x^6-y^7
b) x^5-4*x^4+x^3+10*x^2-4*x-8
c) (x+2)*(x-1)*(x-a)*(x*a^2+x*b^2-a*b)
d) 32*sin(x)*cos(x)^5-32*sin(x)*cos(x)^3+6*sin(x)*cos(x)-
32*cos(x)^6+48*cos(x)^4-18*cos(x)^2+1
e) (2)^3*(3)^2*(5)^2*(197)
f) (2)*(3)^2*(5)*(101)*(3803)*(3607)*(27961)*(3541)
3.
a) 3
x− y
b)
xi y
1
c)
a 3 * b3
4.
a) r =cos(4*x)+sin(4*x); how = combine
b) r =4*x^3-3*x; how =expand
c) cos(a+b)*(a+b)
5.
a) -a
a
-2*a
b) a^(1/2)
a^(1/2)
a^(1/2)
-3*a^(1/2)
c) 1
-2
a
a*b/(a^2+b^2)
LUCRAREA 7
Această lucrare îşi propune prezentarea calculelor cu matrici

simbolice, rezolvarea sistemelor liniare simbolice, chiar şi a celor
nedeterminate.
7.2. Calcule simbolice în algebra liniară
Unele funcţii simbolice au primit acelaşi nume ca cel pentru

calcule simbolice pentru simplicitate. Astfel determinantul unei matrici
simbolice se calculează tot cu funcţia det. Exemple:
>>syms a b c d;
>>det([a, b; c, d])
ans =
a*d-b*c
>> B = sym([2/3 1/3;1 1]);
>> r = det(B)
r=
1/3
Şi funcţia inv are aceiaşi denumire indiferent de tipul calculului,
numeric sau simbolic. Exemple:
>>inv(A)
ans =
[ d/(a*d-b*c), -b/(a*d-b*c)]
[ -c/(a*d-b*c), a/(a*d-b*c)]
>>inv(B)
ans
[ 3, -1]
[ -3, 2]
Rezolvarea unui sistem nedeterminat este un calcul simbolic şi

acum putem să o facem. Să considerăm sistemul:
⎧ x + y + z =1
⎪
⎨ x − y + 2z = 2
⎪ 2 y − z = −1
⎩
Definim acum matricea coeficienţilor necunoscutelor

şi vectorul termenilor liberi:
>> A=[1 1 1;1 -1 2;0 2 -1]
A=
1 1 1
1 -1 2
0 2 -1
>> B=[1;2;-1]
B=
1
2
-1
Construim şi matricea extinsă:

>>Aext[A B];
Comparăm rangul matricei A a coeficienţilor necunoscutelor cu rangul
matricei extinse Aext.
>> rank(A)
ans =
2
>> rank(Aext)
ans =
2
Deoarece rangurile acestor două matrici sunt egale sistemul este
compatibil (adică are soluţie). Deoarece valoarea comună a acestor două
ranguri (şi anume 2) este mai mică decât numărul necunoscutelor (şi
nume 3) rezultă că sistemul este nedeterminat (adică are o infinitate de
soluţii).
Rezolvarea problemei continuă cu considerarea unei submatrice
(notată A1) a matricei A submatrice de ordin egal cu rangul lui A (adică
2 în cazul dat) şi care să aibă acelaşi rang cu A (deci 2). O astfel de
submatrice este cea formată de coeficienţii lui x şi y din primele două
ecuaţii:
>> A1=[1 1;1 -1]

A1 =
1 1
1 -1
Vectorul coloană al termenilor liberi corespunzător ecuaţiilor

intrate în submatrice (aici primele două ecuaţii) se obţine din scăderea
coloanelor necunoscutelor secundare (cele care nu au coeficienţi în
submatrice, aici doar z) privite acum ca si simboluri, din elementele

vectorului termenilor liberi. Deci:
>> syms z
>> B1=[1-z;2-2*z]
B1 =
1-z
2-2*z
Soluţia simbolică a sistemului se obţine acum simplu:
>> x=A1\B1
x=
3/2-3/2*z
-1/2+1/2*z
⎧ 3
⎪ x = 2 (1 − α )
⎪
⎪ 1
Sau, altfel scris: ⎨ y = − (1 − α ) α ∈ R
⎪ 2
⎪ z =α
⎪
⎩
Pentru a substitui unele valori simbolice cu altele se utilizează

funcţia subs;
R=subs(exprsimb,old,new)
Unde R va conţine rezultatul substituţiei, old lista simbolurilor de
înlocuit în ordinea primei lor apariţii (nu este obligatoriu) în expresia
simbolică pusă între acolade,iar new lista corespunzătoare a valorilor
noi, în corespondenţă de 1 la 1 cu simbolurile din lista old, tot între
acolade. R este tot o expresie simbolică.
De exemplu în sistemul nedeterminat de mai sus putem înlocui

simbolul z cu valoarea sum(2):
>> subs(x,z,sym(2))
ans =
-3/2
1/2
În schimb dacă înlocuim pe z cu valoarea numerică 2 obţinem:

>> subs(x,z,2)
ans =
-1.5000
0.5000
În exemplul de mai sus nu a fost nevoie de acolade pentru că a
fost un singur argument. Dacă însă avem mai multe substituţii acoladele
sunt obligatorii:
>> subs(x+y+z,{x,z},{2,-4})
ans =
-2+y
7.3. APLICAŢII
1.
a) Fie polinomul P [ X ] = X 2 − ( a + d )i X + ( aid − bic ) * I 2 unde X este
⎡1 0 ⎤
o matrice pătrată de ordinul 2 , iar I 2 = ⎢ ⎥ . Să se calculeze P[A],
⎣0 1 ⎦
⎡a b ⎤
unde A = ⎢ ⎥ . Analog să se calculeze R[B] pentru polinomul R[X],
⎣c d ⎦
şi matricea B date de:
R [ X ] = X 2 − 2i( a + 2ib )i X + ( a − b )i( a + 5ib )i I 6
⎡a b b b b b⎤
⎢b a b b b b ⎥⎥
⎢
⎢b b a b b b⎥
B=⎢ ⎥
⎢b b b a b b⎥
⎢b b b b a b⎥
⎢ ⎥
⎢⎣ b b b b b a ⎥⎦
b) Să se calculeze inversele matricelor:
⎡1 0 0 0 0 b⎤
−a 0 ⎢ 0 ⎥⎥
⎡1 0⎤ ⎢0 1 0 0 0
⎢0 1 −a 0 ⎥⎥ ⎢ −a 0 1 0 0 0⎥
C=⎢ ; D=⎢ ⎥
⎢0 0 1 −a ⎥ ⎢ 0 −a 0 1 0 0⎥
⎢ ⎥ ⎢0
⎣0 0 0 1⎦ 0 −a 0 1 0⎥
⎢ ⎥
⎣⎢ 0 0 0 −a 0 1 ⎦⎥
2.
a) Să se arate că determinanţii matricelor C şi D definite la punctul 1 b)
sunt egali.
b) Să se scrie sub formă de produs determinantul matricei B definită la
1a) şi să se deducă de aici care sunt condiţiile ca determinantul să fie
nenul.
3. Să se rezolve sistemele nedeterminate:
⎧x + y +t −u =1
⎪
a) ⎨ x + z + 2it + u = 2 ;
⎪x −t +u = 0
⎩
⎧ x1 − x2 + 2i x3 + 3i x4 + 5i x5 = 2
⎪
⎪2i x1 − 2i x2 + x3 − 4i x5 = 0
⎪
b) ⎨−3i x1 + x2 − 2i x3 − 2i x4 = 1 ;
⎪− x + 2i x − 2i x + 3i x + 3i x = 3
⎪ 1 2 3 4 5
⎪⎩ − 2i x2 + x3 + x4 + x5 = 3
⎧ 3i x + y − 2i z + 4it − u = 10
⎪ 2i x + 3i y − z + t + 4iu = 20
⎪⎪
c) ⎨ x − 4i y + 6i z − 2it − u = −2
⎪ −3i x − 3i y + 9i z − 9it + 5iu = 7
⎪
⎪⎩ 4i x − 18i y + 31i z − 13it = 9
4 . Să se determine valorile numerice ale expresiilor pentru valorile
indicate:
a 3 + b3 − c 3
a) pentru a=3, b=-1 şi c=1;
a 2bc + ab 2 c + abc 2
b) x 2 ln ( z 2 + 1) + x3 z − xz 2 pentru x=2şi z=-2;
sin x + cos 2 y + 1
c) pentru x=π/3 şi y=π/6.
cos y + sin 2 x + 1
7.4. Indicaţii
1.
a) syms a b c d
A=[a b;c d]
collect(A^2-(a+d)*A+(a*d-b*c)*eye(2))
syms a b
B=b*ones(6)+(a-b)*diag(ones(1,6))
expand(B^2-2*(a+2*b)*B+(a-b)*(a+5*b)*eye(6))
b) C=diag(ones(1,4))-a*diag(ones(1,3),1)
inv(C)
D=-a*diag(ones(1,4),-2)+diag(ones(1,6))
D(1,6)=b
inv(D)
2.
a)det(C)
det(D)
b) factor(det(B))
3.
a)Necunoscute principale x y z şi secundare(simboluri) t şi u

syms t u
A=[1 1 0;1 0 1;1 0 0]
B=[1-t+u;2-2*t-u;t-u]
x=A\B
b) Necunoscute principale x1, x2, x3, x4 şi x5 secundară

A=[1 -1 2 3;2 -2 1 0;-3 1 -2 -2;-1 2 -2 3]
B=[2-5*t;4*t;1;3-3*t]
x=A\B
c) Rangul este 3 deci necunoscute principale 3 adică x, y şi z, iar

secundare t şi u.
A=[3 1 -2;2 3 -1;1 -4 6]
B=[10-4*t+u;20-t-4*u;-2+2*t+u]
x=A\B
4. syms a b c x y z
a)
>> u=(a^3+b^3-c^3)/(a^2*b*c+a*b^2*c+a*b*c^2)
u=
(a^3+b^3-c^3)/(a^2*b*c+a*b^2*c+a*b*c^2)
>> subs(u,{a,b,c},{3,-1,1})
b)
>> v=x^2*log(z^2+1)+x^3*z-x*z^2
v=
x^2*log(z^2+1)+x^3*z-x*z^2
>> subs(v,{x,z},{2,-2})
c)
>> w=(sin(x)+sqrt((cos(y))^2+1))/(cos(x)+sqrt((sin(y))^2+1))
w=
(sin(x)+(cos(y)^2+1)^(1/2))/(cos(x)+(sin(y)^2+1)^(1/2))
>> subs(w,{x,y},{pi/3,pi/6})
7.5. Soluţii
1.
⎡0 0 0 0 0 0⎤
⎢0 0 0 0 0 0 ⎥⎥
⎢
⎡0 0⎤ ⎢0 0 0 0 0 0⎥
a) ⎢ ⎥ ; ⎢ ⎥;
⎣0 0⎦ ⎢0 0 0 0 0 0⎥
⎢0 0 0 0 0 0⎥
⎢ ⎥
⎢⎣ 0 0 0 0 0 0 ⎥⎦
⎡1 − a 2 ib 0 −aib 0 −b ⎤
⎢ ⎥
⎡1 a a2 a3 ⎤ ⎢ 0 1 0 0 0 0 ⎥
⎢ ⎥ ⎢ ⎥
⎢ 2⎥ ⎢ a − a3 ib 1 − a 2 ib 0 − aib ⎥
b) ⎢ 0 1 a a ;
⎥ ⎢
a⎥ ⎢0 a 0 1 0 0 ⎥
⎢0 0 1 ⎥
⎢0 0 0 1 ⎥⎦ ⎢ a 2 − a 4 ib a − a3 ib 1 2 ⎥
−a ib
⎣
⎢ ⎥
⎢⎣ 0 a2 0 a 0 1 ⎥⎦
2.
a) 1
5
b) (a + 5ib) * ( a − b ) deci a ≠ b a ≠ −5ib
3.
⎧x = α − β
⎪ y = −2iα + 2i β + 1
⎪⎪
a) ⎨ z = −3iα + 2 ; α, β ∈ R
⎪t = α
⎪
⎪⎩u = β
⎧ 32 64
⎪ x1 = − 33 + 33 iα
⎪
⎪ x = − 15 − 14 iα
⎪ 2 11 11
⎪
⎪ 26 80
b) ⎨ x3 = − − iα ; α ∈ R
⎪ 33 33
⎪ 35 37
⎪ x4 = 33 − 33 iα
⎪
⎪ x5 = α
⎪⎩
⎧ x = -16/17iα +10/3+11/51i β
⎪ y=10/17iα +16/3-94/51i β
⎪⎪
c) ⎨z=15/17iα +8/3-56/51i β ; α,β ∈ R
⎪ t=α
⎪
⎪⎩u=β
4.
a)
ans =
-2.7778
b)
ans =
-17.5622
c)
ans =
1.3528
LUCRAREA 8
Această lucrare îşi propune prezentarea utilizării calcului

simbolic în analiza matematică: limite, derivate, integrale, grafice de
funcţii. De asemenea prezintă reprezentarea grafică a funcţiilor
simbolice.
8.2. Calcule simbolice cu funcţii
Putem calcula limita unei funcţii într-un punct cu ajutorul

funcţiei limit. Aceasta are mai multe forme pe care le vom prezenta aici.
Primul mod de calcul foloseşte forma limit(numef) unde numef
este o expresie simbolică a unei funcţii de variabilă x, sau numele unei
astfel de funcţii. Limita se calculează în 0. Exemplu:
>> syms x
>> limit(sin(x)/x)
ans =
1
Pentru a indica faptul că dorim limita în alt punct trebuie ca după
expresia simbolică (sau numef) să indicăm valoarea către care tinde x.
Exemplu:
>> limit((x^2-1)*log(x),2)
ans =
3*log(2)
Putem calcula şi limite al căror rezultat este ±∞. Exemplu:
>> limit(1/(x-1)^2,1)
ans =
Inf
De asemenea putem calcula limite laterale indicând ‚left’ pentru
stânga, respectiv ‚right’ pentru dreapta. Trebuie însă indicate variabila
(de obicei x) , punctul în care se calculează limita laterală şi care limită
laterală se doreşte. Exemplu:
>> limit(1/x,x,0,'left')
ans =
-Inf
În acest din urmă mod se pot calcula limitele în care variabila
tinde la ±∞. Exemplu:
>> limit((2-x-x^2)/(x^2+1),x,inf,'left')
ans =
-1
>> limit((1-x^3)/(x^2+1),x,-inf,'right')
ans =
Inf
Funcţia derivată a unei funcţii date se obţine cu funcţia diff.
Variabila de derivat este considerată implicit x. Exemplu:
>> diff(x^5*log(x^2+1))
ans =
5*x^4*log(x^2+1)+2*x^6/(x^2+1)
Se pot calcula şi derivate de ordin superior indicând ca argument
al lui diff ordinul derivatei. Astfel dacă dorim derivata de ordin 3 pentru
funcţia de mai sus obţinem:
>> diff(x^5*log(x^2+1),3)
ans =
60*x^2*log(x^2+1)+150*x^4/(x^2+1)-
72*x^6/(x^2+1)^2+16*x^8/(x^2+1)^3
Pentru a calcula derivata în funcţie de altă variabilă decât x se va
indica acest lucru ca argument al funcţiei dis între apostroafe. Exemplu:
>> diff(t*sin(t^2+1),'t')
ans =
sin(t^2+1)+2*t^2*cos(t^2+1)
Putem utiliza faptul că putem deriva în raport cu altă variabilă
∂3 f
decât x la calculul derivatelor parţiale. Astfel pentru funcţia
∂ 2 x∂y
f ( x, y ) = x 3 ⋅ sin y se va calcula astfel:
>> diff(diff(x^3*sin(y),2),'y')
ans =
6*x*cos(y)
sau
>> diff(diff(x^3*sin(y),'y'),2)
ans =
6*x*cos(y)
Vom calcula primitiva unei funcţii cu ajutorul funcţiei int. De
exemplu:
>> int(5*x^4*log(x^2+1)+2*x^6/(x^2+1))
ans =
x^5*log(x^2+1)
Se observă faptul că funcţiile int şi diff sunt inverse. Putem
calcula şi integrale definite indicând limitele de integrat (care pot fi
simboluri):
>> int(3*x^2,sin(t),cos(t))
ans =
cos(t)^3-sin(t)^3
Acest lucru ne permite să facem diverse calcule complexe ca de

exemplu să calculăm ∫(∫
1
sin t )
3 ⋅ x 2 dx dt
>> int(int(3*x^2,sin(t),1),t)
ans =
t+1/3*sin(t)^2*cos(t)+2/3*cos(t)
Pentru reprezentarea grafică 2D a funcţiilor simbolice se
utilizează comanda ezplot. Daca f este o expresie simbolică ce conţine o
singură variabilă simbolică atunci comanda :
ezplot(f,[xmin,xmax,ymin,ymax]) cu xmin<x<xmax şi
ymin<f(x)<ymax.
Dacă nu se indică limitele atunci se consideră ca interval de
definiţie implicit [-2π, 2π]. Pentru funcţii implicite de forma
g(x,y)=0,adică expresia lui g conţine două variabile simbolice se
utilizează aceiaşi comandă De exemplu
>> syms x y
>> f=(x^4-1)*exp(-x);
f=
(x^4-1)*exp(-x)
>> ezplot(f,[-2,2])
>> g=x^2-y^4
g=
x^2-y^4
>> ezplot(g,[-2,2])
Fig.8.1
Fig.8.2
Pentru reprezentarea grafică a suprafeţei generate de funcţia

z=f(x,y) se utilizează funcţia ezsurf:
ezsurf(f,[xmin,xmax,ymin,ymax]) cu xmin<x<xmax şi
ymin<f(x)<ymax.
De exemplu:
>> f=x*sin(y)
f=
x*sin(y)
>> ezsurf(f)
Fig.8.3
8.3. APLICAŢII
1.Să se calculeze limitele:
x3 + 1 x +1 −1 1 − cos x ln(1 + x)
a) lim ; b) lim ; c) lim ; d) lim .
x →−1 x 2 + 1 x →0 3 x + 1 − 1 x →0 2 x →0 x
x
2. Să se calculeze limitele:
x
x3 − 1
⎛ x −1 ⎞
a) lim
x →+∞
( )
x + a − x ; b) lim
3
x →−∞ x + 1
; c) lim ⎜ ⎟ ;
x →∞ ⎝ x + 1 ⎠
d) lim
(
ln 1 + e x ).
x →∞ x
3. Să se calculeze:
( )
a) f’(x) dacă f ( x ) = 2i xisin x − x 2 − 2 icos ( x ) ;
b) f’’(x) dacă f ( x ) = e x iarcsin x ;
x5
c) f’’’(x) dacă f ( x ) = .
ex
∂2 f
d) dacă f ( x, y ) = 3 ⋅ x3 ⋅ sin x + y ⋅ e x⋅ y
∂x∂y
4. Să se calculeze primitivele funcţiilor:
3 x2
a) f ( x ) = x 2 ie x ; b) f ( x ) = e a i x i sin ( bi x ) ; c) f ( x ) = ;
x 2 − 6i x + 10
x2
d) f ( x ) = .
10
( x − 1)
⎛ x2 ⎞
5. Să se arate că funcţia f ( x ) = ⎜ + x + 1⎟ie x − x − 1 este soluţie a
⎜ 2 ⎟
⎝ ⎠
ecuaţiei diferenţiale:
yiv − 2i yiii + y ii = e x
6. Să se reprezinte grafic funcţiile:

a) f ( x) = ( x 2 − 1) sin x x ∈ [ −2, 2] Să se precizeze apoi numărul de
rădăcini al funcţiei f de pe acest interval.
b) funcţia implicită g ( x, y ) = x 2 sin y + y ln ( x ) = 0 .
c) h ( x, y ) = ( x 2 − 1) sin y .
8.4. Indicaţii
syms x y t a b h
1.
a) limit((x^3+1)/(x^2+1),-1)
b) limit((sqrt(x+1)-1)/((x+1)^(1/3)-1))
c) limit((1-cos(x))/x^2)
d) limit(log(1+x)/x)
2.
a) limit(sqrt(x+a)-sqrt(x),x,inf,'left')
b) limit((x^3-1)/(x^3+1),x,-inf,'right')
c) limit(((x-1)/(x+1))^x,x,inf,'left')
d) limit(log(1+exp(x))/x,x,inf,'left')
3.
a) diff(2*x*sin(x)-(x^2-2)*cos(x))
b) diff(exp(x)*asin(x),2)
c) diff(x^5/exp(x),3)
d) diff(diff(3*x^3*sin(x)+y*exp(x*y)),’y’)
4.
a) int(x^2*exp(x^3))
b) int(exp(a*x)*sin(b*x))
c) int(x^2/(x^2-6*x+10))
d) int(x^2/(x-1)^10)
5.
d2f=diff((x^2/2+x+1)*exp(x)-x-1,2)
d3f=diff((x^2/2+x+1)*exp(x)-x-1,3)
d4f=diff((x^2/2+x+1)*exp(x)-x-1,4)
collect(d4f-2*d3f+d2f)
6.
a)
>>f=(x^2-1)*sin(2*x)
>> ezplot(f,[-2,2])
Numărul rădăcinilor este dat de numărul intersecţiilor axei Ox cu
graficul lui f.
b)
>> g=x^2*sin(y)+y*log(x)
>> ezplot(g)
c)
>> h=(x^2-1)*sin(y)
>> ezsurf(h)
8.5. Soluţii
1.
a) 0
3
b)
2
1
c)
2
d) 1
2.
a) 0
b) 1
c) e−2
d) 1
3.
a) 2*sin(x)+(x^2-2)*sin(x)
b) exp(x)*asin(x)+2*exp(x)/(1-x^2)^(1/2)+exp(x)/(1-x^2)^(3/2)*x
c) 60*x^2/exp(x)-60*x^3/exp(x)+15*x^4/exp(x)-x^5/exp(x)
d) 2*y*exp(x*y)+y^2*x*exp(x*y)
4.
a) 1/3*exp(x^3)
b) -b/(a^2+b^2)*exp(a*x)*cos(b*x)+a/(a^2+b^2)*exp(a*x)*sin(b*x)
c) x+3*log(x^2-6*x+10)+8*atan(x-3)
d) -1/4/(x-1)^8-1/9/(x-1)^9-1/7/(x-1)^7
6 a) 5 rădăcini
Fig.8.4
LUCRAREA 9
Această lucrare îşi propune prezentarea operatoriilor logici şi

relaţionali, modul de creare al expresiilor logice şi modul de utilizare al
acestora. De asemenea se precizează accesarea indexată a elementelor
matricelor.
9.2. Operatori relaţionali şi logici.
Operatorii relaţionali şi logici sunt utilizaţi la crearea expresiilor

logice necesare fluxului unui program scris în MATLAB. O
caracteristică comună a acestor operatori este tipul de date de intrare şi
de ieşire. Astfel, ca date de intrare sunt acceptate doar datele numerice şi
sunt interpretate astfel: orice număr diferit de 0 este interpretat drept
valoarea logică „adevărat” (A), iar valoarea 0 drept valoarea logică
„fals” (F). Datele de ieşire nu pot fi decât numerele 1 sau 0, interpretate
ca fiind valorile logice A, respectiv F.
În MATLAB sunt definiţi 6 operatori relaţionali:
Operator relaţional Semnificaţie

< Mai mic

<= Mai mic sau egal
> Mai mare
>= Mai mare sau egal
== egal
~= diferit
Operatorii relaţionali pot fi folosiţi pentru a compara:

Două matrici de aceiaşi dimensiune. În acest caz rezultatul este
tot o matrice de aceiaşi dimensiune cu matricele de comparat.
Compararea se face element cu element. Dacă elementele
corespunzătoare verifică această condiţie atunci în matricea rezultat
elementul corespunzător va fi 1. Dacă această condiţie nu este verificată
atunci elementul corespunzător va fi 0.
O matrice cu un scalar. În acest caz rezultatul este tot o matrice
de dimensiunea matricei de comparat, iar compararea se face prin
compararea fiecărui element al matricei cu scalarul dat.
Vom considera matricele A şi B definite prin:
>> A=[1 0 -2 10 0;-5 30 -10 0 1;2 0 1 1 1;-1 3 2 0 0]
A=
1 0 -2 10 0
-5 30 -10 0 1
2 0 1 1 1
-1 3 2 0 0
>> B=2*A
B=
2 0 -4 20 0
-10 60 -20 0 2
4 0 2 2 2
-2 6 4 0 0
Vom determina elementele pozitive ale lui A şi elementele lui A

egale cu elementele lui B astfel:
>> A>0
ans =
1 0 0 1 0
0 1 0 0 1
1 0 1 1 1
0 1 1 0 0
>> A==B
ans =
0 1 0 0 1
0 0 0 1 0
0 1 0 0 0
0 0 0 1 1
In ambele matrici ce au rezultat pe poziţiile elementelor cu

valoarea 1 sunt elemente ce verifică aceste condiţii.
În lucrarea 2 am precizat faptul că indicii de accesare a unui
element dintr-o matrice pot fi nu numai scalari ci şi vectori şi chiar
matrici. Cum rezultatul unei comparaţii cu operatorii relaţionali este o
matrice, rezultă că putem utiliza în principiu o comparaţie pentru a
accesa elementele unei matrici. Acest tip de accesare se numeşte
indexare logică. Rezultatul este un vector cu acele elemente ale matricei

ce verifică această condiţie. De exemplu dacă dorim să obţinem
elementele lui A mai mari ca 5 vom scrie:
>> A(A>5)
ans =
30
10
Doar două elemente ale lui A sunt mai mari ca 5: 30 şi 10.
Observaţie. Există mai multe posibilităţi pentru a accesa toate
elementele lui A. Prima ar fi să utilizăm o matrice cu toate elementele 1,
adică o condiţie adevărată pentru fiecare element, drept indice. De
exemplu să dăm comanda A(A==A). Alta ar fi să utilizăm operatorul :
(revezi lucrarea 2), A(:). Recomandăm a doua metodă ca fiind mai scurtă
şi mai rapidă.
Operatorii logici constituie o cale de a defini expresii logice( cu
ajutorul operatorilor relaţionali) . Există trei operatori logici:
Operatori logici Semnificaţie

& Şi (and)
| Ori (or)
~ Nu (not)
Mai există un operator logic definit ca o funcţie: xor(A,B)- sau

exclusiv -. Prezentăm acum tabelul de definiţie al operatorilor logici ( 1
reprezintă adevărat (A), iar zero reprezintă valoarea logică fals (F)).:
A B A&B A|B ~A xor(A,B)

0 0 0 0 1 0
1 0 0 1 0 1
0 1 0 1 1 1
1 1 1 1 0 0
Putem acum construi exemple mai complexe de determinare a

unor elemente ale unor matrici. Astfel ca să determinăm elementele lui
A (matricea din exemplul de mai sus) din intervalul (1,20) trebuie să
dăm comanda A((A>1)&(A<20)) Si obţinem elementele 2, 3, 2, 10.
Apariţia elementelor este în ordinea coloanelor matricei A. Pentru
obţinerea elementelor ce sunt în afara acestui interval avem două
posibilităţi: fie utilizăm expresia logică de mai sus şi adăugăm în faţa ei
operatorul ~ adică dăm comanda A(~((A>1)&(A<20))) , fie utilizăm
operatorul | şi dăm comanda A((A<=1)|(A>=20)).
Există mai multe funcţii numite funcţii relaţionale şi logice. Ele
au caracteristic faptul că au ca răspuns numai numerele 0 (A) sau 1
(F).Le vom prezenta pe scurt pe fiecare:
any(v) Răspunde cu 1 dacă vectorul v are cel puţin un element
nenul şi cu 0 dacă toate elementele sunt 0.
all(v) Răspunde cu 1 dacă toate elementele lui v sunt nenule şi cu
0 dacă există cel puţin un element nul.
Fiind cele mai utilizate funcţii pentru clarificare prezentăm un exemplu.
Fie vectorii [0 1 2], [1 2 3] şi [0 0 0]. Atunci:
vector v any(v) all(v)

[0 1 2] 1 0
[1 2 3] 1 1
[0 0 0] 0 0
fiind(x) Răspunde cu un vector conţinând indicii elementelor nenule

ale lui x.
isnan(x) Răspunde cu un vector de aceiaşi dimensiune cu x ale cărui
elemente sunt 1 sau 0 după cum elementul corespunzător al lui x este
NaN sau nu.
isfinite(x) Răspunde cu un vector de aceiaşi dimensiune ca x ale cărui
elemente sunt 1 sau 0 după cum elementul corespunzător al lui x este
finit sau nu. NaN este considerat nefinit.
>> v=[1 NaN inf -inf]
v=
1 NaN Inf -Inf
>> isfinite(v)
ans =
1 0 0 0
9.3. APLICAŢII
1. Fie vectorii x = [1 5 2 8 9 0 1] şi y = [5 2 2 6 0 0 2]. Executaţi şi

explicaţi rezultatele următoarelor comenzi:
a) x > y
b) y < x
c) x == y
d) x <= y
e) y >= x
f) x | y
g) x & y
h) x & (~y)
i) (x > y) | (y < x)
j) (x > y) & (y < x)
2.Fie vectorii x = 1:10 şi y = [3 1 5 6 8 2 9 4 7 0]. Execută şi

interpretează următoarele comenzi de indexare logică:
a) x((x > 3) & (x < 8))

b) x(x > 5)
c) y(x <= 4)
d) x( (x < 2) | (x >= 8) )
e) y( (x < 2) | (x >= 8) )
f) x(y < 0)
3. Fie x=[3 15 9 12 -1 0 -12 9 6 1]. Determinaţi comanda care:
a) defineşte vectorul a obţinut din x prin schimbarea elementelor

pozitive cu 0;
b) defineşte vectorul b obţinut din x prin schimbarea elementelor ce se

divid cu 3, cu valoarea 1;
c) defineşte vectorul c obţinut din x prin schimbarea elementelor pare cu
valoarea lor multiplicată cu 5;
d) defineşte vectorul d ce va conţine doar acele elemente ale lui x ce sunt
mai mari ca 10;
e) defineşte vectorul e obţinut din x prin schimbarea elementelor ce sunt
mai mici ca media elementelor lui x, cu 0;
f) defineşte vectorul f obţinut din x prin schimbarea elementelor ce sunt
mai mari decât media elementelor lui x cu diferenţa dintre valoarea lor şi
medie.
4. a) Creaţi vectorul x=randperm(35) (funcţia randperm(n) generează o

permutare aleatoare a numerelor naturale de la 1 la 35). Evaluaţi funcţia:
⎧ 2 daca x < 6
⎪
y ( x) = ⎨ x − 4 daca 6 <= x <= 20
⎪
⎩36 − x daca 20 <= x <= 35
utilizând indexarea logică. Verificaţi răspunsul desenând graficul lui
y(x).
b) Desenaţi graficul funcţiei de semnal sinusoidal discontinuu :
⎧sin(t ) daca sin(t ) > 0

x (t ) = ⎨ pentru t=1,…,10s,
⎩0 daca sin(t ) ≤ 0
utilizând indexarea logică.
5. Problema evitării operaţiilor neconvenabile. În unele situaţii avem un

vector cu unele elemente0. Dacă cu acest vector facem diverse calcule
putem ajunge ca să efectuăm operaţii interzise ca de exemplu împărţiri
cu 0. De exemplu:
>> x=[7 3 0 5 -2 0 -1 0 pi]

x=
7.0000 3.0000 0 5.0000 -2.0000 0 -1.0000 0 3.1416
>>y= sin(x)./x
Warning: Divide by zero.
y=
0.0939 0.0470 NaN -0.1918 0.4546 NaN 0.8415 NaN
0.0000
Se observă faptul că unde am avut elemente 0 la rezultat avem

NaN fapt ce va conduce la rezultate eronate dacă , de exemplu, vom dori
să calculăm suma elementelor vectorului y. Cum ieşim din această
situaţie?
6. O problemă de balistică. Înălţimea şi viteza unui proiectil lansat cu

viteza iniţială v0 şi cu un unghi θ sunt date de:
1
h ( t ) = v0t sin θ − gt 2
2
v ( t ) = v02 − 2v0 gt sin θ + g 2t 2
Unde g este acceleraţia gravitaţională. Proiectilul va atinge solul
când h(t)=0 , ceea ce conduce la timpul de revenire t g = 2 ( v0 / g ) sin θ
(se egalează cu 0 prima ecuaţie). Pentru θ = 40o , v0=20 m/s, şi g=9.81
m/s2 , determinaţi timpul când înălţimea h nu este mai mică de 6m iar
viteza este simultan cel mult 16 m/s.
9.4. Indicaţii
3.
>> x = [3 15 9 12 -1 0 -12 9 6 1]
x=
3 15 9 12 -1 0 -12 9 6 1
a)>> a=x;a(x>0)=0
b)Se va utiliza funcţia rem(x,n), x un vector de numere întregi, iar n un
număr natural. Funcţia ne dă un vector în care elementele sunt restul
împărţirii fiecărui element al lui x la n. În situaţia noastră rem(x,3) ne va
da resturile împărţirii la 3. Dar pe noi ne interesează ca în acest vector pe
poziţia în care este 0, adică elementul se împarte exact la 3, să avem
valoarea 1( adică adevărat) şi 0 în rest (adică fals, nu se împarte exact la
3).Acest lucru se obţine pur şi simplu aplicând operatorul ~ (not) la
funcţie. Deci
>> b=x;b(~rem(x,3))=5
c) >> c=x;c(~rem(x,2))=5*c(~rem(x,2))
d) >> d=x(x>10)
e)media elementelor unui vector este dată de funcţia mean(x). Deci
>> e=x;e(x<mean(x))=0
f) >> f=x;f(x>mean(x))=f(x>mean(x))-mean(x)
4. a) Mai întâi creăm vectorul x:

>> x=randperm(35)
Apoi vom crea vectorul y de aceiaşi dimensiune cu x. Dimensiunea lui x
este dată de size(x). x=randperm(35)om crea vectorul y numai cu cifra 1:
>> y=ones(size(x))
Acum putem calcula valorile reale ale lui y utilizând indexarea logică:
>> y(x<6)=2
>> y((x >= 6) & (x < 20))=x((x >= 6) & (x < 20))-4
>> y((x >= 20) & (x <= 35))=36-x((x >= 20) & (x <= 35))
Acum putem trasa graficul lui y în funcţie de x cu comanda:
>> plot(x,y,'or')
b) Mai întâi definim timpul t:
>>t=0:0.1:10;
Apoi definim funcţia x(t):
>> x=sin(t);
Punem valoarea 0 în locul valorilor negative ale lui x:
>> x=x.*(x>0);
Facem graficul şi punem etichetele:
>> plot(t,x)
>> axis([0 10 -0.1 1.1])
>> xlabel('Timpul [s]')
>> ylabel('Amplitudinea')
>> title('Semnal sinusoidal discontinuu')
5. Definim x ca în problemă:
>> x=[7 3 0 5 -2 0 -1 0 pi]
Ideea este că vom utiliza în locul valorii 0 cea mai mică valoare relativă
pozitivă pe care calculatorul o poate reprezenta. Aceasta este:
eps= 2−52 ≈ 2.2204e-016
Comanda de înlocuire este:
>> x=x+(x==0)*eps
Acum putem calcula:
>> sin(x)./x
6. Definim datele iniţiale:

>> v0=20;g=9.81;theta=40*pi/180;
Calculăm acum timpul de revenire al proiectilului tg, ceea ce ne dă şi
intervalul de definiţie al timpului unde problema are sens:
>> tg=2*v0*sin(theta)/g
Definim acum intervalul de timp şi calculăm vitezele şi înălţimile
pe acest interval:
>> t=0:0.01:tg;
>> v=sqrt(v0^2-2*v0*g*sin(theta)*t+g^2*t.^2);
>> h=v0*t*sin(theta)-0.5*g*t.^2;
Determinăm acum când înălţimea nu este mai mică decât 6m şi
viteza nu este mai mare decât 16 m/s :
>> u=find(h>6&v<16)
In vectorul u se află rangurile elementelor din v şi h ce verifică
această condiţie. Evident rangurile corespunzătoare din t ne dau timpii în
care condiţiile sunt îndeplinite . Aceşti timpi aparţin unui interval dat de
primul rang şi ultimul rang din u. Determinăm capetele acestui interval
astfel:
>> t1=t(u(1))
>> t2=t(u(end))
Soluţia problemei este intervalul [t1,t2]
9.5. Soluţii
1.
a) >> x > y
ans =
0 1 0 1 1 0 0
Vectorul rezultat are 1 pe poziţia în care elementul lui x este mai mare
decât elementul lui y şi 0 unde elementul lui x este mai mic sau egal cu
elementul corespunzător al lui y.
Analog pentru restul comenzilor.
2.
a) >> x((x > 3) & (x < 8))
ans =
4 5 6 7
Analog pentru restul comenzilor.
3.
a) a =
0 0 0 0 -1 0 -12 0 0 0
b) b =
5 5 5 5 -1 5 5 5 5 1
c) c =
3 15 9 60 -1 0 -60 9 30 1
d) d =
15 12
e) e =
0 15 9 12 0 0 0 9 6 0
f) f =
3.0000,10.8000,4.8000,7.8000,-1.0000,0,-12.0000,4.8000,1.8000,
1.0000
4. a) x =
Columns 1 through 15
24 31 8 21 25 15 27 30 26 2 29 22 16 19
10
33 7 35 4 28 3 11 14 32 6 12 23 9 5 20
18 13 34 17 1
y=
12 5 4 15 11 11 9 6 10 2 7 14 12 15 6
3 3 1 2 8 2 7 10 4 2 8 13 5 2 16
14 9 2 13 2
Fig.9.1
Fig.9.2
5. x =
7.0000 3.0000 0.0000 5.0000 -2.0000 0.0000 -1.0000
0.0000 3.1416
>> sin(x)./x
ans =
0.0939 0.0470 1.0000 -0.1918 0.4546 1.0000 0.8415
1.0000 0.0000
6. [0.85, 1.78]
LUCRAREA 10
Această lucrare îşi propune prezentarea comenzilor de control if,

switch, for şi while şi modul de utilizare al acestora. Se prezintă şi
modul de utilizare al comenzilor îmbricate.
10.2. Comenzi de control a execuţiei unui program.
Deşi, de obicei, cerem calculatorului execuţia secvenţială a unor

comenzi avem situaţii când nu dorim acest lucru. În una din aceste
situaţii, în funcţie de o condiţie executăm fie o secvenţă de instrucţiuni,
fie altă secvenţă de instrucţiuni. În altă situaţie dorim execuţia repetată a
unei secvenţe de instrucţiuni. Pentru a dirija în modul dorit execuţia
fluxului de comenzi MATLAB s-au introdus comenzi speciale care
constituie scopul lucrării.
Comand de ramificare „if” are mai multe forme. Prima formă şi
cea mai simplă este:
if condiţie
secvenţa de instrucţiuni
end
unde condiţie este o expresie logică ce se evaluează. Efectul unei astfel

de comenzi este: dacă condiţie este adevărată se execută secvenţa de
instrucţiuni şi apoi se trece la execuţia comenzilor ce urmează după end.
Dacă condiţie nu este adevărată se trece la execuţia comenzi de
după end.
Exemplu:
>> x=5;
>> ind=2;
>> if ind<25
ind=ind+1;
end
>> ind
ind =
3
Efectul execuţie lui if se vede prin faptul că ind a fost mărit cu 1

deoarece x<25. Altfel ind ar fi rămas neschimbat.
Observaţie. Toate comenzile din secvenţe din cadrul comenzilor de
control trebuie să se termine cu ;
Comanda if cu clauza else este utilizată când se doreşte execuţia
unei secvenţe pe condiţie adevărată şi a altei secvenţe pe condiţie falsă:
if condiţie
secvenţa 1 de comenzi
else
end
Secvenţa 1 se execută dacă condiţia este adevărată iar secvenţa 2

dacă condiţia este falsă. De exemplu:
>> interval =0.9;

>> if interval<1
xinc=interval/10;
else
xinc=0.1;
end
>> xinc
xinc =
0.0900
Datorită unor condiţii complexe, uneori este necesară îmbricarea
comenzilor if. Pentru aceste cazuri există opţiunea elseif:
if conditie1
Secvenţa 1 de comenzi
elseif conditie2
elseif conditie3
……………………………..
Else
Secvenţa n de comenzi
Exemplu:
>> n=7;
>> ind=1;
>> if n>10
ind=10;
elseif n>5
ind=5;
else
ind=0;
end
>> ind
ind =
5
În cazul unor ramificări multiple pentru a preveni scrierea unor
secvenţe if îmbricate complexe se utilizează comanda switch-case:
switch expresie
case valoare1
scvenţa 1 de comenzi
case valoare2
…………………………….
otherwise
secvenţa n de comenzi
end
Exemplul de la if – else se poate implementa şi cu switch – case:
>> interval=0.9;
>> switch interval<1
case 1
xinc=interval/10;
case 0
xinc=0.1;
end
>> xinc
xinc =
0.0900
Pentru scrierea buclelor cu număr de cicluri cunoscut se

utilizează comanda for.
for variabila=expresie
secvenţa de comenzi
end
Observaţii:
Dacă rezultatul evaluării expresiei este o matrice vidă, atunci se
sare direct la prima comandă după end fără să se execute secvenţa de
comenzi;
Dacă rezultatul evaluării expresiei este o matrice cu n coloane
atunci secvenţa de comenzi se va executa de n ori. Variabila va lua pe
rând ca valoare coloana k la execuţia k şi poate fi utilizată cu această
valoare în secvenţa de comenzi;
Dacă rezultatul evaluării expresiei este un vector cu n elemente,
atunci secvenţa de comenzi se va executa de n ori, la a k-a execuţie
variabila luând ca valoare elementul de ordin k din vector;
Dacă rezultatul evaluării expresiei este un scalar secvenţa de
comenzi se va executa o singură dată, iar variabila va lua ca valoare acel
scalar;
Nu se poate termina o buclă for prin modificarea variabilei;
Se poate utiliza în expresie operatorul : ;
Variabila va avea la sfârşit ca valoare ultima coloană,respectiv
ultimul element.
Vom calcula valoarea n! :
>> n=6;
>> fact=1;
>> for ind=1:n
fact=fact*ind;
end
>> fact
fact =
720
Observaţie. Exemplul de mai sus este pur didactic. Ca regulă
generală atunci când există funcţii predefinite care calculează o valoare
este bine să le utilizaţi pe acelea. Nu există o funcţie specială pentru
factorial. Dar funcţia gamma dată de:
∞
gamma (a ) = ∫ e −t t a −1 dt
0
verifică gamma(n+1)=n! şi este bine să o utilizăm. De asemenea există

funcţia prod(v) care calculează produsul elementelor vectorului v şi deci
prod(1:n) va calcula n! :
>> gamma(7)
ans =
720
>> prod(1:6)
ans =
720
Buclele for se pot îmbrica. În exemplul următor vom înlocui

elementele unei matrici cu restul împărţirii lor la 3:
>> A=[1 5 9;-3 7 0;6 9 4]

A=
1 5 9
-3 7 0
6 9 4
>> [l,c]=size(A);
>> for i=1:l
for j=1:c
A(i,j)=rem(A(i,j),3);
end
end
>> A
A=
1 2 0
0 1 0
0 0 1
Observaţie. Acelaşi rezultat se obţine (mult mai rapid!!!) şi prin

comanda:
>> A=rem(A(:,:),3);
Asupra optimizărilor execuţiei comenzilor vom reveni în altă lucrare.

Există situaţii când ciclurile se execută atât timp cât este
îndeplinită o condiţie. Pentru această buclă există definită comanda
while.
While conditie
Secvenţa de comenzi
End
Observaţie. La buclele while există posibilitatea ca pentru o

condiţie dată să se cicleze la infinit. Pentru a evita acest lucru este bine
să introduceţi un număr maxim de iteraţii:
it=1;
itmax=1000;
while condiţie & (it<itmax)
secvenţa de comenzi
it=it+1;
end
În toate manualele de specialitate drept exemplu pentru bucla

while este dat calculul lui eps (acurateţea relativă a reprezentării în
virgulă flotantă în dublă precizie). Valoare lui eps reprezintă distanţa
dintre 1 şi următorul număr real în dublă precizie mai mare ca 1
reprezentabil :
>> it=0;
>> itmax=100;
>> xeps=1;
>> while (((1+xeps)>1)&(it<itmax))
xeps=xeps/2;
it=it+1;
end
>> it-1
it =
52
>> xeps=xeps*2
xeps =
2.2204e-016
Numărul de împărţiri la 2 este cu 1 mai mic decât it şi deci

eps=2 ≈ 2.2204x10-16.
-52
Uneori este util să ieşim forţat dintr-o buclă. Pentru aceasta se va

folosi comanda break care dă controlul la prima comandă de după end-
ul buclei.
>> x
x=
1 0 7 NaN 8
>> for ind=1:length(x)
if x(ind)==NaN
break
end
x(ind)=rem(x(ind),5);
end
>> x
x=
1 0 2 NaN 8
Se observă faptul că prelucrarea s-a oprit la NaN, altfel în loc de
8 ar fi fost 3 (restul împărţirii lui 8 la 5).
10.3. Aplicaţii
1.Fie secvenţa if următoare:

if x<10
y=2*x;
elseif x<100
y=100-x;
elseif x<1000
y=1000-x/2;
else
y=sqrt(x)
Dacă x=5 cât este y?
2. Scrieţi o secvenţă if care pornind de la o variabilă x să introducă în

variabila y unul din şirurile : ’scalar’,’vector’ sau ’matrice’ după cum
este x este scalar,vector sau matrice.
3. În variabila lungime se află valoarea numerică a unei măsurări de

lungime. Unitatea de lungime cu care s-a făcut măsurarea poate fi: ’ft’
pentru picior, ’in’ pentru inci, ’m’ pentru metru şi ’mm’ pentru
milimetru memorată în variabila unitate. Sa se creeze o secvenţă switch-
case care pune în lungime_metrii valoarea în metrii ai măsurătorii.
4. Fiind dat un vector v să se construiască un vector w ale cărui elemente

sunt date de:
v ( i − 1) + v ( i + 1)
w (i ) =
2
Pentru elementul w(1) se va considera că elementul v(0)=0

(v(0)nu există). Analog, deoarece v(end+1) nu există se va considera că
este 0.
5.În teoria semnalelor formula:
1
y ( k ) = ( x ( k ) + x ( k − 1) + x ( k − 2 ) )
2
defineşte un filtru de medie cu 3 puncte. Filtrele sunt utilizate pentru
înlăturarea zgomotului din semnal. Folosind un semnal sinusoidal cu
zgomot aleatoriu comparaţi graficele semnalului şi a semnalului filtrat.
Intervalul de timp va fi de 10 s.
6. Să se determine indicii (linie,coloană) ale elementului maxim şi a

celui minim dintr-o matrice.
7. Problema răcirii sticlei cu bere. Temperatura de afară şi din nefericire

şi a berii este de 30o C. Există un frigider care în interior are temperatura
de 10o C. Punem bineînţeles sticla în frigider. După câte minute ajunge
la temperatura de 14o C ca să o putem răcori cu ea?
10.4. Indicaţii
1.Definim întâi pe x şi apoi introducem secvenţa if.
>> x=5;
>> if x<10
y=2*x;
elseif x<100
y=100-x;
elseif x<1000
y=1000-x/2;
else
y=sqrt(x);
end
>> y
y=
10
Analog pentru celelalte valori ale lui x.
2. vom utiliza funcţia [l,c]=size(x) pentru a vedea dacă x este scalar,

vector sau matrice. Această funcţie introduce în l numărul de linii, iar în
c numărul de coloane ale matricii x. În MATLAB orice variabilă este o
matrice. Dacă l=c=1 este vorba evident de un scalar. Dacă l=1 sau c=1
este vorba evident de un vector şi x este o matrice în rest.
3. Pentru transformare::
- pentru inci → metru y=0.0254*x;
- pentru picior → metru y=0.3048*x;
- pentru milimetru → metru y=x/1000.
Este bine de utilizat şi clauza otherwise în cazul nostru înseamnă
faptul că unitatea nu există şi să introducem în acest caz NaN în y pentru
a semnala că transformarea unităţilor nu s-a putut efectua.
4. Se va construi vectorul vx cu size(vx)=size(v)+2, care are ca prim şi

ultim element pe 0. Apoi se va defini w cu formula:
v ( i − 1) + v ( i + 1)
w ( i − 1) =
2
Vom avea grijă, ca bucla să înceapă de la 2 şi să se termine la
„length(vx)-1”.
5. Un semnal sinusoidal este dat de exemplu de formula:

⎛ 2π ⎞
s = sin ⎜ t⎟
⎝ 5 ⎠
unde t este timpul. Zgomotul poate fi obţinut în MATLAB cu:
>> z=0.1*randn(size(t));
Semnalul sinusoidal cu zgomot x va fi suma semnalului
sinusoidal s cu zgomotul z.
Pentru definirea timpului t vom utiliza o comandă nouă:
linspace(a,b,n)
care împarte în n intervale egale intervalul [a,b]. În analiza şi prelucrarea
semnalelor este util ca n să fie putere a lui 2. Nu este cazul aici, dar vom
pune totuşi n=512=29 .
Este evident că pentru primul şi al doilea element al semnalului
filtrat nu putem aplica formula de mediere. De aceea primul element
filtrat se ia chiar x(1), iar al doilea ½(x(2)+x(1)).
6. Problema va utiliza bucle for îmbricate. Pentru teste vom utiliza if.
Vom nota lmin şi cmin indici căutaţi pentru elementul minim, respectiv
lmax şi cmax indicii elementului maxim.
7. Să notăm cu Tf temperatura din frigider. Dacă la momentul ti

temperatura berii este Ti atunci temperatura Ti+1 de la momentul ti+1 este
dată de:
Ti +1 = Ti + K ⋅ (ti +1 − ti ) ⋅ (T f − Ti )
unde, pentru simplificare, K este o coeficientul de conducţie al căldurii
comun pentru ansamblul bere-sticlă. Pentru simplificarea formulei vom
considera unitatea de măsură a timpului minutul şi măsurătorile se vor
face din minut în minut. Deci ti+1 – ti = 1. Vom presupune că pentru
constanta K este valabil K=0.05. Notaţii:
k=0.05 – constanta de condiţie;

tbf=14 – temperatura berii finală;
tb – temperatura berii calculată în minutul t;
tbn - temperatura berii calculată în minutul t+1;
t – minutul curent, in final răspunsul dorit.
10.5. Soluţii
1a) 10; b) 50; c) 750; d) 70.7107;
2.
>> x=[1 2 3];
>> if l==1&c==1
y=’scalar’;
elseif l==1|c==1
y=’vector’;
else
y=’matrice’;
end
>> y
y=
vector
3.
>> lungime=4.25;
>> unitate=’ft’;
>> switch unitate
case ‚in’
lungime_metrii=lungime*0.0254;
case ‚ft’
lungime_metrii=lungime*0.3048;
case ‚m’
lungime_metrii=lungime;
case ‚mm’
lungime_metrii=lungime/1000;
otherwise
lungime_metrii=NaN;
end
>> lungime_metrii
lungime_metrii =
1.2954
4.
>> v=[1 0 5 7 3 4 5 5 8]
v=
1 0 5 7 3 4 5 5 8
>> vx=[0 v 0]
vx =
0 1 0 5 7 3 4 5 5 8 0
>> for ind=2:length(vx)-1
w(ind-1)=(vx(ind-1)+vx(ind+1))/2;
end
>> w
w=
0 3.0000 3.5000 4.0000 5.5000 4.0000 4.5000 6.5000 2.5000
5.
>> t=linspace(0,10,512);
>> s=sin(2*pi/5+t);
>> z=0.1*randn(size(t));
>> x=s+z;
>> y=zeros(size(t));
>> y(1)=x(1);
>> y(2)=(x(2)+x(1))/2;
>> for k=3:length(t)
y(k)=(x(k)+x(k-1)+x(k-2))/3;
end
>> subplot(2,1,1);
>> plot(t,x)
>> xlabel(‚timp [s]’)
>> ylabel(‚amplitudine semnal’)
>> title(‚Semnal sinusoidal cu zgomot’)
>> subplot(2,1,2)
>> plot(t,y)
>> xlabel(‚timp [s]’)
>> ylabel(‚amplitudine semnal’)
>> title(‚Semnal filtrat’)
Fig.10.1
Se observă faptul că semnalul filtrat a eliminat în mare măsură
zgomotul.
6.
>> a=[1 2 3;0 -2 3;-2 -1 0];
>> [r,c]=size(a);
>> lmin=1;lmax=1;cmin=1;cmax=1;
>> elemin=a(1,1);
>> elemax=a(1,1);
>> for i=1:r
for j=1:c
if a(i,j) > elemax
elemax=a(i,j);
lmax=i;
cmax=j;
end
if a(i,j) < elemin
elemin=a(i,j);
lmin=i;
cmin=j;
end
end
end
>> [elemax lmax cmax]
ans =
3 1 3
>> [elemin lmin cmin]
ans =
-2 2 2
Elementul maxim este 3 şi se află pe linia 1 coloana 3, iar
elementul minim este -2 şi se află pe linia 2 coloana 2. Se remarcă faptul
că, deşi există mai multe elemente maxime s-au minime, este reţinut
primul întâlnit.
7.
>> k=0.05;
>> tbf=14;
>> tb=30;
>> t=1;
>> tf=10;
>> while tb > tbf
tbn=tb+k*(tf-tb);
tb=tbn;
t=t+1;
end
>> t
t=
33
Deci după 33 de minute putem scoate berea din frigider la
temperatura de 14o C. Cam durează şi dacă afară e 30o C o să ni se pară
o veşnicie !!
LUCRAREA 11
Această lucrare îşi propune prezentarea modului de definire al

programelor MATLAB. Se precizează structura unui astfel de program
şi tipurile de programe MATLAB. Se prezintă şi principalele comenzi de
intrare/ieşire.
11.2. Programe m-file. Comenzi de intrare – ieşire.
Programele sursă în MATLAB, numite generic m-files, sunt de

două tipuri: script şi funcţie (function în engleză). Sintactic diferenţa faţă
de un script este că funcţia are o primă linie de forma:
function [lista-param-iesire]=nume-functie(lista-param-intrare).
Pentru creare lor se poate utiliza orice editor de texte. Totuşi noi
recomandăm editorul MATLAB care are nişte facilităţi proprii pentru
programele MATLAB (de aceea îl vom utiliza). Pentru crearea unui
program selectaţi meniul File, aici selectaţi New, iar în pup-up selectaţi
M-file. Se va deschide o fereastră de editare ca mai jos:
Se introduc comenzile apoi se va salva în modul următor: Se selectează
meniul File din editor, iar apoi Save as. Va apare o fereastră în care se
introduce numele fişierului (obligatoriu!) şi eventual directorul sau tipul
dorit (obligatoriu .m) . Recomandăm ca să introduceţi doar numele
lăsând pe celelalte la valorile implicite alese de MATLAB. Pentru
execuţie în cazul scriptului se introduce pur şi simplu numele (introdus

la salvare),iar In cazul funcţiei trebuie introdusă o comandă
asemănătoare cu prima linie dar fără function. (recomandăm, la funcţie,
ca numele cu care a fost salvată să coincidă cu nume-functie din prima
linie).
Fig.11.1
Prezentăm în continuare două exemple simple. Primul exemplu va crea
un script numit sindoix ce va calcula sin 2x , va defini x şi va apela
scriptul.
Deschideţi cu File>New>M-file fereastra Edit şi Introduceţi comanda:
y=2*sin(x).*cos(x);
Apoi cu File>: Save As… salvaţi cu numele sindoix. Apoi în Command
window daţi comenzile:
>> x=pi/3;
>> sindoix
>> y
y=
0.8660
Al doilea exemplu va defini o funcţie numită cosdoix ce va
calcula cos 2x .
Deschideţi cu File>New>M-file fereastra Edit şi Introduceţi comenzile:
function y=cosdoix(x)
y=cos(x).*cos(x)-sin(x).*sin(x);
Apoi cu File>: Save As… salvaţi cu numele cosdoix. Apoi în Command
window daţi comenzile:
>> y=cosdoix(x)
>>y
y=
-0.5000
>> (1+cosdoix(x))./cosdoix(x)
ans =
-1.0000
>> 1+sindoix
??? Attempt to execute SCRIPT sindoix as a function.
Observaţie. Funcţia a putut fi utilizată într-o formulă (atenţie la
situaţia când există mai mulţi parametrii în lista de ieşire!), pe când
scriptul nu. Deci MATLAB consideră scriptul ca un şir de instrucţiuni
,pe când la funcţie importanţi sunt parametrii de ieşire. În cazul când
există doar un parametru de ieşire (care poate fi un scalar,vector sau
matrice) parantezele pătrate pot lipsi. Parantezele rotunde de la lista-
param-intrare pot lipsi doar dacă nu există nici un parametru de intrare.
Vom analiza pe rând cele două tipuri si vom sublinia avantajele,
dezavantajele şi diferenţele dintre ele.
Scriptul este pur şi simplu o secvenţă de instrucţiuni şi a apărut
din necesitatea reutilizării multiple a secvenţei respective de instrucţiuni.
Avantaje:
utile în cazul programelor mari cu secvenţe de comenzi care se repetă

aleatoriu (nu sunt bucle pur şi simplu) deci utile doar programatorilor
avansaţi;
Dezavantaje:
creează şi modifică variabile din zona de lucru fără nici un avertisment;
sunt sursa unor erori greu detectabile (în argou, bugs);
nu pot fi utilizate în expresii.
Spre deosebire de script funcţia este tratată drept un subprogram,
adică drept o unitate distinctă de restul programului.
Avantaje:
Funcţia comunică cu programul apelant prin cele două liste: lista-
param-iesire şi lista-param-intrare.
Nu modifică datele din zona de lucru a programului apelant.
Permite organizarea structurală a programării.
Dezavantaje:
Folosirea în exces a funcţiilor poate duce la fărâmiţarea excesivă
a programului pierzându-se din claritate.
Vom discuta acum despre câteva funcţii de intrare/ieşire
predefinite.
Pentru a introduce date de la tastatură în program date se
utilizează funcţia input:
nr=input(’text’)
sir=input(’text’,’s’)
În primul caz pe ecran apare text, iar calculatorul aşteaptă până
introduceţi un număr terminat cu tastarea return. În al doilea caz ce se
tastează este interpretat drept un şir. Dacă nu se tastează decât tasta
return atunci în variabila de intrare se introduce matricea vidă (empty
matrix).
În exemplul următor exemplificăm introducerea de date cu varianta
implicită:
y=input(’Continuati y/n [y] :’,’s’)

if isempty(y)
y=’y’;
end
Tastarea doar a tastei return a introdus în y matricea vidă pe care
isempty o va detecta şi atunci în y se va introduce şirul ’y’.
Observaţie. Pe cât posibil evitaţi funcţia input deoarece întrerupe
execuţia şi duce la pierderi de timp de execuţie.
Pentru afişarea datelor pe ecran se folosesc două funcţii. Prima
dintre ele disp are o structură simplă şi are rolul de a obţine cât mai rapid
datele pe ecran (în detrimentul aspectului).
Dis(‚text’) va lista un text
Dis(x) va lista matricea x si are acelaşi efect cu comanda:
>>x
Pentru obţinerea unor ecrane cu date aranjate sugestiv, se
utilizează funcţia fprintf care permite formatarea ecranului. Comanda
diferă foarte puţin de cea din limbajul C++.
Fprintf(’format’,lista-parametrii)
Format este un şir ce conţine părţi de test dar şi indicaţii de
poziţionare a parametrilor din listă în ordine. Parametrul de poziţionare
începe cu caracterul %. Numărul acestor parametrii de poziţionare este
egal cu cel al parametrilor din listă, iar corespondenţa lor se face în
ordine de la stânga la dreapta. Astfel primului parametru de poziţionare
îi corespunde primului parametru din listă, ş. a. m. d.
Parametrii de poziţionare au forma:
%ls pentru şiruri cu lungimea cel mult l;
%ld pentru numere întregi, l lungimea maximă
%l.vf pentru numere în virgulă flotantă, l lungimea maximă, v numărul
de zecimale
%l.ve ca şi f dar cu notaţie ştiinţifică
%l.vg cea mai compactă formă dintre e, f sau d
Număr %8.4f %12.3e %10g %8d

2 2.0000 2.000e+000 2 2
sqrt(2) 1.4142 1.414e+000 1.41421 1.414214e+000
sqrt(2e-11) 0.0000 4.472e-006 4.47214e-006 4.472136e-006
sqrt(2e11) 447213.5955 4.472e+005 447214 4.472136e+005
Tabelul 11.1
În afara acestor parametrii se mai utilizează şirul \n pentru sal la

linie nouă. Tabelul 1 exemplifică legătura dintre număr şi reprezentarea
lui pe ecran în funcţie de parametrul de poziţionare utilizat. Exemplu:
>> x=1:4;
>> y=sqrt(x);
>> fprintf('y= %9.4f\n',y)
y= 1.0000
y= 1.4142
y= 1.7321
y= 2.0000
Vom prezenta acum un script care desenează banda lui Möebus.

Definiţi scriptul următor:
for a=0:112;
for b=0:60;
u=a/2;
w=b/2;
v=w/50-0.3;
X(a+1,b+1)=cos(u)+v*cos(u/2)*cos(u);
Y(a+1,b+1)=sin(u)+v*cos(u/2)*sin(u);
Z(a+1,b+1)=v*sin(u/2);
end
end
surf(X,Y,Z)
view(55, 50)
shading interp
Salvaţi-l cu numele bandam. Apoi în Command Window tastaţi

bandam. Efectul va fi apariţia benzii Möebus în fereastra de grafică.
1⎛ x ⎞
Se ştie că, dacă x>0, şirul an = ⎜ an −1 + ⎟ converge la x . Folosind
2⎝ an −1 ⎠
acest şir vom crea o funcţie care să calculeze x cu o precizie dorită.
Pentru aceasta scrieţi în edit comenzile:
function y=radpat(x,prec)
% Functia radpat calculeaza radacina patrata a lui x
% Se utilizeaza faptul ca sirul a(n)=0.5*(a(n-1)+x/a(n-1)) tinde catre
% radicalul lui x
% Apelul se face cu y=radpat(x,prec) sau radpat(x,prec)
% parametrii intrare
% x numarul din care se extrage radicalul
% prec precizia dorita
% parametrii iesire
% y radacina patrata a lui x cu precizia prec
% variabile locale
% maxit numarul maxim de iteratii
% it iteratia curenta
% yold valoarea lui y din iteratia anterioara
maxit=1000;
it=0;
y=0.1;
yold=1;
while abs(yold-y)>prec & it<maxit
yold=y;
y=0.5*(yold+x/yold);
it=it+1;
end
if it==maxit
disp('Atentie!! S-au depasit numarul maxim de iteratii');
end
Salvaţi cu numele radpat

Apoi în Command Window da-ti comanda care va calcula
rădăcina pătrată din 7 cu precizia 0.001.
>> radpat(7,0.001)
ans =
2.6458
Observaţie Liniile care încep cu %. Ele autodocumentează
funcţia. Remarcaţi ce informaţii s-au menţionat
ce face funcţia;
ce se utilizează pentru obţinerea parametrilor de ieşire (foarte sumar);
cum se fac apelurile funcţiei;
descrierea parametrilor de intrare;
descrierea parametrilor de ieşire;
descrierea variabilelor locale;
alte informaţii
În comunitatea utilizatorilor MATLAB aceste comentarii sunt ca

o lege nescrisă. Daţi comanda:
>> help radpat

Functia radpat calculeaza radacina patrata a lui x
Se utilizeaza faptul ca sirul a(n)=0.5*(a(n-1)+x/a(n-1)) tinde catre
radicalul lui x
Apelul se face cu y=radpat(x,prec)
parametrii intrare
x numarul din care se extrage radicalul
prec precizia dorita
parametrii iesire
y radacina patrata a lui x cu precizia prec
variabile locale
maxit numarul maxim de iteratii
it iteratia curenta
yold valoarea lui y din iteratia anterioara
Observaţi că aceste comentarii au apărut pe ecran. În acest mod

puteţi obţine informaţii sumare dar folositoare despre orice funcţie din
MATLAB. Dacă veţi tasta:
type radpat
veţi obţine lista programului radpat.
Pentru a salva matricea A într-un fişier text data1.dat utilizăm
următoarea comandă:
save data1.dat A –ascii
Matricea A s-a memorat în fişierul data1.dat
Pentru a încărca o matrice memorată într-un fişier utilizăm
comanda:
load data1.dat
s-a încărcat matricea în memorie şi a primit numele data1.
11.3. Aplicaţii
1.Definiţi funcţia tipvar care pornind de la o variabilă x ne răspunde cu

tipul ei: ’scalar’,’vector’ sau ’matrice’.
2.Definiţi funcţia care are ca date de intrare o lungime x şi unitatea de

măsură um a lui x, iar ca date de ieşire lungimea în metrii. Unităţile de
măsură valide sunt
- ’ft’ pentru picior 1 ft=0.3048 m;
- ’in’ pentru inch 1 in= 0.0254 m;
- ’km’ pentru kilometru;
- ’mm’ pentru milimetru;
- ’yd’ pentru yard 1 yd= 0.91 m;
- ’mlt’ pentru mila terestră 1 mlt= 1609.3 ;
- ’mlm’ pentru mila marină 1 mlm= 1852 m.
n
n
1 ⎛ 1⎞
3. Se ştie că şirurile: an = 1 + ∑ şi bn = ⎜1 + ⎟ au aceiaşi limită e
k =1 k ! ⎝ n⎠
(numărul lui Euler), adică în MATLAB exp(1)=2.71828182845905.
Definiţi funcţiile e1, (respectiv e2), care utilizând şirul an, (respectiv bn),
să calculeze pe e (dată ieşire) cu precizia prec(dată intrare), indicând şi
câţi termeni din şir au fost evaluaţi în it (dată ieşire) . Comparând cei
doi it obţineţi deduceţi care din cele două şiruri converge mai rapid la e.
4. Revenire la problema berii reci. În ex.7 Lucrarea 10 s-a presupus că

temperatura mediului ambient este de 30oC. În realitate uneori au fost şi
39oC. De aceea trebuie să rezolvăm complet problema aceasta
importantă. Va trebui să construim un tabel cu valorile de timp de răcire

pentru temperaturi cuprinse între 20oC şi 45oC. Timpi vor fi calculaţi cu
o funcţie brrc (a se citi be-re-re-ce) ce are ca parametru de intrare
temperatura ambientală, iar ca parametru de ieşire durata de răcire în
minute.
5. Se ştie că MATLAB memorează matricile coloană după coloană. De

aceea o matrice poate fi privită (şi deseori MATLAB o face!) ca un
vector de lungime r*c (r – număr linii, c- număr coloane). Să se
definească o funcţie indvect pentru care dându-se o matrice x şi indicii
(i,j) ai unui element să se obţină indicele k al aceluiaşi element în x
privit ca vector. De asemenea fiind dată o matrice x şi indicele k al unui
element din x fiind privit ca un vector să se scrie o funcţie vectind ce
determină indicii (i,j) ai aceluiaşi element din x privit ca o matrice.
11.4. Indicaţii
1.Vezi Ex.2 de la Lucrarea 10.
2. Vezi Ex.3 de la Lucrarea 10.
3. Structura funcţiilor e1 şi e2 de calcul a lui e este asemănătoare cu cea

a funcţiei radpat din exemplul de mai sus.
4.Vezi Ex. 4 lucrarea 10. În plus trebuie impuse nişte condiţii ca

problema să aibă sens:
- Temperatura mediului (adică cea iniţială a berii) trebuie să fie
cea de vară să zicem în intervalul [20, 45];
- Temperatura finală a berii trebuie să fie evident mai mică decât

cea iniţială Si evident mai mare decât temperatura frigiderului;
- Coeficientul de conducţie trebuie să fie un număr pozitiv
subunitar.
Dacă nu sunt verificate condiţiile de mai sus nu se calculează
nimic şi se iese din funcţie cu comanda return (asta chiar face această
comandă.
Vom construi un tabel în care fiecare linie va corespunde unei
temperaturi iniţiale ,prima coloană va conţine aceste temperaturi. Restul
coloanelor vor conţine durata de răcire pentru o temperatură din
intervalul 12oC, … , 16oC, intervalul optim de răcire. Tabelul îl vom
construi într-un script ca să-l putem testa. La tipărire vom utiliza funcţia
fprintf.
5.Formula de calcul a lui k este dată de (r numărul de linii al matricii) :

k = ( j − 1) r + i
Dacă cunoaştem indicele k atunci di formula de mai sus deducem că i
este restul împărţirii lui k la r iar j va fi dat de formula:
k −i
j= +1
r
Reamintim că restul împărţirii unui număr n la m este rem(n,m).
11.5. Soluţii
1.
Fig.11.2
g
>> x=1;
>> tipvar(x)
ans =
scalar
>> z=[1 2 3];
>> tipvar(z)
ans =
vector
>> w=[1 2;3 4];
>> tipvar(w)
ans =
matrice
2.
Fig.11.3
Fig.11.4
>> x=1.82;
>> u='yd';
>> lmet(x,u)
ans =
1.6562
>> x=0.023;
>> u='mlm';
>> lmet(x,u)
ans =
42.5960
>> u='kkk';
>> lmet(x,u)
Atentie unitate inexistenta!!

ans =
NaN
3. Funcţia e1:
Fig.11.5
Fig.11.6
Funcţia e2:
Fig.11.7
>> [y1,i1]=e1(0.001);
>> [y2,i2]=e2(0.001);
>> i1
i1 =
7
>> i2
i2 =
1359
Se observă faptul că primul şir este mult mai rapid convergent.
Dar chiar dacă rulăm programele la infinit nu vom obţine niciodată
valoarea exactă a lui e !!! (nici exp(1) nu este valoarea exactă a lui e!!).
Numărul e este o abstracţie tipic umană. Este un număr cu o infinitate
de zecimale care este caracterizat exact de faptul că este limita şirurilor

de mai sus.
4. Funcţia brrc:
Fig.11.8
Fig.11.9
Scriptul tabel este:
Fig.11.10
Dacă tastăm în MATLAB

>> tabel
Obţinem:
Tabel racire bere [min]

Temp. mediu durata durata durata durata durata durata
grd.Celsius[gC] la 13gC la 14gC la 15gC la 16gC la 17gC la 18gC
===================================================
20 25 19 15 11 8 6
21 27 21 17 13 10 8
22 29 23 19 15 12 9
23 30 24 20 17 14 11
24 32 26 22 18 15 12
25 33 27 23 19 16 14
26 34 29 24 21 18 15
27 35 30 25 22 19 16
28 36 31 26 23 20 17
29 37 32 28 24 21 18
30 38 33 29 25 22 19
31 39 34 29 26 23 20
32 40 35 30 27 24 21
33 41 36 31 28 25 22
34 42 36 32 29 26 23
35 43 37 33 29 26 24
36 44 38 34 30 27 24
37 44 39 34 31 28 25
38 45 39 35 32 29 26
39 46 40 36 32 29 27
40 46 41 36 33 30 27
41 47 41 37 34 31 28
42 48 42 38 34 31 29
43 48 43 38 35 32 29
44 49 43 39 35 32 30
45 49 44 39 36 33 30
De exemplu durata de răcire a berii în cazul temperaturii

mediului de 30oC şi cea de răcire de 14oC este de 33 minute.(la
intersecţia liniei 30 cu coloana 14).
5. Funcţia indvect:
Fig.11.11
Fig.11.12
>> a=[1 2 3;4 5 6;7 8 9]
a=
1 2 3
4 5 6
7 8 9
>> indvect(a,2,3)
ans =
8
>> [i,j]=vectind(a,8)
i=
2
j=
3
LUCRAREA 12
Această lucrare îşi propune prezentarea unor exemple simple dar

semnificative ale aplicării MATLAB în modelarea şi rezolvarea
problemelor tehnico-ştiinţifice.
12.2. Exemple de utilizare MATLAB în modelarea şi

rezolvarea problemelor tehnice.
În cazul proiectelor complexe rezolvarea lor se face etapizat, în

mai multe etape. Când dorim ca o componentă a proiectului să fie
rezolvată spunem că avem de rezolvat o problemă. Rezolvarea
problemelor presupune parcurgerea următoarelor etape:
A. Definirea problemei. În această etapă se face recunoaşterea
problemei profund, până în cele mai mici detalii. Se determină ce
informaţii sau date (numite generic date de intrare) sunt disponibile., ce
cunoştinţe şi din ce domeniu pot fi aplicate şi ce răspunsuri ,informaţii
(numite generic date de ieşire) sunt aşteptate.
În cazul problemelor academice (ca şi în cazul problemelor pe
care le vom rezolva) această etapă este parcursă de instructor. Cazul
problemelor prost definite este dezastruos pentru că face ca toate
eforturile ulterioare să fie în van.
B. Crearea unui model matematic, În această etapă se determină

principiile, legile, formulele ce se pot aplica sau au legătură cu
problema. Se fac notaţiile necesare pentru date şi variabile,iar apoi se
construieşte un model pur matematic al problemei.
C. Determinarea metodei de calcul. În această etapă se face
analiza numerică a problemei. În esenţă acum se determină dacă modelul
matematic poate fi rezolvat numeric. Acest lucru înseamnă că problema
a fost prost definită (în cele mai multe cazuri). Dacă modelul poate fi
rezolvat numeric se indică algoritmii cunoscuţi ce vor fi utilizaţi sau se
indică pas cu pas rezolvarea dacă algoritmul este propriu.
D. Implementarea. Se alege un limbaj de programare adecvat şi
se construieşte un program bazat pe algoritmul definit la punctul C.
Programul MATLAB are avantajul că este adaptat algoritmilor numerici,
astfel încât fiecare pas al algoritmului se transformă într-o comandă
MATLAB.
E. Testare şi validare rezultate. Acum se testează programul cu
aşa numitele date de test, se verifică şi rezultatele intermediare dacă sunt
cumva cunoscute. În sfârşit se introduc datele reale şi se obţin rezultatele
problemei.
Exemplu de rezolvare problemă.
Un obiect este aruncat în aer de la sol cu viteza de 50 mile/oră cu
un unghi de 30 grade faţă de orizontala de la nivelul solului. Determinaţi
timpul de zbor (în secunde) şi distanţa (în metrii) dintre punctul de
lansare şi punctul unde obiectul atinge din nou solul.
A. Trebuie reamintit că limbajul natural în care sunt formulate
problemele este de obicei imprecis. Faţă de textul de mai sus sunt câteva
precizări şi presupuneri de făcut:
prin expresia „este aruncat în aer de la sol” trebuie înţeles că înălţimea
faţă de sol a punctului de aruncare este 0;
Nu s-a precizat nimic despre proprietăţile corpului aruncat. de

exemplu cele geometrice. Gândiţi-vă la probele de aruncarea discului,
aruncarea ciocanului, aruncarea greutăţii sau aruncarea suliţei la atletism
unde forma corpului aruncat are efecte substanţiale asupra timpului de
zbor şi distanţei de zbor. (De ce?) Întrucât nu s-a făcut nici o precizare
vom presupune că proprietăţile corpului nu au efecte majore (se spune
efecte neglijabile) asupra rezultatelor.
Şi proprietăţile mediului pot influenţa rezultatele. De exemplu
poate sufla puternic vântul şi sigur rezultatele ar fi afectate. Se
presupune că efectele acţiunii mediului asupra corpului sunt neglijabile.
Totuşi o interacţiune cu mediul nu poate fi neglijată. Este
interacţiunea dintre planeta Pământ şi corp.(Hopa! Nu s-a precizat locul
în Univers unde are loc acţiunea! Dar cum suntem pământeni se poate
face presupunerea că aruncarea are loc pe planeta Pământ. Deşi mi-ar
place să văd calculele pentru o aruncare pe Lună, unde oamenii au
călătorit deja.)Interacţiunea dintre aceste două corpuri este dată de g,
acceleraţia gravitaţională. Cum nu se vorbeşte de g în problemă se poate
presupune că g=9.81m/s2 , acceleraţia de la nivelul solului.
Ne punem întrebarea dacă problema are sens, adică dacă obiectul
va zbura. Unui englez datele de intrare pot să i se pară în regulă pentru
că mintal ştie cu aproximaţie din experienţa şi cunoştinţele lui cam ce
este cu viteza de 50 mile/oră. Pentru noi este însă o nebuloasă, aşa că
vom presupune că obiectul va zbura măcar un pic.
Pentru că am vorbit că viteza este dată în unităţi de măsură
englezeşti trebuie să ajungem la unităţile standard pentru noi (MKS). În
problemă nu se precizează corespondenţa dintre unităţi deci avem de
aflat această corespondenţă. 1 milă = 1609,3m
1 oră = 3600 secunde;

360 grade = 2π radiani.
- Datele de ieşire (rezultatele) sunt clar precizate şi nu comportă discuţii.

- Teoria de aplicat este de mecanică partea de cinetică în două
dimensiuni.
B. Pentru crearea unui model matematic avem nevoie de
următoarele notaţii:
- v0 =50 mile/oră– viteza de lansare ;
- α=30o – unghiul de lansare;
- t – timpul în secunde;
- g=9.81 m/s2 – acceleraţia gravitaţională;
- (x(t), y(t)) – coordonatele carteziene ale unui punct de pe traiectorie.
Ideea de bază este descompunerea vitezei v în componenta
orizontală vx şi componenta verticală vy:
vy V
α vx
Din figură aplicând trigonometria elementară rezultă:

vx = v cos α
v y = v sin α
Deoarece nu există nici o forţă care să acţioneze pe direcţia

orizontală rezultă că pe această direcţie corpul se deplasează rectiliniu şi
uniform cu viteza vx:
x ( t ) = vx t = vt cos α
Pe verticală mişcarea rectilinie şi uniformă este frânată de forţa
gravitaţională :
1
y ( t ) = vt sin α − gt 2
2
În acest mod am creat un model matematic prin care putem
determina un punct de pe traiectorie la un moment t.
c. Cand corpul este la sol atunci y(t)=0 adică:
1
vt sin α − gt 2 = 0
2
Ecuaţia are două soluţii ts = 0 corespunzător momentului
2v sin α
startului şi t f = corespunzător momentului final al zborului,
g
când a revenit pe sol. În acest fel am obţinut unul din răspunsuri durata
zborului care este tf.. Distanţa parcursă este dată de: : x ( t f ) = vt f cos α .
−∆ v 2 sin 2 α
Înălţimea maxima este data de y max = = (de la
4a 2g
funcţia de gradul 2!!)
D. Evident vom utiliza programul MATLAB pentru
implementare şi vom defini o funcţie numită zbor:
function [distanta, durata]=zbor(viteza,unghi)
% funcţia calculează distanţa şi durata unui zbor prin aruncare
%
% Apelare [distanta,durata]=zbor(viteza,unghi)
%
% parametrii intrare
% viteza – viteza de aruncare in mile/ora

% unghi – unghiul de aruncare în o
%
% parametrii iesire
% distanta – dstanta dintre locul de aruncare si locul de cadere in m
% durata - durata zborului in secunde s
% variabile locale
% v - viteza de aruncare în m/s
% alfa – unghiul de aruncare in radiani
% g – acceleratia gravitationala
% t - vectorul discretizat al timpului
% x – vectorul distantelor la momentele t
% y – vectorul inaltimilor la momentele t
% ymax – inaltimea maxima
%
% facem transformarea de unităti a datelor initiale
g=9.81; % acceleratia gravitationala in m/s2
v=viteza*1609.3/3600; % viteza de aruncare in m/s
alfa=unghi*pi/180; % unghiul de aruncare in radiani
%
% calculam rezultatele
durata=2*v*sin(alfa)/g;
distanta=v*durata*cos(teta);
%
% in plus calculam traiectoria şi o desenam
t=0:0.1:durata;
x=v*t*sin(alfa);
y=v*t*sin(alfa)-g*t.^2;
plot(x,y,’r’)
title(’Traiectoria de zbor’)
xlabel(’Distanta [m] ’)
ylabel (’Inaltimea [m] ’)
disp(’inaltimea maxima’)
ymax=v*sin(alfa)/g
E. Problema este prea simplă ca să comporte testări complexe. Apelarea
funcţie cu datele iniţiale din problemă a condus la următoarele rezultate:
>> [dh,dt]=zbor(50,30);
Inaltimea maxima
ymax =
6.3658
>> dh
dh =
44.1033
>> dt
dt =
2.2784
Deci înălţimea maximă a fost de 6.3659m, distanţa parcursă de
44.1033m, iar durata zborului 2.2784s. Graficul traiectoriei este:
Fig.12.1
Cum ne şi aşteptam o formă de parabolă.
Observaţie. În toate lucrările de până acum la rubrica Indicaţii se
prezentau pe scurt primele 4 puncte din etapele de rezolvare a unei
probleme, iar la rubrica Soluţii cel de-al cincilea punct. Nu vom prezenta
niciodată la rubrica indicaţii aşa de amănunţit o problemă aşa cum am
făcut mai sus.
12.3. Aplicaţii
1. Un observator de înălţime h, aflat la o distanţă d de o clădire,

observă capătul de sus al clădirii sub un unghi α. Să se determine
înălţimea y a clădirii în funcţie de α, h şi d. Caz numeric h=1,80m,
d=30m şi α=60o. (Vezi figura de mai jos.)
α
C Β
h
D
d
Fig. 12.2
2. În figura 12.3 este prezentat un transportor – încărcător.

Greutatea acestei maşini este G1=4500N, iar greutatea încărcăturii este
G2=2500N. Care sunt forţele de reacţiune pe axul din faţă al maşinii (Nf)
şi pe axul din spate (Ns) al maşinii?
G2
A B
Ns G11
Nf
1.5a a 1.5a
Fig. 12.3
3. În figura 12.4 este prezentat un rezervor de gaz lichefiat ce

trebuie proiectat. Volumul rezervorului umplut trebuie să fie 500000
litrii. Costul construcţiei cupolei este de 500 €/m2 iar al părţii cilindrice
este de 300 €/m2. Baza este din beton armat şi are suprafaţa în formă de
cerc a cărui rază este cu 1m mai mare decât al cercului de bază al
cilindrului şi costă 25 €/m2. Etanşarea dintre cilindru şi bază costă 50
€/m. Câteva presupuneri şi limitări sunt necesare:
- datorită suprafeţei disponibile raza cilindrului nu poate depăşi 8m;
- limitări tehnice conduc la limita inferioară pentru rază de 2m;
- nu sunt permise goluri de aer în rezervor.
In aceste condiţii se cere proiectarea unui rezervor cu cost minim de

construcţie
r
h
Fig. 12.4
4. Calculul circuitelor electrice. În figura 12.5 este reprezentat un

circuit electric. Cunoscându-se tensiunea U şi rezistenţele R1, R2, R3,
R4, R5, să se determine intensităţile I1, I2, I3.
Caz numeric U=200V, R1`=R2=R3=5Ω, R4=R5=15Ω.
R 1
I 2
R 2 R 3
+
U - R I R
I 4 5
1 3
Fig. 12.5
5. La macaraua din fig. 12.6 se cunosc: G=10kN, a=1.2m, b=1m, c=8m,

d=2m. Pentru G2=0 determinaţi cea mai mică valoare a lui G1 pentru
care macaraua nu îşi pierde stabilitatea. In aceleaşi condiţii determinaţi
cea mai mare valoare a lui G1 pentru care macaraua nu-si pierde
stabilitatea. Pentru această valoare maximă care este cea mai mare
greutate G2 pe care o poate ridica macaraua. În sfârşit ca la orice macara
cârligul macaralei se poate deplasa de-a lungul braţului adică c variază.
Dacă variaţia lui c este între valorile de 4m şi 8m să se facă un
tabel pentru greutăţile maxime ridicate din jumătate în jumătate de
metru.
d c
b
G1 G
G2
A B
NA NB
a
Fig.12.6
Observaţie. Am utilizat intenţionat comanda disp pentru ai vedea

posibilităţile. Această comandă de obicei listează un singur şir. Dacă
dorim listarea a mai multor şiruri acestea trebuie puse ca elemente ale
unei matrici sau vector.
12.4. Indicaţii
1. Problema este clar formulată, iar figura este un element

ajutător care înlătură orice ambiguitate. Este limpede că înălţimea
clădirii y poate fi calculată din y=AB+BD. Dar BD=h şi rămâne de
determinat segmentul AB. În triunghiul dreptunghic ABC cateta BC=d
AB
iar unghiul ABC = α . Din definiţia tangentei tg α = . Deci
BC
AB = BC tg α = d tg α .Obţinem deci soluţia y = h + d tg α . Un script
cladire va face calculele pentru cazul numeric.:
% date iniţiale
h=1.8;
d=30;
alfa=60*pi/180; % unghiul transformat în radiani
% calculul inaltimii cladirii
y=h+d*tan(alfa);
2. Problema este corect formulată. Pentru rezolvare vom observa

că în condiţiile în care transportorul stă pe loc singura mişcare ce poate
avea loc este o rotaţie (de exemplu greutatea ridicată este prea mare şi
atunci botul maşinii coboară şi spatele maşinii se ridică). Această
mişcare este dată de momentele ce sunt create de forţele ce acţionează.
Deci trebuie să precizăm care sunt ecuaţiile de echilibru ale

momentelor. Sunt două puncte în care aceste momente acţionează asupra
maşinii, punctele A şi B. Întrucât maşina este în echilibru suma
momentelor în cele două puncte este zero. Un moment faţă de un punct
este creat de o forţă înmulţită cu braţul forţei(distanţa de la punctul de
aplicare al forţei la punctul în cauză). Forţele care se aplică chiar în
punct având braţul 0 nu creează momente. Pentru punctul A avem
ecuaţia:
N f ⋅ 2.5a − G1 ⋅1.5a − G2 ⋅ 4a = 0
Braţele forţelor sunt obţinute prin translatarea pe verticală până la
nivelul solului a punctelor de aplicare a lor şi a punctului A acum toate
aceste puncte aflându-se pe acelaşi segment. Semnele contrare sunt date
după cum forţa produce o mişcare de rotaţie în sensul mersului
trigonometric (semnul +) sau invers (semnul -). Pentru punctul B
obţinem ecuaţia:
G1 ⋅ a − N s ⋅ 2.5a − G2 ⋅1.5a = 0
Deci:
G ⋅1.5 + G2 ⋅ 4
Nf = 1
2.5
G − G2 ⋅1.5
Ns = 1
2.5
De remarcat faptul că rezultatele nu depind de valoarea lui a.
Scriptul ridic rezolvă numeric modelul:
% date iniţiale
g1=4500;
g2=2500;
% calculul inaltimii cladirii
nf=(g1*1.5+g2*4)/2.5;
ns=(g1-g2*1.5)/2.5;
3. Enunţul problemei spune cam tot ce este necesar. Putem

presupune că se doreşte costul construcţiei cu aproximaţie la nivel de
euro, eurocenţii fiind neglijabili. Sunt nevoie cunoştinţe de geometrie
elementară privind ariile şi volumele cilindrului şi emisferei:
- lungimea cercului de rază r este: 2πr;
- aria laterală a unui cilindru de rază r şi înălţime h este: 2πrh;
- volumul unui cilindru de rază r şi înălţime h este: πr2h;
- aria unei emisfere de rază r este :2πr2;
- volumul unei emisfere de rază r este :⅔πr3.
Trebuie făcută transformarea din litrii în metrii cubi ştiind că
1l=1dm3. Deci volumul rezervorului este de 500 m3. Dar volumul
rezervorului este:
2
VR = π r 2 h + π r 3 = 500 m3
3
Această formulă permite exprimarea înălţimii în funcţie de rază:
1500 − 2π r 3
h=
3π r 2
Costul construcţiei va fi suma a 4 costuri: cel al cilindrului,al
emisferei,al suprafeţei de beton şi al lungimii îmbinării beton-cilindru.:
cos t = 300 ⋅ 2π rh + 500 ⋅ 2π r 2 + 25 ⋅ π ( r + 1) + 50 ⋅ 2π r
2
O primă variantă de rezolvare ar fi să considerăm raza variind din

milimetru în milimetru între limitele admise de 2 până la 8 m.
Corespunzător se află şi h din formula de mai sus. Înlocuind
obţinem un vector de cost pentru care calculăm minimumul. Scriptul
p143v1 în MATLAB este:
% se definesc vectorii r şi h
r=2:0.001:8;
h=(1500-2*pi*r.^3)/3/pi./r.^2;
% se calculeaza vectorul cost
cost=300*2*pi*r.*h+1000*pi*r.^2+25*pi*(r+1).^2+100*pi*r;
% desenam graficul costului in funcţie de raza

plot(r,cost)
title(’Functia cost’)
xlabel(’raza [m]’)
ylabel(’costul [euro]’)
% calculăm costul minim raza si inaltimea corespunzatoare
[costmin,indmin]=min(cost);
disp(’Costul minim in euro este: ’)
disp(costmin)
disp(’Raza minima in metrii este: ’)
disp(r(indmin))
disp(’Inaltimea minima in metrii este: ’)
disp(h(indmin))
Varianta 2 de rezolvare presupune utilizarea funcţiei fminbnd ce
calculează minimumul funcţiei şi valoarea punctului de minim pentru
funcţii de o variabilă. Aceasta înseamnă că, în funcţia cost în locuim h cu
formula în funcţie de r de mai sus. Comenzile sunt:
>>f=inline('200*(15002*pi*r^3)/r+1000*pi*r^2+25*pi*(r+1)^2+100*pi
*r')
f=
Inline function:
f(r) = 200*(1500-2*pi*r^3)/r+1000*pi*r^2+25*pi*(r+1)^2+100*pi*r
>> [ropt,fval]=fminbnd(f,2,8)
>> hopt=(1500-2*pi*ropt^3)/3/pi/ropt^2
Unde ropt este raza optimă, hopt este înălţimea optimă iar fval costul
minim.
4. În circuitul de rezolvat avem N=4 noduri (punctele negre) şi

L=6 laturi(porţiuni de circuit ce unesc nodurile). Legile lui Kirchoff ne
spun că pe orice porţiune de circuit închis suma tensiunilor (diferenţelor
de potenţial) este nulă. Se pot obţine astfel multe ecuaţii dar numai
L-N+1=3 sunt independente. Adică exact câte necunoscute avem. Acest
lucru înseamnă că soluţia este unică. Pentru obţinerea celor 3 ecuaţii
independente am ales următoarele 3 circuite închise:
1 – circuitul ce conţine sursa de tensiune U,rezistenţa R2 şi rezistenţa R4;
2 – circuitul ce conţine rezistenţa R1, rezistenţa R2 şi rezistenţa R3;
3 – circuitul ce conţine rezistenţa R3, rezistenţa R4 şi rezistenţa R5.
Pentru circuitul 1 pe latura rezistenţei R2 diferenţa de potenţial
este V2=R2I1-R2I2, iar pentru latura rezistenţei R4 este V4= R4I1- R4I3.
Sursa U are tensiunea –VU cu semn contrar potenţialului rezistenţelor
(rezistenţele consumă curent, sursele produc curent). Deci ecuaţia este:
−VU + R2 ⋅ ( I1 − I 2 ) + R4 ⋅ ( I1 − I 3 ) = 0
Analog pentru circuitele 2 şi 3 se obţin ecuaţiile:
R1 ⋅ I 2 + R3 ⋅ ( I 2 − I 3 ) + R2 ⋅ ( I 2 − I1 ) = 0
R5 ⋅ I 3 + R3 ⋅ ( I 3 − I 2 ) + R4 ⋅ ( I 3 − I1 ) = 0
Pentru a rezolva acest sistem liniar în necunoscutele I1, I2, I3
trebuie să-l aducem la forma canonică. Obţinem sistemul:
⎧ ( R2 + R4 ) I1 − R2 I 2 − R4 I 3 = VU
⎪
⎨ − R2 I1 + ( R1 + R2 + R3 ) I 2 − R3 I 3 = 0
⎪− R I − R I + ( R + R + R ) I = 0
⎩ 4 1 3 2 3 4 5 3
Pentru rezolvare vom utiliza facilităţile de calcul simbolic a lui

MATLAB determinând o soluţie generală. Pentru cazul particular vom
utiliza funcţia subs:
>> syms vu r1 r2 r3 r4 r5
>> A=[r2+r4,-r2,-r4;-r2,r1+r2+r3,-r3;-r4,-r3,r3+r4+r5]
A=
[ r2+r4, -r2, -r4]
[ -r2, r1+r2+r3, -r3]
[ -r4, -r3, r3+r4+r5]
>> b=[vu;0;0]
b=
vu
0
0
>> sol=A\b
sol =
vu*(r2*r3+r3*r1+r4*r1+r4*r2+r4*r3+r5*r1+r2*r5+r5*r3)/(r4*r2*r1+r4
*r5*r1+r4*r2*r5+r4*r5*r3+r4*r3*r1+r2*r5*r1+r2*r5*r3+r2*r3*r1)
vu*(r2*r5+r2*r3+r4*r3+r4*r2)/(r4*r2*r1+r4*r5*r1+r4*r2*r5+r4*r5*r3
+r4*r3*r1+r2*r5*r1+r2*r5*r3+r2*r3*r1)
vu*(r2*r3+r4*r1+r4*r2+r4*r3)/(r4*r2*r1+r4*r5*r1+r4*r2*r5+r4*r5*r3
+r4*r3*r1+r2*r5*r1+r2*r5*r3+r2*r3*r1)
>> subs(sol,[vu,r1,r2,r3,r4,r5],[200,5,5,5,15,15])
5. Macaralele au nevoie de contragreutăţi (de valoare G1) pentru

a echilibra asimetria centrului de greutate (punctul de aplicare a lui G)în
ipoteza G2=0 Astfel dacă contragreutatea este prea mică macaraua se va
roti în jurul punctului B şi va cădea în faţă. Cea mai mică valoare a lui
G1 pentru care nu se întâmplă acest lucru o vom nota minG1. Dar când
ştim că am găsit această valoare. Simplu când roata A se ridică în sus
adică NA=0. Acum dacă alegem o contragreutate prea mare macaraua se
va roti în jurul punctului A ( şi ca mai sus NB=0) valoarea cea mai mare
a lui G1 pentru care acest lucru nu se produce o vom nota cu maxG1.

Evident când contragreutatea ca avea o valoare apropiată de minG1
macaraua nu va putea ridica o greutate G2 prea mare. Deci în practică
contragreutatea va avea o valoare apropiată de maxG1.Aflarea lui
minG1 şi a lui maxG1 răspunde la primele două cerinţe ale problemei.
Pentru calculul lui minG1 vom analiza momentele create în
punctul B Suma lor trebuie să fie 0 .momente creează doar minG1 şi G.
Braţul forţei lui minG1 este d+a/2, iar braţul forţei G este b-a/2. Deci în
ipoteza că NA=0 şi G2=0 obţinem :
⎛ a⎞ ⎛ a⎞
min G1 ⋅ ⎜ d + ⎟ − G ⋅ ⎜ b − ⎟ = 0
⎝ 2⎠ ⎝ 2⎠
Semnul – din faţa lui G indică faptul că G are tendinţa de a roti
macaraua în sens invers decât minG1. Deci :
2b − a
min G1 = G
2d + a
Pentru calculul lui maxG1 analizăm momentele în punctul A.
Ţinem cont că acum NB=0 şi G2=0 şi obţinem:
⎛ a⎞ ⎛ a⎞
max G1⎜ d − ⎟ − G ⎜ b + ⎟ = 0
⎝ 2⎠ ⎝ 2⎠
Deci:
2b + a
max G1 = G
2d − a
Greutate G2 maximă pe care macaraua o poate ridica o vom nota
cu maxG2. Întrucât această greutate se obţine când contragreutatea are
valoarea maxim admisibilă maxG1 rezultă că NA=0. Suma momentelor
în B trebuie să fie 0. Braţele forţelor sunt: d+a/2 pentru maxG1,b-a/2
pentru G şi c-a/2 pentru maxG2. forţele G şi maxG2 rotesc macaraua în
sens invers lui maxG1. deci:
⎛ a⎞ ⎛ a⎞ ⎛ a⎞
max G1⎜ d + ⎟ − G ⎜ b − ⎟ − max G 2 ⎜ c − ⎟ = 0
⎝ 2⎠ ⎝ 2⎠ ⎝ 2⎠
Rezultă:
max G1( 2d + a ) − G ( 2b − a )
max G 2 =
2c − a
Pentru calculul tabelului vom da valori lui c cuprinse între 4 şi 8
m.
Observaţie. Din cele de mai sus rezultă că 2b-a>0,2c-a>0 şi 2d-
a>0. Dacă 2b-a<0 atunci minG1=0. (Centrul de greutate G este plasat
între roti şi macaraua este stabilă fără încărcătură)
Scriptul macara care face aceste calcule este:
% initializare date cunoscute
G=10000;
a=1.2;
b=1;
c=4:0.5:8;
d=2;
% teste de validare
if 2*b-a<0
disp(' a incompatibil cu b - rezultate eronate')
elseif 2*c-a<0
disp(' a incompatibil cu c - rezultate eronate')
elseif 2*d-a<0
disp(' a incompatibil cu d - rezultate eronate')
end
% calculele
minG1=(2*b-a)/(2*d+a)*G;
disp(['Valoarea minima a lui G1 este: ',num2str(minG1)])
maxG1=(2*b+a)/(2*d-a)*G;
disp(['Valoarea maxima a lui G1 este: ',num2str(maxG1)])
maxG2=(maxG1*(2*d+a)-G*(2*b-a))./(2*c-a);
disp(['Val. maxima a lui G2 pentru c=8 este: ',num2str(maxG2(end))])
% tabelul
disp(' c maxG2')
for ind=1:length(c)
disp([' ',num2str(c(ind)),' ',num2str(maxG2(ind))])
end
12.5. Soluţii
1.
>> cladire
>> y
y=
53.7615
Deci y=53.76m.
2.
>> ridic
>> nf
nf =
6700
>> ns
ns =
300
3. Varianta 1
>> p143v1
Costul minim in euro este:
1.0812e+005
Raza minima in metrii este:
4.2040
Inaltimea minima in metrii este:

6.2026
Pentru varianta 2 avem rezultatele:
ropt =
4.2035
fval =
1.0812e+005
>> hopt=(1500-2*pi*ropt^3)/3/pi/ropt^2
hopt =
6.2050
Diferenţele dintre rezultatele celor două variante sunt minime . Graficul
funcţiei cost este dat mai jos:
Fig.12.7
4.
>> subs(sol,[vu,r1,r2,r3,r4,r5],[200,5,5,5,15,15])
ans =
20
10
10
Deci I1=20A, I2=10A, I3=10A.
5. Execuţia scriptului macara:

>> macara
Valoarea minima a lui G1 este: 1538.4615
Valoarea maxima a lui G1 este: 11428.5714
Val. maxima a lui G2 pentru c=8 este: 3474.9035
c maxG2
4 7563.0252
4.5 6593.4066
5 5844.1558
5.5 5247.8134
6 4761.9048
6.5 4358.3535
7 4017.8571
7.5 3726.7081
8 3474.9035
Se remarcă faptul că greutatea maximă pe care macaraua o poate ridica

este mai mare când c este mai mic.
LUCRAREA 13
Această lucrare continuă prezentarea unor exemple semnificative

ale utilizării MATLAB. Gradul de complexitate însă este mai mare decât
în lucrǎrile din prima parte şi programele sunt mai elaborate. Se introduc
şi comenzi specifice calculului vectorial.

rezolvarea problemelor tehnice.
13.2.1. Calcul vectorial în MATLAB
Deoarece unele probleme necesită pentru rezolvare calcul cu

vectori prezentăm aici noţiuni elementare de calcul vectorial în
MATLAB. Ne vom ocupa doar de calculul vectorial în 3 dimensiuni.
Vom considera vectorii ca triplete (x1,x2,x3) scrise orizontal (pentru
MATLAB are sens şi vectorul scris vertical). Cele trei valori din
paranteză reprezintă de fapt un punct în coordonate carteziene. Vectorul
este de fapt s săgeată ce plecă din O(0,0,0) şi are vârful în x(x1,x2,x3).
Vom utiliza în cele ce urmează pentru exemplificări vectorii x(1,-2,6) şi
y(2,1,5). Adunarea şi scăderea a doi vectori se face obişnuit cu operatorii
+ şi - :
>> x=[1,-2,4]
x=
1 -2 4
>> y=[2,1,5]
y=
2 1 5
>> x+y
ans =
3 -1 9
>> x-y
ans =
-1 -3 -1
Şi înmulţirea cu o constantă se face în mod obişnuit:
>> 3*x
ans =
3 -6 12
>> -2*y
ans =
-4 -2 -10
Lungimea segmentului din săgeată se numeşte mărimea
vectorului şi se obţine cu funcţia MATLAB norm:
>> norm(x)
ans =
4.5826
>> norm(y)
ans =
5.4772
Produsul scalar a doi vectori se face cu funcţia dot :
>> dot(x,y)
ans =
20
Produsul vectorial a doi vectori z=xXy se face cu ajutorul
funcţiei MATLAB cross şi este evident tot un vector :
>> z=cross(x,y)
z=
-14 3 5
Produsul exterior a doi vectori este o matrice care se obţine în
MATLAB înmulţind transpusa lui x cu y:
>> x'*y
ans =
2 1 5
-4 -2 -10
8 4 20
Vectorul unitate ux( are mărimea 1. deci norm(ux)=1) pe direcţia
lui x se obţine cu formula:
>> ux=x/norm(x)
ux =
0.2182 -0.4364 0.8729
>> norm(ux)
ans =
1
Unghiul ( în radiani) dintre vectorii x şi y se obţine cu formula:
>> alfa=acos(dot(x,y)/(norm(x)*norm(y)))
alfa =
0.6488
>> alfagr=alfa*180/pi
alfagr =
37.1726
Deci unghiul dintre vectorii x şi y este de 0.6488 radiani sau
37.1726o.
Vom spune că doi vectori sunt ortogonali dacă dot(x,y)=0.
evident din formula de mai sus rezultă că unghiul dintre ei este 90o.
Proiecţia z a vectorului x pe vectorul y este de forma ay unde a este o
constantă ce se cere determinată. În MATLAB această constantă este :
>> a=dot(x,y)/norm(y)^2
a=
0.6667
Deci z=0.6667y.
13.3. Aplicaţii
1. În fig.13.1 în punctele C şi D sunt reprezentate două

debarcadere de pe malul unui lac. Problema constă în a afla distanţa CD
dintre cele două debarcadere cunoscând unghiurile şi distanţele din
figură.
E
D
C
O
15 B
O
45
30 O 500 m
45O
30 O
Fig.13.1
2. Un mecanic de metrou are graficul acceleraţiilor dintre staţiile

A şi B ca în fig.13.2. Deci în primele 8 secunde merge cu acceleraţia de
1m/s2, în intervalul ∆t (necunoscut de noi dar cunoscut de mecanic)
accelerează cu 2m/s2, iar în ultimele 10 secunde accelerează cu -2m/s2
(frânează dacă vreţi). Determinaţi intervalul ∆t şi distanţa d dintre staţii.
2
a [m/s ]
t[s]
0
20 s ∆t 40 s
-1
I II III
Fig.13.2
3. Un vapor navighează cu viteza de 20 noduri la 60o NE.

Curentul local datorită mareei are viteza de 2 noduri la 300o NW. Vântul
bate cu viteza de 0.5 noduri la 180o S. Calculaţi viteza reală şi cursul
real al vaporului (Vezi figura 13.3 pentru poziţiile vectorilor viteză).
O
360
O
0
CURENT
Y L
α
VAPOR
O O
270 90
VANT
O
180
Fig.13.3
13.4. Indicaţii
1.Din relaţia CD=BE-BC-DE rezultă că trebuie sa aflăm mai

întâi lungimea segmentelor BE, BC şi DE. Prima lungime ce o vom afla
va fi BC. În triunghiul dreptunghic ce are ca şi ipotenuză pe AB :
500 500
sin 30o = ⇒ AB =
AB sin 30o
În ABC al treilea unghi este : Cˆ = 180o − 30o − 45o . Folosim
teorema sinusurilor în ABC pentru a calcula latura BC :
BC AB AB sin 30o
= ⇒ BC =
sin 30o sin Cˆ sin Cˆ
În ABE determinăm unghiul Â : Aˆ = 180o − 30o − 45o . Atunci

unghiul Eˆ = 180o − Aˆ − Bˆ ⇒ Eˆ = 180o − (180o − 30o − 45o ) − 450 = 30o
Rezultă că ABC ~ ABE (sunt asemenea) având două unghiuri
egale. Deci au laturile proporţionale:
BE AB AB 2
= ⇒ BE =
AB BC BC
În ABE aplicăm teorema sinusurilor:
AE AB AB sin 45o
= ⇒ AE =
sin 45o sin 30o sin 300
În ADE calculăm unghiul D̂ : Dˆ = 180o − 30o − 150 . În acelaşi
triunghi aplicăm teorema sinusurilor:
DE AE AE sin15o
= ⇒ DE =
sin15o sin Dˆ sin D
Putem acum utiliza prima formulă pentru calculul lui CD.
Scriptul distcd de mai jos face toate aceste calcule.
% calculam unghiurile intiale si sinusurile lor
u15=15*pi/180;
u30=30*pi/180;
u45=45*pi/180;
uc=(180-30-45)*pi/180;
ud=(180-30-15)*pi/180;
su15=sin(u15);
su30=sin(u30);
su45=sin(u45);
suc=sin(uc);
sud=sin(ud);
% segmentul BC
ab=500/su30;
bc=ab*su30/suc;
%segmentul BE
be=ab^2/bc;
% segmentul DE
ae=ab*su45/su30;
de=ae*su15/sud;
% segmentul CD cerut
cd=be-bc-de;
disp(['distanta dintre debarcadere este: ',num2str(cd),' metrii'])
2. vom determina întâi durata ∆t. Vom nota cu to=0 momentul

când metroul pleacă din A şi aI=1 m/s2, cu t1 momentul când începe
acceleraţia de aII=2 m/s2 , cu t2 momentul când începe frânarea
(acceleraţia aIII=-2 m/s2) şi cu t3 momentul opririi în B. Din definiţia
t
dv 3
acceleraţiei: a = ⇒ ∆v = ∫ a dt .
dt t0
Viteza la momentul to este 0 şi la fel la momentul t3 când s-a

oprit în B. Deci ∆v=0 Pentru calculul integralei ţinând cont de formula
funcţiei a :
⎧ aI daca t ∈ [t0 , t1 ]
⎪
a = ⎨ aII daca t ∈ [t1 , t2 ]
⎪a
⎩ III daca t ∈ [t2 , t3 ]
Atunci :
t3 t1 t2 t3 t1 t2 t3
∫ a dt = ∫ a dt + ∫ a dt + ∫ a dt = ∫ aI dt + ∫ aII dt + ∫ aIII dt =
t0 t0 t1 t2 t0 t1 t2
t1 t2 t3
= aI ∫ dt + aII ∫ dt + aIII ∫ dt = aI ( t1 − t0 ) + aII ( t2 − t1 ) + aIII ( t3 − t2 ) =

t0 t1 t2
= aI ∆t I + aII ∆t II + aIII ∆t III

Dar ∆t = ∆t II , ∆t I = 20s, ∆t III = 40 s şi obţinem astfel relaţia ce-l

aI ∆t I + aIII ∆t III
determină pe ∆t : ∆t = − . În continuare vom folosi
aII
formulele pentru viteza şi distanţă cu viteza iniţială v0 şi distanţa iniţială
d0 :
v = v0 + a∆t
1
d = d 0 + v0 ∆t + a∆t 2
2
Vom aplica aceste formule pe fiecare din intervalele I, II, III.
Pentru intervalul I nu avem viteză iniţială şi nici distanţă iniţială
1
şi deci avem : vI = aI ∆t I d I = aI ∆t I2 Pentru intervalul II viteza iniţială
2
este chiar vI, iar distanţa iniţială este dI şi deci formulele sunt:
1
vII = vI + aII ∆t II d II = d I + vI ∆t II + aII ∆t II2
2
Analog pentru intervalul III valorile iniţiale sunt cele obţinute la
intervalul II şi deci avem formula (ştim că vIII=0) :
1
d III = d II + vII ∆t III + aIIL ∆t III
2
2
Scriptul metrou de mai jos face calculele :
% date initiale
acci=1;
accii=2;
acciii=-2;
deltati=20;
deltatiii=40;
% calculul lui deltaii
deltatii=-(acci*deltati+acciii*deltatiii)/accii;
% primul interval
vi=acci*deltati;
di=0.5*acci*deltati^2;
% al doilea interval
vii=vi+accii*deltatii;
dii=di+vi*deltatii+0.5*accii*deltatii^2;
% intervalul al treilea
diii=dii+vii*deltatiii+0.5*acciii*deltatiii^2;
disp(['durata intervalului este : ',num2str(deltatii),'s'])
disp(['distanta dintre statii este : ',num2str(dii),'m'])
3. În acest caz avem vectori cu două dimensiuni, deci de forma

(x,y). Viteza reală a vasului este suma vectorilor precizaţi în problemă.
Numai că noi nu cunoaştem aceşti vectori, ci mărimile lor şi
unghiurile pe care le fac cu axa verticală din desen. În figura 13.3 în
stânga sus am desenat un vector de lungime L şi unghi α. Se vede
imediat că x şi y sunt proiecţiile vectorului pe axe. Deci x=Lcos α, iar
y=Lsin α. Scriptul vapor de mai jos face calculele necesare :
% date initiale
vvapor=20;
uvapor=60*pi/180;
vcurent=2;
ucurent=300*pi/180;
vvant=0.5;
uvant=180*pi/190;
% determinam vectorul viteza al vaporului
disp('vectorul viteza al navei este')
V=vvapor*[cos(uvapor),sin(uvapor)]
% determinam vectorul viteza al curentului
disp('vectorul viteza al curentului mareic este')
S=vcurent*[cos(ucurent),sin(ucurent)]
% determinam vectorul viteza al vaporului

disp('vectorul viteza al vantului este')
T=vvant*[cos(uvant),sin(uvant)]
% calculam viteza reala si cursul (unghiul) navei
disp('viteza reala a navei este')
U=V+S+T;
vrn=norm(U)
alfa=atan2(U(2),U(1))*180/pi;
% verificam daca alfa este pozitiv
if alfa < 0
alfa=360+alfa;
end
disp('cursul vasului este:')
alfa
Am utilizat în acest script funcţia atan2 pentru inversa tangentei

⎡ π π⎤
pentru că spre deosebire de funcţia atan se află în intervalul ⎢ − , ⎥ ,
⎣ 2 2⎦
funcţia atan2 se află în intervalul [ −π , π ] .
13.5. Soluţii
1.
>> distcd
distanta dintre debarcadere este: 896.5755 metri
2.
>> metrou
durata intervalului II este : 30s
distanta dintre statii este : 1700m
3.
>> vapor
vectorul viteza al navei este
V=
10.0000 17.3205
vectorul viteza al curentului mareic este
S=
1.0000 -1.7321
vectorul viteza al vantului este
T=
-0.4932 0.0823
viteza reala a navei in noduri este
vrn =
18.8671
cursul vasului in grade este:
alfa =
56.1592
Se remarcă o deviere de aproape 4 grade de la curs şi o reducere a vitezei
cu 1.1 noduri, cauzate de maree şi vânt. Cu ce unghi trebuie să
cârmească căpitanul şi cu cât trebuie să mărească viteza pentru ca viteza

reală să fie de 20 noduri şi cursul 60 NE este altă problemă.
LUCRAREA 14
Această lucrare continuă prezentarea unor exemple semnificative

ale utilizării MATLAB. Gradul de complexitate însă este mai mare decât
în lucrarea 1 şi programele sunt mai elaborate. Unul dintre ele introduce
o animaţie simplă.

rezolvarea problemelor tehnice. (Continuare)
14.3. Aplicaţii
1. În figura 14.1 este reprezentată o roată C de centru O, de rază

R. Se cunosc raza R=0.7 m şi acceleraţia unghiulară ω = −0.001 rad/s.
Dacă punctul M de pe circumferinţa roţii, este punctul de contact al roţii
cu solul S la t=0, să se determine viteza şi acceleraţia lui M la t=125s.
Rostogolirea roţii este fără frecare.
C
R
M X
S
Fig.14.1
2. În figura 14.2 este reprezentat un braţ de robot ce are două

legături conectate prin două îmbinări: o îmbinare bază şi o îmbinare cot.
În fiecare îmbinare se află câte un motor ce roteşte braţul. Baza
permite doar rotaţii. Lungimile legăturilor sunt L1, respectiv L2, iar
unghiurile cu orizontala sunt α1, respectiv α2. Braţul robotului se află la
momentul 0 într-o poziţie cunoscută, adică se cunosc cele două unghiuri
şi se află în repaus, adică viteza unghiulară şi acceleraţia unghiulară a
fiecărei legături sunt nule. De asemenea el ajunge la momentul t în altă
poziţie (alte unghiuri cunoscute) tot în repaos. Se cere determinarea unei
funcţii ce să descrie mişcarea braţului de robot de la 0 la t şi să se traseze
graficul traiectoriei lui A. Caz particular: tf=10s, α1(0)=-19o, α2(0)=44o,
α1(tf)=43o, α2(tf)=151o, L1=1.2m, L2=0.9m. Indicaţie: De fapt este vorba
de două funcţii ce precizează cele două unghiuri la fiecare moment t.
y
Brat de robot
A
Mana
L2
α2
L1
Cot
α1 X
Baza
Fig.14.2
3. Se dă o placă dreptunghiulară pentru care se cunosc

temperaturile părţilor laterale. Temperaturile sunt : partea de nord, est şi
vest a plăcii au temperatura de 100oC, iar partea de sud 50oC.
Presupunând că distribuţia de temperaturi pe placă este o funcţie
continuă şi derivabilă f ce depinde doar de poziţia punctului pe placă să
se determine această distribuţie cu toleranţa 0.01. Dacă (0,0) sunt
coordonatele colţului din stânga jos al tablei şi (50,50) coordonatele
colţului din dreapta sus care este temperatura punctului V(21.18, 34.55)?
14.4. Indicaţii
1. Cunoaştem deci raza r, acceleraţia unghiulară a roţii auc şi

timpul t. Prima mărime care o putem afla este viteza unghiulară la
momentul t vuc=auc*t. De asemenea putem afla unghiul de rotaţie la
momentul t alfa=-π/2+vuc*t+1/2*auc*t2. Pentru acest unghi dorim să
aflăm care sunt vectorul unitar tangent şi vectorul unitar normal la cercul
circumferinţă în punctul corespunzător acestui unghi pe cerc. Este
evident vorba despre un vector în două dimensiuni. Vom prezenta aici
un alt mod de a utiliza perechea (x,y) care reprezintă vectorul. Am mai
spus că (x,y)=L(cosα,sinα), putem echivala deci un vector bidimensional
cu numărul complex z=x+iy=||z||(cosα,sinα)=||z||eiα. Pentru calculul lui
||z|| avem funcţia abs(z), iar pentru calculul lui α avem funcţia angle(z).
Putem defini acum vectori unitari doriţi, cel tangent vtc=ei*(alfa+π/2) şi cel
normal vnc=ei*(alfa+π). Trebuie să calculăm viteza liniară şi acceleraţia
liniară a centrului C la momentul 0, care sunt viteza iniţială şi
acceleraţia iniţială pentru punctul M. Astfel viteza este vc=-vuc+r şi
acceleraţia este ac=-auc*r. Putem acum calcula în sfârşit viteza
liniară şi acceleraţia liniară a lui M la momentul t. Viteza este
vm=vc+vuc*r*vtc, iar acceleraţia este am=ac+auc*r*vtc+vuc2*vnc.
Evident am obţinut rezultatul sub forma unor numere complexe a
căror parte reală şi imaginară sunt componentele vectorilor căutaţi.
Funcţia roata are ca date de intrare r – raza, tf – timpul şi auc –
acceleraţia unghiulară. Programul roata are 3 părţi. Prima parte face
calculele pentru obţinerea rezultatelor. A doua parte construieşte graficul
traiectoriilor. A treia parte face o animaţie a mişcării roţii de la
momentul t=0 la momentul t=tf cu reprezentarea vectorului viteză în
punctul M.
function roata(r,auc,tf)
%deplasarea unei roti

% Date initiale
%r=0.7; %raza
t=0:0.1:tf; %Timpul din zecime in zecime de secunda
%auc=-0.001; %acceleratia
%partea I
% Viteza unghiulara a rotii
vuc=auc*t';%rad/s
%unghiul de rotatie al rotii
alfa=-pi/2+vuc.*t'+0.5*auc*t'.*t';
% Vectorii normal si tangent
vtc=exp(i*(alfa+pi/2));
vnc=exp(i*(alfa+pi));
%viteza centrului O
vc=-vuc*r;
%Acceleratia centrului O
ac=-auc*r;
%viteza lui M
vm=vc+vuc*r.*vtc;
% acceleratia lui M
am=ac+auc*r*vtc+vuc.*vuc*r.*vnc;
disp(['Vectorul viteza al lui M este : ','[',num2str(real(vm(end))),...
',',num2str(imag(vm(end))),']'])
mav=abs(vm(end));
ualfa=angle(vm(end))*180/pi;
if ualfa < 0
ualfa=360+ualfa;
end
disp(['marimea si unghiul vitezei in M:

',num2str(mav),',',num2str(ualfa)])
disp(['Vectorul acceleratie al lui M este : ','[',num2str(real(am(end))),...
',',num2str(imag(am(end))),']'])
aav=abs(am(end));
aalfa=angle(am(end))*180/pi;
if ualfa < 0
ualfa=360+ualfa;
end
disp(['marimea si unghiul acceleratiei in M :
',num2str(aav),',',num2str(aalfa)])
% scalam viteza, raza pentru reprezentare grafica
vm=vm*10;
r=r*auc/-0.001;
disp('Tasteaza orice tasta pentru a continua.......');
pause;
% Partea II
% graficul traiectoriilor
%Traiectoria lui O
ec=vc.*t'+i*r;
%Traiectotia lui M
em=ec-r*vnc;
plot(real(ec),imag(ec),'r',real(em),imag(em),'b')
title('Traiectoria lui O (rosu) si M (albastru)')
pause;
% partea III
% generarea animatie
%desenul initial
%generarea partii fixe-fundalul, baza fiind dependenta de r si ex(end)
xdr=real(ec(end))/2;
ydr=r;
s0=fundal(xdr,-ydr/2,2*xdr,ydr,0);
hd0=fill(s0.x,s0.y,'c');
title('Miscarea cu rostogolire a unei roti - viteza');
hold on; % comanda care fixează fundalul
%desenarea rotii C in pozitia initiala

s1=disc(real(ec(1)),imag(ec(1)),r,alfa(1));
hd1=fill(s1.x,s1.y,'g');
%desenarea punctului M in pozitia initiala

sem=disc(real(em(1)),imag(em(1)),r*0.08,alfa(1));
hdem=fill(sem.x,sem.y,'b');
%desenarea vectorului viteza in M in pozitia initiala

av=vector(real(em(1)),imag(em(1)),abs(vm(1)),angle(vm(1)));
hdav=fill(av.x,av.y,'r');
axis equal;
axis manual;
axis off;
disp('Tasteaza orice tasta pentru animatie.......');
pause;
n=max(size(alfa));
for l=1:n,
%desenarea rotii C la momentul t=l

s1=disc(real(ec(l)),imag(ec(l)),r,alfa(l));
set(hd1,'XData',s1.x,'YData',s1.y);
%desenarea punctului M in pozitia initiala

sem=disc(real(em(l)),imag(em(l)),r*0.08,alfa(l));
set(hdem,'XData',sem.x,'YData',sem.y);
%desenarea vectorului viteza in M in pozitia initiala

av=vector(real(em(l)),imag(em(l)),abs(vm(l)),angle(vm(l)));
set(hdav,'XData',av.x,'YData',av.y);
drawnow; % aceasta comanda face efectiv desenarea in noua pozitie

end;
pause;
% Recomandarea este ca partile în miscare sa fie definite ca subfunctii
function coord=fundal(xc,yc,xl,yl,a)
%coord=fundal(xc,yc,xl,yl,a)
%coord.x coord.y
%calculul coordonatelor unui dreptunghi de lungime xl si de latime yl.
%dreptunghiul este rotit cu unghiul a
coord.x=zeros(1,5);
coord.y=zeros(1,5);
sa=sin(a);
ca=cos(a);
coord.x(1)=xc-xl/2*ca+yl/2*sa;
coord.y(1)=yc-xl/2*sa-yl/2*ca;
coord.x(2)=xc+xl/2*ca+yl/2*sa;
coord.y(2)=yc+xl/2*sa-yl/2*ca;
coord.x(3)=xc+xl/2*ca-yl/2*sa;
coord.y(3)=yc+xl/2*sa+yl/2*ca;
coord.x(4)=xc-xl/2*ca-yl/2*sa;
coord.y(4)=yc-xl/2*sa+yl/2*ca;
coord.x(5)=coord.x(1);
coord.y(5)=coord.y(1);
function coord=disc(xc,yc,r,a)
%coord=disc(xc,yc,r,a)
%coord.x coord.y
%calculul coordonatelor unui disc de centru (xc,yc), de raza r. (24 laturi)
%o raza este desenată la unghiul a.
n=12;%1/2 numar de laturi
th=a:pi/n:a+2*pi;
coord.x=zeros(1,2*n+2);
coord.y=zeros(1,2*n+2);
coord.x=xc+r*cos(th);
coord.y=yc+r*sin(th);
coord.x(2*n+2)=xc;
coord.y(2*n+2)=yc;
function coord=vector(xa,ya,r,a)
%coord=vector(xa,ya,r,a)
%coord.x coord.y
%calculul coordonatelor unui vector cu punctul de aplicare (xa,ya),
%de lungime r si avand un unghi a
coord.x=zeros(1,5);
coord.y=zeros(1,5);
coord.x(1)=xa;
coord.y(1)=ya;
b=xa+i*ya+r*exp(i*a);
coord.x(2)=real(b);
coord.y(2)=imag(b);
% an unghiul varfurilor sagetii
an=165*pi/180;
c=b+0.2*r*exp(i*(a+an));
d=b+0.2*r*exp(i*(a-an));
coord.x(3)=real(c);
coord.y(3)=imag(c);
coord.x(4)=real(d);
coord.y(4)=imag(d);
coord.x(5)=coord.x(2);
coord.y(5)=coord.y(2);
2. Poziţia punctului A în plan este dată de formulele:

x = L1 cos α1 + L2 cos (α1 + α 2 )
y = L1 sin α1 + L2 sin (α1 + α 2 )
Este necesară determinarea cu aproximaţie a funcţiilor α1(t) şi
α2(t) cu t ∈ [ 0, 2] . Vom aproxima aceste funcţii prin polinoame. Evident
cele două funcţii sunt independente. Dar ce grad trebuie să aibă
polinoamele? Acest lucru ne este impus de condiţiile pe care trebuie să
le verifice cele două funcţii. Condiţiile sunt: în t=t0=0, cât şi în t=tf se
cunosc unghiurile (deci 2 condiţii) cât şi vitezele care sunt nule (deci
încă 2 condiţii) şi evident şi acceleraţiile sunt nule (deci încă 2 condiţii.
În total funcţiile trebuie să verifice 6 condiţii. Rezultă că putem
determina în mod unic câte un polinom de grad 5 pentru fiecare funcţie
care să verifice condiţiile. Vom calcula acest polinom pentru α1(t)
calculele făcându-se identic şi pentru α2(t). Deci:
α1 ( t ) = a5 + a4t + a3t 2 + a2t 3 + a1t 4 + a0t 5
α 2 ( t ) = b5 + b4t + b3t 2 + b2t 3 + b1t 4 + b0t 5
Rezultă α1 ( 0 ) = a5 . De asemenea derivatele de ordin 1 şi 2 în 0

sunt 0. Derivând obţinem :
α1 ( t ) = a4 + 2a3t + 3a2t 2 + 4a1t 3 + 5a0t 4
α1 ( t ) = 2a3 + 6a2t + 12a1t 2 + 20a0t 3
Înlocuind t=0 şi egalând cu 0 rezultă că a4 = 0, a5 = 0 . Punem
condiţii şi în punctul tf şi obţinem:
⎧a2t 3f + a1t 4f + a0t 5f = α1 ( t f ) − α1 ( 0 )
⎪⎪
⎨ 3a2t 2f + 4a1t 3f + 5a0t 4f = 0
⎪ 6a t + 12a t 2 + 20a t 3 = 0
⎪⎩ 2 f 1 f 0 f
Adică un sistem liniar în necunoscutele a2, a1 şi a0. Acelaşi

sistem se obţine şi pentru celălalt polinom.
Scriptul robot rezolvă aceste sisteme şi construieşte graficul
traiectoriei lui A.
% date initiale
xa10=-19*pi/180;
xa1tf=43*pi/180;
xtf=10;
xa20=44*pi/180;
xa2tf=151*pi/180;
L1=1.2;
L2=0.9;
% calculul simbolic al functiilor
syms a1tf a10 tf t a2tf a20
x=[tf^3,tf^4,tf^5;3*tf^2,4*tf^3,5*tf^4;6*tf,12*tf^2,20*tf^3]
y=[a1tf-a10;0;0]
a=x\y;
alfa1=a10+a(1)*t^3+a(2)*t^4+a(3)*t^5;
z=[a2tf-a20;0;0];
b=x\z;
alfa2=a20+b(1)*t^3+b(2)*t^4+b(3)*t^5;
% functia alfa1 pentru cazul dat
disp('alfa1')
falfa1=subs(alfa1,{a10,a1tf,tf,t},{xa10,xa1tf,xtf,t})
disp('alfa2')
falfa2=subs(alfa2,{a20,a2tf,tf,t},{xa20,xa2tf,xtf,t})
% calculul traiectoriei punctului A
tt=0:0.1:xtf;
% vectorul unghiurilor alfa1 de la 0 la tf
aa1=double(subs(falfa1,t,tt));
% vectorul unghiurilor alfa2 de la 0 la tf
aa2=double(subs(falfa2,t,tt));
% calculul pozitiei lui A
x=L1*cos(aa1)+L2*cos(aa1+aa2);
y=L1*sin(aa1)+L2*sin(aa1+aa2);
% Traiectoria lui A
plot(x,y,'r')
title('Traiectoria punctului A')
Remarcaţi în acest script utilizarea combinată de tipuri simbolic

şi numeric. Remarcaţi utilizarea funcţiei subs pentru substituţii şi a
funcţiei double pentru trecerea la modul numeric (implicit) al lui
MATLAB.
3. Este limpede că nu avem destule date pentru a determina o

formulă exactă pentru f. Ne propunem atunci să determinăm
temperaturile cu aproximaţie într-un număr discret de puncte. De aceea
împărţim placa într-un număr finit de puncte egal distanţate între ele.
Deoarece funcţia f este continuă şi derivabilă este logic să

presupunem că valoarea într-un punct este media aritmetică a valorilor
temperaturilor a celor patru vecini ai săi pe linie şi pe coloană: cel din
nord, cel din vest, cel din sud şi cel din est (vezi figura 14.3):
T ( m − 1, n ) + T ( m, n − 1) + T ( m + 1, n ) + T ( m, n + 1)
T ( m, n ) =
4
Este limpede că trebuie să reluăm calculele până când pentru

toate punctele temperatura calculată anterior şi temperatura prezentă
diferă mai puţin decât toleranţa. Presupunem că am rezolvat problema
discretă. Atunci cum determinăm temperatura unui punct oarecare
V(x,y)? Orice astfel de punct se va afla într-un pătrat ale cărui colţuri au
temperaturile cunoscute. Este limpede că temperatura lui V va depinde
de temperaturile colţurilor, dar şi de poziţia punctului faţă de colţuri. O
astfel de formulă este:
⎛ ⎛ ⎛ 2 ⎞ ⎛ 2 ⎞⎞ ⎞
⎜ 1 ⎜T ⎜1− ( xA − xV ) + ( yA − yV ) ⎟ + T ⎜1− ( xB − xV ) + ( yB − yV ) ⎟ ⎟ + ...⎟
2 2
⎜ 2 ⎜⎜ A ⎜ d 2 ⎟ B⎜ d 2 ⎟ ⎟⎟ ⎟
⎜ ⎝ ⎝ ⎠ ⎝ ⎠⎠ ⎟
TV = ⎜ ⎟
⎜ ⎛ ( xC − xV ) + ( yC − yV ) ⎞
2 2 ⎛ ( xD − xV ) + ( yD − yV ) ⎞ ⎟
2 2
⎜... + TC ⎜1− ⎟ + T ⎜1− ⎟ ⎟

⎜ ⎜ d 2 ⎟ D
⎜ d 2 ⎟ ⎟
⎝ ⎝ ⎠ ⎝ ⎠ ⎠
(50, 50)
(m-1,n)
(m,n-1) (m,n) (m,n+1)
A B
(m+1,n)
V
C D
(0, 0)
Fig.14.3
Scriptul temperatură are trei părţi. Mai întâi calculează distribuţia

temperaturilor pe placă, apoi temperatura lui V şi în final graficul
distribuţiei temperaturilor pe placă.
%
% Acest program calculează distribuţia
% temperaturilor intr-o placa
%
nrr = input('Numar de linii ');
nrc = input('Numar de coloane ');
iso1 = input('temperatura la nord ');

iso3 = input('Temperatura la sud ');
iso2 = input('Temperatura la vest ');
iso4 = input('Temperatura la est ');
toler = input('Toleranta ');
lx=input('lungimea placii lx= ');
ly=input('latimea placii ly= ');
vx=input('abscisa lui V, vx= ');
vy=input('ordonata lui V, vy= ');
%
% Initializeaza matricea temperaturilor
%
old = zeros(nrr,nrc);
old(:,1) = iso2 + zeros(nrr,1);% vest
old(:,nrc) = iso4 + zeros(nrr,1); % est
old(nrr,:) = iso3 + zeros(1,nrc); % sud
old(1,:) = iso1 + zeros(1,nrc); % nord
disp('Temperaturi initiale')
disp(old)
disp(' ')
new = old;
equilibrium = 0;
%
% Bucla de calcul. Se iese cand |old-new|<toller
%
while ~equilibrium
for m=2:nrr-1
for n=2:nrc-1
new(m,n) = (old(m-1,n) + old(m,n-1) +...
old(m,n+1) + old(m+1,n))/4;
end
end
if all(new-old <= toler)
equilibrium = 1;
disp('Temperaturi finale');
disp(new)
end
old = new;
end
% Calculul lui tv
% Determinarea colturilor dreptunghiului lui tv
dx=lx/(nrc-1);
dy=ly/(nrr-1);
vecx=zeros(1,nrc);
vecy=zeros(1,nrr);
for ind=2:nrc
vecx(ind)=dx*(ind-1);
if vx<vecx(ind)
xst=vecx(ind-1);
ms=ind-1;
xdr=vecx(ind);
md=ind;
break
end
end
for ind=2:nrr
vecy(ind)=dy*(ind-1);
if vy<vecy(ind)
yjos=vecy(ind-1);
nj=ind-1;
ysus=vecy(ind);
ns=ind;
break
end
end
dg=sqrt(dx^2+dy^2); % diagonala dreptunghiului
tv=1/2*new(ms,ns)*(1-sqrt((xst-vx)^2+(ysus-vy)^2)/dg);
tv=tv+1/2*new(md,ns)*(1-sqrt((xdr-vx)^2+(ysus-vy)^2)/dg);
tv=tv+1/2*new(ms,nj)*(1-sqrt((xst-vx)^2+(yjos-vy)^2)/dg);
tv=tv+1/2*new(md,nj)*(1-sqrt((xdr-vx)^2+(yjos-vy)^2)/dg);
disp(' temperatura in punctul V este :')
disp(tv)
surf(new)
14.5. Soluţii
1.
>> roata(0.7,-0.001,125)
Vectorul viteză al lui M este : [0.098361,-0.086823]
mărimea şi unghiul vitezei în M : 0.1312,318.5651
Vectorul acceleraţie al lui M este : [-0.010066,-0.0020522]
mărimea şi unghiul acceleraţiei în M : 0.010273,-168.4769
Tastează orice tastă pentru a continua.......
Fig.14.4
2.
falfa1 =
-19/180*pi+31/9000*pi*t^3-31/60000*pi*t^4+31/1500000*pi*t^5
falfa2 =
11/45*pi+107/18000*pi*t^3-107/120000*pi*t^4+107/3000000*pi*t^5
3.
>> Temperatura
Numar de linii 6
Numar de coloane 6
temperatura la nord 100
Temperatura la sud 50
Temperatura la vest 100
Temperatura la est 100
Toleranta 0.01
lungimea placii lx= 50
latimea placii ly= 50
abscisa lui V, vx= 21.18
ordonata lui V, vy= 34.55
Temperaturi initiale
100 100 100 100 100 100
100 0 0 0 0 100
100 0 0 0 0 100
100 0 0 0 0 100
100 0 0 0 0 100
50 50 50 50 50 50
Temperaturi finale
100.0000 100.0000 100.0000 100.0000 100.0000 100.0000
100.0000 97.7127 96.3779 96.3779 97.7127 100.0000
100.0000 94.4840 91.4391 91.4391 94.4840 100.0000
100.0000 88.8022 83.4846 83.4846 88.8022 100.0000
100.0000 77.2582 70.2416 70.2416 77.2582 100.0000
50.0000 50.0000 50.0000 50.0000 50.0000 50.0000
temperatura in punctul V este :

83.4363
Graficul temperaturilor:
Fig.14.5
LUCRAREA 15
15.1. Depanarea şi optimizarea programelor

MATLAB.
Pe parcursul conceperii şi implementării unui program

MATLAB se pot face o serie de erori. Primul tip de erori cu care ne
întâlnim este cel al erorilor sintactice, adică nu respectăm regulile
stabilite în MATLAB pentru expresii, funcţii şi celelalte componente ale
limbajului. Prezentăm trei dintre cele mai des întâlnite:
- Punerea greşită a parantezelor în expresii. Exemplu:
>> 3/(2+3))
??? 3/(2+3))
|
Error: Unbalanced or misused parentheses or brackets.
La sfârşitul expresiei a fost pusă o paranteză în plus. De

remarcat modul cum semnalează MATLAB erorile sintactice –
prin scrierea atenţionărilor cu culoare roşie.
- Nescrierea, omiterea unui operator:
>> x=2;
>> 5*(4+2x)
??? 5*(4+2x)
|
Error: Missing MATLAB operator.
În exemplul de mai sus apare eroarea cea mai des întâlnită –

omiterea operatorului înmulţire ’*’.
- Scrierea incorectă a numelui variabilelor, a funcţiilor, etc.
>> 1+2*sinx
??? Undefined function or variable 'sinx'.
Eroarea constă în scrierea incorectă a funcţiei sin x. În MATLAB
toate funcţiile au argumentul scris între paranteze rotunde. Deci corect
este sin(x).
Erorile sintactice sunt uşor de depistat pentru că ni le semnalează
MATLAB. Un program nu este executat de MATLAB până când nu mai
are nici o eroare sintactică.
Odată lansat în execuţie un program MATLAB poate depista o
altă clasă de erori numită ’ erori de execuţie’. Exemplul tipic este
împărţirea cu 0. Şi alte tipuri de funcţii şi operaţii pot duce la rezultate
nedorite: NaN, Inf sau empty matrix:
>> x=-2:0.1:2;
>> y=x;
>> [x,y]=meshgrid(x,y);
>> z=x.*sin(y)./(x.^2-y.^2);
Warning: Divide by zero.
Eroarea provine din faptul că atunci când x=y în calculul lui z

apare o împărţire cu 0. În Ex.5 de la Lucrarea 9 am arătat cum se rezolvă
astfel de erori. În acest caz definim variabila aayy=x@ - y2 şi apoi dăm
comanda:
>> xxyy=xxyy+(xxyy==0)*eps
ce va introduce valoarea foarte mică eps în locul elementelor nule. Deci

secvenţa corectă este:
>> x=-2:0.1:2;
>> y=x;
>> [x,y]=meshgrid(x,y);
>> xxyy=x.^2-y.^2;
>> xxyy=xxyy+(xxyy==0)*eps;
>> z=x.*sin(y)./xxyy;
În sfârşit programul funcţionează fără erori. Dar dacă totuşi nu

obţinem rezultatul dorit?!! Cauza este că am dat peste cea de-a treia
categorie de erori , şi anume erorile logice. Sunt cele mai greu de
depistat erori pentru că MATLAB nu se ocupă de logica programului.
Logica programului este un lucru ce ţine numai de cel ce
programează. Erorile logice pot fi prevenite şi depistate mai uşor dacă
respectaţi câteva reguli nescrise ale programării. În primul rând
programul trebuie conceput modularizat. Aceasta înseamnă să
descompuneţi programul în module ce vor deveni funcţii sau scripturi.
Trebuie testat fiecare modul în sensul verificării faptului că la nişte date
de intrare modulul livrează înapoi date de ieşire corecte. Alte reguli ar fi
următoarele:
Fă un test cu un set de date iniţiale pentru care rezultatele finale
şi unele rezultate intermediare sunt cunoscute şi compară cu ce ai
obţinut.
Pentru a vedea unele rezultate intermediare care ar fi utile în
depanare anulează ; de la sfârşitul liniei comenzii pentru a vedea imediat
rezultatul comenzii. (Lucru nerecomandabil în mod obişnuit).
Adaugă comenzi care să listeze unele variabile cheie dar şi locul în
program unde au fost listate (poate ulterior au fost modificate).
Utilizează comanda keyboard care opreşte execuţia programului

şi dă controlul tastaturii ceea ce permite să dăm o comandă de
vizualizarea a oricărei variabile dorite.
Pentru programele mari utilizaţi comenzile funcţiei debugger din
fereastra edit. Acest mod presupune o oarecare experienţă în
programarea în MATLAB
Observaţie. Toate recomandările de mai sus duc la încetinirea
substanţială a execuţiei programului şi trebuie înlăturate după depanare.
Am corectat erorile sintactice, şi cele de execuţie, şi cele logice şi
în sfârşit programul face ce trebuie să facă. Totuşi nu suntem mulţumiţi.
Timpul de rulare este neaşteptat de mare. Trebuie să îmbunătăţim
performanţa programului, să-l optimizăm. Pentru măsurarea timpului de
execuţie avem comenzile tic şi toc. Definiţi scriptul rxtictoc dat de:
tic
t=1;
for i=1:10000000
t=(t+i)/t;
end
t
toc
Dacă-l punem în execuţie obţinem (pentru un P4 cu 1GB
DDR400):
>> rxtictoc
t=
3.162777778741289e+003
Elapsed time is 0.297000 seconds.
Vom prezenta câteva tehnici de reducere a timpului de execuţie a
programelor MATLAB.
Vectorizarea. Sub acest nume sunt cunoscute metodele prin care
anumite operaţii se execută asupra întregii matrici şi nu element cu
element. De exemplu înmulţirea element cu element a unei matrici se

poate face individual sau printr-o singură comandă: definim scriptul inm
de mai jos:
Fig.15.1
Lansăm in execuţie scriptul:
>> A=ones(1000,1000);
>> B=A;
>> inm
Se observă că timpul de execuţie vectorizat este mult mai mic.

Este util să utilizăm vectorizarea şi în cazul funcţiilor. Scriptul vecsin
este un exemplu simplu cu rezultatele:
>> t=0:0.01:100000;
>> i=0;
>> vecsin
Iar scriptul este:
Fig.15.2
În afara execuţiei mai rapide vectorizarea are şi avantajul scrierii

unui număr mai mic de comenzi (şanse mai mici de eroare) şi al creşterii
clarităţii programului.
Observaţie. Performanţele codării nevectorizate au crescut mult
la versiunea MATLAB6.5(r13) şi mai ales la versiunea MATLAB7(r14).
De aceea în exemplele de mai sus diferenţele de timp sunt mult mai mici
decât la versiunile anterioare. Totuşi diferenţa în favoarea vectorizării
există plus celelalte avantaje.
Funcţii build-in. Este bine să utilizăm funcţii built-in, adică deja
existente decât să definim noi o funcţie. Am mai vorbit în Lucrarea 9
despre calculul factorialului. Să vedem acum cât durează calculul lui
70!. Scriptul de execuţie este:
>> n=70;
>> testfb
Scriptul testfb şi funcţia fact:

Fig.15.3
Fig.15.4
Se remarcă primul timp pentru gamma(71) foarte mic. Timpul

pentru prod(1:70) este egal cu cel pentru funcţia noastră fact dar măcar
nu am scris decât comanda de apel.
Prealocarea. Este esenţial pentru performanţă să prealocăm
matricile (mai ales cele mari). Astfel dacă ele vor fi create element cu
element MATLAB va mări dimensiunile noii matrici la fiecare calcul. În
plus există riscul ca matricea creată să nu ocupe un spaţiu continuu în
memorie ceea ce duce evident la scăderea vitezei de acces. Vom măsura
timpii pentru ambele situaţii. Matricea B este creată în scriptul preal1:
Fig.15.5
Testul în MATLAB este:

>>k=10000;
>>n=1000;
>> A=floor(k*rand(n,n));
>> [r,c]=size(A);
>> preal1
>> B=zeros(r,c); % Aici prealocăm B
>> preal1
Se observă timpul substanţial mai mic în cazul prealocării.
Primele trei comenzi arată cum se creează o matrice de ordin n cu
numere întregi aleatoare pe intervalul [0, k].
Accesarea indexată. Deşi este considerată de unii drept principala
componentă a vectorizării, considerăm că merită o prezentare specială.
În esenţă accesarea indexată înlocuieşte căutarea elementelor matricii A
ce verifică o anumită condiţie cu expresia A (condiţie) ce livrează un
vector ce conţine toate elementele ce verifică această condiţie. După cum
am mai exemplificat şi în lucrările anterioare A(A>0) va livra un vector
ce are ca elemente elementele pozitive ale lui A. În exemplul următor ne
propunem să calculăm suma elementelor mai mari decât 5 ale unei
matrici A. Scriptul suma5 va face acest lucru cu şi fără indexare şi

compară timpii de calcul:
Fig.15.6
Executăm scriptul suma5:

>> A=floor(10*rand(10000,1000));
>> [r,c]=size(A);
>> suma5
ans =
29986704
s=
29986704
Se observă faptul că timpul de calcul este substanţial redus prin
accesarea indexată.
15.2. Aplicaţii
1.Scrieţi exact aşa cum este scris scriptul supr1, apoi depanaţi-l :
x=-2:0,2:2;
y=(6-x)./(3-x;
(x,y)=meshgraid(x,y);
z=(x.^2+y.^2)/(x*y);
Surf(x,y,z)
2.Să se determine matricea alab ale cărui elemente sunt obţinute din
elementele a doi vectori a şi b astfel: fiecare element al lui a este ridicat
la puterea fiecare element al lui b. De exemplu dacă a=[1,2] şi b= [2,3],
⎡11 21 ⎤ ⎡1 4 ⎤
atunci alab va fi alab = ⎢ 3 3 ⎥ , adică: alab = ⎢1 8 ⎥
⎣1 2 ⎦ ⎣ ⎦
3. Tips and tricks. Sub acest nume în informatică se înţelege şmecheria,
trucul cu care obţinem mai rapid o soluţie. În acest punct de vedere
vectorizarea pare că face parte din această categorie.
a) Cum definim o matrice a cărui elemente sunt egale cu un număr dat.
Da-ti cel puţin două soluţii.
b) Cum obţinem un vector a cărui elemente sunt în ordine inversă cu cele
ale unui vector dat? Da-ţi o soluţie cu buclă şi una vectorizată.
c) Cum definim o matrice de tip mXn cu coloane identice cu un vector
dat? Daţi cel puţin două soluţii.
4.Vectorizarea buclei for cu if. Deseori prelucrarea elementelor unei

matrici conduce l două bucle for îmbricate (pentru a accesa elementul) şi
un if pentru prelucrare:
for i=1:r
for j=1:c
if cond
prelucrare1 a(i,j);
else
prelucrare2 a(i,j);
end
end
end
De exemplu pentru condiţie avem a(i,j)>5, iar prelucrare 1 poate
fi a(i,j)=a(i,j)=5, iar prelucrare 2 : a(i,j)=-a(i,j).
Cum se scrie această secvenţă fără nici un for şi fără if?
5. Să se scrie o funcţie indlinie care are ca parametru de intrare o matrice

iar ca parametru de ieşire o matrice cu acelaşi număr de linii şi cu două
coloane ce va conţine indicii primului element nenul al fiecărei linii din
matricea iniţială. Matricea de ieşire va avea mai puţine linii dacă în
matricea de intrare există linii numai cu 0. Încercaţi să determinaţi şi o
formă vectorizată a funcţiei.
6. Să se creeze o funcţie vectz care are ca parametru de intrare un vector

x, iar ca parametru de ieşire un vector y de aceiaşi lungime ca şi x, ale
cărui elemente nenule sunt aceleaşi ca elementele corespunzătoare din x,
iar în locul elementelor nule se pune valoarea elementului nenul anterior.
Astfel dacă x=[1 3 0 0 0 4 5 0 0 6 0 7] atunci y=[ 1 3 3 3 3 4 5 5 5 6 6
7]. Se va presupune că x are întotdeauna primul element nenul.
15.3. Indicaţii
1.Erori sintactice:
Linia 1 col. 7 – se pune punct în loc de virgula zecimală (notaţia
americană);
Linia 2 col .14 – paranteză închisă;
Linia 3 col. 3 – paranteze pătrate pentru parametrii de ieşire;
Linia 3 col. 7 – funcţia meshgraid inexistentă (este meshgrid);
Linia 4 col. 14 – operaţia de împărţire cu punct;
Linia 4 col. 18 – operaţia de împărţire cu punct;
Linia 5 col. 1 - funcţia surf cu litera s mic;
Erori de execuţie:
Linia 4 - împărţire cu 0;
2. Este clar că alab va fi o matrice cu numărul de linii egal cu lungimea

lui b iar numărul de coloane egal cu lungimea lui a. Se pot face două
bucle for îmbricate pentru determinarea elementelor lui alab. Aceasta
este forma clasică a programării. MATLAB are funcţia meshgrid ce
transformă vectorii în matrici şi care poate fi utilizată.
3. a) O soluţie ar fi utilizarea lui ones(n,m). O altă soluţie ar fi utilizarea

funcţiei repmat(A,n,m) care repetă o matrice A de n ori pe linie şi de m
ori pe coloană.
b) Definim o buclă în care primul element al noului vector să fie egal cu
ultimul element al celui dat, al doilea element al noului vector să fie egal
cu penultimul element al celui dat, ş. a. m. d. pentru vectorizare putem
utiliza adresarea cu operatorul :.
c) Fiind vorba de o matrice, o vom crea cu două bucle for îmbricate.
Există şi forme vectorizate ale scriptului bazate pe concatenare şi
operatorul : sau repmat.
4. Se va utiliza accesarea indexată.

5. Prelucrarea obişnuită a elementelor unei matrici cu două bucle for şi
un if ca la Ex. 4 anterior se complică prin faptul că apare o condiţie în
plus (aceasta este prelucrarea doar a primului element din linie). Cum
MATLAB memorează matricile pe coloană vectorizarea acestei
probleme trebuie altfel gândită (dacă este posibil). Pentru prelucrarea cu
for-if este necesar un semnal care să ne spună că pentru linia în execuţie
am găsit deja primul element. Pentru matricea y de ieşire este necesar un
indice de lucru special ce trebuie incrementat cu 1 la fiecare memorare
de indici.
6. Este necesară o variabilă în care să memorăm pe parcursul unei

prelucrări cu o buclă for ultimul element nenul. Această variabilă trebuie
iniţializată cu valoarea primului element din x (presupus nenul).
Varianta vectorizată se bazează pe următoarele observaţii. Să
presupunem că avem vectorul x=[x1,x2,0,0,x3,0,x4] şi putem obţine
vectorul diferenţelor elementelor nenule consecutive.
xdcons=[x1,x2-x1,0,0,x3-x2,0,x4-x3],
atunci vectorul soluţie:
vsol=[x1,x2,x2,x2,x3,x3,x4]
se obţine prin aplicarea funcţiei cumsum asupra lui xdcons. Funcţia
cumsum(x) creează un vector ce are pe poziţia k suma elementelor lui x
de la 1 la k, adică pentru vdcons de mai sus.
x1 deci x1
x1+(x2-x1) deci x2
x1+(x2-x1)+0 deci x2
x1+(x2-x1)+0+0 deci x2
x1+(x2-x1)+0+0(x3-x2) deci x3
x1+(x2-x1)+0+0(x3-x2)+0 deci x3
x1+(x2-x1)+0+0(x3-x2)+0+(x4-x3) deci x4.
15.4. Soluţii
1.
Fig.15.7
2.
Fig.15.8
3.
Fig.15.9
Execuţia:
>> a=1:10000;
>> b=1:20;
>> alab1
>> alab2
Se remarcă timpul mult mai mic al scriptului vectorizat.
3. a) Presupunem că t este constanta egală cu toate elementele şi n şi m

dimensiunile matricii. Putem da oricare din comenzile:
>> A=k*ones(n,m);
Sau
>>A=k; A=repmat(A,n,m);
b) O buclă for rezolvă problema:
for i=1:length(v)
w(i)=v(length(x)-i+1);
end
Vectorul w va conţine elementele lui v în ordine inversă. Vectorial:
W=v(end:-1:1)
Iată o utilizare interesantă a lui end.
c) Presupunem că avem vectorul coloană v de dimensiune m. Atunci
putem crea matricea M astfel:
for i=1:m
for j=1:n
M(i,j)=v(i);
end
end
Variantele vectorizate sunt:
N=v(:,ones(n,1))
Sau
O=repmat(v,1,n)
4. Scriptul iniţial este forcuif :
Fig.15.10
Scriptul cu indexare fararor:
Fig.15.11
Funcţia indlinie nevectorizată este:
Fig.15.12
Iar funcţia vectorizată indliniv este:
Fig.15.13
Punerea în execuţie:
>> A=[ 0 0 1 ;0 1 0 ;0 0 1 ;1 1 2 ;0 2 1 ; 0 0 0 ;0 0 2 ];
A=
0 0 1
0 1 0
0 0 1
1 1 2
0 2 1
0 0 0
0 0 2
>> y=indlinie(A)
y=
1 3
2 2
3 3
4 1
5 2
7 3
>> y=indliniv(A)
y=
1 3
2 2
3 3
4 1
5 2
7 3
Pe fiecare linie a lui y prima valoare este linia , iar a doua valoare
este coloana elementelor căutate.
6. Funcţia vectz (cu bucla for cu if) este:
Fig.15.14
Funcţia vectorizată (cu funcţiile fiind, diff şi cumsum) este:
Fig.15.15
Punerea în execuţie:
>> x=[1 3 0 0 0 4 5 0 0 6 0 7] ;
>> vectz(x)
ans =
1 3 3 3 3 4 5 5 5 6 6 7
>> vectzo(x)
ans =
1 3 3 3 3 4 5 5 5 6 6 7
Această problemă 6 este un exemplu că uneori vectorizarea este
complexă şi nu aduce avantaje deosebite.
LUCRAREA 16
16.1. Sisteme neliniare.
Ne propunem să rezolvăm sistemul neliniar:

⎧ 2 x1 − x2 = e − x1
⎨ − x2
⎩− x1 + 2 x2 = e
Trebuie subliniat că nu există vreo regulă sau metodă generală
pentru rezolvarea tutor sistemelor neliniare. MATLAB are o funcţie
fsolve cu care se pot rezolva astfel de sisteme care însă nu funcţionează
întotdeauna.
Pentru apelul acestei funcţii se utilizează mai multe forme din
care prezentăm doar două:
x=fsolve(functie,x0).
Sau forma mai complexă
[x,fval]=fsolve(functie, x0,options),
unde x este soluţia obţinută, x0 este o valoare iniţială de la care pornesc
căutările, functie este funcţia vectorială de mai multe variabile a cărui
zero vrem să-l determinăm, fval este valoarea funcţiei în soluţia x, iar
options conţine opţiunile de rezolvare dorite de utilizator.
Referitor la options vom prezenta doar cele mai importante
opţiuni şi cum se setează acestea:
Opţiunea Valori posibile

Display off, iter,final(implicit)
MaxIter Valoare întreagă (implicit 1000)
TolFun Valoare reală implicit eps precizia de calcul a lorilor funcţiei
TolX Valoare reală implicit eps precizia soluţiei
Atribuirea de alte valori decât cele implicite pentru options se

face cu comanda optimset:
Options=optimset(’opt1’,’val1’,’opt2’,’val2’,…)
Exemplu:
Options=optimset(’Display’,’iter’,MaxIter’.’100’,’TolX’,’0.000001’)
Putem trece acum la rezolvarea sistemului. Definim întâi funcţia
snlfun”
function y=snlfun(x)
y=[2*x(1)-x(2)-exp(-x(1));-x(1)+2*x(2)-exp(-x(2))];
Acum putem scrie comenzile de rezolvare a sistemului:
>> x0=[-5;-5]; % soluţia iniţială
>> options=optimset('Display','iter');
>> [x,fval]=fsolve(@snlfun,x0,options)
Norm of First-order Trust-region

Iteration Func-count f(x) step optimality radius
0 3 47071.2 2.29e+004 1
1 6 12003.4 1 5.75e+003 1
2 9 3147.02 1 1.47e+003 1
3 12 854.452 1 388 1
4 15 239.527 1 107 1
5 18 67.0412 1 30.8 1
6 21 16.7042 1 9.05 1
7 24 2.42788 1 2.26 1
8 27 0.032658 0.759511 0.206 2.5
9 30 7.03149e-006 0.111927 0.00294 2.5
10 33 3.29525e-013 0.00169132 6.36e-007 2.5
Optimization terminated: first-order optimality is less than
options.TolFun.
x=
0.5671
0.5671
fval =
1.0e-006 *
-0.4059
-0.4059
Observaţie. Cu fsolve şi în general cu orice altă metodă se obţine

doar o singură soluţie, în acest exemplu x1=x2=0.5671. S-ar putea ca
sistemul să aibă şi alte soluţii. Acestea se pot obţine prin schimbarea
soluţiei iniţiale.
Pentru sistemele cu un număr mic de necunoscute (până la 5-6
necunoscute) şi cu funcţia f de rezolvat netedă (adică de două ori
derivabilă) recomandăm metoda lui Newton . Această metodă se bazează
pe faptul că şirul recurent definit de:
x ( n + 1) = x ( n ) + W −1 f ( x ( n ) )
unde W este Jacobianul lui f în x(n), adică W este matricea a cărui
elemente sunt:
∂f
W ( i, j ) = i ( x ( n ) )
∂x j
converge, în anumite condiţii către soluţia ecuaţiei f(x)=0, unde f este de
forma:
⎧ f1 ( x1 , x2 ,… , xn )
⎪
⎪ f ( x , x ,… , xn )
f ( x) = ⎨ 2 1 2
⎪
⎪ f n ( x1 , x2 ,… , xn )
⎩
Metoda se implementează uşor pentru sisteme relativ mici:
>>f=inline(’[2*x(1)-x(2)-exp(-x(1));-x(1)+2*x(2)-exp(-x(2))]’); Funcţia
>>df=inline(’[2+exp(-x(1)) -1;-1 2+exp(-x(2))]’); % Jacobianul
>>x=[-5;-5];
>>for i=1:100
dx=-df(x)\f(x);
x=x+dx;
if dx<100*eps
break
end
end
>>[x f(x)]
ans =
0.5671 0.0000
0.5671 0.0000
Am obţinut evident aceleaşi rezultate.

Funcţia fsolve rezolvă şi alte tipuri de probleme ca de exemplu ecuaţii
matriciale complicate sau calcule de valori optime. De exemplu ne
propunem să rezolvăm ecuaţia matricială:
⎡1 2 ⎤
X3 = ⎢ ⎥
⎣3 4 ⎦
Rezolvarea în MATLAB este:
>> F=inline('X^3-[1 2;3 4]')

F=
Inline function:
F(X) = X^3-[1 2;3 4]
>> X0=ones(2,2)
X0 =
1 1
1 1
>> X=fsolve(F,X0)
Optimization terminated: first-order optimality is less than
options.TolFun.
X=
-0.1291 0.8602
1.2903 1.1612
Verificare:
>> X^3
ans =
1.0000 2.0000
3.0000 4.0000
16.2. Aplicaţii
1.Să se rezolve ecuaţiile matriciale:
⎡5 4⎤
a) X 2 = ⎢ ⎥;
⎣4 5⎦
⎡ −1 1 ⎤
b) X 2 − 3 X = ⎢ ⎥;
⎣ 1 −1⎦
⎡4 3 1⎤
c) X − 2 x = ⎢⎢ 3 2 3 ⎥⎥ .
2
⎢⎣ 1 3 4 ⎥⎦
2.Să se rezolve sistemele următoare:
⎧ x3 + y = 1 ⎡ −5⎤
a) ⎨ 3 cu soluţia iniţială ⎢ ⎥ utilizând atât fsolve cât şi metoda
⎩ y − x = −1 ⎣6⎦
lui Newton;
⎧⎪ x 2 + ( y − 1)2 = 5 ⎡ −1⎤
b) ⎨ întâi cu soluţia iniţială ⎢ 0 ⎥ şi apoi cu soluţia
⎪⎩ ( )
2
x − 1 + y 2
= 1 ⎣ ⎦
⎡1 ⎤
iniţială ⎢ ⎥ ;
⎣ 2⎦
⎧ x + y + z =1 ⎡2⎤
⎪ ⎢ 2 ⎥.
c) ⎨ x 2 + y 2 + z 2 = 3 cu aproximaţia iniţială ⎢ ⎥
⎪ x3 + y 3 − z 3 = 3 ⎢⎣ −2 ⎥⎦
⎩
16.3. Indicaţii
1.
a) Comenzile MATLAB pentru aflarea soluţiei sunt:
>> F=inline('x^2-[5 4;4 5]');

>> x0=3*ones(2);
>> x=fsolve(F,x0);
b) Comenzi asemănătoare cu cele de la a)
>> F=inline('x^2-3*x-[-1 1;1 -1]');

>> x0=3*ones(2);
>> x=fsolve(F,x0);
c) Comenzi asemănătoare cu cele de la a)
>> F=inline('x^2-2*x-[4 3 1;3 2 3;1 3 4]');

>> x0=3*ones(2);
>> x=fsolve(F,x0);
2.
a) Comenzile pentru varianta cu fsolve sunt:
>> F=inline('[x(1)^3+x(2)-1;x(2)^3-x(1)+1]');
>> x0=[-5;6];
>> x=fsolve(F,x0);
Comenzile pentru metoda lui Newton sunt:
>>F=inline('[x(1)^3+x(2)-1;x(2)^3-x(1)+1]');
>>DF=inline('[3*x(1)^2 1;-1 3*x(2)^2]');
>>x=[-5;6];
>>for i=1:100
Dx=-DF(x)\F(x);
x=x+Dx;
end
b) Comenzile sunt:
>> f=inline('[x(1)^2+(x(2)-1)^2-5;(x(1)-1)^2+x(2)^2-1]');
>> x0=[-1;0];
>> x=fsolve(f,x0);
Se înlocuieşte apoi x0 cu [1;2]
c) Comenzile sunt:
>>f=inline('[x(1)+x(2)+x(3)-1;x(1)^2+x(2)^2+x(3)^2-3;x(1)^3+x(2)^3-
x(3)^3-3]');
>> x0=[1;2;-2];
>> x=fsolve(f,x0);
16.5. Soluţii
1.
a)
>> x
x=
2.0000 1.0000
1.0000 2.0000
b) Aceiaşi ca la a)
>> x
x=
2.0000 1.0000
1.0000 2.0000
c)
>> x
x=
0.9987 1.0026 1.9987

1.0026 1.9948 1.0026
1.9987 1.0026 0.9987
2.
a) >> x
x=
1.0000
0.0000
b)
⎛1⎞
Pentru x0=[-1;0] se obţine soluţia ⎜ ⎟ ;
⎝ −1 ⎠
⎛ 2⎞
Pentru x0=[1’2] se obţine soluţia ⎜ ⎟
⎝0⎠
c)
x=
1.0000
1.0000
-1.0000
LUCRAREA 17
17.1. Ecuaţii diferenţiale de ordinul I
Ne propunem să arătăm cum MATLAB rezolvă ecuaţii

diferenţiale de ordinul I. Există mai multe tipuri de astfel de ecuaţii
pentru care MATLAB oferă funcţii de rezolvare. Ne vom limita doar la
ecuaţii de forma y’=f(x,y) sau la sisteme de astfel de ecuaţii de forma:
⎧ y ′ = f ( x, y , y , , y )
⎪ 1 1 1 2 n
⎪⎪ y2′ = f 2 ( x, y1 , y2 , , yn )
⎨
⎪
⎪ ′
⎩⎪ yn = f n ( x, y1 , y2 , , yn )
Nu vom utiliza decât funcţia ODE45 pentru rezolvarea acestor
ecuaţii. Forma generală a acestei funcţii pentru ecuaţia y’=f(x,y) este:
[x,y]=ode45(f,[a,b],v)
unde [a,b] este domeniul de valori al lui x,iar v=y(a) valoarea iniţială în
a.
Ne propunem să rezolvăm ecuaţia diferenţială simplă:
y′ = − xy 2 cu x ∈ [ 0, 2] şi condiţia iniţială y ( 0 ) = 1 .
Pentru aceasta trebuie să definim funcţia ce descrie ecuaţia asemănător
ca la sistemele neliniare din lucrarea anterioarǎ:
>> F=inline('-x*y^2')
F=
Inline function:
F(x,y) = -x*y^2
>> [x,y]=ode45('F',[0,2],1)
Putem acum să facem graficul funcţiei y(x). În plus ştim că
2
această problemă are soluţia y ( x ) = 2 şi vom compara graficele
x +2
soluţie aproximative cu cel al soluţiei exacte (acesta din urmă
reprezentat cu o)
>> t=0:0.1:2;
>> r=2./(t.^2+2);
>> plot(x,y,t,r,'o')
Fig.17.1
Se observă faptul că cele două grafice se suprapun.(Soluţia

obţinutǎ cu ode45 a fost desenatǎ cu culoarea albastrǎ, iar soluţia exactǎ
cu cerculeţe).
Tot cu ode45 putem rezolva şi sisteme de ecuaţii diferenţiale
definind f ca un vector vertical. Evident că şi condiţia iniţială devine un
vector. Ne propunem să rezolvăm sistemul:
⎧ y1′ = − y2 + x + 1
⎨ cu x ∈ [ 0, π ] şi y1 ( 0 ) = 1, y2 ( 0 ) = −1 .
⎩ y2′ = y1 − x + 1
Comenzile pentru rezolvare sunt:
>> F=inline('[-y(2)+x+1;y(1)-x+1]','x','y');
>> [x,y]=ode45(F,[0,pi],[1,-1]);
>> plot(x,y(:,1),x,y(:,2),'r',x,sin(x)+cos(x)+x,'o',x,sin(x)-cos(x)+x,'o')
Cu ’o’ vor fi desenate soluţiile exacte:
Fig.17.2
Se remarcă faptul că cele două funcţii au coincis cu soluţiile

exacte.
17.3. Aplicaţii
1. Să se rezolve următoarele ecuaţii diferenţiale de ordinul I, să se

traseze graficele soluţiilor şi să se facă un tabel format cu valoarea
soluţiei din 5 în 5:
a) y′ + 4 y = cos x x ∈ [ 0, 2π ] , y(0)=1. Cât este y (π 3) ?
b) xy′ + 2 y = sin x x ∈ [π , 2π ] y (π ) = 1 π . Cât este y ( 4π 3) ?
c) x 2 y′ = 1 − x 2 + y 2 − x 2 y 2 x ∈ [1, 3] y (1) = 0 . Cât este y(2.654)?
2. Să se rezolve următoarele sisteme de ecuaţii diferenţiale de ordinul I :
⎧ y1′ = y1 + y2
a) ⎨ x ∈ [ 0, e ] y1 ( 0 ) = 0, y2 ( 0 ) = 1 .
⎩ y2′ = 3 y1 + y2 − 3 xe
x
⎧⎪ y ′ = − y
b) ⎨ 1 2
cu x ∈ [ 0, π ] y1 ( 0 ) = 1, y2 ( 0 ) = −1 .
′
⎪⎩ y2 = y1
17.4. Indicaţii
1.
a)Comenzile care trebuie date sunt următoarele:
>> F=inline('cos(x)-4*y')
>> [x,y]=ode45(F,[0,2*pi],1);
>> [x(1:5:end) y(1:5:end)]
>> plot(x,y)
>> interp1(x,y,pi/3,'cubic')
b)Comenzile sunt:
>> f=inline('1/x*(sin(x)-2*y)');
>> [x,y]=ode45(f,[pi,2*pi],1/pi);
>> [x(1:5:end),y(1:5:end)]
>> plot(x,y)
>> interp1(x,y,4*pi/3,'cubic')
c) Comenzile sunt:
>> f=inline('1/x^2*(1-x^2+y^2-x^2*y^2) ');

>> [x,y]=ode45(f,[1,3],0);
>> [x(1:5:end),y(1:5:end)]
>> plot(x,y)
>> interp1(x,y,2.654,'cubic')
2.
a) Comenzile sunt:
>> F=inline('[y(1)+y(2);3*y(1)+y(2)-3*x*exp(x)]','x','y');
>> [x,y]=ode45(F,[0,exp(1)],[0,1]);
>> plot(x,y(:,1),x,y(:,2),'r')
b) Comenzile sunt:
>> f=inline('[-y(2);y(1)]','x','y');
>> [x,y]=ode45(f,[0,pi],[1,-1]);
>> plot(x,y(:,1),x,y(:,2),'r')
17.5. Soluţii
1.
a)
>> [x(1:5:end) y(1:5:end)]
ans =
0 1.0000
0.1211 0.7117
0.3885 0.4017
0.6640 0.2753
0.9737 0.1965
1.3695 0.1079
1.8715 -0.0131
2.4039 -0.1345
2.8895 -0.2131
3.3212 -0.2420
3.7409 -0.2275
4.1569 -0.1741
4.5738 -0.0907
4.9920 0.0084
5.4297 0.1104
5.8940 0.1954
6.2832 0.2353
>> interp1(x,y,pi/3,'cubic')
ans =
0.1802
Fig.17.3
b)
>> [x(1:5:end) y(1:5:end)]
ans =
3.1416 0.3183
3.5343 0.2308
3.9270 0.1342
4.3197 0.0391
4.7124 -0.0450
5.1051 -0.1104
5.4978 -0.1520
5.8905 -0.1679
6.2832 -0.1592
>> interp1(x,y,4*pi/3,’cubic’)
ans =
0.0700
Fig.17.4
c)
>> [x(1:5:end) y(1:5:end)]
ans =
1.0000 0
1.2500 -0.0500
1.5000 -0.1682
1.7500 -0.3330
2.0000 -0.5463
2.2500 -0.8328
2.5000 -1.2602
2.7500 -2.0328
3.0000 -4.1318
>> interp1(x,y,2.654,’cubic’)
ans =
-1.6684
Fig.17.5
2.
a)
Fig.17.6
b)
Fig.17.7
LUCRAREA 18
18.1. Ecuaţii diferenţiale de ordin II sau mai mare.
Dacă ştim (vezi lucrarea anterioarǎ) să rezolvăm sisteme de

ecuaţii diferenţiale de ordinul I putem rezolva printr-un truc de
substituţie ecuaţii diferenţiale de ordin superior.
Astfel ecuaţia diferenţială:
(
y ( n ) = f x, y, y′, y′′, , y ( n −1) )
prin substituţia următoare: y = y1 , y′ = y2 , y′′ = y3 , , y ( n − ) = yn devine
un sistem de ecuaţii diferenţial de ordinul I :
⎧ y1′ = y2
⎪ y2′ = y3
⎪⎪
⎨
⎪ yn′ −1 = yn
⎪
⎪⎩ yn′ = f ( x, y1 , y2 , , yn )
Sǎ remarcǎm faptul cǎ numǎrul ecuaţiilor din sistem este egal cu

ordinul ecuaţiei diferenţiale ce a generat sistemul.
Să rezolvăm atunci ecuaţia : y′′ − 3 y′ + 2 y = 0 pentru x ∈ [ 0, 1]
cu condiţiile iniţiale y ( 0 ) = 1, y′ ( 0 ) = 2
Conform celor de mai sus notăm y=y1 şi y’=y2. Evident y′′ = y2′
şi obţinem sistemul:
⎧ y1′ = y2
⎨
⎩ y2′ = 3 y2 − 2 y1
Comenzile de rezolvare sunt:
>> F=inline('[y(2);3*y(2)-2*y(1)]','x','y')
F=
Inline function:
F(x,y) = [y(2);3*y(2)-2*y(1)]
>> [x,y]=ode45(F,[0,1],[1,2]);
>> plot(x,y(:,1),x,exp(2*x),'ro')
Fig.18.1
Să remarcăm coincidenţa dintre soluţia exactă ( y ( x) = e 2 x , cu

cerculeţe de culoare roşie) şi cea aproximată (culoarea albastră)
Observaţie 1. În comanda inline trebuie precizată ordinea
variabilelor acesta fiind motivul pentru care am adăugat după formule şi
variabilele în ordine, Acest lucru este cerut de ode45 care dă eroare dacă
nu i se transmite şi ordinea variabilelor. Mai este util aceastǎ ordine şi
atunci când variabila de defuniţie nu apare în ecuaţii.
2. Cu ode45 se obţine soluţia y într-un număr finit de puncte
(implicit 50). Pentru a afla soluţia într-un punct oarecare x0 al
intervalului [a, b] trebuie să interpolam vectorii x şi y cu funcţia interp1:
interp1(x,y,x0,’cubic’).
18.2. Aplicaţii
1.Să se rezolve următoarele ecuaţii sau sisteme diferenţiale:

a) y′′ + 2 y′ + 2 y = 4 cos 3t x ∈ [ 0, 10] y ( 0 ) = −1, y′ ( 0 ) = 2
b) xy′′ + y′ = cos x x ∈ [1, 3] , y (1) = 2, y′ (1) = 5
c) y′′′ + y′′ + y′ + y = 0 cu x ∈ [ 0, π ] , y ( 0 ) = 0, y′ ( 0 ) = 1, y′′ ( 0 ) = 0
18.3. Indicaţii
1.
a) Transformăm ecuaţia într-un sistem:
⎧ y1′ = y2
⎨
⎩ y2′ = −2 y1 − 2 y2 + 4 cos x
Comenzile sunt:
>> F=inline('[y(2);-2*y(1)-2*y(2)+4*cos(x)]','x','y');
>> [x,y]=ode45(F,[0,10],[-1,2]);
>> plot(x,y(:,1))
b) Sistemul echivalent este:
⎧ y1′ = y2
⎪
⎨ cos x − y1
⎪⎩ y2′ = x
Comenzile sunt:
>> F=inline('[y(2);(cos(x)-y(1))/x]','x','y');
>> [x,y]=ode45(F,[1,3],[2,5]);
>> plot(x,y(:,1))
c) Sistemul echivalent este:
⎧ y1′ = y2
⎪
⎪
⎨ y2′ = y3
⎪
⎪⎩ y3′ = − y1 − y2 − y3
Comenzile sunt:
>> f=inline('[y(2);y(3);-y(1)-y(2)-y(3)]','x','y');
>> [x,y]=ode45(f,[0,pi],[0;1;0]);
>> plot(x,y(:,1))
18.4. Soluţii
1.
a)
Fig.18.2
b)
Fig.18.3
c)
Fig.18.4
LUCRAREA 19

rezolvarea problemelor tehnice. Aplicaţii
1. In figura 19.1 este prezentat un circuit neliniar, neliniaritatea

fiind dată de dioda D. Diferenţa de potenţial (tensiunea) este dată de :
VD = VT I 0 − VT ln( I )
unde I este intensitatea curentului prin circuitul în care se află dioda iar
VT şi I0 sunt caracteristici cunoscute ale diodei. Într-o lucrare anterioară
am analizat un circuit liniar unde în locul diodei D era o rezistenţă R
Cunoscându-se tensiunea U şi rezistenţele R1, R2, R3, R5 şi VT,
I0 să se determine intensităţile I1, I2, I3.
Caz numeric U=5V, R1`=R2=R3=5Ω, R5=15Ω VT=15 Ω.
R 1
I 2
R 2 R 3
+
U -
I R
I
5
1 D 3
Fig.19.1
2. O problemă de bungee-jumping. Ne aflăm pe un pod de pe

care vrem să practicăm bungee-jumping. Distanţa până la sol este de 100
m. dispunem de o coardă elastică de 120 m dar nu ştim ce lungime să
utilizăm pentru o săritură în siguranţă deplină. Cunoaştem regula lui 2m
adică această coardă la extensia elastică maximă nu poate depăşi
100m-2m=98m. Cunoaştem de asemenea că are constanta de elasticitate
k=40 N/m. presupunem la capătul corzii o persoană cu masa de 100 kg.
Mai ştim rezistenţa aerului ca având formula:
R = −c1v − c2 v v
Adică se opune mişcării proporţional cu viteza şi cu pătratul
vitezei în sens opus deplasării. Constantele sunt c1≈1 şi c2≈1. Se cere
evident lungimea maximă a corzii ce trebuie lăsată liberă în jos pentru
sărituri sigure şi graficul traiectoriei corpului. Să se traseze graficul
variaţiei vitezei în timp. Este importantă rezistenţa aerului?
3. Problema mişcării unui proiectil. Se cunosc viteza iniţială a

proiectilului şi faptul că rezistenţa aerului este direct proporţională cu
pătratul distanţei Se cere unghiul de lansare al proiectilului de masă m
pentru ca acesta să atingă punctul fix de coordonate (xf,yf). Se
presupune că punctul de lansare al proiectilului este punctul de
coordonate (0, 0).
19.2. Indicaţii
1. În circuitul de rezolvat avem N=4 noduri (punctele negre) şi

L=6 laturi(porţiuni de circuit ce unesc nodurile). Legile lui Kirchoff ne
spun că pe orice porţiune de circuit închis suma tensiunilor (diferenţelor
de potenţial) este nulă. Se pot obţine astfel multe ecuaţii dar numai
L-N+1=3 sunt independente. Adică exact câte necunoscute avem. Acest
lucru înseamnă că soluţia este unică. Pentru obţinerea celor 3 ecuaţii
independente am ales următoarele 3 circuite închise:
1 – circuitul ce conţine sursa de tensiune U,rezistenţa R2 şi dioda D;
2 – circuitul ce conţine rezistenţa R1, rezistenţa R2 şi rezistenţa R3;
3 – circuitul ce conţine rezistenţa R3, dioda D şi rezistenţa R5.
Pentru circuitul 1 pe latura rezistenţei R2 diferenţa de potenţial
este V2=R2I1-R2I2, iar pentru latura diodei D este:
VD=.VTln(I1)- VTI0-(VTln(I3)- VTI0)= VTln(I1/I3)
Sursa U are tensiunea –VU cu semn contrar potenţialului rezistenţelor
(rezistenţele consumă curent, sursele produc curent). Deci ecuaţia este:
⎛I ⎞
−VU + R2 ⋅ ( I1 − I 2 ) + VT ⋅ ln ⎜ 1 ⎟ = 0
⎝ I3 ⎠
Analog pentru circuitele 2 şi 3 se obţin ecuaţiile:
R1 ⋅ I 2 + R3 ⋅ ( I 2 − I 3 ) + R2 ⋅ ( I 2 − I1 ) = 0
⎛I ⎞
R5 ⋅ I 3 + R3 ⋅ ( I 3 − I 2 ) + VT ⋅ ln ⎜ 3 ⎟ = 0
⎝ I1 ⎠
Pentru a rezolva acest sistem liniar în necunoscutele I1, I2, I3
trebuie să-l aducem la forma canonică. Obţinem sistemul:
⎧ ⎛ I1 ⎞
⎪ R2 I1 − R2 I 2 + VT ⋅ ln ⎜ ⎟ = VU
⎪ ⎝ I3 ⎠
⎪
⎨ − R2 I1 + ( R1 + R2 + R3 ) I 2 − R3 I 3 = 0
⎪
⎪− R I + ( R + R ) I − V ⋅ ln ⎜⎛ I1 ⎟⎞ = 0
⎪⎩ 3 2 3 5 3 T
⎝ I3 ⎠
Pentru rezolvare vom utiliza funcţia fsolve considerând pentru
datele numerice date, vectorul valoare iniţială v=[2;1;1]
>> f=inline('[5*x(1)-5*x(2)+15*log(x(1)/x(3))-5;-5*x(1)+15*x(2)-
5*x(3);-5*x(2)+20*x(3)-15*log(x(1)/x(3))]');
>> s=fsolve(f,[2;1;1])
2. Avem de determinat forţele ce acţionează asupra corpului în

cădere liberă. Acestea sunt:
- Greutatea. Aceasta este gr=mg unde g este acceleraţia gravitaţională.
Întrucât nu s-a precizat nimic despre această acceleraţie putem
presupune că g=9.8 m/s2.
- Rezistenţa aerului. Aceasta a fost dată în problemă şi este:
ra = −c1v − c2 v v
- Forţa elastică. Aceasta este F=-kx.
Suma acestor forţe trebuie să echilibreze forţa creată de mişcarea
corpului fa=ma, adică fa=gr+ra+fe
Cunoaştem că v = x, a = x şi deci obţinem ecuaţia diferenţială de
ordinul II ( punctul de deasupra înseamnă derivata în raport cu timpul,
două
puncte derivata de ordinul 2 în raport cu timpul):
mx + c1 x + c2 x x + kx − mg = 0
Transformăm această ecuaţie într-un sistem de două ecuaţii
diferenţiale de ordinul I. O facem notând x=x1 şi v=x2. Obţinem:
⎧ x1 = x2
⎪
⎨ c1 c2
⎪⎩ x2 = g − m x2 − m x2 x2 − kx1
Acest sistem îl putem rezolva cu ode45, dar nu cunoaştem
lungimea lun a coardei elastice. Pentru început putem presupune că
această lungime este lun=30 m. Odată rezolvat ne propunem să vedem
dacă această lungime este optimă. Pentru aceasta calculăm dl=98-
max(y(:,1)) adică diferenţa dintre 98 şi maximumul atins de coardă.
Dacă este 0 (sau măcar o diferenţă mai mică decât toleranţa) am
găsit soluţia problemei. Dacă dl nu este 0, facem incrementarea
lun=lun+dl/2 şi reluăm procesul de rezolvare al ecuaţiei diferenţiale dar
cu noua lungime. Continuăm până când dl este 0 (sau mai mic decât
toleranţa aici 1 cm). Scriptul bjex de mai jos utilizează funcţia bjfun
pentru descrierea sistemului. O singură observaţie, funcţia elastică
acţionează doar când poziţia x a corpului depăşeşte lungimea lun.
function xdt=bjfun(t,x,lun)
m=100;
g=9.8;
c1=1;
c2=1;
k=40;
gr=m*g;
ra=-c1*x(2)-c2*abs(x(2))*x(2);
if x(1)<lun
fe=0;
else
fe=-k*(x(1)-lun);
end
xdt=[x(2);(gr+ra+fe)/m];
Şi acum scriptul
y=zeros(200,2);
lun=30;
ind=1;
while abs(max(y(:,1))-98)>0.01
[t,y]=ode45(@bjfun,[0,70],[0;0],[],lun);
dl=98-max(y(:,1))
lun=lun+dl/2;
ind=ind+1;
if ind>20
break
end
end
disp([' lungimea este :',num2str(lun)])
plot(t,y(:,1))
disp (’tastaţi orice tasta pentru a continua …’)
pause;
plot(t,y(:,2))
Pentru a vedea dacă este sau nu importantă rezistenţa aerului
vom modifica funcţia bjfun înlocuind linia unde se calculează ra cu
comanda ra=0.
3. Traiectoria proiectilului nu poate fi calculată exact (adică cu o

formulă) decât în cazul când rezistenţa aerului este nulă. De aceea aici
avem o problemă de optimizare. Ecuaţiile mişcării sunt date de:
x = vx ; y = v y ; vx = −cvvx ; v y = − g − cvv y ; v = vx2 + v y2
Variabila independentă naturală este timpul t, dar de mare
importanţă pentru problema noastră este distanţa x de aceea este util să
privim pe x ca variabilă independentă şi timpul să fie variabila

dependentă. Atunci avem relaţiile:
dx dt 1
= vx → = ;
dt dx vx
dy dy dt 1 v
= ⋅ = vy ⋅ = y ;
dx dt dx vx vx
dvx dx dvx dv dv 1 dv −cvvc
= ⋅ = vx x → x = ⋅ x = = −cv
dt dt dx dx dt vx dt vx
dv y dx dv y dv dv 1 dv − g − cvv y
= ⋅ = vx y → y = ⋅ y = .
dt dt dx dx dx vx dt vx
In felul acesta am obţinut un sistem de patru ecuaţii diferenţiale

pentru funcţiile necunoscute vx(x), vy(x), y(x) şi t(x). Rezolvarea acestui
sistem presupune cunoscute vitezele iniţiale:
vx0 ; v 0y cu vx0 = v 0 cos α ; v 0y = v 0 sin α .
Si deci unghiul de lansare α. Vom începe cu un unghi de lansare
iniţial egal cu unghiul format de linia dreaptă dintre punctul de lansare si
ţintă şi orizontală. Apoi vom determina valoarea lui α prin minimizarea
expresiei:
y( x f ) − y f
Pentru minimizare vom utiliza funcţia fminbnd.
Valorile numerice sunt: viteza iniţiala 200 m/s, gravitaţia 9.8
2
m/s , coeficientul de rezistenţă al aerului este 0.001 kg/m, iar poziţia
ţintei este x=1000m, y=100m.
Funcţia proiectil face optimizarea unghiului de lansare
function proiectil
clear all;
global Vinit Gravty Cres Xend Yend

vinit=200; gravty=9.8; cres=0.001;
xend=1000; yend=100;
disp(' ');
disp('Cautarea unghiului optim initial');
disp('pentru a tinti cu un proiectil');
disp('un obiect fix'); disp(' ');
disp(['viteza initiala = ',num2str(vinit)]);
disp(['acceleratia gravitationala = ',num2str(gravty)]);
disp(['coeficientul de rezistenta al aerului (cu v^2) = ',num2str(cres)]);
disp(['coordonatele tintei = (', ...
num2str(xend),',',...
num2str(yend),')']); disp(' ');
% transformarea datelor initiale in variabile globale;
Vinit=vinit; Gravty=gravty; Cres=cres;
Xend=xend; Yend=yend;
% se face optimizarea
fstart=180/pi*atan(yend/xend); fend=75;
disp('Asteptati un moment pentru optimizare')
bestung=fminbnd(@mindis,fstart,fend);
% listarea rezultatelor finale
[y,x,t]=traject(bestung,vinit,gravty,cres,xend);
dmin=abs(yend-y(length(y))); disp(' ')
disp(['precizia este de ', ...
num2str(dmin),' cand']);
disp(['unghiul initial este: ', ...
num2str(bestung),' grade']);
disp(['durata zborului :',num2str(t(end))])
%
%
function [dsq,x,y]=mindis(unghi)
%
% [dsq,x,y]=mindis(unghi)
% ~~~~~~~~~~~~~~~~~~~~~~~~
%
% este functia de minimizat cu fminbnd
% functia calculeaza eroarea de tintire pe axa y
%pentru un unghi dat
%
% unghi - unghiul de inclinare in grade
%
% dsq - patratul erorii de tintire
% x,y - coordonatele traiectoriei urmate de proiectil
%
% Vinit, Gravty,Cres, Xend parametrii globali utilizati
%
% foloseste functia traject
%----------------------------------------------
global Vinit Gravty Cres Xend Yend
[y,x,t]=traject ...
(unghi,Vinit,Gravty,Cres,Xend,1);
dsq=(y(end)-Yend)^2;
function [y,x,t]=traject ...

(unghi,vinit,gravty,cres,xend,noplot)
%
% [y,x,t]=traject ...
% (unghi,vinit,gravty,cres,xend,noplot)
% ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
% aceasta functie rezolva ecuatia diferentiala

% pentru un proiectil supus atractiei gravitationale
% si la o rezistenta aerului proportionala cu
% patratul vitezei
%
% unghi - unhiul de lansare al proiectilului
% vinit - viteza de lansare a proiectilului
% gravty - acceleraratia gravitationala la nivelul solului
% cres - coeficientul de rezistenta al aerului
% (ra=cres*v^2)
% xend - coordonata x a tintei
% pana la aceasta valoare seste necesar calculul solutiei
% viteza de lansare trebuie sa fie suficient de mare
% pentru ca proiectilu sa poata atinge deasupra solului
% aceasta dustanta.
% daca nu poate ajunge la xend programul se tremina cu
% un mesaj de eroare
% noplot - parametru de listare a traiectoriei doar in final
%
% iesiri
% y - coordonara y a traiectoriei
% x - coorsonata x a traiectoriei
% t - timpul
%
% variabile globale
% grav - gravitatia
% resc cres - coeficientul rezistentei aerului
% vtol - toleranta utilizata pentru a verifica daca
% viteza initiala de lansare este admisibila
%
% utilizeaza functia: projcteq

%----------------------------------------------
global grav resc vtol
% date initiale implicite daca nu se transmit la intrare
if nargin ==0
unghi=45; vinit=200; gravty=9.8;
cres=0.001; xend=1000;
end;
% se calculeaza unele variabile locale si
% solutia initiala necesara ec. dif.
grav=gravty; resc=cres; ung=pi/180*unghi;
vtol=vinit/1e6;
z0=[vinit*cos(ung); vinit*sin(ung); 0; 0];
% se rezolva ecuatia diferentiala pentru functia projcteq
deoptn=odeset('RelTol',1e-6);
[x,z]=ode45('projcteq',[0,xend],z0,deoptn);
y=z(:,3); t=z(:,4); n=length(x);
xf=x(n);
yf=y(n);
% se traseaza la final traiectoria
if nargin < 6
plot(x,y,'k-',xf,yf,'mo');
xlabel('x [m]'); ylabel('y [m]');
title('Traiectoria proiectilului ');
axis('equal'); grid on; figure(gcf);
end
function zp=projcteq(x,z)
%
% zp=projcteq(x,z)
% ~~~~~~~~~~~~~~~~
%
% functia care defineste miscarea proiectilului
% franat de propria gtrutate si de o rezistenta a
% aerului proportionala cu patratul vitezei
%
% x - coordonata orizontala (variabila functiei)
% z - vectorul ce contine [vx; vy; y; t];
%
% zp - derivata dz/dx egala cu
% [vx’(x); vy’(x); y’(x); t’(x)];
%
% variabile globale:
%
% grav - acceleratia gravitationala
% resc - tcoeficientul de rezistenta al aerului
% vtol - variabila de validare a vitezei initiale
% whether vx is zero
%----------------------------------------------
%
global grav resc vtol
vx=z(1); vy=z(2); v=sqrt(vx^2+vy^2);
if vx<vtol
disp(' ');error(' ');
end
zp=[-resc*v; -(grav+resc*v*vy)/vx; ...
vy/vx; 1/vx];
19.3. Soluţii
1.
s=
0.3520
0.2056
0.2640
2.
>> bjex
lungimea este :44.4881 m
Fig.19.2
Se observă că echilibrul se realizează pe la 70 de metrii unde

forţa elastică a corzii extinse echilibrează greutatea corpului.
Utilizând funcţia bjfun modificată cu ra=0 obţinem:
>> bjex
lungimea este :28.5233 m
Evident lungimea corzii este mai mică (mai bine nu-i aşa?) dar
surpriza vine de la graficul traiectoriei corpului, oscilaţia în sus sau în
jos devine infinită în timp, deci corpul nu se va oprii niciodată!
Fig. 19.3
Graficul vitezei este:
Fig.19.4
Viteza se amortizează spre 0.
3.
>> proiectil
Cautarea unghiului optim initial

pentru a tinti cu un proiectil
un obiect fix
viteza initiala = 200
acceleraţia gravitaţională = 9.8

coeficientul de rezistenta al aerului (cu v^2) = 0.001
coordonatele ţintei = (1000,100)

Asteptati un moment pentru optimizare
Warning: Failure at t=6.605480e+002. Unable to meet integration
tolerances without reducing the step size below the smallest value
allowed (1.818989e-012) at time t.
precizia este de 9.4222e-006 când
unghiul iniţial este: 23.4767 grade
durata zborului :9.6112 sec
Graficul traiectoriei este:
Fig.19.5
LUCRAREA 20
20.1. Simulink. Elemente de bază.
Un sistem dinamic este o noţiune abstractă, matematică in care,

una sau mai multe reguli descriu dependenţa de timp a unui punct dintr-
un spaţiu abstract, de obicei spaţiul geometric real cu trei dimensiuni.
Simulink este o componentă a pachetului MATLAB pentru modelarea,
analiza şi simularea sistemelor dinamice. Utilizarea programului
Simulink se face în mai mulţi paşi:
1. Se lansează din MATLAB programul Simulink. Acest lucru se
face scriind comanda >> Simulink sau din bara de unelte se apasă
butonul Simulink. Apare o fereastră numită Simulink Library

Browser (vezi figura 20.2) care anunţă că Simulink este activ.
2.Modelarea. In această etapă se creează sau se modifică un
model preexistent al unui sistem dinamic, Un model de tip Simulink este
o diagramă formată din blocuri (vezi figura 20.1).
Fig.20.1
Un bloc este o reprezentare a unor entităţi fundamentale ale

sistemului dinamic şi constă din 3 componente: 0, una sau mai multe
intrări, 0, una, sau mai multe ieşiri şi o funcţie care descrie cum se obţin
ieşirile din intrări. Blocurile sunt de mai multe tipuri dar primesc
automat în model un nume unic. Dacă unul dintre blocuri se repetă (cum
este cazul în figura 20.1), atunci MATLAB adaugă numere la sfârşitul
numelui pentru a deosebi blocurile. Legăturile dintre blocuri se numesc
conexiuni.
Fig.20.2
O conexiune este o linie ce uneşte o ieşire a unei conexiuni cu o

intrare a altei conexiuni. O categorie specială de blocuri este cea cu 0
intrări. Aceste blocuri se numesc surse. O altă categorie de blocuri nu au
decât intrări şi se numesc colectoare ( de la cuvântul englezesc sinks).
Blocurile se găsesc pe categorii în Simulink Library Browser
(vezi figura 20.2). Crearea unui nou model se face tastând butonul .
Apare o fereastră nouă unde trebuie să introducem blocurile (vezi Figura
20.3).
Fig.20.3
Pentru a introduce un bloc în model se utilizează mouse-ul cu

drag-and move. Adică ne ducem pe bloc în categoria dorită, îl selectăm
apăsând butonul din stânga al mouse-ului, ţinem butonul apăsat ne
plasăm pointerul mose-ului unde dorim în fereastra modelului şi apoi
eliberăm butonul din stânga. De exemplu să introducem în model o
sursă. Pentru aceasta ne ducem în Simulink Library Browser selectăm
Sources, apoi din dreapta tragem în fereastra modelului blocul Sine
Wave . Se va obţine situaţia din figura 20.4.
Fig.20.4
Acum vom selecta un colector de exemplu Scope din Snks:

Fig. 20.5
Vom conecta aceste blocuri cu o conexiune. Pentru aceasta ne

vom duce cu mouse-ul pe ieşirea din dreapta a blocului Sin Wave până
când apare o cruce. Apăsăm butonul stânga şi-l ţinem apăsat şi deplasăm
vârful săgeţii până la intrarea din stânga a blocului Scope până când
apare iar o cruce. Atunci eliberăm butonul mouse-ului şi conexiunea este
creată. Se obţine ceva asemănător cu Figura 20.6.
Fig.20.6
Cu aceasta am creat un prim model (unul din cele mai simple cu

putinţă).
3.Introducerea satelor. Modelul conţine surse care s-ar putea să
introducă corect datele. De obicei vrem modificarea datelor implicite a
surselor cu valorile noastre. Astfel Sin Wave generează la teşire funcţia
Asin(wt+d)unde A(amplitudinea) are valoarea 1, w(frecvenţa) are
valoarea 1, iar d(defazajul în radiani) are valoarea 0. Noi dorim la intrare
funcţia 2sin(πt+π/2). Pentru aceasta dăm în model dublu clic pe Sin
Wave. Apare fereastra din figura 20.7 în care modificăm amplitudinea
cu 2, frecvenţa cu pi şi phase (defazajul) cu pi/2 şi apăsăm ok.
Fig.20.7
4. Lansarea simulării . Se face apăsând butonul din

fereastra modelului. Odată simularea începută acest buton se transformă
în Intr-un buton stop cu care se poate opri instalarea.
5. Vizualizarea rezultatelor. Acest lucru se face dând un clic

dublu pe fiecare colector definit. Dând dublu –clic pe colectorul Scope
în modelul nostru obţinem (vezi figura 20.8):
Fig.20.8
6. Analiza rezultatelor. În această fază se face interpretarea

rezultatelor şi se concluzionează dacă simularea este corectă sau nu.
Dacă nu este corectă se poate trece din nou la faza 2 pentru modificarea
mouse-ului. Alteori dorim put şi simplu modificarea datelor de intrare
pentru a vedea cum se comportă modelul cu noul set de date. Alteori
dorim să introducem noi blocuri etc.
Astfel pentru modelul acesta simplu am parcurs toate etapele.
Dorim acum să introducem un bloc nou între sursă şi destinaţie
de exemplu blocul Gain (înmulţire cu o constantă, de exemplu cu

4). Acest lucru se face prin tragerea blocului din Simulink Library
Browser pe conexiunea dintre Sin Wave şi Scope. Automat conexiunea

este întreruptă şi noul bloc este înserat (vezi figura 20.9)
Fig. 20.9
Dăm acum dublu clic pe blocul Gain şi modificăm în fereastra

apărută câmpul Gain cu valoarea 4. mai introducem un bloc între Gain şi
Scop şi anume blocul Saturation din cadrul blocurilor Discontinuities.
Pentru aceasta tragem întâi mai la dreapta blocul Scop i observăm că
oriunde vom mişca blocul conexiunea ce-l leagă de Gain îl va urma
automat. Acum tragem blocul Saturation peste conexiunea dintre Gain şi
Scope. Blocul Saturation are ca scop ca funcţia de ieşire să fie între
anumite limite. Pentru aceasta dăm dublu-clic pe Saturation şi pentru
limita superioară punem 4 (upper limit), iar pentru cea inferioară punem
-3 (lower limit). De asemenea mai dorim ca semnalul iniţial să fie şi el
vizualizat pe un bloc Scope. Pentru aceasta trebuie să bifurcăm semnalul

de ieşire din Sine Wave. Mai întâi Tragem un nou bloc Scop în model.
Automat va primi numele Scope 1. Acum de ducem pe
conexiunea dintre Sin Wave şi Gain cam unde dorim să înceapă
bifurcaţia conexiunilor şi apăsăm butonul drapata al mouse-ului şi-l
ţinem apăsat ducem mouse-ul pe intrarea lui Scop 1 şi eliberăm butonul
dreapta. Automat s-a creat o conexiune între bifurcaţie şi blocul Scop 1.
Acest lucru înseamnă că semnalul va ajunge şi l-a blocul Gain şi
la blocul Scope 1 (vezi Figura 20.10).
Fig.20.10
Putem acum lansa simularea. La terminare dăm dublu-clic pe

Scop şi vizualizăm semnalul prelucrat cu Gain şi Saturation (vezi figura
20.11) . Pentru a vedea semnalul iniţial dăm dublu clic pe Scope 1.
Rezultatul este prezentat în figura 20.12 In această figură este supărător
faptul că graficul nu este chiar o sinusoidă. Acest lucru se datorează
faptului că paşii de timp au fost prea mari (valoarea implicită 0.2).
Pentru ai facem mai mici accesăm în fereastra modelului meniul
Simulation şi aici Configuration Parameters ( sau direct cu tastele
CTRL+E). Aici modificăm câmpul max step size (pus pe auto) cu
valoarea 0.05. Reluăm apoi simularea şi obţinem în Scop1 imaginea din
figura 20.13 . Dacă totuşi dorim ambele grafice pe acelaşi Scope vom
utiliza bara Mux (care preia două sau mai multe ieşiri într-un singur
vector dependent de timp ce va conduce la reprezentarea a două sau mai
multe ieşiri pe acelaşi Scop. Pentru ştergerea lui Scop1 îl selectăm şi clic
dreapta şi delete. La fel cu conexiunea nedorită. Vom face o conexiune
nouă de la Sin Wave la Mux.
Fig.20.11
Fig.20.12
Fig.20.13
Fig.20.14
În figura 20.14 avem modelul modificat. Bara Mux se alungeşte

cu mouse-ul şi plimbăm Scop pentru ca şi conexiunile să fie linii drepte.
Lansăm simularea şi dublu clic pe Scope, Obţinem figura 20.15
unde semnalul iniţial este mov(magenta), iar cel prelucrat este cu galben
(yellow).
Fig. 20.15
In continuare vom prezenta un model în care prelucrările semnalelor vor

fi mai complicate.
Ne propunem acum să modelăm sistemul care modelează
prelucrarea de semnal dată de funcţia:
f ( x ) = x 2 sin 5 x − 2 x + 5
Pentru crearea acestui model trebuie să facem următorii paşi:
1 Tragem prima sursă Ramp. Această sursă defineşte semnalul x
ca o valoare liniară de timp.
2 Dublu clic pe Ramp şi verificăm ca sloap să fie 1. Sloap este de
fapt tangenta unghiului pe care dreapta x(t) o face cu orizontala. Vom
pune 1 şi ceilalţi parametrii să fie 0. Asta îndeamnă că x(t)=t şi deci

generăm un semnal care este egal cu valoarea timpului.
3 Tragem Sin Wave ca a doua sursă. Avem nevoie de ea ca să
definim sin(5x).
4 Dublu clic pe Sin Wave Si definim frecvenţa ca fiind 5. Restul
parametrilor rămân nemodificaţi.
5 Tragem din Math Operations două blocuri Polynomials (avem
de definit două polinoame x2 şi -2x+5/Punem unul din aceste blocuri pe
aceiaşi orizontală cu Ramp (va fi -3x+5), iar al doilea Intre Ramp şi Sin
Wave (va fi x2).
6. Dublu clic pe primul Polynomials şi la polynomial coefficients
scriem [-2,5] şi apoi OK. Am definit astfel polinomul -2x+5.
7 Dublu clic pe al doilea Polynomials şi la polynomial
coeficients scriem [2,0,0]. Am definit astfel polinomul x2.
8 Tragem din Math Operations blocul Product şi-l punem între
Sin Wave şi Polinomials (x2) Pentru a face produsul între Sin Wave şi
Polynomials (x2).
9.Punem între Polynomials (-2x+5) şi Product Un bloc Sum tras
din Commonly Used Blocks.
10. Tragem din Sinks un bloc Scope.
11.Facem o conexiune între Ramp şi Polynomials (-2x+5).
12. Facem o conexiune de la Sin Wave la Product.
13. De la mijlocul conexiunii definite la 11 cu clic dreapta
tragem o conexiune la Polynomials (x2).
14.Facem o conexiune de la Polynomials (x2) la Product.
15. Facem o conexiune de la Polynomials (-2x+5) la Sum.
16. Facem o conexiune de la Product la Sum.
17 Facem o conexiune de la Sum la Scope. (Vezi figura 20.16).
18. In fereastra modelului accesăm meniul Simulation şi aici

alegem Configuration Parameters Aici ne uităm la Simulation Time.
Deoarece avem x=t trebuie să punem start 0 şi stop 4 şi apoi Ok.
19. Lansăm simularea cu butonul din fereastra modelului.

20. Dublu clic pe Scope pentru a vizualiza rezultatul simulării/
(Vezi figura 20.17).
Fig. 20.16
Fig. 20.17
19.4. Aplicaţii
1 Realizaţi modelul care simulează transformarea gradelor Fahrenheit în

grade Celsius pe intervalul 0oC – 100oC.
2. Sa se simuleze sistemul ce are ca funcţie de prelucrare funcţia :
f ( x ) = x 2 − 1sin 2 x + ( 2 x − 3) ln x − 3 .
19.5. Indicaţii şi soluţii.
1.Ecuaţia dintre temperatura în grade Fahrenheit şi Celsius este :
9C-5F+160=0
Pentru a modela sistemul facem paşii după ce lansăm Simulink şi

deschidem un nou model:
1. Tragem o sursă Ramp.
2. Tragem Gain şi0l modificăm prin dublu clic cu valoarea 5
3. Tragem un bloc Constant şi îi punem valoarea -160.
4 Tragem un bloc Sum.
5. Tragem un bloc Constant şi îi punem valoarea 9.
6. Tragem din Math un bloc Divide.
7 Tragem din Discontinuities un bloc Saturation şi punem limita minimă
0 şi maximă 100.
8. tragem un bloc Scope.
9 Facem o conexiune Intre Ramp şi Gain.
10. Facem o conexiune între Gain şi Sum.
11.Facem o conexiune Intre Constant şi Sum.
12. Facem o conexiune între Sum şi Divide.
13. Facem o conexiune între Constant1 şi Divide.
14. Facem o conexiune între Divide şi Saturation.
15 Facem o conexiune între Saturation şi Scop. (Vezi figura 20.18).
16 . Definim în meniul Simulation, submeniul Configuration Parameters
valoarea de start ca fiind 0 şi cea finală ca fiind 250.
17. Tastăm butonul pentru a porni simularea

18. Dublu clic pe Scope pentru a vizualiza rezultatul. (Vezi figura
20.19).
2.
Pentru a modela şi simula n astfel de sistem trebuie să facem
paşii:
1. Lansăm Simulink şi deschidem un nou model.
2. Tragem o sursă Ramp şi o lăsăm cu valorile implicite (deci x=t).
3. Tragem o sursă Sin Wave şi modificăm frecvenţa la 2.
4. Tragem din Math un bloc Polynomials şi definim polinomul [1,0,-1].
5. Tragem din Math un bloc Polynomials şi definim polinomul [2,-3].
6. Tragem din Math un bloc Math Function şi alegem funcţia log.
7. Tragem din Math un bloc Math Function şi alegem funcţia sqrt.
Fig. 20.18
Fig.20.19
8. Tragem din Math un bloc Product.

9. Mai tragem din Math un bloc Product.
10. Tragem din Commonly Used un bloc Constant şi-l modificăm cu
valoarea -3.
11. Tragem din Commonly Used un bloc Sum. Dăm apoi dublu clic şi
adăugăm un plus în căsuţa List of signs. Această căsuţă ne dă semnele
intrărilor. Acum trebuie să avem aici trei de + pentru că adunăm trei
termeni. Puteam să punem la Constant valoarea 3 şi atunci ar fi trebuit să
punem în Sum un minus pentru al scădea pe 3. Numărul semnelor (+ sau
-) din List of signs ne spune şi numărul intrărilor în Sum. Acum vom
avea 3 intrări în Sum pentru că în List of signs avem 3 de +.
12. Facem o conexiune de la Sine Wave la Product1.
13. Facem o conexiune de la Ramp la Polinomials.

14. Facem o conexiune de la conexiunea de la 13 cu butonul dreapta
apăsat laPolynomials1.
15. Facem o conexiune de la conexiunea de la 13 la Math Function.
16 Facem o conexiune de la Math Function la Product.
17. Facem o conexiune de la Polynomials la Product.
18. Facem o conexiune de la Polynomials1 la Math Function1.
19. Facem o conexiune de la Math Function1 la Product1.
20. Facem o conexiune de la Product la Sum.
21. Facem o conexiune de la Product1 la Sum.
22. Facem o conexiune de la Constant la Sum.
23. Facem o conexiune de la Sum la Scop (Vezi figura 20.20
24. În Simulation la submeniul Configuration Parameters modificăm
startul la 1 şi stopul la 8.
25. Tastăm butonul pentru a porni simularea

26. Dublu clic pe Scope pentru a vizualiza rezultatul. (Vezi figura
20.21).
Fig.20.20
Fig.20.21
LUCRAREA 21
21.1. Simulink. Simularea sistemelor dinamice

bazate pe ecuaţii diferenţiale de ordinul 1.
În această lucrare ne propunem să utilizăm Simulink la

rezolvarea ecuaţiilor diferenţiale de ordinul I. O astfel de ecuaţie arată
astfel:
x = f ( x, t ) cu t ∈ [ a, b ] , x ( a ) = xa
Am văzut că în MATLAB putem rezolva o astfel de ecuaţie
astfel:
x = −2 x + 2t 2 − 1 cu t ∈ [ 0,3] , x ( 0 ) = 1
Programul MATLAB în acest exemplu este:
f=inline('-2*x+2*t^2-1','t','x');
>> [t,y]=ode45(f,[0,3],1);
>> plot(t,y,'r')
Graficul rezultat este:
Fig.21.1
Şi în Simulink utilizând blocul Integrator putem face

integrarea ecuaţiei. Paşii ce trebuie făcuţi sunt următorii:
Se lansează Simulink.
Se deschide un nou model.
Tragem un bloc Ramp din Sources.
Tragem un bloc Polynomials din Math. Clic stânga dublu pe
bloc si completăm cu [2,0,-1] (Adică polinomul 2t2-1).
Tragem un bloc Sum din Common Used.
Tragem un bloc Integrator din Continuos. Cu dublu clic stânga

deschidem fereastra lui de parametrii şi la intial condition punem
1(valoarea iniţială).
Tragem un bloc Gain din Common Used. Un clic dreapta şi
alegem meniul Format, iar aici Flip (rotaţie cu 180o. Apoi dublu clic
stânga pe bloc şi punem valoarea -2 (înmulţim pe x cu -2). Plasăm blocul
sub blocul Integrator .
Tragem un bloc Scope din Sinks.
Conectăm blocul Ramp cu blocul Polynomials.
Conectăm blocul Polynomials cu blocul Sum.
Conectăm blocul Sum cu blocul Integrator.
Conectăm blocul Integrator cu blocul Scope.
Conectăm blocul Gain cu blocul Sum.
Din mijlocul conexiunii dintre Integrator şi Scope cu clic dreapta
tragem o conexiune la Gain.
In meniul Simulation alegem Configuration parameters şi
completăm stop cu valoarea 3 (am definit astfel domeniul de definiţie a
lui t ca fiind între 0 şi 3). În acest moment modelul arată ca în figura
21.2.
Lansăm simularea.
Dublu clic stânga pe Scope si obţinem imaginea din figura 21.3.
Se remarcă faptul că graficul din figura 21.3 este identic (normal, nu-i
aşa?) cu cel din figura 21.1
Avantajul utilizării Simulink în astfel de probleme este
flexibilitatea mărită a acestui model. Putem modifica uşor sursele pentru
a schimba condiţiile de rezolvare. De asemenea se modifică cu uşurinţă
orice bloc schimbând complet problema.
Din această cauză Simulink este utilizat la rezolvarea unor
probleme practice în care condiţiile variază.
Fig.21.2
Fig.21.3
21.2. Aplicaţii
1.Fie ecuaţia diferenţială de ordinul I dată de:

x = 2 x + t + 1, x ∈ [1, e ] , x (1) = −1
Să se rezolve în MATLAB cu funcţia ode45 şi să se traseze graficul
funcţiei rezultat.
Să se simuleze ecuaţia cu Simulink şi să se compare rezultatul simulării
din Scope cu cel de la punctul a.
2. Un vagon de tramvai de masă m este tras de forţa motorului F cu o
viteză v. Acestui tramvai i se opune o forţă de rezistenţă Fr direct
proporţională cu viteza v (vezi figura 21.4). Dacă se cunosc masa
m=1000 Kg şi coeficientul de proporţionalitate al forţei de rezistenţă Fr
c=40 N*s/m, să se simuleze mişcarea tramvaiului presupunând că
porneşte de pe loc şi calea de rulare este dreaptă (fără curbe sau
denivelări), în următoarele situaţii:
a) Toată forţa motorului F=400N se aplică de la pornire.
b) Forţa motorului acţionează prin impulsuri (F=400N).
c) Forţa motorului creşte treptat cu câte 40N/s
d) Forţa motorului creşte treptat cu câte 40N/s dar este limitată la
valoarea maximă F=400.
e) Aceiaşi problemă ca la d) doar că forţa de rezistenţă este direct
proporţională cu pătratul vitezei.
Fr=-cv
Fig.21.4
1.
a) Comenzile MATLAB sunt:
>> f=inline('2*x+t+1','t','x');
>> [t,x]=ode45(f,[1,exp(1)],-1);
>> plot(t,x,'r')
Fig.21.5
b) Modelul creat cu Simulink se aseamănă cu cel creat la început (vezi
figura 21.6). În figura 21.7 este vizualizat rezultatul din blocul Scope.
Comparând figura 21.5 cu figura 21.7 remarcăm faptul că cele două
grafice sunt identice.
2. Pentru început să aplicăm legea a III –a a lui Newton. Rezultă că:

ma=F-Fr=F – cv
dv
Dar a = = v Şi deci obţinem ecuaţia diferenţială de ordinul I:
dt
F − cv
v=
m
Fig. 21.6
Fig.21.7
a) Se utilizează la intrare o sursă Step. Sistemul modelat este cel din

figura 21.8.
Fig. 21.8
La step s-a pus Step time 0 şi initial şi final value ca fiind 400. Integrator
este lăsat aşa cum este iar la Gain -40. Dublu clic pe Scop şi-am obţinut:
Fig. 21.9
Se remarcă faptul că după aproximativ 150s viteza se stabilizează

la 10m/s, aproximativ 36km/h.
b) vom modifica intrările pentru ca după 100 s forţa să scadă
instantaneu la 0. Pentru aceasta se mai adaugă un bloc step în care la
Step Time punem 100, la initial value 0 iar la final value -400( vezi
figura 21.9 pentru model şi figura 21.10 pentru graficul vitezei).
Fig.21.9
Fig.21.10
c) Se modifică modelul pentru a introduce o sursă Ramp în care

se pune sloap 40 (creşterea pe secundă a forţei) restul neschimbat (vezi
figura 21.11 pentru model şi figura 21.12 pentru rezultat).
Fig.21.11
Fig. 21.12
Se remarcă faptul că nu se ajunge la echilibru viteza crescând
continuu.
d) Creşterea vitezei de la punctul precedent se datorează creşterii
forţei fără vreo limită. Punem acum o limită superioară creşterii forţei
printr-un bloc Saturation care va face limitarea creşterii la valoarea 400
N. Astfel în blocul Saturation modificăm UpperLimit la 400. Blocul va
fi plasat între Ramp şi Sum (vezi figurile 21.13 şi 21.14).
Fig. 21.13
Fig. 21.14
Se remarcă faptul că după un anumit timp viteza ajunge la starea
de echilibru de 10m/s. Acest model simulează corect situaţia reală a
plecării unui tramvai din staţie.
e) Vom folosi modelul de la d) Problema este că forţa de

rezistenţă este acum proporţională cu pătratul distanţei şi deci în locul
blocului Gain vom pune un bloc polynomials cu [-40,0,0]
Fig. 21.15
Fig. 21.16
Se remarcă faptul că tramvaiul ajunge la echilibru mult mai
repede, dar viteza de echilibru este mult mai mică, în jur de 3.3m/s adică
doar aproximativ 12 km/h.
LUCRAREA 22
22.1. Simulink. Simularea sistemelor dinamice

bazate pe ecuaţii diferenţiale de ordinul 1I.
În această lucrare ne propunem să utilizăm Simulink la

rezolvarea ecuaţiilor diferenţiale de ordinul I. O astfel de ecuaţie arată
astfel:
x = f ( x, x, t ) cu t ∈ [ a, b ] , x ( a ) = x0 , x ( a ) = x1
Am văzut că în MATLAB putem rezolva o astfel de ecuaţie
astfel:
x = 2 x − 2 x + 2t 3 − 9t 2 + 2t cu t ∈ [ 0, 2] , x ( 0 ) = −3, x ( 0 ) = −2
Pentru a rezolva aceastǎ ecuaţie diferenţialǎ o transformǎm intr-
un sistem de ordinul I cu douǎ funcţii necunoscute fǎcând substituţiile
urmǎtoare:
⎧⎪ y1 = x ( t )
⎨
⎪⎩ y2 = x ( t )
Rezultǎ sistemul de ordinul I:
⎧ y1 = y2
⎨ cu y1(0)=-3 şi y2(0)=-2
⎩ y2 = 3 y2 − 2 y1 + 2t − 9t + 2t
3 2
Programul MATLAB în acest exemplu este:

f=inline('[y(2);3*y(2)-2*y(1)+2*t^3-9*t^2+2*t]','t','y');
>> [t,y]=ode45(f,[0,2],[-3;-2]);
>> plot(t,y(:,1),'r',t,t.^3-2*t-3,'o')
Graficul rezultat este (cu ‚o’ am desenat soluţia exactǎ):
Fig.22.1
Şi în Simulink utilizând blocul Integrator de douǎ ori

putem face integrarea ecuaţiei. Paşii ce trebuie făcuţi sunt următorii:
Tragem un bloc Ramp din Sources.

Tragem un bloc Polynomials din Math. Clic stânga dublu pe
bloc Si completăm cu [2,-9,2,0] (Adică polinomul 2t3-9t2+2t).
P P P P
Tragem un bloc Sum din Common Used.

Tragem un bloc Integrator din Continuos. Cu dublu clic stânga
deschidem fereastra lui de parametrii şi la intial condition punem -
2(valoarea iniţială a derivatei în 0).
Tragem un alt bloc Integrator din Continuos. Cu dublu clic
stânga deschidem fereastra lui de parametrii şi la intial condition punem
--3(valoarea iniţială a funcţiei necunoscute în 0).
Tragem un bloc Gain din Common Used. Un clic dreapta şi
alegem meniul Format, iar aici Flip (rotaţie cu 180o. Apoi dublu clic
P P
stânga pe bloc şi punem valoarea 3 (înmulţim derivata cu 3). Plasăm

blocul sub primul bloc Integrator .
Tragem un alt bloc Gain din Common Used. Un clic dreapta şi
alegem meniul Format, iar aici Flip (rotaţie cu 180o. Apoi dublu P P
clic stânga pe bloc şi punem valoarea -2 (înmulţim funcţia

necunoscutǎ cu 3). Plasăm blocul sub primul bloc Gain.
Tragem un bloc Scope din Sinks.
Conectăm blocul Ramp cu blocul Polynomials.
Conectăm blocul Polynomials cu blocul Sum.
Conectăm blocul Sum cu primul bloc Integrator.
Conectǎm primul bloc Integrator cu al doilea bloc Integrator.
Conectăm al doilea bloc Integrator cu blocul Scope.
Conectăm primul bloc Gain cu blocul Sum.
Din mijlocul conexiunii dintre primul bloc Integrator şi al doilea
bloc Integrator cu clic dreapta tragem o conexiune la primul bloc Gain.
Din mijlocul conexiunii dintre al doilea bloc Integrator şi blocul
Scope cu clic dreapta tragem o conexiune la al doilea bloc Gain.
În meniul Simulation alegem Configuration parameters şi

completăm stop cu valoarea 2 (am definit astfel domeniul de definiţie a
lui t ca fiind între 0 şi 2). În acest moment modelul arată ca în figura
22.2.
Lansăm simularea.
Dublu clic stânga pe Scope si obţinem imaginea din figura 22.3. Se
remarcă faptul că graficul din figura 22.3 este identic (normal,nu-i aşa?)
cu cel din figura 22.1
Avantajul utilizării Simulink în astfel de probleme este
flexibilitatea mărită a acestui model. Putem modifica uşor sursele pentru
a schimba condiţiile de rezolvare. De asemenea se modifică cu uşurinţă
orice bloc schimbând complet problema.
Din această cauză Simulink este utilizat la rezolvarea unor
probleme practice în care condiţiile iniţiale sunt variabile.
Fig. 22.2
Fig. 22.3
22.2. Aplicaţii
1.Fie ecuaţia diferenţială de ordinul I dată de:

x = −2sin t ⋅ x − x − 2sin t + (1 + t ) cos 2t − t , x ∈ [ 0, π ] , x ( 0 ) = 0, x ( 0 ) = 1
Să se rezolve în MATLAB cu funcţia ode45 şi să se traseze graficul
funcţiei rezultat.
Să se simuleze ecuaţia cu Simulink şi să se compare rezultatul simulării
din Scope cu cel de la punctul a.
2. Sistemul mecanic corp-arc (vezi figura 22.4). Un corp de masǎ m este

ataşat de un zid Z printr-un arc de constantǎ k. Corpul este tras în
direcţia pozitivǎ a axei Ox de o forţǎ F. Mişcǎrii se opune o forţǎ de
rezistenţǎ R compusǎ din forţa de frecare cu solul S şi rezistenţa la
înaintare opusǎ de aer. Se ştie cǎ aceastǎ forţǎ R este direct proporţionalǎ
cu viteza de deplasare a corpului, constanta de proporţionalitate fiind B.

Lungimea arcului neîntins este l.
Valori numerice: F=4o N, m=1000 kg, k=20 N/m, B=40 Ns/m, l=1
m.
Se cere simularea mişcǎrii sistemului.
Z
F
K
m R
Fig. 22.4
1.
a) Comenzile MATLAB sunt:
>> f=inline('[y(2);-2*sin(t)*y(2)-y(1)-2*sin(t)+(1+t)*cos(2*t)-t]','t','y');
>> [t,y]=ode45(f,[0,pi],[0;1]);
>> plot(t,y(:,1))
Fig. 22.5
b) Modelul creat cu Simulink se aseamănă cu cel creat la

începutul lucrǎrii (vezi figura 22.6). Au apǎrut douǎ blocuri funcţie
utilizator (fcn) pentru a descrie ecuaţia. Funcţia f(u) a fost definitǎ cu
blocul fcn din user defined functions ca -2*sin(u)+(1+u)*cos(2*u)-u. La
fel s-a procedat şi fcn1 cu -2*sin(u).
In figura 22.7 este vizualizat rezultatul din blocul Scope.
Comparând figura 22.5 cu figura 22.7 remarcăm faptul că cele două
grafice sunt identice.
Fig. 22.6
Fig.22.7
2. Trebuie sǎ obţinem ecuaţia echilibrului forţelor pentru acest

sistem mecanic. Forţa de deplasare este datǎ de ma unde a este
acceleraţia. Forţa de rezistenţǎ R este R=-Bv, iar rezistenţa opusǎ de arc
este –kx. Deci ecuaţia este:
ma=F-Bv-kx
Scriind cǎ acceleraţia este derivata a doua a distanţei, iar viteza

derivata întâi a distanţei obţinem ecuaţia diferenţialǎ de ordinul II :
mx = F − B ⋅ x − k ⋅ x
Modelul generat de Simulink pentru rezolvarea acestei ecuaţii

este:
Fig. 22.8
La blocul step se dǎ valoarea finalǎ 40 deci va genera forţa F.

Consatanta 1000 reprezintǎ masa m care imparte suma obţinutǎ. Se dǎ
dublu clic pe al doilea bloc integrator şi se pune valoarea iniţialǎ 1 (cât
este valoarea lungimii arcului neântins x(0)=1) . La primul bloc
integrator nu se face nici o schimbare valoarea implicitǎ este 0 şi este ce
ne trebuie.
In meniul Simulation alegem Configuration parameters şi
completăm stop cu valoarea 200 (am definit astfel domeniul de definiţie
a lui t ca fiind între 0s şi 200s). Rolul blocului Saturation este de a
împiedica ca x(t) sǎ ia o valoare mai micǎ decǎt 1. Pentru aceasta dublu
clic pe blocul Saturation şi completat cu upper limit 5 (arcul nu se poate
întinde mai mult de 5 m) şi lower limit 1 (arcul nu poate fi presat sub
valoarea lungimii sale).
Lansǎm simularea şi dupǎ terminarea ei dǎm dublu clic pe blocul

Scope pentru a vedea graficul traiectoriei x(t). Se observǎ în figura 22. 9
cǎ la un moment dat mişcarea se va opri corpul fiind la distanţa de 2 faţǎ
de origine.
Fig. 22.9
LUCRAREA 23
23.1. Simulink. Subsisteme
Drept exemplificare vom considera procesul de transfer de

căldură reprezentat schematic în figura 23.1.
Abur suprasaturat
TA
.
q
Lichid in Lichid out
. .
To mO
TI mI
TA
Abur condensat
Fig. 23.1
Se fac următoarele presupuneri:

Aburul ce intră în sistem este saturat, iar lichidul condensat ce

rezultă are aceiaşi temperatură ca aburul de la intrare (TA).
Lichidul din tub este necompresibil.
Energia înmagazinată în pereţii tubului este neglijabilă.
Toate proprietăţile fizice ale lichidului din tub nu variază axial
sau longitudinal (cu excepţia temperaturii lichidului).
Nu avem pierderi de masă, deci are loc : mi = mo (Cantitatea de
lichid ce intră în tub în unitatea de timp este aceiaşi cu cantitatea de fluid
ce iese din tub în unitatea de timp).
Vom nota cu punct deasupra derivata în raport cu timpul.
În aceste ipoteze ecuaţiile ce caracterizează sistemul sunt:
q = K ⋅ A ⋅ (TA − To )
m ⋅ C ⋅ To = m ⋅ C ⋅ (Ti − To ) + q
Notaţiile utilizate sunt:
q cantitatea de căldură transferată lichidului din tub pe unitatea de timp;
m masa lichidului din tub;
kW
K constanta de transfer căldură abur – lichid măsurată în o ;
K ⋅ m2
A aria tubului măsurată în m2; P P
TA temperatura aburului;
To temperatura cu care iese lichidul din tub (temperatura de echilibru);
Ti temperatura cu care intră lichidul din tub;
kJ
C căldura specifică a lichidului din tub măsurată în o ;
K ⋅ kg
Prima ecuaţie se numeşte ecuaţia transferului de căldură, iar a
doua ecuaţia balanţei energetice. Deoarece ne interesează doar
temperatura de ieşire vom utiliza prima ecuaţie doar pentru a calcula
membrul drept la a doua ecuaţie pe care însă o vom integra.
Caz numeric:
kW
K=0.8 ;
K ⋅ m2
o
A=300 m2; P P
m=1680 kg;
m =100/3 kg/s (Notaţie în MATLAB – mpct);
kJ
C=1.8 o ;
K ⋅ kg
TA=150 oC (Notaţie în MATLAB – TA);
P P
Ti=100 oC; (Notaţie în MATLAB – TI);

P P
To=140 oC (la momentul t=0); (Notaţie în MATLAB – TO);

P P
q =2400 kW/s (Notaţie în MATLAB – qpct);

Pentru a nu complica modelul fiecare ecuaţie o vom defini printr-
un bloc subsistem. Vom proceda astfel:
Se definesc în MATLAB toate valorile numerice de mai sus cu
comenzile:
>> K=0.8;A=300;m=1680;mpct=100/3;Ta=150;Ti=100;TO=130;
>> qpct=1400;C=1.8;
Simulink va căuta în Workspace orice variabilă pe care nu o
găseşte în blocurile lui. Acest mod de predefinire a variabilelor este mai
uşor de utilizat şi mai flexibil deoarece putem oricând relua o nouă
simulare cu alte valori fără să mai umblăm în modelele simulink.
În meniul File al modelului alegem Save As… şi salvăm modelul
cu numele trcal.
Din bibliotecă, din directorul Ports&Subsystems tragem blocul
Subsystem în model.
Clic stânga pe numele blocului şi-l schimbăm din Subsystem în
ratatc (de la rata transfer căldură).
Dublu clic stânga pe blocul redenumit ratatc şi se deschide o

fereastră ca în figura 23.2. (Este de fapt un model nou pentru
subsistemul ratatc – remarcaţi numele din stânga sus al ferestrei).
Fig. 23.2
Ne ocupăm acum de acest submodel ce va calcula pe q . Clic

dreapta pe conexiune şi dă-m Delete ca să ştergem conexiunea. (Mai
avem de introdus blocuri).
Din Ports&Subsystems se mai trage un bloc In şi-l redenumim
TO.
Redenumim primul bloc In cu numele TA. (Dacă aveţi deschis modelul
trcal ve-ti observa că automat s-a actualizat blocul ratatc).
Tragem un bloc Sum din Commonly Used Blocks. Dublu clic pe
el şi în câmpul List of Signs al doilea + îl facem -.
Tragem un bloc Gain din Commonly Used Blocks. Dublu clic pe
el şi în câmpul Gain scriem K*A.
Modificăm numele câmpului Out1 în qpct.

Facem o conexiune între TA şi Sum.
Facem o conexiune între TO şi Sum.
Facem o conexiune între Sum şi Gain.
Facem o conexiune între Gain şi qpct. Cu acesta subsistemul este gata şi
trebuie să arate ca în figura 23.3.
Fig.23.3
Revenim la modelul principal trcall şi tragem un nou bloc

Subsystem pe care-l redenumim balenerg ca în figura 23.4.
Dublu clic pe blocul balenerc şi se deschide un nou model
identic cu cel din Figura 23.2. Ştergem conexiunea dintre In1 şi Out1
Mai tragem două blocuri In (2 respectiv 3) In 2 deasupra lui în1,
iar In 3 sub In1.
Fig.23. 4
Redenumim blocurile In astfel::
In 1 cu mpct;
In2 cu TI;
In3 cu qpct.
Redenumim blocul Oit1 cu TO.
Tragem un bloc Sum
Tragem un bloc product la dreapta lui Sum şi dăm dublu clic pe el. În
câmpul List of Signs modificăm ultimul + în -.
Tragem un bloc Gain la dreapta şi dăm dublu clic pe el. În
câmpul Gain introducem C
Mai tragem un bloc Sum la dreapta.
La dreapta tragem un bloc Gain şi dăm dublu clic pe el. În
câmpul Gain introducem expresia 1/(m*C).
Tragem la dreapta un bloc Integrator şu dăm dublu clic pe el. În
câmpul Initial Condition introducem valoarea 130.
Facem o conexiune între Ti şi Sum.

Facem o conexiune între Sum şi Product.
Facem o conexiune între Product şi Gain.
Facem o conexiune între Gain1 şi Sum la dreapta.
Facem o conexiune între Sum şu Gain1.
Facem o conexiune între Gain1 şi integrator.
Facem o conexiune între Integrator şi qpct.
Facem o conexiune dintre Integrator şi primul Sum la semnul –
cu clic dreapta pe conexiunea dintre integrator şi qpct şi tragerea ei la
semnul minus al lui Sum Se va obţine modelul din figura 23.5.
Fig.23. 5
Revenim la modelul principal. La care adăugăm 3 constante la

intrare , două blocuri Scope la ieşire şi conexiunile ca în figura 23.6.
Fi.23.6
In meniul Simulation în configuration Parameters punem în
câmpul Stop Time valoarea 50.
Dăm Start Simulation.
Dublu clic pe ieşirile Scope şi obţinem figurile 23.7 şi 23.8.
Fig. 23.7
Fig. 23.8
In realitate schimbătoarele de căldură se pun mai multe în

cascadă pentru a avea un randament mai mare (temperatura de ieşire
finală să fie aproape de temperatura aburului suprasaturat).
Vom modela aici un lanţ de 4 schimbătoare de căldură. Descriem
în mare cum se va obţine modelul.
Se deschide în Simulink un nou model pe care-l vom numi fourtrcal.
Se trage din Ports&Subsystems un bloc Subsystem pe care-l vom
denumi Atrcal.
Dăm dublu clic pe blocul Atrcal Si ştergem tot.
Deschidem blocul trcal si cu ajutorul comenzii CTRL+A selectăm tot
apoi dăm comanda CTRL+C pentru copiere.
Revenim în blocul Atrcal şi poziţionăm mouse -ul în interiorul
modelului şi dăm comanda Paste (adică CTRL+V).
Ştergem blocurile de intrare constante şi în locul lor inserăm
blocuri In schimbându-le numele cu cele de la constantele pe care le
înlocuiesc.
Analog înlocuim blocurile Scope cu blocuri Out schimbând
corespunzător şi numele. Se va obţine modelul din figura 23.9.
Fig. 23.9
Revenim la modelul principal. Dăm clic pe blocul Atrcal şi apoi
CTRL+C (copy).
Cu ajutorul comenzii CTRL+V multiplicăm blocul A ca în final să avem
4 astfel de blocuri.
Pentru ca să listăm temperaturile de ieşire de la fiecare bloc
Atrcal vom introduce un bloc Mux la dreapta sus şi dublu clic pe e; iar la
Number of inputs punem 4 (numărul de temperaturi de ieşire testate).
Restul blocurilor şi conexiunile trebuie în aşa fel introduse pentru
a obţine modelul din figura 23.10 :
Fig.23.10
În meniul simulation se alege Configuration Parameters şi aici se

completează Stop Time cu 50.
Se lansează simularea.
Se dă dublu clic pe cele două Scopuri pentru a vedea distribuţia
temperaturilor de ieşire şi cantitatea totală de căldură consumată în
fiecare secundă. Se obţin astfel figurile 23.11 şi 23.12.
Fig.23.11
Fig.23.12
Să remarcăm că se ajunge la un echilibru când temperatura finală
de la ultimul schimbător este peste 149.5oC Si cantitatea de căldură
P P
transmisă în fiecare secundă este de aproximativ 320 kJ.

LUCRAREA 24
24.1. Simulink. Subsisteme mascate
Ne propunem să obţinem un bloc simulink nou, un bloc utilizator

pendanim care va face animaţia mişcării unui pendul. Vom face acest
lucru încercând să simulăm următoarea problema a pendulului cu ax
(vezi figura 24.1). d
Fig.24.1
Necunoscuta problemei este variaţia în timp a unghiului θ pe

care îl face axa pendulului cu verticala. Aici momentul produs de
mişcarea de rotaţie a pendulului trebuie să echilibreze suma momentelor
produse de greutatea pendulului şi de forţele de frânare. Momentul
produs de forţele de frânare se presupune direct proporţional cu viteza
unghiulară. Aceste două momente se opun mişcării inerţiale a pendulului
şi deci vom pune semnul – în faţa lor.
Se obţine ecuaţia:
Jθ = −mgd sin θ − cθ
⎛ L2 ⎞
unde J = m ⋅ ⎜ + d 2 ⎟ iar c este constanta momentului de frânare.
⎝ 12 ⎠
Vom utiliza în simulare următoarele valori numerice:
lungimea pendulului L=0.495 m;
distanţa dintre ax şi centrul de greutate d=0.023 m;
masa pendulului m=0.43 kg;
acceleraţia gravitaţională g=9.81 m/s2; P P
coeficientul momentului generat de forţele de frânare c=0.00035kg m2/s.

P P
Rezultă că J=0.009 kg m2.

P P
În modelul ce-l vom crea nu vom avea date de intrare iar ca ieşiri
vom avea graficul lui θ şi o animaţie ce va sugera mişcarea pendulului.
Programul de animaţie este denumit pendanim şi este listat aici :
function [sys,x0]=pendanim(t,x,u,flag,ts)
%PENDANIM S-function pentru animatia miscarii unui pendul
global PendAnim1
if flag==2,
if any(get(0,'Children')==PendAnim1),
if strcmp(get(PendAnim1,'Name'),'Animatie pendul'),
set(0,'currentfigure',PendAnim1);
hndlList=get(gca,'UserData');
x=[u(1) u(1)+2*sin(u(2))];
y=[0 -2*cos(u(2))];
set(hndlList(1),'XData',x,'YData',y);
set(hndlList(2),'XData',u(1),'YData',0);
drawnow;
end
end
elseif flag == 4 % salt la urmatorul test
% ns memoreaza numarul de teste
ns = t/ts;
% Timpul pentru urmatorul test.
sys = (1 + floor(ns + 1e-13*(1+ns)))*ts;
elseif flag==0,
% Initializeaza figura
animinit('Animatie pendul');
[flag,PendAnim1] = figflag('Animatie pendul');
axis([-3 3 -2 2]);
hold on;
x=[0 0];
y=[0 -2];
hndlList(1)=plot(x,y,'LineWidth',5,'EraseMode','background');
hndlList(2)=plot(0,0,'.','MarkerSize',25,'EraseMode','back');
set(gca,'DataAspectRatio',[1 1 1]);
set(gca,'UserData',hndlList);
sys=[0 0 0 2 0 0];
x0=[];
end
Putem acum să descriem modul în care se obţine modelul.

Definim aceste constante în MATLAB pentru a le apela de aici

în Simulink. Recomandăm definirea lor într-un script numit penduldate.
Apelăm Simulink şi deschidem un nou model.
Tragem un bloc Sum.
Tragem un bloc Integrator. Dublu clic pe el şi punem la initial value
valoarea -0.5 (valoarea vitezei unghiulare la momentul t=0).
Mai tragem un bloc Integrator. Dublu clic pe el şi punem în
câmpul initial value valoarea π/3 (valoarea unghiului θ la momentul
t=0).
Tragem un bloc Gain sub primul bloc Integrator, clic dreapta,
Format şi apoi Flip block. Dublu clic pe blocul Gain şi în câmpul Gain
se introduce –c/J, apoi OK.
Tragem un nou bloc Gain sub primul bloc Gain, clic dreapta,
Format şi apoi Flip block. Dublu clic pe blocul Gain şi în câmpul Gain
se introduce –m*g*d/J, apoi OK.
Tragem un bloc Trigonometric Function din Math Operations.
Deoarece funcţia implicită este chiar funcţia sin de care avem nevoie, nu
modificăm aici nimic.
Tragem un bloc Scope la dreapta ultimului bloc Integrator
Din meniul User-Defined Functions se trage un bloc S-Function
sub blocul Scope. Dublu clic pe acest bloc şi introducem In S-
Sunction Name numele pendanim (numele programului nostru de
animaţie) şi clic OK..
Se dă CTRL+G pentru a anunţa ca blocul să fie subsystem.
Acum dublu clic pe el şi ştergem OUT1 şi conexiunea cu el (subsistemul
are ca ieşire o figură). Închidem fereastra subsistemului căci nu mai
avem ce modifica aici.
Clic dreapta pe bloc şi alegem Subsystem Mask. Se selectează
tab-ul Parameters se dă clic pa butonul Add din stânga sus şi se
completează ca în figura 24.2 şi apoi OK.
Fig. 24.2
Dublu clic pe bloc şi în câmpul durata se va trece 0.01.

Tragem un bloc Mux (bara neagră) In stânga blocului pendanim.
Tragem un bloc Constant în stânga sus a blocului Mux. Dublu clic şi
introducem valoarea 0.
Facem acum toate conexiunile necesare pentru a obţine modelul
din Fig.24.3
Fig.24.3
Salvaţi modelul cu numele pendul.

In meniul Simulation al modelului pendul se alege Configuratuon
Parameters. Aici se modifica câmpul Stop Time cu valoarea 39 şi
câmpul Max step size cu valoarea 0.1 (pentru un desen precis al lui θ în
Scope). Se dă OK.
Se lansează simularea.
Va apare un desen animat ca în Fig.24.4
Fig.24.4
Dublu clic pe Scope pentru graficul lui θ (vezi figura 24.5).
Fig.24.5
BIBLIOGRAFIE
1) ****, „Lessons in electric circuits”, Vol. 4: Digital, www.

allaboutcircuits.com.
2) ****, http://www.datatranslation.com/white_papers/
HTU UTH
3) ***, “Building GUIs with MATLAB”, The MathWorks, Inc.,

December 1996
4) ***, “DSP Guide”, www.dspguide.com
5) ***, “Using MATLAB”, version 7, The MathWorks, Inc., 2006
6) Ardelean, D., Kloetzer, M., Pastravanu, O., "Crearea unei
biblioteci SIMULINK pentru exploatarea retelelor neuronale in
identificare" (http://iasi.bu.edu/~kmarius/Publications/rria.pdf ).
HTU UTH
7) Blanchet, G., Charbit, M., „Digital Signal and Image Processing

Using MATLAB”, HERMES Science Europe Ltd, 2001 si ISTE
Ltd, 2006.
8) Davis, T.A., Sigmon, K., „MATLAB Primer, Seventh Edition”,
Chapman & Hall/CRC, 2005.
9) Ghinea, M., Fireţeanu, V., „MATLAB. Calcul numeric ~ grafică
~ aplicaţii”, Ed. Teora, 1995.
10) Gopi, E.S., „Algorithm Collections for Digital Signal Processing
Applications using MATLAB”, Springer, The Netherlands, 2007.
11) Hahn, B., Valentine, D.T., “Essential MATLAB for Engineers
and Scientists”, 3rd Ed., Elsevier 2007
P P
12) Hu, Y., H., Hwang, J.-N. (editori), "Handbook of Neural Network
Signal Processing", CRC PRESS, 2002
13) Hunt, B.R., Lipsman, R.L., Rosenberg, J.M. et al., „A Guide to
MATLAB for Beginners and Experienced Users”, Cambridge
University Press, 2001.
14) Karris, S.T., „Circuit Analysis II with MATLAB – Applications”,

Orchard Publications, Fremont, California, 2003
15) Karris, S.T., „Digital Circuit Analysis and Design with Simulink
Modeling ”, Orchard Publications.
16) Karris, S.T., „Introduction to Simulink with Engineering
Applications”, Orchard Publications, 2006.
17) Karris, S.T., „Signals and Systems with MATLAB Computing and
Simulink Modeling”, 3rd ed., Orchard Publications, 2007.
18) Kiusalaas, J., „Numerical Methods in Engineering with
MATLAB”, Cambridge University Press, 2005.
19) Knight, A., „Basics of MATLAB and Beyond”, Chapman &
Hall/CRC, 2000.
20) Mathews, J.H., Fink, K.D., „Numerical Methods using MATLAB,
Third Edition”, Prentice Hall, 1999.
21) McMahon, D., „MATLAB Demystified. A Self Teaching Guide”,
Ed. McGraw & Hill., 2007.
22) Mitu, N., Paleu, V., Bujoreanu, C., “Solving Systems of
Nonlinear Algebraic Equations With Some Software Packages”,
prezentat la cel de-al doilea Simpozion A.C.M.E., Iasi, 2006 si
publicat in Buletinul I.P.I., Tom LII (LIV), Fasc. 6A, 2006,
Sectia Const. Mas., pp. 297-307.
23) Morgan, D., „Practical DSP Modeling, Techniques, and
Programming in C”, John Wiley @ Sons, Inc., 1994
24) Otto, S.R., Denier, J.P., „An Introduction to Programming and
Numerical Methods in MATLAB”, Springer-Verlag London
Limited, 2005.
25) Register, A.H., „A Guide to MATLAB Object-Oriented
Programming”, CRC Press, SciTech Publishing Inc., 2007.
26) Stearn, S.D., David, R.A., "Signal Processing Algorithms in

Matlab”, Prentice Hall PTR, Upper Saddle River, New Jersey
07458
27) Wilamowski, B.M., "Neural Networks and Fuzzy Systems" din
"The Mechatronics Handbook", CRC Press, 2002
28) Wilson, H.B., Turcotte, L.H., Halpern, D., „Advanced
Mathematics and Mechanics Applications Using MATLAB, 3rd
Ed.”, Chapman & Hall/CRC, 2003.

MATLAB Mitu Paleu Final

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

MATLAB Mitu Paleu Final

Încărcat de

Drepturi de autor:

Formate disponibile

Nicolae Mitu Viorel Paleu

5.1. Obiectivele lucrării...................................................................... 63

LUCRAREA 11 ................................................................................... 144

16.5. Soluţii ...................................................................................... 253

Pentru cursul ”Programarea Calculatoarelor şi Limbaje de

avantaj, pentru aceştia timpul de însuşire al limbajului MATLAB fiind

Aceste lucrări de laborator trebuie parcurse în ordinea prezentată

1.1. Obiectivele lucrării.

Această lucrare îşi propune prezentarea mediului de programare

1.2. Ferestrele MATLAB.

Lansarea programului MATLAB se face simplu: fie dând click

şi ora deschiderii sesiunii. Această zonă ne permite să nu scriem

Mai există o fereastră des utilizată, fereastra grafică. Această

1.3. Expresii şi calcule

Ca orice program de modelare matematică MATLAB este

cot – cotangentă; acot – arccotangent;

În manualul de referinţă aflat pe site-ul MathWorks se găsesc

Care dintre expresii este mai mare?

Să se afle valoarea fracţiilor:

Să se efectueze calculele cu constante speciale:

5. De la analiza matematică se ştie că limitele:

Cum explicaţi rezultatele?

6. Pentru x=0.5 şi t= 2 calculaţi expresiile:

1.5. Indicaţii şi soluţii

-1.0446 Deci 2π < π 2 . Analog şi punctele b) şi c).

5. Erorile sunt date de: abs(cos(pi/4)-(sin(pi/4+h)-sin(pi/4))/h) ,

satisfăcătoare pentru maşinile de 32 biţi. Precizia se va dubla odată cu

2.1. Obiectivele lucrării.

Această lucrare îşi propune însuşirea lucrului cu matrici : crearea,

2.2. Matrici şi vectori

2.2.1. Matrici şi vectori. Definiţii.

În teoria informaţiei o matrice este un tablou în care informaţiile

matricilor pătrate elementele de pe diagonala ce porneşte din colţul din

2.2.2. Definirea matricilor în MATLAB.

Pentru definirea matricilor în MATLAB se utilizează operatorul

Se obţine cu ajutorul comenzii [1,2,3;3,2,1]. Un vector linie [1 2

orizontală a matricilor A cu B vom scrie [A,B] matricile A şi B trebuind

2.2.3. Accesarea elementelor unei matrici.

Accesarea individuală a unui element se face indicând linia şi

A(A>0). Expresia din paranteză trebuie să fie o expresie logică pe care

2.2.4. Operaţii cu matrici şi vectori.

Matricile de acelaşi tip se pot aduna obţinându-se o matrice a

este posibil MATLAB va efectua înmulţirea.

2.2.5. Funcţii de matrici.

Sunt foarte multe funcţii de matrici. Vom prezenta pe scurt cele

1. Definiţi în MATLAB vectorii şi matricile de mai jos:

2. Creaţi vectorii va, vb, vc şi vd care să aibă următoarele elemente:

3. Prin concatenarea matricilor şi vectorilor de mai sus, definiţi în

4. Cu ajutorul funcţiei diag(v,n), (unde n este distanţa de la diagonala

5. Utilizând matricile şi vectorii definiţi în exerciţiile 1, 2 şi 3, calculaţi:

6. Utilizând matricile A şi B să se definească matricile:

7. Să se creeze sau calculeze, după caz :

8. Utilizând matricea B definită la 1.c) scrieţi comenzile necesare pentru

e) o matrice formată din elementele din colţurile lui B.

2.4. Indicaţii şi soluţii

⎡ -180 -167 -90 170 135 160 ⎤

⎡ -19.0000 -8.0000 -1.0000 ⎤

⎡ 0.4161 -0.5403 -0.1585 -1.0000 -1.0000 -1.0000 ⎤

3.1. Obiectivele lucrării.

Această lucrare îşi propune prezentarea principalelor probleme ce

3.2 . Elemente de algebră liniară în MATLAB

Fie ecuaţiile matriciale Ai X = B , respectiv, Y i A = B . Din

3.2.2. Sisteme liniare.

Din algebra liniară se ştie faptul că sistemele liniare sunt de trei

1. a) x=-2:0.1:2; y1=exp(x/2).sin(2x); y2=(x-2)./(x.^2+1);