Introducere

Obiectivele cursului
Cursul de Metode Numerice îşi propune ca obiectiv familiarizarea
viitorilor specialişti în domeniul energetic cu noile tehnologii bazate pe
informatică şi cu principiile care stau la baza aplicaţiilor informatice în acest
domeniu.
Competenţe conferite
După parcurgerea materialului studentul va fi capabil să rezume şi să
explice în ce constau particularităţile noilor tehnici şi tehnologii aflate la zona
comună între informatică şi ingineria electrică, ce aduc nou faţă de abordările
clasice în domeniu şi să poată testa noi aplicaţii bazate pe acestea.
Resurse şi mijloace de lucru
– parcurgerea cursului se poate face secvenţial sau pe fiecare
unitate de învăţare separat (cu excepţia unităţii 6 care presupune
cunoştinţele din unitatea 2);
– pentru programele dezvoltate în Java: pachetul de dezvoltare
soft Eclipse IDE (http://www.eclipse.org)
– pentru programele dezvoltate în C++ (mediul de dezvoltare
soft BorlandC++)
Structura cursului
Cursul este structurat pe 6 Unităţi de învăţare (UI):
– 1. Metode numerice pentru rezolvarea ecuaţiilor neliniare
– 2. Metode numerice pentru rezolvarea sistemelor de ecuaţii liniare
– 3. Interpolarea şi aproximarea funcţiilor
– 4. Metode pentru integrare numerică
– 5. Metode numerice pentru rezolvarea ecuaţiilor şi a sistemelor de
ecuaţii diferenţiale
– 6. Rezolvarea numerică a circuitelor şi reţelelor electrice in regim
staţionar sau cvasistaţionar ecuaţii
1
Cerinţe preliminare
- Bazele Electrotehnicii
- Programarea calculatoarelor (C++ sau Java)
- Matematici speciale (algebră liniară, geometrie analitică, ecuaţii
diferenţiale)
Durata medie de studiu
1. Metode numerice pentru rezolvarea ecuaţiilor neliniare – 2 ore
2. Metode numerice pentru rezolvarea sistemelor de ecuaţii liniare – 2 ore
3. Interpolarea şi aproximarea funcţiilor – 2 ore
4. Metode pentru integrare numerică - 2 ore
5. Metode numerice pentru rezolvarea ecuaţiilor şi a sistemelor de ecuaţii
diferenţiale – 3 ore
6. Rezolvarea numerică a circuitelor şi reţelelor electrice in regim staţionar sau
cvasistaţionar – 3 ore
2
Cuprins
Introducere .................................................................................................................................. 1
1. METODE NUMERICE PENTRU REZOLVAREA ECUAŢIILOR NELINIARE ............... 4
1.1. Introducere ....................................................................................................................... 4
1.2. Competenţele unităţii de învăţare .................................................................................... 4
2. METODE NUMERICE PENTRU REZOLVAREA SISTEMELOR DE ECUAŢII
LINIARE ..................................................................................................................................... 9
2.1. Introducere ....................................................................................................................... 9
2.2. Competenţele unităţii de învăţare .................................................................................... 9
2. 3. Metoda de eliminare a lui Gauss ................................................................................... 10
2.4. Metoda Gauss-Seidel ..................................................................................................... 13
3. INTERPOLAREA ŞI APROXIMAREA FUNCŢIILOR ..................................................... 15
3.1. Introducere ..................................................................................................................... 15
3.2. Competenţele unităţii de învăţare .................................................................................. 15
3.3. Interpolarea liniară ......................................................................................................... 16
3.4. Interpolarea cu funcţii Spline ......................................................................................... 17
3.5. Regresia funcţiilor. Metoda celor mai mici pătrate ........................................................ 19
3.5.1. Regresia liniară ....................................................................................................... 20
4. METODE PENTRU INTEGRARE NUMERICĂ ............................................................... 23
4.1. Introducere ..................................................................................................................... 23
4.2. Competenţele unităţii de învăţare .................................................................................. 23
5. METODE NUMERICE PENTRU REZOLVAREA ECUAŢIILOR ŞI A SISTEMELOR
DE ECUAŢII DIFERENŢIALE ............................................................................................... 28
5.1. Introducere ..................................................................................................................... 28
5.2. Competenţele unităţii de învăţare .................................................................................. 28
5.3. Metoda lui Euler ............................................................................................................. 29
5.4. Metoda Runge-Kutta de ordinul IV ............................................................................... 30
5.5. Metoda Runge-Kutta pentru sisteme de ecuaţii diferenţiale .......................................... 31
6. REZOLVAREA NUMERICĂ A CIRCUITELOR ŞI REŢELELOR ELECTRICE IN
REGIM STAŢIONAR SAU CVASISTAŢIONAR ................................................................ 34
6.1. Introducere ..................................................................................................................... 34
6.2. Competenţele unităţii de învăţare .................................................................................. 34
6.3. Metoda potenţialelor de noduri ...................................................................................... 37
6.4. Metoda curenţilor ciclici ............................................................................................... 40
Anexa 1 ..................................................................................................................................... 44
Instalarea mediului de programare Eclipse ............................................................................... 44
Anexa 2 ..................................................................................................................................... 49
1.1. Program bisectie -Metoda bisectiei - injumatatirea intervalului; ....................................... 49
Anexa 3. Programe în Java ....................................................................................................... 61
Bibliografie...............................................................................................................................57
Anexa 1.....................................................................................................................................58
Anexa 2.....................................................................................................................................63
Anexa 3.....................................................................................................................................75
3
1. METODE NUMERICE PENTRU REZOLVAREA
ECUAŢIILOR NELINIARE

1.1. Introducere
Deoarece în cele mai multe cazuri concrete întâlnite în problemele tehnice
specifice ingineriei electrice şi energetice apar modele matematice neliniare,
trebuie studiată şi posibilitatea rezolvării acestora cu ajutorul unor metode
specifice, prin utilizarea calculatorului. Abordarea problemelor din această
perspectivă presupune adaptarea şi implementarea unor algoritmi de analiză
numerică. Un astfel de capitol îl constituie metodele de rezolvare a ecuaţiilor
neliniare.
1.2. Competenţele unităţii de învăţare
După parcurgerea materialului studentul va fi capabil să identifice, să
explice un model de ecuaţie neliniară şi să testeze rezolvarea acesteia cu ajutorul
calculatorului .
Durata medie de parcurgere a primei unităţi de învăţare este de 2 ore.
4
Orice ecuaţie care nu se poate scrie sub forma unei funcţii liniare, se numeşte ecuaţie
neliniară. Rezolvarea unei ecuaţii neliniare presupune găsirea unui punct c din intervalul de
definiţie al lui f(x), numit rădăcina ecuaţiei, care are proprietatea că f(c)=0, unde f este o
funcţie continuă, definită pe intervalul [a, b], cu valori în R.
Cea mai simplă metodă de rezolvare a ecuaţiilor neliniare este metoda înjumătăţirii
intervalului. Această metodă se aplică dacă pe intervalul dat există în mod sigur o singură
rădăcină.
Fie [a,b] intervalul pe care se studiază problema. Pe acest interval există o singură
radacină dacă f(a) ∙ f(b) < 0. Se calculează punctul c de la mijlocul intervalului şi se determină
în care din cele două jumătăţi se află rădăcina. Astfel, dacă f(a) ∙ f(c) < 0, rădăcina se află în
intervalul [a,c], iar în caz contrar în intervalul [b,c]. Se restrânge intervalul în jurul rădăcinii şi
se aplică acelaşi procedeu pentru noul interval de mai multe ori până când se obţine un
interval în jurul rădăcinii mai mic decât o eroare admisă, ε.
Figura 1.1. Metoda înjumătăţirii intervalului
Pe baza acestui principiu se poate dezvolta un algoritm de rezolvare iterativ:
5
Figura 1.2. Algoritmul de calcul la metoda înjumătăţirii intervalului
Exemplu:
Să se rezolve ecuaţia:
ln(x) + x = 0
pe intervalul [0.01, 2].
Să se scrie un program de calcul (utilizând limbajul de programare C++
sau Java), care să implementeze algoritmul prezentat pentru exemplul de mai
sus.

O altă metodă care permite rezolvarea ecuaţiilor neliniare este metoda coardei sau
secantei variabile. La această metodă principiul de restrângere a intervalului este acelaşi, dar
diferă relaţia de calcul a punctului c. Astfel, în cadrul acestei metode, punctul c se determină
prin intersecţia coardei care uneşte punctele de pe funcţie de la marginile intervalului cu axa
Ox, ca în figura 1.3:
6
Figura 1.3. Metoda coardei variabile
Punctul c de la intersecţia coardei cu axa Ox se obţine prin rezolvarea sistemului de
ecuaţii de mai jos, determinându-l pe x:
- Să se rezolve sistemul de ecuaţii de mai sus şi să se determine relaţia de calcul
pentru punctul c din figura 1.3.
- Să se modifice programul de calcul de la metoda înjumătăţirii intervalului prin
introducerea noii relaţii de calcul a punctului c.
Observaţie: la metoda coardei variabile testul final, de încetare al calculelor, se va
înlocui prin:
|f(c)|<ε
7
Să ne reamintim...
- ce este o ecuaţie neliniară şi prin ce se deosebeşte de una clasică?
- cum putem testa dacă un interval este bun?
- cum ştim în ce moment am determinat rădăcina ecuaţiei cu suficientă acurateţe?
Rezumat
In acest capitol am văzut:
- ce este o ecuaţie neliniară
- cum putem identifica un interval în care să găsim soluţia ecuaţiei
- cum putem găsi soluţia ecuaţiei prin două metode numerice simple şi
eficiente (metoda înjumătăţirii intervalului şi metoda coardei variabile).
Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice, ca
de exemplu:
- determinarea caracteristicilor şi a punctelor de funcţionare pe aceste
caracteristici în cazul unor elemente, echipamente şi dispozitive electrice
şi electronice utilizate în inginerie
- determinarea momentelor de timp în care diferite mărimi (tensiuni,
curenţi, puteri etc.) trec prin 0
- determinarea parametrilor de funcţionare a unor elemente neliniare în
circuite sau reţele electrice.

8
2. METODE NUMERICE PENTRU REZOLVAREA
SISTEMELOR DE ECUAŢII LINIARE

2.1. Introducere
In multe cazuri concrete întâlnite în energetică apar modele matematice la
care soluţionarea se bazează pe rezolvarea unor sisteme de ecuaţii linare cu foarte
multe ecuaţii – de ordinul sutelor sau miilor. Pentru aceste sisteme rezolvarea,
uneori în timp real, fără utilizarea calculatorului este imposibilă. In acest capitol
vor fi abordate metodele de rezolvare a sistemelor de ecuaţii liniare.
2.2. Competenţele unităţii de învăţare
După parcurgerea materialului studentul va fi capabil să identifice şi să
explice un model bazat pe sisteme de ecuaţii liniare şi să testeze rezolvarea
acestora cu ajutorul calculatorului .
Durata medie de parcurgere a unităţii de învăţare este de 2 ore.
Se consideră următorul sistem liniar cu n ecuaţii şi n necunoscute:
9
n n nn n n
n n
n n
b x a x a x a
b x a x a x a
b x a x a x a
· + + +
· + + +
· + + +
...
...
...
2 2 1 1
...
2 2 2 22 1 21
1 1 2 12 1 11
(2.1
)
Acest sistem de ecuaţii liniare se poate scrie sub formă matricială astfel:

,
`

.
|
·

,
`

.
|

,
`

.
|
n n nn n n
n
n
b
b
b
x
x
x
a a a
a a a
a a a
. .
.
. . . .
.
.
2
1
2
1
2 1
2 22 21
1 12 11
(2.2
)
sau mai simplu:
B X A · ⋅ (2.3
)
unde A este o matrice pătrată, numită matricea coeficienţilor, X este vectorul
necunoscutelor, iar B este vectorul termenilor liberi.
Metodele clasice de rezolvare a sistemelor de ecuaţii bazate pe calculul
determinantului nu sunt eficiente pentru sistemele mari, datorită numărului foarte mare de
operaţii. Pentru aceste sisteme există două categorii de metode de rezolvare:
- metode directe la care soluţia sistemului se obţine după ce matricile sunt
transformate într-o formă convenabilă (matrice unitate sau matrice triunghiulară) într-un
număr finit de paşi (de regulă egal cu numărul de ecuaţii ale sistemului). Aceste metode sunt
utilizate cu succes pentru sisteme la care numărul ecuaţiilor este de ordinul sutelor.
- metode iterative la care soluţia sistemului se obţine prin alegerea unei soluţii iniţiale
aleatoare şi corectarea acesteia într-un număr de iteraţii care depinde de precizia impusă. Deşi
sunt metode aproximative, pentru sistemele dominant diagonale (la care termenii de pe
diagonala sistemului sunt mult mai mari în valoare absolută decât restul termenilor) ele sunt
convergente şi soluţia se obţine mult mai rapid decât în cazul metodelor directe. Ele se
utilizează pentru sistemele cu număr foarte mare de ecuaţii.
2. 3. Metoda de eliminare a lui Gauss
Această metodă de rezolvare a sistemelor de ecuaţii liniare are la bază transformarea
succesivă a matricii coeficienţilor astfel încât să se obţină 1 pe diagonala principală şi 0 sub
diagonală. Acest lucru se obţine prin înmulţirea la stânga cu o matrice M pătrată convenabil
aleasă, în mai multe etape. Astfel în urma primei înmulţiri se va obţine 0 pe prima coloană, cu
excepţia primului coeficient, care va fi 1.
10

,
`

.
|
·

,
`

.
|

,
`

.
|
'
'
2
'
1
2
1
' '
2
'
2
'
22
'
1
'
12
. .
. 0
. . . .
. 0
. 1
n n nn n
n
n
b
b
b
x
x
x
a a
a a
a a
(2.4
)
După cea de-a doua înmulţire se va transforma coloana a doua:

,
`

.
|
·

,
`

.
|

,
`

.
|
"
"
2
"
1
2
1
"
"
2
"
1
"
12
. .
. 0 0
. . . .
. 1 0
. 1
n n nn
n
n
b
b
b
x
x
x
a
a
a a
(2.5
)
Se repetă tot acest proces până la ultima coloană. Pentru a nu se modifica vectorul
termenilor liberi, matricea M se va înmulţi şi cu matricea coloană B.
In urma efectuării ultimei înmulţiri sistemul va arăta astfel:

,
`

.
|
·

,
`

.
|

,
`

.
|
n n
n
n
b
b
b
x
x
x
a
a a
. .
1 . 0 0
. . . .
. 1 0
. 1
2
1
2
1
2
1 12
(2.6
)
Matricea M îşi modifică forma de fiecare dată. Astfel, pentru transformarea coloanei j
a matricii A, termenii matricei M se calculează după cum urmează:
• matricea M va fi identică cu matricea unitate, mai puţin coloana j.
• pentru coloana j deasupra diagonalei termenii vor fi egali cu 0.
• termenul de pe diagonală va fi:
] ][ [
1
] ][ [
j j a
j j m ·
.
• termenii de sub diagonală vor fi:
j i
j j a
j i a
j i m > − ·
] ][ [
] ][ [
] ][ [
.
Forma finală a matricii M pentru coloana j este:
11

,
`

.
|


·
1 . . 0
. . . .
. .
1
. .
. . 0 . .
0 . 0 . 1
jj
nj
jj
ij
jj
a
a
a
a
a
M
(2.7
)
în care
] ][ [ j i a
reprezintă elementele matricii A.
După ce matricea coeficienţilor a fost transformată, se calculează vectorul X al
necunoscutelor, în ordine descrescătoare, cu relaţia:

+ ·
· − ·
n
i j
j ij i i
n i x a b x
1
1 , ;
(2.8
)
Algoritmul poate fi descris în paşii următori:
1. Se declară matricea pătrată A[n][n] şi vectorul termenilor liberi B[n]
2. col = 1
3. Se calculează matricea M pentru coloana col.
4. Se înmulţeşte matricea M cu matricea A. Rezultatul i se va atribui matricii A.
5. Se înmulţeşte matricea M cu vectorul B. Rezultatul i se va atribui vectorului B.
6. Daca col < n se incrementează col şi se reia de la pasul 3, altfel se trece la pasul 7
7. Se calculează vectorul necunoscutelor x[i].
8. Se afişează vectorul necunoscutelor x[i].
Exemplu:
Se consideră sistemul de ecuaţii de mai jos:
Să se scrie un program de calcul (utilizând limbajul de programare C++
sau Java), care să implementeze algoritmul prezentat pentru exemplul de mai
sus.
12

2.4. Metoda Gauss-Seidel
Aceste metode sunt convergente numai pentru sistemele de ecuaţii a căror matrice de
coeficienţi este dominant diagonală.
Se numeşte matrice dominant diagonală matricea la care termenii de pe diagonală au
valorile absolute mai mari sau cel mult egale cu suma valorilor absolute a termenilor aflaţi pe
aceeaşi linie cu ei. Acest lucru se exprimă matematic astfel:
n i a a
n
i j
j
ij ii
, 1 , | | | |
1
· ≥


· (2.9)
În cazul metodei Gauss-Seidel algoritmul porneşte de la o soluţie a sistemului aleasă în
mod arbitrar, de obicei soluţia nulă. Scopul este de a corecta succesiv soluţia iniţială până la
obţinerea soluţiei reale a sistemului. Relaţia utilizată este cea de mai jos:
n i x a x a b
a
x
n j
i j
k
j j i
i j
j
k
j j i i
i i
k
i
, 1 ,
1
1
) 1 (
,
1
1
) (
,
,
) (
·

,
`

.
|
⋅ − ⋅ − ⋅ ·
∑ ∑
·
+ ·

− ·
·
(2.10)
Algoritmul se încheie atunci când diferenţa dintre două soluţii determinate succesiv este
mai mică decât o valoare impusă iniţial, adică este îndeplinită condiţia:
n i x x
k
i
k
i
, 1 ,
) 1 ( ) (
· ≤ −

ε
(2.11)
Să se scrie un program de calcul (utilizând limbajul de programare C++
sau Java), care să implementeze algoritmul Gauss-Seidel pentru exemplul de mai
jos:
.
5
4
3
;
5 1 1
0 3 1
1 2 4

,
`

.
|
·

,
`

.
|


· B A
13
Să ne reamintim...
- ce este un sistem de ecuaţii liniare?
- care este cea mai bună metodă de rezolvare şi în ce condiţii se poate folosi?
Rezumat
In acest capitol am văzut:
- ce este un sistem de ecuaţii liniare şi cum se poate exprima cu ajutorul
matricilor
- cum putem alege cea mai bună şi mai rapidă metodă de rezolvare
- cum putem găsi soluţia sistemelor de ecuaţii liniare cu ajutorul a două
metode numerice simple şi eficiente (metoda de eliminare a lui Gauss şi
metoda Gauss-Seidel).
Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice, ca
de exemplu:
- calculul circuitelor şi reţelelor electrice în timp real
- calculul unor probleme de câmp electromagnetic
14
3. INTERPOLAREA ŞI APROXIMAREA FUNCŢIILOR

3.1. Introducere
La ora actuală foarte multe tehnologii utilizează noţiuni digitale, de aceea
conversia mărimilor şi funcţiilor analogice în mărimi şi funcţii digitale şi invers
necesită metode adecvate. Unele din aceste metode, mai exact partea de interpolare
şi de aproximare a funcţiilor vor fi tratate în acest capitol.
3.2. Competenţele unităţii de învăţare
După parcurgerea materialului studentul va fi capabil să identifice şi să
explice în ce anume constă interpolarea şi regresia funcţiilor şi să testeze
rezolvarea acestora cu ajutorul calculatorului .
Durata medie de parcurgere a unităţii de învăţare este de 2 ore.
15
3.3. Interpolarea liniară
Atunci când se cunoaşte expresia analitică a unei funcţii y = f(x) unde x ia valori pe un
domeniu, se poate calcula valoarea ei pentru orice x din domeniul de definiţie. In realitate de
multe ori apar cazuri când nu se cunoaşte expresia analitică, ci doar câteva puncte prin care
trece funcţia respectivă. Se pune problema de a determina valoarea funcţiei şi pentru alte
valori intercalate între punctele date. Aceasta constituie interpolarea.
Cea mai simplă metodă este interpolarea liniară. Ea prezintă dezavantajul că
aproximează cel mai grosolan o funcţie prin segmente de dreaptă, dar este cea mai rapidă
pentru că efectuează cele mai puţine calcule.
Dacă se dau două puncte (x
1
, y
1
) şi (x
2
, y
2
), ecuaţia dreptei care trece prin aceste puncte
este:
y y
x x
y y
x x


·


1
1
2 1
2 1
Cu această relaţie se poate calcula valoarea y pentru orice punct x aflat între cele două
puncte x
1
şi x
2
:
( ) y y
x x
x x
y y · +


⋅ −
1
1
2 1
2 1
In cazul în care se dau mai multe puncte, se procedează la liniarizarea pe porţiuni.
Astfel se iau două câte două puncte şi se aplică formula de mai sus.
Algoritmul de programare se poate reprezenta astfel:
1. Se declară numărul de puncte cunoscute n.
2. Se declară valorile lui x şi y pentru punctele cunoscute: x[i] şi y[i] pentru i = 0..n-1.
3. Se citeşte valoarea lui x în care vrem să determinăm funcţia y.
4. Intr-un ciclu for cu j luând valori de la 0 la n-2 se compară dacă x > x[j] şi x < x[j+1],
pentru a şti în care subinterval ne aflăm. Valoarea lui j pentru care se satisface condiţia se
memorează într-o variabilă k.
5. Se calculează y cu relaţia de mai sus unde x
1
= x[k], y
1
= y[k], x
2
= x[k+1], y
2
= y[k+1].
6. Se scrie y
7. STOP
16
3.4. Interpolarea cu funcţii Spline
O metodă mai precisă de interpolare este interpolarea Lagrange. Gradul polinomului
care se obţine este cu atât mai mare cu cât numărul de puncte este mai mare. Aceasta implică
un număr mare de calcule, şi din acest motiv nu se utilizează prea des.
Spre deosebire de polinoamele Lagrange, în cazul funcţiilor Spline se lucrează cu un
polinom de gradul trei pentru a accelera viteza de calcul.
Forma generală a unui polinom de gradul III este: P(t) = at
3
+ bt
2
+ ct + d. Acest lucru
se poate scrie sub formă matricială astfel:
[ ]
P a b c d
t
t
t
· ⋅

]
]
]
]
]
]
3
2
1
In plan un punct este reprezentat prin coordonatele x(t) şi y(t), iar în spaţiu intervine şi
coordonata z(t). In continuare se va lucra doar în funcţie de parametrul t, urmând ca în final să
se treacă la coordonatele x şi y. Se pot aranja lucrurile astfel încât pentru cele două puncte de
la capetele unui interval să se obţină o reprezentare astfel: pentru primul punct să-i
corespundă lui t valoarea 0, iar pentru al doilea punct să-i corespundă lui t valoarea 1.
Coeficienţii a, b, c, d se obţin din 4 condiţii şi anume la capetele intervalului se dau şi
valorile coordonatelor punctelor şi derivatele, pentru a se obţine racordarea graficului.
Aceasta înseamnă că se cunosc P(0), P(1), P'(0) şi P'(1), unde P'(t) este polinomul derivat:
P'(t) = 3at
2
+ 2bt + c. Din cele patru condiţii se obţin coeficienţii:
a P P P P
b P P P P
c P
d P
· − + ′ + ′ +
· − ′ − ′ −
· ′
·
¹
'
¹
¹
¹
¹
¹
2 1 1 0 2 0
3 1 1 2 0 3 0
0
0
( ) ( ) ( ) ( )
( ) ( ) ( ) ( )
( )
( )
care se pot scrie sub formă matricială:
[ ] [ ]
a b c d P P P P · ′ ′



]
]
]
]
]
]
( ) ( ) ( ) ( ) 0 1 0 1
2 3 0 1
2 3 0 0
1 2 1 0
1 1 0 0
In aceste condiţii polinomul P devine:
17
[ ]
P t P P P P
t
t
t
( ) ( ) ( ) ( ) ( ) · ′ ′ ⋅



]
]
]
]
]
]

]
]
]
]
]
]
0 1 0 1
2 3 0 1
2 3 0 0
1 2 1 0
1 1 0 0 1
3
2
In practică această relaţie se foloseşte astfel:
• se dau punctele de la marginea intervalului, adică P(0) şi P(1)
• se dau sau se calculează derivatele la capetele intervalului P'(0) şi P'(1)
• se alege un număr de puncte în care vrem să interpolăm funcţia dându-i valori echidistante
lui t în intervalul [0,1]
• Se calculează polinomul P(t) în aceste puncte
Dacă avem mai multe intervale, se aplică acelaşi algoritm pentru fiecare interval luat
în parte.
La reprezentarea în plan polinomul P este de fapt un vector cu două componente x(t)
şi y(t), iar la reprezentarea în spaţiu este un vector cu trei componente x(t), y(t) şi z(t).
Pentru calculul derivatei într-un punct se consideră dreptele care se obţin unind
punctul respectiv cu cele două puncte vecine, din stânga şi din dreapta. Se face media
unghiurilor acestor drepte cu axa Ox orizontală, obţinându-se unghiul α . Componentele
polinomului derivat vor fi x' = k·cos(α ) şi y' = k·sin (α ), unde k se alege în urma unor
încercări. Valorile uzuale sunt între 1 şi 3. (Observaţie: pentru valoarea k=0 se obţine chiar
interpolarea liniară). Pentru punctele extreme vom avea doar un singur vecin, şi se ia unghiul
respectiv.
Algoritmul de interpolare cu funcţii Spline va fi următorul:
1. Se dau n puncte în care se cunoaşte funcţia
2. Se dă numărul de puncte m în care vrem să determinăm funcţia interpolată
3. Se calculează derivatele în punctele cunoscute
4. Se deschide un ciclu for cu i de la 0 până la n-1
5. Punctul corespunzător lui t = 0 va fi cel cu indicele i, iar pentru t = 1 va fi cel cu indicele
i+1, şi se vor lua ca atare polinoamele P şi P'.
6. Se deschide un ciclu for cu j de la 0 până la m
7. Se calculează t = j / m
8. Se calculează x(t) şi y(t) cu ultima relaţie, unde x(t) şi y(t) sunt componentele polinomului
P(t)
9. Se închide ciclul cu j
10. Se închide ciclul cu i.
11. STOP
18
Exemplu:
Se dau punctele:
(1,9), (2,8), (3,5), (4,8), (5,4), (6,6), (7,2), (8,3), (9,5), (10,1).
Să se calculeze funcţia interpolată pentru m = 50 şi să se reprezinte grafic
punctele obţinute.
Să se scrie un program care să implementeze algoritmul de interpolare
Spline pentru exemplul de mai sus.
3.5. Regresia funcţiilor. Metoda celor mai mici pătrate
Acest procedeu este utilizat atunci când se doreşte determinarea valorii funcţiei în
interiorul sau în afara domeniului de valori pentru care au fost efectuate măsurători
experimentale şi ca urmare au fost obţinute un număr de
n
de perechi de coordonate:
( ) ( )
n n
y x y x , ,
1 1
⋅ ⋅ ⋅
.
Metoda permite stabilirea unei expresii analitice pentru funcţia necunoscută, care poate
fi utilizată atât în interiorul intervalului conţinând determinări experimentale
[ ]
n
x x ,
1
cât şi în
afara lui.
Principiul metodei este următorul: se presupune că s-a ales o aproximare
( ) x f
a
funcţiei necunoscute. În acest caz se consideră două categorii ale valorilor funcţiei şi anume:
• Valorile exacte, obţinute în urma măsurătorilor:
n
y y ⋅ ⋅ ⋅
1
.
• Valorile aproximative, calculate cu funcţia de aproximare:
( ) n i x f y
i i
, 1 , · ·
.
Ca urmare se produc abaterile:
n i y y d
i i i
, 1 , · − ·
Forma funcţiei alese (polinomială, logaritmică, trigonometrică, etc.) depinde de forma
graficului funcţiei reale fiind în concordanţă cu acesta. Alegerea unei expresii pentru
( ) x f

presupune utilizarea unor coeficienţi reali în expresia acesteia.
Metoda celor mai mici pătrate constă în determinarea valorilor acestor coeficienţi astfel
încât să se obţină valoarea minimă a sumei pătratelor abaterilor, adică a sumei:
19
2
1 1
2
) (
∑ ∑
· ·
− · ·
n
i
i i
n
i
i
y y d S
În continuare se prezintă modul de determinare a coeficienţilor pentru cazul unei drepte.
3.5.1. Regresia liniară
Forma funcţiei este următoarea:
( )
0 1
a x a x f + ⋅ ·
Valorile coeficienţilor
1
a
şi
0
a
se vor obţine punând condiţia ca suma pătratelor
abaterilor să fie minimă:
Condiţia de minim se obţine prin rezolvarea următorului sistem de ecuaţii:
care este echivalent cu sistemul:
ale cărui soluţii sunt:
20
( )
2
1
0 1
1
2
∑ ∑
· ·
− ⋅ − · ·
n
i
i
n
i
i
a x a y d S
( )
( )
¹
¹
¹
¹
¹
'
¹
· − ⋅ −
· ⋅ − ⋅ −

¹
¹
¹
¹
¹
'
¹
·


·




·
·
0
0

0
0
1
0 1
1
0 1
0
1
n
i
i i
n
i
i i i
a x a y
x a x a y
a
S
a
S
¹
¹
¹
¹
¹
'
¹
· ⋅ + ⋅
⋅ · ⋅ + ⋅
∑ ∑
∑ ∑ ∑
· ·
· · ·
n
i
i
n
i
i
n
i
i i
n
i
i
n
i
i
y x a a n
y x x a x a
1 1
1 0
1 1
2
1
1
0

¹
¹
¹
¹
¹
¹
¹
¹
¹
¹
¹
¹
¹
'
¹

,
`

.
|
− ⋅

,
`

.
|

,
`

.
|
− ⋅ ⋅
·

,
`

.
|
− ⋅

,
`

.
|
⋅ ⋅
,
`

.
|

,
`

.
|

,
`

.
|
·
∑ ∑
∑ ∑ ∑
∑ ∑
∑ ∑ ∑ ∑
· ·
· · ·
· ·
· · · ·

2
1 1
2
1 1 1
1
2
1 1
2
1 1 1
2
1
0
n
i
i
n
i
i
n
i
i
n
i
i
n
i
i i
n
i
i
n
i
i
n
i
i i
n
i
i
n
i
i
n
i
i
x x n
x y y x n
a
x x n
y x y x y
a
În mod analog se procedează în cazul unei aproximări a funcţiei prin intermediul unui
polinom de grad mai mare ca 1.
Pentru alte funcţii (logaritm, exponenţială etc.) prin schimbări de variabile se poate
aplica acelaşi procedeu pentru determinarea coeficienţilor funcţiilor.
Să se determine coeficienţii dreptei de regresie prin aplicarea formulelor de
mai sus pentru punctele de la exemplul anterior.
21
Să ne reamintim...
- ce anume presupune interpolarea funcţiilor?
- care este deosebirea dintre interpolare şi regresie?
Rezumat
In acest capitol am văzut:
- ce reprezintă interpolarea şi care sunt cele mai des utilizate metode.
- cum se pot obţine informaţii mai detaliate despre o funcţie atunci când
nu se cunosc suficiente date iniţiale
- cum se poate obţine o funcţie de regresie în cazul în care se doreşte
obţinerea unei expresii analitice
Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice, ca
de exemplu:
- citirea şi prelucrarea informaţiilor de pe caracteristicile unor dispozitive
şi echipamente
- prelucrarea datelor experimentale obţinute în urma unor măsurători
22
4. METODE PENTRU INTEGRARE NUMERICĂ

4.1. Introducere
Foarte multe relaţii întâlnite în energetică utilizează integrala definită a
unor mărimi electrice şi neelectrice pentru calculul valorilor medii, a valorilor
efective, pentru prelucrarea graficelor de sarcină. In cazul în care se lucrează cu
valori neregulate, rezolvarea pe cale analitică devine foarte greoaie, uneori
imposibilă şi astfel apare necesitatea de a utiliza metodele de rezolvare numerică a
integralelor definite.
4.2. Competenţele unităţii de învăţare
După parcurgerea materialului studentul va fi capabil să identifice, să
explice un model în care este nevoie de integrarea numerică a funcţiilor şi să
testeze rezolvarea acesteia cu ajutorul calculatorului.
Durata medie de parcurgere a unităţii de învăţare este de 2 ore.
23
In multe cazuri în care trebuie calculată integrala definită a unei funcţii, aceasta nu se
poate calcula analitic, doar numeric. Dezavantajele metodelor numerice de integrare constau
în faptul că ele nu sunt exacte şi introduc erori, dar aceste erori pot fi evaluate şi minimizate
pe cât posibil. Aceste erori depind de metoda folosită. Cea mai simplă dintre metodele de
integrare este metoda dreptunghiurilor.
Integrala definită a unei funcţii f(x) pe un interval [a,b] reprezintă aria de sub grafic. In
cadrul metodelor numerice de integrare se aleg nişte puncte x
i
, echidistante pe intervalul dat,
şi aria graficului se împarte astfel în fâşii paralele. La metoda dreptunghiurilor se aproximează
aria unei fâşii cu aria dreptunghiului corespunzător, iar întreaga integrală va fi suma ariilor
acestor fâşii. Dacă intervalul corespunzător este [x
i
, x
i+1
], atunci aria dreptunghiului respectiv
este:
( ) S x x f x
i i i i
· − ⋅
+1
( )
în cazul în care înălţimea dreptunghiului este valoarea funcţiei din stânga intervalului.
Dacă se alege valoarea din dreapta intervalului, în formula de mai sus se va înlocui f(x
i
) cu
f(x
i+1
). O altă variantă este cea cu valoarea de la mijlocul intervalului f((x
i
+x
i+1
)/2). Aceste
variante se pot vedea în figura de mai jos.
Figura 4.1. Integrarea numerică prin metoda dreptunghiurilor
24
Algoritmul de integrare numerică este următorul:
1. S declară funcţia care trebuie integrată şi intervalul [a,b] de definiţie
2. Se alege numărul de puncte n al reţelei şi se calculează pasul reţelei: h = (b-a) / n.
3. Se iniţializează I = 0.
4. Se deschide un ciclu for cu i de la 0 la n-1 inclusiv.
5. Se calculează x
i
= a + i * h şi x
i+1
= x
i
+ h.
6. Se calculează I = I + S unde S se calculează cu una din formulele descrise mai sus.
7. Se închide ciclul.
8. Se scrie I.
9. STOP
Exemplu:
Să se calculeze integralele următoare prin metoda dreptunghiurilor:
1
0
. sin xdx
π

2.
1
1
0
2
+

x
dx
Să se scrie un program de calcul (utilizând limbajul de programare C++
sau Java), care să implementeze algoritmul prezentat pentru exemplul de mai
sus.

O altă metodă este cea a trapezelor, caz în care aria fâşiei se înlocuieşte cu aria unui
trapez. In acest caz se obţine:
( ) S x x
f x f x
i i i
i i
· − ⋅
+
+
+
1
1
2
( ) ( )
La metoda trapezelor precizia de calcul a integralei este mai bună decât la metoda
dreptunghiurilor.
Pentru a minimiza eroarea de calcul la metoda trapezelor se ţine cont de faptul că
eroarea este proporţională cu h
2
. Cu cât numărul de puncte alese este mai mare, cu atât şi
precizia va fi mai bună, dar va creşte şi timpul de calcul. Există însă o variantă de corecţie a
erorii, fără a efectua foarte multe calcule suplimentare. Se calculează integrala pentru două
25
numere diferite de puncte, n şi m, pe acelaşi interval şi pe baza celor două rezultate obţinute se
calculează coeficientul de proporţionalitate al erorii. Cu valoarea obţinută se corectează
rezultatul pentru una din cele două variante. În acest mod precizia creşte simţitor.
Algoritmul de calcul este identic cu cel de la metoda dreptunghiurilor, cu deosebirea că
formula lui S trebuie adaptată la relaţia pentru trapeze.
Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java),
care să implementeze algoritmul prezentat pentru exemplul de mai sus.
26
Să ne reamintim...
- ce se înţelege prin integrala definită a unei funcţii şi care este
semnificaţia ei geometrică?
- de ce nu se pot utiliza metodele clasice pentru majoritatea semnalelor şi
funcţiilor întâlnite în energetică?
- în câte puncte trebuie divizat intervalul de integrare pentru a obţine o
precizie suficientă?
- cum se pot corecta erorile de integrare?
Rezumat
In acest capitol am văzut:
- în ce constă rezolvarea numerică a integralei definite a unei funcţii în
cazul în care expresia acesteia este neregulată sau foarte complicată.
- care metodă este mai bună din punct de vedere al simplităţii şi al
preciziei de calcul
- cum se pot corecta micile erori obţinute
Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice, ca
de exemplu:
- calculul valorii medii şi efective a mărimilor electrice importante
(tensiunea, intensitatea curentului, puterea).
- calculul energiei electrice în funcţie de graficul de sarcină al puterii
electrice în funcţie de timp

27
5. METODE NUMERICE PENTRU REZOLVAREA
ECUAŢIILOR ŞI A SISTEMELOR DE ECUAŢII
DIFERENŢIALE

5.1. Introducere
In multe cazuri concrete întâlnite în energetică apar modele matematice
bazate pe rezolvarea unor ecuaţii sau sisteme de ecuaţii diferenţiale. Pentru aceste
probleme rezolvarea, uneori în timp real, fără utilizarea calculatorului este
imposibilă. In acest capitol vor fi abordate metodele numerice cele mai des
întâlnite de rezolvare a ecuaţiilor şi a sistemelor de ecuaţii diferenţiale.
5.2. Competenţele unităţii de învăţare
După parcurgerea materialului studentul va fi capabil să identifice şi să
explice un model bazat pe ecuaţii sau sisteme de ecuaţii diferenţiale şi să testeze
rezolvarea acestora cu ajutorul calculatorului .
Durata medie de parcurgere a unităţii de învăţare este de 3 ore.
O ecuaţie diferenţială se poate pune sub forma:
28

şi reprezintă tangenta la graficul funcţiei y(t) care trebuie determinată. Spre deosebire
de metodele analitice la care rezolvarea înseamnă determinarea expresiei analitice, la
metodele numerice se determină valorile lui y pentru valorile discretizate ale lui t. Astfel
intervalul de definiţie al lui t se împarte într-un număr de subintervale cu pasul h, iar valorile
discretizate ale lui t se vor nota cu t
i
. Pentru rezolvare trebuie cunoscute de asemenea
condiţiile iniţiale, adică valoarea lui y la momentul t = 0. Cunoscând tangenta la grafic se
determină punctul următor şi procesul se repetă.
Metodele pot fi de două categorii, în funcţie de cantitatea de informaţie utilizată la
deducerea valorii funcţiei într-un punct, precum şi de modul de efectuare al calculelor:
- Metode directe sau metode de tip Runge-Kutta, acest tip de metode utilizează
numai informaţiile obţinute la punctul precedent iar calculul se efectuează prin
aplicarea relaţiei de recurenţă.
- Metode indirecte sau de tip predictor-corector, acest tip de metode utilizează
informaţiile obţinute la două puncte determinate anterior iar calculul se efectuează
printr-un proces iterativ în care relaţia de recurenţă este aplicată până la obţinerea
valorii funcţiei cu o precizie impusă iniţial
5.3. Metoda lui Euler
Metoda constă în aproximarea graficului funcţiei într-un punct prin tangenta la grafic
dusă în acel punct.
f (x)
x
m
x
y
m
h
x
m+1
m+1
y
L
Fig. 5.1. Metoda lui Euler.
29
Formula de recurenţă se obţine din ecuaţia dreptei care trece printr-un punct şi care are
tangenta cunoscută. La metoda Euler eroarea de trunchiere poate fi apreciată ca fiind:
2
h k e
T
⋅ ·
.
Aceasta determină o valoare semnificativă a erorii de trunchiere şi ca urmare gradul de
precizie al metodei Euler este redus.
5.4. Metoda Runge-Kutta de ordinul IV
Relaţia care determină valoarea y
i+1
în funcţie de y
i
la metoda Runge-Kutta de ordinul
IV este:
unde:
Eroarea la această metodă depinde h
5
, de aceea este foarte utilizată fiind o metodă
foarte rapidă şi foarte precisă în acelaşi timp.
Algoritmul de rezolvare prin această metodă se poate concretiza astfel:
1. Se declară funcţia f(t,y) şi intervalul de definiţie [a,b] pentru t.
2. Se scrie condiţia iniţială y(0).
3. Se alege numărul de puncte n
4. Se calculează pasul h=(b-a)/n.
5. Se deschide un ciclu for cu i de la 0 la n-1
6. Se calculează t
i
.
7. Se calculează k
1
, k
2
, k
3
, k
4
.
8. Se calculează y
i+1
cu relaţia de mai sus.
9. Se scrie valoarea lui y
i+1
.
10. Se închide ciclul.
11. STOP
30
Exemplu:
Să se rezolve următoarele ecuaţii diferenţiale:
1.
dy
dt
t ·cos( )
pe intervalul [0,2π ] cu condiţia iniţială y(0) = 0.
2.
dy
dt
t y
·
− 10 100
0 01
sin( )
.
pe intervalul [0,0.1] cu condiţia iniţială y(0) = 0.
Să se scrie un program de calcul (utilizând limbajul de programare C++
sau Java), care să implementeze algoritmul prezentat pentru exemplele de mai
sus.
5.5. Metoda Runge-Kutta pentru sisteme de ecuaţii diferenţiale
Un sistem de ecuaţii diferenţiale se poate pune sub forma:

dy
dt
f t y y y i n
i
i n
· · ( , , ,.., ), ..
1 2
1
Spre deosebire de cazul unei singure ecuaţii diferenţiale, la sistemele de ecuaţii
diferenţiale, coeficienţii de la metoda Runge-Kutta vor fi nişte vectori cu mai multe valori (în
general egal cu numărul de ecuaţii diferenţiale). Astfel în relaţia care determină setul de valori
la momentul următor de timp în funcţie de în funcţie de valorile la momentul actual de timp:
( ) y y
h
k k k k
i i +
· + + + +
1 1 2 3 4
6
2 2
mărimile y şi k
1
, k
2
, k
3
, k
4
vor fi nişte vectori:
( )
k f t y
k f t
h
y k
h
k f t
h
y k
h
k f t h y k h
j j i i j
j j i i j j
j j i i j j
j j i i j j
1
2 1
3 2
4 3
2 2
2 2
, ,
, , ,
, , ,
, , ,
( , )
,
,
,
·
· + +
|
.

`
,

· + +
|
.

`
,

· + +
31
Algoritmul de rezolvare prin această metodă se poate concretiza astfel:
1. Se declară funcţiile f
i
(t,y
j
) şi intervalul de definiţie [a,b] pentru t.
2. Se scrie condiţia iniţială y
i
(0).
3. Se alege numărul de puncte n
4. Se calculează pasul h=(b-a)/n.
5. Se deschide un ciclu for cu i de la 0 la n-1
6. Se deschide un ciclu for cu j de la 1 la numărul de ecuaţii diferenţiale.
7. Se calculează k
1
8. Se deschide un ciclu for cu j de la 1 la numărul de ecuaţii diferenţiale.
9. Se calculează k
2
10. Se deschide un ciclu for cu j de la 1 la numărul de ecuaţii diferenţiale.
11. Se calculează k
3
12. Se deschide un ciclu for cu j de la 1 la numărul de ecuaţii diferenţiale.
13. Se calculează k
4
14. Se calculează y
i+1
cu relaţia de mai sus.
15. Se scrie valoarea lui y
i+1
.
16. Se închide ciclul pentru i.
17. STOP
Exemplu:
Să se rezolve sistemul de ecuaţii diferenţiale (corespunzătoare ecuaţiei unui
circuit RLC serie alimentat cu tensiune sinusoidală la borne):
¹
¹
¹
¹
¹
'
¹
·
− −
·
1
2
2 1 1
1000
01 . 0
5 ) 314 sin( 10
y
dt
dy
y y t
dt
dy
şi să se reprezinte grafic mărimile y
1
(curentul prin circuit) şi y
2
(tensiunea pe
condensator) în funcţie de timp, pentru t de la 0 la 0,1s.
Să se scrie un program de calcul (utilizând limbajul de programare C++
sau Java), care să implementeze algoritmul prezentat pentru exemplul de mai
sus.
32
Să ne reamintim...
- ce este o ecuaţie diferenţială fără derivate parţiale?
- ce rol au condiţiile iniţiale pentru rezolvarea pe cale numerică?
- prin ce se deosebeşte metoda de rezolvare a sistemelor de cea pentru o
singură ecuaţie?
Rezumat
In acest capitol am văzut:
- în ce constă rezolvarea pe cale numerică a ecuaţiilor şi a sistemelor de
ecuaţii diferenţiale
- care este rolul condiţiilor iniţiale pentru rezolvarea acestora
Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice, ca
de exemplu:
- calculul circuitelor şi reţelelor electrice în regimuri tranzitorii
- rezolvarea ecuaţiilor de stare pentru sisteme dinamice

33
6. REZOLVAREA NUMERICĂ A CIRCUITELOR ŞI
REŢELELOR ELECTRICE IN REGIM STAŢIONAR SAU
CVASISTAŢIONAR

6.1. Introducere
Rezolvarea circuitelor şi reţelelor electrice constituie unul din cele mai
importante capitole ale ingineriei electrice şi energetice. Metodele tradiţionale de
rezolvare pot fi utilizate, dar în cazul real datorită numărului foarte mare de
elemente de circuit care sunt de ordinul sutelor sau miilor, rezolvarea este foarte
greoaie, uneori imposibilă. Din această cauză se recurge la varianta numerică.
6.2. Competenţele unităţii de învăţare
După parcurgerea materialului studentul va fi capabil să identifice, să
explice un model de rezolvare a circuitelor sau reţelelor electrice şi să testeze
rezolvarea cu ajutorul calculatorului.
Durata medie de parcurgere a unităţii de învăţare este de 3 ore.
34
Pentru a putea rezolva problemele de circuite sau reţele electrice la care numărul
elementelor este ridicat trebuie să apelăm la elemente de teoria grafurilor. Un graf liniar este
definit ca o mulţime de puncte, numite noduri, şi de segmente numite laturi, nodurile fiind
unite prin laturi. Laturile care intră sau ies dintr-un nod se numesc incidente la nodul
respectiv. Fiecare latură a grafului are un sens şi se numeşte latură orientată. Graful care are
laturile orientate se numeşte graf orientat.
Un subgraf este o submulţime de laturi şi noduri ale grafului. O cale este un subgraf
particular care constă dintr-o secvenţă ordonată de laturi cu următoarele proprietăţi:
• cu excepţia a două noduri, toate celelalte noduri au câte două laturi incidente;
• cele două noduri numite terminale au incidentă o singură latură a subgrafului;
• niciun subgraf propriu al acestui subgraf cu aceleaşi noduri terminale nu are
proprietăţile 1 şi 2.
Un subgraf este conex dacă există cel puţin o cale între orice pereche de noduri. O
buclă este un subgraf conex particular al grafului în care la fiecare nod sunt incidente câte
două laturi ale subgrafului (sau o cale închisă). Un arbore este un subgraf conex al unui graf
conex care conţine toate nodurile grafului, dar nu conţine bucle. Laturile care intervin în
structura unui arbore se numesc ramuri, iar laturile care nu intervin în structura arborelui se
numesc joncţiuni. Acestea din urmă alcătuiesc complementul unui arbore sau coarborele.
Arborele la care toate ramurile sunt incidente într-un nod comun se numeşte arbore stelat, iar
arborele la care toate nodurile pot fi ordonate astfel încât arborele să prezinte o singură cale
pornind de la primul şi terminând cu ultimul se numeşte arbore liniar.
Atunci când se dă un graf se poate spune precis care sunt laturile incidente la fiecare
nod, precum şi care sunt orientările lor faţă de noduri. Invers, se poate spune despre un graf că
este complet determinat dacă se cunosc aceste informaţii. Un graf poate fi reprezentat sub
formă grafică sau matricială. Din punct de vedere al prelucrării informaţiilor, forma cea mai
convenabila de prezentare este cea matricială. Pentru un graf cu n + 1 noduri şi l laturi,
matricea completă de incidenţă A este o matrice de dimensiuni (n + 1) x l având valorile
elementelor:

1 ·
ij
a
dacă latura j este incidentă la nodul i şi iese din nod;

1 − ·
ij
a
dacă latura j este incidentă la nodul i şi intră în nod;

0 ·
ij
a
dacă latura j nu este incidentă la nodul i;
Liniile acestei matrici nu sunt independente, pentru că pe fiecare coloană există un
singur termen egal cu 1 şi un singur termen egal cu -1, astfel că prin însumarea tuturor liniilor
35
se obţine o linie cu toţi termenii egali cu 0. Pentru a obţine o matrice independentă, cel puţin o
linie poate fi eliminată, obţinându-se matricea redusă de incidenţă de dimensiuni n x l.
Cu ajutorul matricei reduse, prima teoremă a lui Kirchhoff se poate exprima în formă
matricială mult mai simplu:
0 · ⋅ I A
unde matricea I este o matrice coloană ai cărei termeni sunt curenţii prin laturile
circuitului.
O altă matrice care poate fi utilizată pentru a reprezenta un graf este matricea B, cu
dimensiunile o x l, unde o = l - n, şi are elementele:

1 ·
ij
b
dacă latura j aparţine ochiului i şi are acelaşi sens

1 − ·
ij
b
dacă latura j aparţine ochiului i şi are sens contrar.

0 ·
ij
b
dacă latura j nu aparţine ochiului i.
Cu ajutorul acestei matrici, cea de-a doua teoremă a lui Kirchhoff se poate scrie sub
formă matricială:
0 · ⋅U B
unde matricea
U
este o matrice coloană ai cărei termeni sunt tensiunile electrice la
capetele laturilor circuitului.
Cu ajutorul relaţiilor (6.1) şi (6.2) se obţin în total l relaţii, dar numărul de necunoscute
este 2l, din care l necunoscute sunt curenţii prin laturi şi l necunoscute sunt tensiunile la
bornele laturilor. Pentru a putea rezolva acest sistem de ecuaţii este nevoie de relaţii între
curenţii prin laturi şi tensiunile la bornele laturilor. Aceasta constituie închiderea sistemului
de ecuaţii.
Pentru elemente ideale de circuit cum ar fi rezistorul ideal, bobina ideală sau
condensatorul ideal, aceste relaţii între curenţi si tensiuni rezultă din legile câmpului
electromagnetic. Astfel pentru rezistorul ideal se obţine o relaţie de proporţionalitate între
curentul prin rezistor şi tensiunea la bornele lui:
i R u ⋅ ·
Pentru bobina ideală se obţine o ecuaţie diferenţială, în care tensiunea este
proporţională cu derivata curentului electric:
dt
di
L u ·
Pentru condensatorul ideal se obţine tot o ecuaţie diferenţială în care curentul este
proporţional cu derivata tensiunii electrice:
dt
du
C i ·
36
Pentru a putea efectua rezolvarea circuitelor sau reţelelor electrice se pot obţine
simplificări dacă se ţine cont de regimul lor de funcţionare. Astfel dacă circuitul se află într-
un regim staţionar sau cvasistaţionar, atunci relaţiile diferenţiale se pot înlocui cu relaţii
algebrice de proporţionalitate, caz în care sistemul de ecuaţii format din relaţiile obţinute pe
baza teoremelor lui Kirchhoff poate fi rezolvat. Dacă circuitul se află în regim dinamic, atunci
trebuie rezolvate în primul rând ecuaţiile diferenţiale aferente circuitului, după care se pot
determina şi celelalte variabile, care nu apar explicit ca derivate în funcţie de timp.
Pentru circuitele electrice aflate în regim staţionar sau cvasistaţionar închiderea
sistemului de ecuaţii se poate realiza deoarece între curenţii prin laturi şi tensiunile electrice la
bornele laturilor există relaţii de proporţionalitate. Rezolvarea sistemului se face însă cu
ajutorul unor metode specifice, deoarece utilizarea ambelor matrici A şi B este greoaie şi,
după cum se va arăta în continuare, inutilă, cele două matrici fiind legate una de alta prin
anumite relaţii. De aceea, prin alegerea convenabilă a unor mărimi drept variabile
independente, se pot transforma relaţiile obţinute cu teoremele lui Kirchhoff şi se pot aşeza
într-o formă echivalentă dar cu un număr mai mic de ecuaţii. Aceste mărimi sunt potenţialele
de noduri V’, sau curenţii ciclici I’.
6.3. Metoda potenţialelor de noduri
Cu ajutorul matricii vector a potenţialelor de noduri
' V
, matricea
U
se poate exprima
prin relaţia de mai jos:
' V A U
t
⋅ ·
Inlocuind această relaţie în cea de-a doua teoremă a lui Kirchhoff, (6.2) şi ţinând cont
că vectorul
' V
este un vector cu mărimi independente, rezultă:
0 · ⋅
t
A B
Aceasta înseamnă cele două matrici
A
şi
B
nu sunt independente una faţă de cealaltă,
şi de aceea nu este necesar să fie utilizate simultan la rezolvarea circuitelor.
Dacă se consideră o singură latură a circuitului, care conţine o sursă de tensiune şi o
rezistenţă, se poate scrie relaţia:
( )
k ek k k
U U G I + ⋅ ·
unde
k
G
reprezintă conductanţa laturii. Această relaţie se poate generaliza sub formă
matricială:
( ) U U G I
e
+ ⋅ ·
unde
G
este o matrice pătrată, de dimensiuni
l l ×
şi care conţine pe diagonala
principală conductanţele laturilor circuitului, iar restul termenilor sunt
0
. In cazul circuitelor
de curent alternativ la care există cuplaje mutuale între laturi, atunci termenii corespunzători
acestor cuplaje din matricea
G
sunt diferiţi de
0
.
37
Matricea
e
U
va fi o matrice coloană cu
l
elemente care va conţine tensiunile
electromotoare ale circuitului. Dacă pe o latură nu există astfel de surse, atunci termenul
corespunzător matricii
e
U
va fi
0
.
Prin înlocuirea relaţiilor (6.9) şi (6.6) în relaţia (6.1) şi prin regruparea termenilor se va
obţine un sistem de ecuaţii echivalent:
sc
I V G ' ' ' · ⋅
unde:
t
e sc
A G A G
U G A I
⋅ ⋅ ·
⋅ ⋅ − ·
'
'
Acest sistem de ecuaţii are doar
n
ecuaţii şi se poate rezolva cu ajutorul metodelor
numerice prezentate la unitatea de învăţare numărul 2. După determinarea potenţialelor
nodurilor se pot obţine tensiunile la bornele laturilor şi curenţii electrici prin laturile
circuitului.
Avantajul acestei metode se poate observa în cazul circuitelor mari la care numărul
nodurilor este de câteva sute sau mii, deoarece termenii matricei
A
pot fi completaţi automat
în momentul desenului circuitului. Un dezavantaj al metodei poate fi acela că, folosind
conductanţe în locul rezistenţelor, nu poate fi utilizată pentru laturile care au rezistenţa nulă
(cum ar fi de exemplu în cazul calculelor regimurilor de scurtcircuit), deoarece acest lucru
conduce la o conductanţă infinită. Aceste cazuri se pot evita însă prin reanalizarea circuitului.
Algoritmul metodei este următorul:
1. Se completeaza matricile
e
U
şi
G
.
2. Se completeaza matricea
A
.
3. Se calculeaza matricea
' G
cu relaţia de mai sus.
4. Se calculeaza matricea
' I
cu relaţia mai sus.
5. Se rezolvă sistemul de acuaţii şi rezultă matricea
' V
a potenţialelor de noduri.
6. Se calculează tensiunile la bornele laturilor U şi curenţii prin laturi şi rezultă matricea
I
.
38
Exemplu:
Să se calculeze circuitul electric din figură:
Valorile sunt următoarele:
. 1 2 , 2 4
; 1 2 , 7 , 5 , 2 , 1 0 , 2 0
5 1
6 5 4 3 2 1
V U V U
R R R R R R
e e
· ·
· · · · · ·
Să se scrie un program de calcul (utilizând limbajul de programare C++
sau Java), care să implementeze algoritmul prezentat pentru exemplul de mai
sus.

39
6.4. Metoda curenţilor ciclici
Dacă se utilizează ca mărimi independente curenţii ciclici
I '
, sau curenţii prin ochiuri,
nişte mărimi fictive care circulă prin ochiuri şi nu prin laturi, atunci matricea curenţilor prin
laturi se poate exprima prin relaţia:
' I B I
t
⋅ ·
Inlocuind această relaţie în prima teoremă a lui Kirchhoff, şi ţinând cont că vectorul
I '

este un vector cu mărimi independente, rezultă că:
0 · ⋅
t
B A
Dacă se consideră o singură latură a circuitului, care conţine o sursă de tensiune şi o
rezistenţă, se poate scrie relaţia:
ek k k k
U I R U − ⋅ ·
unde
k
R
reprezintă rezistenţa laturii. Această relaţie se poate generaliza sub formă
matricială:
e
U I R U − ⋅ ·
unde
R
este o matrice pătrată, de dimensiuni
l l ×
şi care conţine pe diagonala
principală rezistenţele laturilor circuitului, iar restul termenilor sunt 0. In cazul circuitelor de
curent alternativ la care există cuplaje mutuale între laturi, atunci termenii corespunzători
acestor cuplaje din matricea
R
sunt diferiţi de 0.
Matricea
e
U
este o matrice coloană cu
l
elemente care conţine tensiunile
electromotoare ale circuitului. Dacă pe o latură nu există astfel de surse, atunci termenul
corespunzător matricii
e
U
este
0
.
Prin înlocuirea relaţiilor de mai sus în cea de-a doua teoremă a lui Kirchhoff în formă
matricială şi prin regruparea termenilor se obţine un sistem de ecuaţii echivalent:
' ' '
e
U I R · ⋅
unde:
R’ = B ∙ R ∙ B
t
U
e
’ = B ∙ U
e
Acest sistem de ecuaţii are doar
o
ecuaţii şi se poate rezolva cu ajutorul metodelor
numerice prezentate în unitatea de învăţare numărul 2. După determinarea curenţilor ciclici se
pot obţine curenţii prin laturi şi tensiunile la bornele laturilor.
40
Algoritmul metodei este următorul:
1. Se completeaza matricile
e
U
şi
R
.
2. Se completeaza matricea
B
.
3. Se calculeaza matricea
' R
cu relaţia de mai sus.
4. Se calculeaza matricea
'
e
U
cu relaţia sus.
5. Se rezolvă sistemul de acuaţii şi rezultă matricea
' I
.
6. Se calculează curenţii prin laturi cu ajutorul matricilor
t
B
şi
' I
şi rezultă matricea
I
.
Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java),
care să implementeze algoritmul prezentat pentru exemplul de mai sus.
41
Să ne reamintim...
- Care este principalul inconvenient în rezolvarea circuitelor şi reţelelor
mari prin metode tradiţionale?
- Care este principalul avantaj al regimului de funcţionare staţionar sau
cvasistaţionar faţă de regimul dinamic de funcţionare?
- Ce matrice este utilizată la metoda potenţialelor de noduri?
- Ce matrice este utilizată la metoda curenţilor ciclici?
Rezumat
In acest capitol am văzut:
- în ce constă abordarea modernă a rezolvării circuitelor şi reţelelor
electrice cu ajutorul calculatorului
- care sunt particularităţile regimurilor staţionar şi cvasistaţionar faţă de
regimul de funcţionare dinamic
- care sunt avantajele şi dezavantajele celor două metode de rezolvare a
circuitelor în regim staţionar şi cvasistaţionar corespunzătoare cazurilor
de curent continuu, respectiv curent alternativ
Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice, ca
de exemplu rezolvarea numerică a circuitelor şi reţelelor electrice care stau la baza
numeroaselor probleme de proiectare, dimensionare, calcul al pierderilor de
energie etc.

42
Bibliografie.
1. Sorea, D., Scutaru, G., Lungoci, C. – Metode Numerice cu Aplicaţii în Ingineria
Electrică, Editura Universităţii Transilvania din Braşov, 2009, ISBN 978-973-598-
507-3
2. Scutaru G., Metode numerice, Editura Universităţii Transilvania Braşov, 1999.
3. Gallardo, D., Burnette, E., McGovern, R., Eclipse in Action. A guide for Java
Developers, Manning Publications Co. Greenwich, 2003.
4. Popa M, Popa A, Militaru R, Notiuni de Analiza Numerica, Editura Sitech 2001.
43
Anexa 1
Instalarea mediului de programare Eclipse
Pentru programatorii Java există foarte multe medii integrate de programare,
cu diverse facilităţi. Unul dintre cele mai utilizate este Eclipse, care prezintă
avantajul că este oferit gratuit utilizatorilor.
Descărcarea şi instalarea
De pe Internet, de la adresa http://www.eclipse.org/downloads se alege
Eclipse Classic pentru platforma Windows. Se despachetează fişierul .zip.
Pentru ca programul Eclipse să poată fi rulat, este necesară existenţa mediului
de dezvoltare Java, cunoscut sub numele de Java SDK (Java Software
Development Kit). Dacă acesta nu este instalat, el poate fi descărcat de la adresa
http://java.sun.com/javase. Se lansează aplicaţia Eclipse prin accesarea
programului executabil eclipse.exe. La pornire trebuie să se aleagă un folder în
care se stochează fişierele (fişierele cu sursele programelor, cele rezultate în
urma compilării etc).
Fig. 1. Lansarea programului eclipse.exe.
Crearea unui proiect Java
Un proiect Java conţine codul sursă şi fişierele aferente pentru un program
Java. In mediul de programare Eclipse există un compilator Java care realizează
automat etapa de compilare, pe măsură ce fişierele sursă sunt modificate. In
cazul în care sunt erori de compilare acestea sunt depistate imediat şi Eclipse
44
oferă totodată sugestii pentru remedierea lor. In unele cazuri poate realiza
automat repararea lor prin dublu click.
Fig. 2. Crearea unui nou proiect în Eclipse.
In fereastra care se va deschide, la primul pas se lasă nemodificată opţiunea
Java Project (figura 3) şi se face click pe Next.
Fig. 3. Crearea unui proiect nou – pasul 1.
La al doilea pas se va da numele proiectului (ex. Laborator1), şi se face
click pe Next. La al treilea pas nu se fac modificări, se face doar click pe Finish.
45
Fig. 4. Crearea unui proiect nou – pasul 2.
In acest moment un proiect nou a fost creat şi urmează definirea
programului Java. Acesta poate fi organizat într-unul sau mai multe pachete
(pentru programele mari şi complexe).
Crearea unui pachet
Un pachet (package) poate conţine una sau mai multe clase Java.
Apartenenţa mai multor clase Java la acelaşi pachet le oferă variabilelor interne
mai multă vizibilitate între ele.
Fig. 5. Crearea unui nou pachet.
In fereastra care se va deschide se tastează numele pachetului. Se recomandă
ca numele pachetelor să fie scris cu litere mici. După tastarea numelui se apasă
Finish.
46
Crearea unei clase
Pentru a scrie primul program trebuie definită prima clasă. Cel mai uşor
exemplu se află în secţiunea Help a mediului Eclipse. Se alege submeniul
Welcome.
Fig. 6. Accesarea tutorialului – pasul 1.
De aici se accesează Tutorials.
Fig. 7. Accesarea tutorialului – pasul 2.
Din fereastra care se va deschide se alege Create a Hello World
application.
47
Fig. 8. Accesarea tutorialului – pasul 3.
48
Anexa 2
Programele în C++
1.1. Program bisectie -Metoda bisectiei - injumatatirea
intervalului;
#include <conio.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
double e=1e-7,a,b,c;
int m;
double f(double x)
{
return log(x)+x;
}
void bisect()
{
if (f(a)*f(b)>0)
{
printf("\n Interval gresit!");
exit(1);
}
if (f(a)*f(b)<=0)
{
m=0;
e100: c=(a+b)/2;
m++;
if (f(a)*f(c)==0) return;
if (f(a)*f(c)<0) b=c;
if (f(a)*f(c)>0) a=c;
if (fabs(b-a)>e) goto e100;
}
}
void main()
{
printf("\n a="); scanf("%lf", &a);
printf("\n b="); scanf("%lf", &b);
bisect();
printf("\n\n Radacina calculata este x = %f\n",c);
printf("\n\n Nr. de iteratii este m = %d\n\n",m);
}
49
1.2. Program secanta -Metoda secantei - coarda variabila;
#include <stdlib.h>
#include <conio.h>
#include <iostream.h>
#include <math.h>
float a,b,c,error;
float f(float x)
{
return x+log(x);
}
void main()
{
cout<<"a="; cin>>a;
cout<<"b="; cin>>b;
c=a;
error=1e-7;
if (f(a)*f(b)>0)
{
cout<<"Intervalul este gresit!";
exit(1);
}
else
while (fabs(f(c))>=error)
{
c=a-f(a)*(b-a)/(f(b)-f(a));
if (f(c)==0)
{
cout<<"Radacina exacta este:"<<c;
exit(1);
}
else
if (f(a)*f(c)>0)
a=c;
else
b=c;
}
cout<<"Radacina (cu eroarea data "<<error<<") este:"<<c;
getch();
}
50
2.1. Program sisteme ecuatii liniare -Metoda Gauss-Jordan;
#include <iostream.h>
#include <conio.h>
#include <math.h>
float A[10][10],B[10],M[10][10],X[10],Aux[10][10],Bux[10];
void produs_matrici(int linA,int colA,int colB,float A[10][10],float B[10]
[10],float M[10][10])
{
int i,j,k; //colA-nr coloane mat A = nr de linii din mat B
for (i=1;i<=linA;i++) //linA-nr linii mat A
for (j=1;j<=colB;j++) //colB-nr linii in B M[linA][colB]
{
M[i][j]=0;
for (k=1;k<=colA;k++)
M[i][j]+=A[i][k]*B[k][j];
}
}
void afisare_matrici(int linie,int coloana, float X[10][10])
{
int i,j;
for (i=1;i<=linie;i++)
{
for (j=1;j<=coloana;j++)
cout<<X[i][j]<<" ";
cout<<endl;
}
}
void afisare_sir(int limita,float X[10])
{
int i;
for (i=1;i<=limita;i++)
cout<<X[i]<<" ";
cout<<endl;
}
void main ()
{
int i,j,k,n;
clrscr();
cout<<"\nNumber of equations:";
cin>>n;
cout<<"Matrix A:";
for (i=1;i<=n;i++)
51
for (j=1;j<=n;j++)
{
gotoxy (j*5+1,i+3);
cin>>A[i][j];
}
cout<<"Matrix B: "<<endl;
for (i=1;i<=n;i++)
{
gotoxy (j*5+1,i+6+n);
cin>>B[i];
}
for(int col=1;col<=n;col++)
{
//Construire matrice M
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
M[i][j]=(i==j)?1:0;
M[col][col]=1/A[col][col];
for(j=col+1;j<=n;j++)
M[j][col]=-A[j][col]/A[col][col];
//Inmultire M A
produs_matrici(n,n,n,M,A,Aux);
//Atribuire rezultat lui A
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
A[i][j]=Aux[i][j];
//Inmultire M B
for(i=1;i<=n;i++)
{
Bux[i]=0;
for (k=1;k<=n;k++)
Bux[i]+=M[i][k]*B[k];
}
//Atribuire rezultat lui B
for(i=1;i<=n;i++)
B[i]=Bux[i];
//Se inchide ciclul col
}
//Calcul solutie X
for(i=n;i>=1;i--)
{
X[i]=B[i];
for(j=i+1;j<=n;j++)
52
X[i]-=A[i][j]*X[j];
}
//Afisare X
for(i=1;i<=n;i++)
cout<<"X"<<i<<"="<<X[i]<<endl;
}
53
3.1. Program interpolare – Interpolarea liniara;
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
int x[10]={1,2,3,4,5,6,7,8,9,10};
int y[10]={9,8,5,8,4,6,2,3,5,1};
int i,j,n=10,k;
double xx[5]={1.25,5.63,9.8,4.24,7.31},yy;
void main(void)
{
int gdriver = DETECT, gmode, errorcode;
initgraph(&gdriver, &gmode, "c:\\Borlandc\\bgi");
for(i=0;i<=4;i++)
{
for(j=0;j<=n-2;j++)
{
if((xx[i]>x[j])&&(xx[i]<x[j+1]))
k=j;
yy=y[k]+(xx[i]-x[k])/(x[k+1]-x[k])*(y[k+1]-y[k]);
}
circle(xx[i]*64,480-yy*48,2);
}
double x_max=10,y_max=10;
for(i=0;i<=n-2;i++)
line(x[i]/x_max*640,480-y[i]/y_max*480,x[i+1]/x_max*640,480-
y[i+1]/y_max*480);
getch();
closegraph();
}
54
3.2. Program interpolare – Interpolarea Spline;
#include <stdio.h>
#include <math.h>
#include <graphics.h>
#include <stdlib.h>
#include <conio.h>
int i,j, k=2, n=10, m=50,color;
double ax, bx, cx, dx, ay, by, cy, dy;
double t;
double x[11], y[11], xd[11], yd[11];
double alfa1, alfa2, alfa, v1, v2;
double xt[100], yt[100];
void main()
{
//Declarare puncte cunoscute:
x[1]= 1; y[1]= 9;
x[2]= 2; y[2]= 8;
x[3]= 3; y[3]= 5;
x[4]= 4; y[4]= 8;
x[5]= 5; y[5]= 4;
x[6]= 6; y[6]= 6;
x[7]= 7; y[7]= 2;
x[8]= 8; y[8]= 3;
x[9]= 9; y[9]= 5;
x[10]= 10; y[10]= 1;
//Calcul derivate in punctele cunoscute:
for(i=1; i<=n; i++)
{
if(i>1)
v1=(y[i]-y[i-1])/(x[i]-x[i-1]);
else
v1=(y[i+1]-y[i])/(x[i+1]-x[i]);
if(i<n)
v2=(y[i+1]-y[i])/(x[i+1]-x[i]);
else
v2=(y[i]-y[i-1])/(x[i]-x[i-1]);
alfa1=atan(v1); alfa2=atan(v2); alfa=(alfa1+alfa2)/2;
xd[i]=k*cos(alfa); yd[i]=k*sin(alfa);
}
// GRAFICE:
//Cerere auto-detectare driver mod grafic:
int driver = DETECT, mode, eroare;
//Initializare mod grafic:
55
initgraph(&driver, &mode, "C:\\borlandc\\bgi");
//Citire rezultat initializare:
eroare = graphresult();
if (eroare != grOk) //aparitie eroare
{
printf("Eroare grafice: %s\n", grapherrormsg(eroare));
printf("Apasa orice tasta pentru oprire:");
getch();
exit(1); //terminare cu eroare de cod
}
//Algoritmul de interpolare:
for(i=1; i<10; i++)
{
//Calcul coeficienti pt. x(t):
ax = -2*x[i+1] + xd[i+1] + xd[i] +2*x[i];
bx = 3*x[i+1] - xd[i+1] - 2*xd[i] -3*x[i];
cx = xd[i];
dx = x[i];
//Calcul coeficienti pt. y(t):
ay = -2*y[i+1] + yd[i+1] + yd[i] +2*y[i];
by = 3*y[i+1] - yd[i+1] - 2*yd[i] -3*y[i];
cy = yd[i];
dy = y[i];
for (j=0; j<=m; j++)
{
t=(double)j/m;
xt[j]=ax*t*t*t + bx*t*t + cx*t +dx;
yt[j]=ay*t*t*t + by*t*t + cy*t +dy;
putpixel(xt[j]/10*640, 480-yt[j]/10*480, WHITE);
} //j
} //i
//Inchidere mod grafic:
getch();
closegraph();
}//main
56
4.1. Program integrare – Integrare numerica;
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
#include <math.h>
double funct(double x)
{
return sin(x);
}
void main(void)
{
double h, a, b, x[60], integral1, integral2, S1[60], S2[60];
int n, i;
cout<<"\nLimita minima a domeniului:";
cin>>a;
cout<<"\nLimita maxima a domeniului";
cin>>b;
n=50;
h=(b-a)/n;
integral1=0;
integral2=0;
for(i=0;i<n;i++)
{
S1[i]=0; S2[i]=0;
}
for(i=0;i<n;i++)
{
x[i]=a+i*h;
x[i+1]=x[i]+h;
S1[i]=(x[i+1]-x[i])*funct(x[i]);
integral1=integral1+S1[i];
S2[i]=(x[i+1]-x[i])*((funct(x[i])+funct(x[i+1]))/2);
integral2=integral2+S2[i];
}
cout<<"\nMetoda dreptunghiului: Valoare integrala:"<<integral1;
cout<<"\nMetoda trapezului: Valoare integrala:"<<integral2;
getch();
}
57
5.1. Program ecuatii diferentiale -Metoda Runge-Kutta ordin 4;
#include<iostream.h>
#include<conio.h>
#include<math.h>
double f(double t, double y)
{
return cos(t);
}
void main()
{
//Definire interval [a,b]
double a=0, b=M_PI ;
double h, n, k1, k2, k3, k4, t, y;
//Valoare initiala
y=0
//Numarul de puncte de esantionare
n=100;
h=(b-a)/n; //Pas de calcul
for(int i=0;i<n;i++)
{
t=a+i*h;
k1=f(t,y);
k2=f(t+h/2,y+k1*h/2);
k3=f(t+h/2,y+k2*h/2);
k4=f(t+h, y+k3*h);
y+=h/6*(k1+2*k2+2*k3+k4);
//Pentru verificare se afiseaza si solutia analitica sin(t+h)
// Daca e corect calculul atunci ele trebuie sa fie egale (cel putin
// 5 sau 6 zecimale
cout<<y<<sin(t+h)<<endl;
}
getch();
}
58
5.2. Program sistem de 2 ecuatii diferentiale -Metoda Runge-Kutta
ordin 4;
#include<math.h>
#include<iostream.h>
#include<conio.h>
#include<graphics.h>
#include<stdio.h>
#include<stdlib.h>
float a=0;
float b=0.1;
float h,t,k11,k21,k31,k41,k12,k22,k32,k42;
int i,n=90;
float y1[100],y2[100];
int gdriver=DETECT, gmode, errorcode;
float f1(float t,float y1, float y2)
{
return (10*sin(100*M_PI*t)-5*y1-y2)/0.01;
}
float f2(float t,float y1, float y2)
{
return 1000*y1;
}
void main()
{
clrscr();
y1[0]=0;
y2[0]=0;
//Initializare mod grafic
initgraph(&gdriver, &gmode, "c:\\borlandc\\bgi");
//Citire rezultat intializare
errorcode = graphresult();
if (errorcode != grOk) //Aparitie eroare
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); //Returnare cu cod de eroare
}
h=(b-a)/n;
for(i=0;i<n-1;i++)
{
t=i*h;
59
k11=f1(t,y1[i],y2[i]);
k12=f2(t,y1[i],y2[i]);
k21=f1(t+h/2,y1[i]+k11*(h/2),y2[i]+k12*(h/2));
k22=f2(t+h/2,y1[i]+k11*(h/2),y2[i]+k12*(h/2));
k31=f1(t+h/2,y1[i]+k21*(h/2),y2[i]+k22*(h/2));
k32=f2(t+h/2,y1[i]+k21*(h/2),y2[i]+k22*(h/2));
k41=f1(t+h,y1[i]+k31*h,y2[i]+k32*h);
k42=f2(t+h,y1[i]+k31*h,y2[i]+k32*h);
y1[i+1]=y1[i]+h/6*(k11+2*k21+2*k31+k41);
y2[i+1]=y2[i]+h/6*(k12+2*k22+2*k32+k42);
if(i>0)
{
line(t/b*640, 240-y1[i]/50*240,
(t+h)/b*640, 240-y1[i+1]/50*240);
line(t/b*640, 240-y2[i]/100*240,
(t+h)/b*640, 240-y2[i+1]/100*240);
}
}
getch();
closegraph();
}
60
Anexa 3. Programe în Java
1.1. Ecuatii neliniare. Metoda injumatatirii intervalului
package ecuatiineliniare;
public class Bisectie {
public static double f(double x){
return Math.log(x) + x;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
double a = 0.001, b=2, c, eps = 1e-6;
if(f(a)*f(b) < 0){
do{
c = (a + b)/2;
if(f(a)*f(c)<0){
b=c;
} else {
a=c;
}
}
while(Math.abs(f(c))>eps);
System.out.println("Metoda injumatatirii intervalului");
System.out.println("Radacina = "+Double.toString(c));
} else {
System.out.println("Interval ales gresit!!!");
}
}
}
61
1.2. Ecuatii neliniare. Metoda coardei variabile
package ecuatiineliniare;
public class SecantaVariabila {
/**
* @param args
*/
public static double f(double x){
return Math.log(x) + x;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
double a = 0.001, b=2, c, eps = 1e-6;
if(f(a)*f(b) < 0){
do{
c = a - f(a)/(f(b)-f(a))*(b-a);
if(f(a)*f(c)<0){
b=c;
} else {
a=c;
}
}
while(Math.abs(f(c))>eps);
System.out.println("Metoda coardei variabile");
System.out.println("Radacina = "+Double.toString(c));
} else {
System.out.println("Interval ales gresit!!!");
}
}
}
62
2.1. Sisteme ecuatii. Metoda eliminării lui Gauss
package sisteme;
public class EliminareGauss {
public static void main(String[] args) {
// se declara matricile a si b ca date de intrare
double[][] a = {{1, 2, 1, 3, 4},
{2, 1, 5, 9, 8},
{5, 0, 6, 4, 3},
{2, 5, 8, 9, 8},
{7, 3, 4, 2, 7}};
double[] b = {11, 25, 18, 32, 23};
// se declara variabilele m, a_aux, x, b_aux
double[][] m= new double[5][5];
double[][] a_aux=new double[5][5];
double[] x= new double[5];
double[] b_aux= new double[5];
// se declara variabilele i, j, k, pas, n
int i, j, k, pas, n=5;
// pentru pas de la primul pana la ultimul
for(pas=0; pas<n; pas++){
// se construieste matricea m pentru pasul pas
for(i=0; i<n; i++){
for(j=0; j<n; j++)
m[i][j] = 0;
m[i][i] = 1;
}
m[pas][pas]=1/a[pas][pas];
for(i=pas+1; i<n; i++)
m[i][pas] = -a[i][pas] / a[pas][pas];
// se inmulteste matricea m cu a
for(i=0; i<n; i++)
for(j=0; j<n; j++){
a_aux[i][j] = 0;
for(k=0; k<n; k++)
a_aux[i][j] += m[i][k] * a[k][j];
}
// rezultatul se va atribui lui a
for(i=0; i<n; i++)
for(j=0; j<n; j++)
a[i][j] = a_aux[i][j];
63
System.out.println("\nMatricea A - dupa pasul "+
Integer.toString(pas));
for(i=0; i<n; i++){
for(j=0; j<n; j++)
System.out.print("\t"+ Double.toString(a[i][j]));
System.out.print("\n");
}
// se inmulteste matricea m cu b
for(i=0; i<n; i++){
b_aux[i] = 0;
for(k=0; k<n; k++)
b_aux[i] += m[i][k] * b[k];
}
// rezultatul se va atribui lui b
for(i=0; i<n; i++)
b[i] = b_aux[i];
// se trece la pasul urmator
}
// se afiseaza matricile a si b transformate
System.out.println("\nMatricea A - forma finala:");
for(i=0; i<n; i++){
for(j=0; j<n; j++)
System.out.print(a[i][j] + "\t");
System.out.print("\n");
}
System.out.println("\nMatricea B - forma finala:");
for(i=0; i<n; i++)
System.out.println(b[i]);
// se calculeaza vectorul x
for(i=n-1; i>=0; i--){
x[i] = b[i];
for(j=i+1; j<n; j++)
x[i] -= a[i][j] * x[j];
}
// se afiseaza vectorul x
System.out.println("Solutia sistemului:\n");
for(i=0; i<n; i++)
System.out.println(x[i]);
}
}
64
2.2. Sisteme ecuatii. Metoda Gauss-Seidel
package sisteme;
public class GaussSeidel {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
double[][] a = {{4, -2, 1},
{1, 3, 0},
{1, -1, 5}};
double[] b = {3, 4, 5};
double[] x = {0, 0, 0};
int i, j, k=0;
double eps = 1e-9, eroare=0, x_aux;
// se incepe procesul iterativ pana cand se ajunge intr-o vecinatate
// in jurul solutiei mai mica decat eps
do{
k++;
eroare = 0;
for(i = 0; i<3; i++){
// se pastreaza valoarea de la iteratia precedenta
x_aux = x[i];
// se calculeaza valoarea lui x pentru noua iteratie
x[i] = b[i]/a[i][i];
for(j = 0; j<3; j++){
if(i!=j){
x[i] -= a[i][j] / a[i][i] * x[j];
}
}
// se evalueaza diferenta valorilor dintre doua iteratii
// si se compara cu eroarea maxima
if(eroare < Math.abs(x[i] - x_aux)){
eroare = Math.abs(x[i] - x_aux);
}
}
System.out.println("Iteratia "+Integer.toString(k)+
": Eroarea maxima: "+ Double.toString(eroare));
}
while(eroare > eps);
// se afiseaza solutia ecuatiei
System.out.println("Solutia sistemului. Metoda Gauss - Seidel:");
for(i=0; i<3; i++){
65
System.out.println(x[i]);
}
}
}
66
3.1. Interpolare Spline
package interpolare;
public class Spline {
// Se dau n puncte în care se cunoaste functia
double[] x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
double[] y = {9, 8, 5, 8, 4, 6, 2, 3, 5, 1};
int n=10;
// Se da numarul de puncte m în care determinam functia interpolata
int m=50;
double[] xArray = new double[500];
double[] yArray = new double[500];
int nrPuncte;
double coef=2;
void setNrPuncte(int nr){
nrPuncte = nr;
}
int getNrPuncte(){
return nrPuncte;
}
void setCoef(double s){
coef = s;
}
double getCoef(){
return coef;
}
public Spline(double s){
setCoef(s);
bodySpline();
}
public Spline(){
bodySpline();
}
public void bodySpline(){
double[][] M1 = new double[2][4];
double[][] M2 = {{2, -3, 0, 1},
{-2, 3, 0, 0},
{1, -2, 1, 0},
{1, -1, 0, 0}};
double[] M3 = new double[4];
double[] M23 = new double[4];
double xx, yy;
int crt=0;
// Se calculeaza derivatele în punctele cunoscute
67
double alfa1=0;
double alfa2=0;
double alfa=0;
double[] xp = new double[10];
double[] yp = new double[10];
for(int i=0; i<n; i++){
if(i>0)
alfa1 = Math.atan2((y[i]-y[i-1]),(x[i]-x[i-1]));
if(i<(n-1))
alfa2 = Math.atan2((y[i+1]-y[i]),(x[i+1]-x[i]));
if(i==0)
alfa = alfa2;
else if(i==(n-1))
alfa = alfa1;
else
alfa = (alfa1 + alfa2)/2;
xp[i] = coef*Math.cos(alfa);
yp[i] = coef*Math.sin(alfa);
}
// Se deschide un ciclu for cu i de la 0 pâna la n-1
for(int i=0; i<(n-1); i++){
// Punctul corespunzator lui t = 0 va fi cel cu indicele i, iar pentru t = 1
// va fi cel cu indicele i+1, si se vor lua ca atare polinoamele P si P'.
M1[0][0]=x[i]; M1[0][1]=x[i+1]; M1[0][2]=xp[i];
M1[0][3]=xp[i+1];
M1[1][0]=y[i]; M1[1][1]=y[i+1]; M1[1][2]=yp[i];
M1[1][3]=yp[i+1];
// Se deschide un ciclu for cu j de la 0 pâna la m
for(int j=0; j<m; j++){
// Se calculeaza t = j / m
double t=(double)j/m;
M3[0] = t*t*t; M3[1] = t*t; M3[2] = t; M3[3] = 1;
// Se calculeaza x(t) si y(t) cu ultima relatie, unde x(t) si y(t) sunt componentele
// polinomului P(t)
for(int k=0; k<4; k++){
M23[k]=0;
for(int l=0; l<4; l++){
M23[k] += M2[k][l]* M3[l];
}
}
xx = 0;
yy = 0;
for(int k=0; k<4; k++){
xx += M1[0][k]*M23[k];
yy += M1[1][k]*M23[k];
}
xArray[crt] = xx;
68
yArray[crt] = yy;
crt++;
// Se închide ciclul cu j
}
// Se închide ciclul cu i.
}
setNrPuncte(crt);
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Spline sp = new Spline();
for(int i=0; i<sp.getNrPuncte(); i++){
System.out.println(Double.toString(sp.xArray[i])+"\t"+
Double.toString(sp.yArray[i]));
}
}
}
69
4. Integrala prin metoda trapezelor
package integrare;
public class Trapez {
/**
* @param args
*/
public static double fct(double x){
double rez;
rez = Math.sin(x);
return rez;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int n=500;
double a=0;
double b=Math.PI;
double h=(b-a)/n;
double x;
double integrala=0;
double integ2 = 0;
for(int i=0; i<n; i++){
x = a + i*h;
integrala += (fct(x) + fct(x+h)) / 2;
if((i%2)==0){
integ2 += (fct(x) + fct(x+2*h)) / 2;
}
}
integrala *= h;
integ2 *= 2*h;
System.out.println("Rezultatul = "+ Double.toString(integrala));
System.out.println("Rezultatul 2 = "+ Double.toString(integ2));
System.out.println("Rezultatul corectat = "+
Double.toString(integrala + (integrala - integ2)/3));
}
}
70
5.1. Ecuatii diferentiale. Metoda Runge-Kutta pentru o ecuatie
package ecuatiidiferentiale;
public class RungeKutta {
int n=100;
static double[] xArray = new double[100];
static double[] yArray = new double[100];
public static double u(double t){
double frecventa = 50;
return 10*Math.sin(2*Math.PI*frecventa*t);
}
public static double f(double t, double y){
double R = 0.1, L = 0.001;
return (u(t) - R*y)/L;
}
public RungeKutta(){
int i;
double t = 0, tf = 0.1, y=0, h, k1, k2, k3, k4;
h = (tf - t) / n;
for(i=0; i<n; i++){
t = i*h;
k1 = f(t, y);
k2 = f(t+h/2, y+k1*h/2);
k3 = f(t+h/2, y+k2*h/2);
k4 = f(t+h, y+k3*h);
y += h/6 * (k1+2*k2+2*k3+k4);
xArray[i] = t+h;
yArray[i] = y;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
RungeKutta rk = new RungeKutta();
for(int i=0; i<rk.n; i++){
System.out.println(Double.toString(RungeKutta.xArray[i])+"\t"+
Double.toString(RungeKutta.yArray[i]));
}
}
}
71
5.2. Metoda Runge-Kutta pentru sistem de 2 ecuatii diferentiale
package ecuatiidiferentiale;
public class SistemRK {
/**
* apelul functiei cu numar variabil de parametri (necesita JRE > 1.5)
*/
static double R = 1, L = 0.002, C=0.002;
static double[] xArray = new double[100];
static double[][] yArray = new double[2][100];
static int nrEc = 2;
int n=100;
public static double u(double t){
double frecventa = 50;
return 10*Math.sin(2*Math.PI*frecventa*t);
}
public static double f(int nrFct, double... a ){
double rez=0;
switch(nrFct){
case 0: rez = a[2]/C; break;
case 1: rez = (u(a[0]) - R*a[2] - a[1])/L; break;
}
return rez;
}
public SistemRK(){
int i;
double t = 0, tf = 0.1, h;
double[] y={0, 0};
double[] k1=new double[2];
double[] k2=new double[2];
double[] k3=new double[2];
double[] k4=new double[2];
h = (tf - t) / n;
for(i=0; i<n; i++){
t = i*h;
for(int j=0; j<nrEc; j++){
k1[j] = f(j, t, y[0], y[1]);
}
for(int j=0; j<nrEc; j++){
k2[j] = f(j, t+h/2, y[0]+k1[0]*h/2, y[1]+k1[1]*h/2);
}
for(int j=0; j<nrEc; j++){
k3[j] = f(j, t+h/2, y[0]+k2[0]*h/2, y[1]+k2[1]*h/2);
}
72
for(int j=0; j<nrEc; j++){
k4[j] = f(j, t+h, y[0]+k3[0]*h, y[1]+k3[1]*h);
}
for(int j=0; j<nrEc; j++){
y[j] += h/6 * (k1[j]+2*k2[j]+2*k3[j]+k4[j]);
yArray[j][i] = y[j];
}
xArray[i] = t+h;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
SistemRK srk = new SistemRK();
for(int i=0; i<srk.n; i++){
System.out.println(Double.toString(SistemRK.xArray[i])+"\t"+
Double.toString(SistemRK.yArray[0][i])+"\t"+
Double.toString(SistemRK.yArray[1][i]));
}
}
}
73
6.1. Metoda potenţialelor de noduri
- clasa pentru numere complexe
package calcule;
public class Complex {
private double real;
private double imag;
public Complex()
{
real = 0;
imag = 0;
}
public Complex(double real, double imag)
{
this.real = real;
this.imag = imag;
}
public String toString() {
if (imag == 0) return real + "";
if (real == 0) return imag + "j";
if (imag < 0) return real + " - " + (-imag) + "j";
return real + " + " + imag + "j";
}

public Complex(double modul, double faza, boolean polar){
if(polar){
real = Complex.XCart(modul, faza);
imag = Complex.YCart(modul, faza);
}
}
public double getImag()
{
return imag;
}
public void setImag(double imag)
{
this.imag = imag;
}
public double getReal()
{
return real;
}
74
public void setReal(double real)
{
this.real = real;
}
public static Complex Sum(Complex a, Complex b)
{
Complex result = new Complex(0,0);
result.setReal(a.getReal() + b.getReal());
result.setImag(a.getImag() + b.getImag());
return result;
}
public static Complex Diff(Complex a, Complex b)
{
Complex result = new Complex(0,0);
result.setReal(a.getReal() - b.getReal());
result.setImag(a.getImag() - b.getImag());
return result;
}
public static Complex Prod(Complex a, Complex b)
{
Complex result = new Complex(0,0);
result.setReal(a.getReal()*b.getReal() - a.getImag()*b.getImag());
result.setImag(a.getReal()*b.getImag() + a.getImag() * b.getReal());
return result;
}
public static Complex Div(Complex a, Complex b)
{
Complex result = new Complex(0,0);
result.setReal((a.getReal() * b.getReal() +
a.getImag() * b.getImag())/
(b.getReal()*b.getReal() + b.getImag()*b.getImag()) );
75
result.setImag((a.getImag() * b.getReal() –
a.getReal() * b.getImag())/
(b.getReal()*b.getReal() + b.getImag()*b.getImag()) );
return result;
}
public static double XCart(double modul, double faza){
return modul * Math.cos(faza);
}
public static double YCart(double modul, double faza){
return modul * Math.sin(faza);
}
public double Abs()
{
return Math.sqrt(real*real + imag*imag);
}
public double Phase()
{
return Math.atan2(imag, real);
}
}
76
- clasa pentru sisteme de ecuatii (metoda eliminarii Gauss in complex)
package calcule;
public class ElimGauss {
private Complex[][] a = new Complex[50][50];
private Complex[] b = new Complex[50];
private int n=5;
private Complex[] rezultat = new Complex[50];
public Complex[] getRezultat () {
return rezultat;
}
public ElimGauss(Complex[][] aMat, Complex[] bMat, int nMat){
if(checkN(nMat)){
a = aMat;
b = bMat;
n = nMat;
rezultat = Compute(a, b, n);
}
}
public boolean checkN( int n) {
if(n<50)
return true;
else
{
System.out.println("Alegeti un numar mai mare de 50");
return false;
}
}
public Complex[] Compute(Complex[][] a, Complex[] b, int n) {
// se declara matricile a si b ca date de intrare
// se declara variabilele m, a_aux, x, b_aux
Complex[][] m= new Complex[50][50];
Complex[][] a_aux=new Complex[50][50];
Complex[] x_aux= new Complex[50];
Complex[] b_aux= new Complex[50];
// se declara variabilele i, j, k, pas, n
int i, j, k, pas;
Complex nrCompInt;
// pentru pas de la primul pana la ultimul
for(pas=0; pas<n; pas++){
// se construieste matricea m pentru pasul pas
for(i=0; i<n; i++){
77
for(j=0; j<n; j++)
m[i][j] = new Complex();
m[i][i] = new Complex(1, 0);
}
// m[pas][pas]=1/a[pas][pas];
nrCompInt = new Complex(1, 0);
m[pas][pas] = Complex.Div(nrCompInt, a[pas][pas]);
for(i=pas+1; i<n; i++){
// m[i][pas] = -a[i][pas] / a[pas][pas];
nrCompInt = new Complex(-a[i][pas].getReal(),-a[i][pas].getImag());
m[i][pas] = Complex.Div(nrCompInt, a[pas][pas]);
}
// se inmulteste matricea m cu a
for(i=0; i<n; i++)
for(j=0; j<n; j++){
a_aux[i][j] = new Complex();
for(k=0; k<n; k++){
// a_aux[i][j] += m[i][k] * a[k][j];
nrCompInt = Complex.Prod(m[i][k], a[k][j]);
a_aux[i][j] = Complex.Sum(a_aux[i][j], nrCompInt);
}
}
// rezultatul se va atribui lui a
for(i=0; i<n; i++)
for(j=0; j<n; j++)
a[i][j] = a_aux[i][j];
System.out.println("\nMatricea A - dupa pasul "+ Integer.toString(pas));
for(i=0; i<n; i++){
for(j=0; j<n; j++){
System.out.print("\t"+a[i][j]);
}
System.out.print("\n");
}
// se inmulteste matricea m cu b
for(i=0; i<n; i++){
b_aux[i] = new Complex();
for(k=0; k<n; k++){
// b_aux[i] += m[i][k] * b[k];
nrCompInt = Complex.Prod(m[i][k], b[k]);
b_aux[i] = Complex.Sum(b_aux[i], nrCompInt);
}
}
// rezultatul se va atribui lui b
for(i=0; i<n; i++)
78
b[i] = b_aux[i];
//se trece la pasul urmator
}
// se afiseaza matricile a si b transformate
System.out.println("\nMatricea A - forma finala:");
for(i=0; i<n; i++){
for(j=0; j<n; j++){
System.out.print("\t"+a[i][j]);
}
System.out.print("\n");
}
System.out.println("\nMatricea B - forma finala:");
for(i=0; i<n; i++){
System.out.println(b[i]);
}
// se calculeaza vectorul x
for(i=n-1; i>=0; i--){
x_aux[i] = b[i];
for(j=i+1; j<n; j++){
// x_aux[i] -= a[i][j] * x_aux[j];
nrCompInt = Complex.Prod(a[i][j], x_aux[j]);
x_aux[i] = Complex.Diff(x_aux[i], nrCompInt);
}
}
// se afiseaza vectorul x
System.out.println("Solutia sistemului:\n");
for(i=0; i<n; i++){
System.out.println(x_aux[i]);
}
return x_aux;
}
}
- clasa pentru metoda potenţialelor de noduri
package calcule;
public class PotentialeNoduri {
Complex[][] Y = new Complex[50][50];
Complex[] Ue = new Complex[50];
int[][] Aredus = new int[50][50];
int nrNoduri;
int nrLaturi;
Complex[] curenti = new Complex[50];
79
Complex[] Vprim = new Complex[50];
int[][] Atranspus = new int[50][50];
Complex[] Iscc = new Complex[50];
Complex[][] Yprim = new Complex[50][50];
Complex nrCompInt;
public PotentialeNoduri( Complex[][] yMat, Complex[] ueMat, int[][] arMat,
int noduri, int laturi){
nrNoduri = noduri;
nrLaturi = laturi;
Y = yMat;
Ue = ueMat;
Aredus = arMat;
TransformaMatrici();
System.out.println("\n\nMatricea Iscc initiala: \n\n\n");
for(int i=0; i<nrNoduri; i++){
System.out.println(Iscc[i]);
}
ElimGauss eg = new ElimGauss(Yprim, Iscc, nrNoduri);
Vprim = eg.getRezultat();
CalculCurenti();
}
public Complex[] getCurenti(){
return curenti;
}
public void TransformaMatrici(){
// A transpus
for(int i=0; i<nrLaturi; i++)
for(int j=0; j<nrNoduri; j++)
Atranspus[i][j] = Aredus[j][i];
// AY = A * Y
Complex[][] AY = new Complex[50][50];
for(int i=0; i<nrNoduri; i++){
for(int j=0; j<nrLaturi; j++){
AY[i][j] = new Complex();
for(int k=0; k<nrLaturi; k++){
// AY[i][j] += Aredus[i][k] * Y[k][j];
nrCompInt = new Complex(Aredus[i][k], 0);
nrCompInt = Complex.Prod(nrCompInt, Y[k][j]);
AY[i][j] = Complex.Sum(AY[i][j], nrCompInt);
}
}
80
}
// Iscc = - AY * Ue
for(int i=0; i<nrNoduri; i++){
Iscc[i] = new Complex();
for(int j=0; j<nrLaturi; j++){
// Iscc[i] -= AY[i][j] * Ue[j];
nrCompInt = Complex.Prod(AY[i][j], Ue[j]);
Iscc[i] = Complex.Diff(Iscc[i], nrCompInt);
}
}
// Yprim = AY * Atranspus
for(int i=0; i<nrNoduri; i++){
for(int j=0; j<nrNoduri; j++){
Yprim[i][j] = new Complex();
for(int k=0; k<nrLaturi; k++){
// Yprim[i][j] += AY[i][k] * Atranspus[k][j];
nrCompInt = new Complex(Atranspus[k][j], 0);
nrCompInt = Complex.Prod(AY[i][k], nrCompInt);
Yprim[i][j] = Complex.Sum(Yprim[i][j], nrCompInt);
}
}
}
}
public void CalculCurenti(){
Complex[] rezInterm = new Complex[50];
for(int i=0; i<nrLaturi; i++){
rezInterm[i] = new Complex();
for(int j=0; j<nrNoduri; j++){
// rezInterm[i] += Atranspus[i][j] * Vprim[j];
nrCompInt = new Complex(Atranspus[i][j], 0);
nrCompInt = Complex.Prod(nrCompInt, Vprim[j]);
rezInterm[i] = Complex.Sum(rezInterm[i], nrCompInt);
}
// rezInterm[i] += Ue[i];
rezInterm[i] = Complex.Sum(rezInterm[i], Ue[i]);
}
for(int i=0; i<nrLaturi; i++){
curenti[i] = new Complex();
for(int j=0; j<nrLaturi; j++){
// curenti[i] += Y[i][j] * rezInterm[j];
nrCompInt = Complex.Prod(Y[i][j], rezInterm[j]);
curenti[i] = Complex.Sum(curenti[i], nrCompInt);
}
}
}
}
81
- clasa pentru definit circuitul pentru metoda potentialelor de noduri
package calcule;
public class TestCircuit {
public static int[][] a =
{{-1, 1, 1, 0, 0, 0},
{ 0, 0, -1, 1, 1, 0},
{ 0, -1, 0, 0, -1, 1}};
private static double[] surse_real = {24, 0, 0, 0, 12, 0};
private static double[] surse_imag = {0, 0, 0, 0, 0, 0};
private static Complex[] Ue = new Complex[6];
public static double[] R = {20, 10, 2, 5, 7, 12};
public static double[] XL = {0, 0, 0, 0, 0, 0};
public static Complex[][] Z = new Complex[6][6];
public static Complex[][] Y = new Complex[6][6];
public static Complex[] curenti = new Complex[6];
public static int noduri = 3;
public static int laturi = 6;
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("\n\nTensiunile: \n\n\n");
for(int i=0; i<laturi; i++){
Ue[i] = new Complex(surse_real[i], surse_imag[i]);
System.out.println(Double.toString(Ue[i].Abs()) +" e_j*"+
Double.toString(Ue[i].Phase()));
}
Complex nrCompInt = new Complex(1, 0);
for(int i=0; i<laturi; i++){
for(int j=0; j<laturi; j++){
if(i!=j) Y[i][j] = new Complex();
}
Z[i][i] = new Complex(R[i], XL[i]);
Y[i][i] = Complex.Div(nrCompInt, Z[i][i]);
}
System.out.println("\n\nY: \n\n\n");
for(int i=0; i<laturi; i++){
System.out.println(Double.toString(Y[i][i].getReal()) +" +j*"+
Double.toString(Y[i][i].getImag()));
}
PotentialeNoduri pn = new PotentialeNoduri(Y, Ue, a, noduri, laturi);
curenti = pn.getCurenti();
82
System.out.println("\n\nTestCircuit\n\n\n");
for(int i=0; i<laturi; i++){
System.out.println(Double.toString(curenti[i].Abs()) +" e_j*"+
Double.toString(curenti[i].Phase()));
}
}
}
83
6.2. Metoda curenţilor ciclici
package calcule;
public class CurentiCiclici {
Complex[][] Z = new Complex[50][50];
Complex[] Ue = new Complex[50];
int[][] B = new int[50][50];
int nrOchiuri;
int nrLaturi;
Complex[] curenti = new Complex[50];
Complex[] Iprim = new Complex[50];
int[][] Btranspus = new int[50][50];
Complex[] UePrim = new Complex[50];
Complex[][] Zprim = new Complex[50][50];
Complex nrCompInt;
public CurentiCiclici( Complex[][] zMat, Complex[] ueMat, int[][] bMat,
int ochiuri, int laturi){
nrOchiuri = ochiuri;
nrLaturi = laturi;
Z = zMat;
Ue = ueMat;
B = bMat;
TransformaMatrici();
System.out.println("\n\nMatricea UePrim initiala: \n\n\n");
for(int i=0; i<nrOchiuri; i++){
System.out.println(UePrim[i]);
}
ElimGauss eg = new ElimGauss(Zprim, UePrim, nrOchiuri);
Iprim = eg.getRezultat();
CalculCurenti();
}
public Complex[] getCurenti(){
return curenti;
}
public void TransformaMatrici(){
// B transpus
for(int i=0; i<nrLaturi; i++)
for(int j=0; j<nrOchiuri; j++)
Btranspus[i][j] = B[j][i];
// BZ = B * Z
Complex[][] BZ = new Complex[50][50];
84
for(int i=0; i<nrOchiuri; i++){
for(int j=0; j<nrLaturi; j++){
BZ[i][j] = new Complex();
for(int k=0; k<nrLaturi; k++){
nrCompInt = new Complex(B[i][k], 0);
nrCompInt = Complex.Prod(nrCompInt, Z[k][j]);
BZ[i][j] = Complex.Sum(BZ[i][j], nrCompInt);
}
}
}
// Zprim = BZ * Btranspus
for(int i=0; i<nrOchiuri; i++){
for(int j=0; j<nrOchiuri; j++){
Zprim[i][j] = new Complex();
for(int k=0; k<nrLaturi; k++){
nrCompInt = new Complex(Btranspus[k][j], 0);
nrCompInt = Complex.Prod(BZ[i][k], nrCompInt);
Zprim[i][j] = Complex.Sum(Zprim[i][j], nrCompInt);
}
}
}
// UePrim = B * Ue
for(int i=0; i<nrOchiuri; i++){
UePrim[i] = new Complex();
for(int j=0; j<nrLaturi; j++){
nrCompInt = new Complex(B[i][j], 0);
nrCompInt = Complex.Prod(nrCompInt, Ue[j]);
UePrim[i] = Complex.Sum(UePrim[i], nrCompInt);
}
}
}
public void CalculCurenti(){
for(int i=0; i<nrLaturi; i++){
curenti[i] = new Complex();
for(int j=0; j<nrOchiuri; j++){
nrCompInt = new Complex(Btranspus[i][j], 0);
nrCompInt = Complex.Prod(nrCompInt, Iprim[j]);
curenti[i] = Complex.Sum(curenti[i], nrCompInt);
}
}
}
}
85
- clasa pentru definit circuitul pentru metoda curentilor ciclici
package calcule;
public class TestCircuit2 {
public static int[][] b =
{{ 1, 0, 1, 1, 0, 0},
{ 0, -1, 1, 0, 1, 0},
{ 0, 0, 0, -1, 1, 1}};
private static double[] surse_real = {24, 0, 0, 0, 12, 0};
private static double[] surse_imag = {0, 0, 0, 0, 0, 0};
private static Complex[] Ue = new Complex[6];
public static double[] R = {20, 10, 2, 5, 7, 12};
public static double[] XL = {0, 0, 0, 0, 0, 0};
public static Complex[][] Z = new Complex[6][6];
public static Complex[] curenti = new Complex[6];
public static int noduri = 3;
public static int laturi = 6;
public static int ochiuri = laturi - noduri;
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("\n\nTensiunile: \n\n\n");
for(int i=0; i<laturi; i++){
Ue[i] = new Complex(surse_real[i], surse_imag[i]);
System.out.println(Double.toString(Ue[i].Abs()) +" e_j*"+
Double.toString(Ue[i].Phase()));
}
for(int i=0; i<laturi; i++){
for(int j=0; j<laturi; j++){
if(i!=j) Z[i][j] = new Complex();
}
Z[i][i] = new Complex(R[i], XL[i]);
}
System.out.println("\n\nZ: \n\n\n");
for(int i=0; i<laturi; i++){
System.out.println(Z[i][i]);
}
CurentiCiclici cc = new CurentiCiclici(Z, Ue, b, ochiuri, laturi);
curenti = cc.getCurenti();
System.out.println("\n\nTestCircuit\n\n\n");
for(int i=0; i<laturi; i++){
86
System.out.println(Double.toString(curenti[i].Abs()) +" e_j*"+
Double.toString(curenti[i].Phase()));
}
}
}
87

Cerinţe preliminare Bazele Electrotehnicii Programarea calculatoarelor (C++ sau Java) Matematici speciale (algebră liniară, geometrie analitică, ecuaţii diferenţiale) Durata medie de studiu 1. Metode numerice pentru rezolvarea ecuaţiilor neliniare – 2 ore 2. Metode numerice pentru rezolvarea sistemelor de ecuaţii liniare – 2 ore 3. Interpolarea şi aproximarea funcţiilor – 2 ore 4. Metode pentru integrare numerică - 2 ore 5. Metode numerice pentru rezolvarea ecuaţiilor şi a sistemelor de ecuaţii diferenţiale – 3 ore 6. Rezolvarea numerică a circuitelor şi reţelelor electrice in regim staţionar sau cvasistaţionar – 3 ore

2

Cuprins
Introducere..................................................................................................................................1 1. METODE NUMERICE PENTRU REZOLVAREA ECUAŢIILOR NELINIARE...............4 1.1. Introducere.......................................................................................................................4 1.2. Competenţele unităţii de învăţare....................................................................................4 2. METODE NUMERICE PENTRU REZOLVAREA SISTEMELOR DE ECUAŢII LINIARE.....................................................................................................................................9 2.1. Introducere.......................................................................................................................9 2.2. Competenţele unităţii de învăţare....................................................................................9 2. 3. Metoda de eliminare a lui Gauss...................................................................................10 2.4. Metoda Gauss-Seidel.....................................................................................................13 3. INTERPOLAREA ŞI APROXIMAREA FUNCŢIILOR.....................................................15 3.1. Introducere.....................................................................................................................15 3.2. Competenţele unităţii de învăţare..................................................................................15 3.3. Interpolarea liniară.........................................................................................................16 3.4. Interpolarea cu funcţii Spline.........................................................................................17 3.5. Regresia funcţiilor. Metoda celor mai mici pătrate........................................................19 3.5.1. Regresia liniară.......................................................................................................20 4. METODE PENTRU INTEGRARE NUMERICĂ...............................................................23 4.1. Introducere.....................................................................................................................23 4.2. Competenţele unităţii de învăţare..................................................................................23 5. METODE NUMERICE PENTRU REZOLVAREA ECUAŢIILOR ŞI A SISTEMELOR DE ECUAŢII DIFERENŢIALE...............................................................................................28 5.1. Introducere.....................................................................................................................28 5.2. Competenţele unităţii de învăţare..................................................................................28 5.3. Metoda lui Euler.............................................................................................................29 5.4. Metoda Runge-Kutta de ordinul IV...............................................................................30 5.5. Metoda Runge-Kutta pentru sisteme de ecuaţii diferenţiale..........................................31 6. REZOLVAREA NUMERICĂ A CIRCUITELOR ŞI REŢELELOR ELECTRICE IN REGIM STAŢIONAR SAU CVASISTAŢIONAR ................................................................34 6.1. Introducere.....................................................................................................................34 6.2. Competenţele unităţii de învăţare..................................................................................34 6.3. Metoda potenţialelor de noduri......................................................................................37 6.4. Metoda curenţilor ciclici...............................................................................................40 Anexa 1.....................................................................................................................................44 Instalarea mediului de programare Eclipse...............................................................................44 Anexa 2.....................................................................................................................................49 1.1. Program bisectie -Metoda bisectiei - injumatatirea intervalului;.......................................49 Anexa 3. Programe în Java.......................................................................................................61 Bibliografie...............................................................................................................................57 Anexa 1.....................................................................................................................................58 Anexa 2.....................................................................................................................................63 Anexa 3.....................................................................................................................................75

3

1. METODE NUMERICE PENTRU REZOLVAREA ECUAŢIILOR NELINIARE

1.1. Introducere
Deoarece în cele mai multe cazuri concrete întâlnite în problemele tehnice specifice ingineriei electrice şi energetice apar modele matematice neliniare, trebuie studiată şi posibilitatea rezolvării acestora cu ajutorul unor metode specifice, prin utilizarea calculatorului. Abordarea problemelor din această perspectivă presupune adaptarea şi implementarea unor algoritmi de analiză numerică. Un astfel de capitol îl constituie metodele de rezolvare a ecuaţiilor neliniare.

1.2. Competenţele unităţii de învăţare
După parcurgerea materialului studentul va fi capabil să identifice, să explice un model de ecuaţie neliniară şi să testeze rezolvarea acesteia cu ajutorul calculatorului .

Durata medie de parcurgere a primei unităţi de învăţare este de 2 ore.

4

se numeşte ecuaţie neliniară. dacă f(a) ∙ f(c) < 0. ε. cu valori în R.Orice ecuaţie care nu se poate scrie sub forma unei funcţii liniare. unde f este o funcţie continuă. Rezolvarea unei ecuaţii neliniare presupune găsirea unui punct c din intervalul de definiţie al lui f(x). Cea mai simplă metodă de rezolvare a ecuaţiilor neliniare este metoda înjumătăţirii intervalului. Metoda înjumătăţirii intervalului Pe baza acestui principiu se poate dezvolta un algoritm de rezolvare iterativ: 5 .b] intervalul pe care se studiază problema. iar în caz contrar în intervalul [b. definită pe intervalul [a. care are proprietatea că f(c)=0. Fie [a. rădăcina se află în intervalul [a.c]. b]. Figura 1. numit rădăcina ecuaţiei.c].1. Astfel. Se restrânge intervalul în jurul rădăcinii şi se aplică acelaşi procedeu pentru noul interval de mai multe ori până când se obţine un interval în jurul rădăcinii mai mic decât o eroare admisă. Se calculează punctul c de la mijlocul intervalului şi se determină în care din cele două jumătăţi se află rădăcina. Această metodă se aplică dacă pe intervalul dat există în mod sigur o singură rădăcină. Pe acest interval există o singură radacină dacă f(a) ∙ f(b) < 0.

Figura 1.01. O altă metodă care permite rezolvarea ecuaţiilor neliniare este metoda coardei sau secantei variabile. La această metodă principiul de restrângere a intervalului este acelaşi. dar diferă relaţia de calcul a punctului c. Algoritmul de calcul la metoda înjumătăţirii intervalului Exemplu: Să se rezolve ecuaţia: ln(x) + x = 0 pe intervalul [0. 2]. care să implementeze algoritmul prezentat pentru exemplul de mai sus. punctul c se determină prin intersecţia coardei care uneşte punctele de pe funcţie de la marginile intervalului cu axa Ox.2.3: 6 . Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java). Astfel. în cadrul acestei metode. ca în figura 1.

Să se modifice programul de calcul de la metoda înjumătăţirii intervalului prin introducerea noii relaţii de calcul a punctului c. Observaţie: la metoda coardei variabile testul final.Să se rezolve sistemul de ecuaţii de mai sus şi să se determine relaţia de calcul pentru punctul c din figura 1. . determinându-l pe x: .3.Figura 1. de încetare al calculelor.3. Metoda coardei variabile Punctul c de la intersecţia coardei cu axa Ox se obţine prin rezolvarea sistemului de ecuaţii de mai jos. se va înlocui prin: |f(c)|<ε 7 .

cum putem identifica un interval în care să găsim soluţia ecuaţiei . curenţi.cum ştim în ce moment am determinat rădăcina ecuaţiei cu suficientă acurateţe? Rezumat In acest capitol am văzut: .) trec prin 0 . ca de exemplu: .cum putem testa dacă un interval este bun? . Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice. 8 .determinarea parametrilor de funcţionare a unor elemente neliniare în circuite sau reţele electrice. echipamente şi dispozitive electrice şi electronice utilizate în inginerie .determinarea momentelor de timp în care diferite mărimi (tensiuni... puteri etc. .Să ne reamintim.cum putem găsi soluţia ecuaţiei prin două metode numerice simple şi eficiente (metoda înjumătăţirii intervalului şi metoda coardei variabile).ce este o ecuaţie neliniară şi prin ce se deosebeşte de una clasică? .determinarea caracteristicilor şi a punctelor de funcţionare pe aceste caracteristici în cazul unor elemente.ce este o ecuaţie neliniară .

Introducere In multe cazuri concrete întâlnite în energetică apar modele matematice la care soluţionarea se bazează pe rezolvarea unor sisteme de ecuaţii linare cu foarte multe ecuaţii – de ordinul sutelor sau miilor. Pentru aceste sisteme rezolvarea. METODE NUMERICE PENTRU REZOLVAREA SISTEMELOR DE ECUAŢII LINIARE 2. Se consideră următorul sistem liniar cu n ecuaţii şi n necunoscute: 9 .2. 2.2. Competenţele unităţii de învăţare După parcurgerea materialului studentul va fi capabil să identifice şi să explice un model bazat pe sisteme de ecuaţii liniare şi să testeze rezolvarea acestora cu ajutorul calculatorului . In acest capitol vor fi abordate metodele de rezolvare a sistemelor de ecuaţii liniare. fără utilizarea calculatorului este imposibilă. uneori în timp real.1. Durata medie de parcurgere a unităţii de învăţare este de 2 ore.

Astfel în urma primei înmulţiri se va obţine 0 pe prima coloană. a1n   x1   b1       .metode directe la care soluţia sistemului se obţine după ce matricile sunt transformate într-o formă convenabilă (matrice unitate sau matrice triunghiulară) într-un număr finit de paşi (de regulă egal cu numărul de ecuaţii ale sistemului).. a2 n   x2   b2  ⋅ = . Deşi sunt metode aproximative.      . . Acest lucru se obţine prin înmulţirea la stânga cu o matrice M pătrată convenabil aleasă. care va fi 1.... + a2 n xn = b2 (2.metode iterative la care soluţia sistemului se obţine prin alegerea unei soluţii iniţiale aleatoare şi corectarea acesteia într-un număr de iteraţii care depinde de precizia impusă... Metoda de eliminare a lui Gauss Această metodă de rezolvare a sistemelor de ecuaţii liniare are la bază transformarea succesivă a matricii coeficienţilor astfel încât să se obţină 1 pe diagonala principală şi 0 sub diagonală. 2. an 2 . Ele se utilizează pentru sistemele cu număr foarte mare de ecuaţii.a11 x1 + a12 x2 + . 10 . + ann xn = bn Acest sistem de ecuaţii liniare se poate scrie sub formă matricială astfel:  a11   a21  . ann   xn   bn       (2. Pentru aceste sisteme există două categorii de metode de rezolvare: .  a  n1 a12 a22 . 3. iar B este vectorul termenilor liberi. datorită numărului foarte mare de operaţii.   .1 ) . an1 x1 + an 2 x2 + . cu excepţia primului coeficient. pentru sistemele dominant diagonale (la care termenii de pe diagonala sistemului sunt mult mai mari în valoare absolută decât restul termenilor) ele sunt convergente şi soluţia se obţine mult mai rapid decât în cazul metodelor directe.3 ) unde A este o matrice pătrată. în mai multe etape. Aceste metode sunt utilizate cu succes pentru sisteme la care numărul ecuaţiilor este de ordinul sutelor... X este vectorul necunoscutelor. .2 ) sau mai simplu: A⋅ X = B (2. Metodele clasice de rezolvare a sistemelor de ecuaţii bazate pe calculul determinantului nu sunt eficiente pentru sistemele mari. numită matricea coeficienţilor.   . + a1n xn = b1 a21 x1 + a22 x2 + .

In urma efectuării ultimei înmulţiri sistemul va arăta astfel:  1 a12  0 1 .  0 0  .   . pentru transformarea coloanei j a matricii A.6 ) Matricea M îşi modifică forma de fiecare dată.   . .      .   .   . matricea M se va înmulţi şi cu matricea coloană B. Forma finală a matricii M pentru coloana j este: 11 . a 2 n   x 2   b2"  ⋅ = . a nn   x n   bn'       (2.5 ) Se repetă tot acest proces până la ultima coloană. a 2 n   x 2   b2  ⋅ = . a1n   x1   b1       .      " .   . termenii matricei M se calculează după cum urmează: • matricea M va fi identică cu matricea unitate. a1' n   x1   b1'       ' . a nn   x n   bn"       (2. .   0 a' n2  . • termenul de pe diagonală va fi: m[ j ][ j ] = 1 . • pentru coloana j deasupra diagonalei termenii vor fi egali cu 0.  0 0  .'  1 a12  '  0 a 22 . a 2 n   x 2   b2'  ⋅ = . a[ j ][ j ] • termenii de sub diagonală vor fi: m[i ][ j ] = − a[i ][ j ] a[ j ][ j ] i > j. a1"n   x1   b1"       " . Pentru a nu se modifica vectorul termenilor liberi. mai puţin coloana j.4 ) După cea de-a doua înmulţire se va transforma coloana a doua: "  1 a12  0 1 .      ' . .   . . Astfel. . 1   x n   bn       (2. .

− a jj . 4. Se declară matricea pătrată A[n][n] şi vectorul termenilor liberi B[n] 2. Daca col < n se incrementează col şi se reia de la pasul 3. i = n.   . 8. 0 0 1 . Se înmulţeşte matricea M cu matricea A. se calculează vectorul X al necunoscutelor.8 x =b − a x . col = 1 3. − a jj a nj . în ordine descrescătoare. . Se înmulţeşte matricea M cu vectorul B. . . care să implementeze algoritmul prezentat pentru exemplul de mai sus.   . Rezultatul i se va atribui matricii A.7 ) în care a[i ][ j ] reprezintă elementele matricii A.  M = . Se calculează matricea M pentru coloana col. Rezultatul i se va atribui vectorului B. După ce matricea coeficienţilor a fost transformată.   0   . Exemplu: Se consideră sistemul de ecuaţii de mai jos: Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java). . 12 . altfel se trece la pasul 7 7.1  . 6. 0  . . .1 i i j =i +1 ∑ ij j ) Algoritmul poate fi descris în paşii următori: 1. a jj aij . 1   (2. Se afişează vectorul necunoscutelor x[i]. cu relaţia: n (2. 5. Se calculează vectorul necunoscutelor x[i].

Se numeşte matrice dominant diagonală matricea la care termenii de pe diagonală au valorile absolute mai mari sau cel mult egale cu suma valorilor absolute a termenilor aflaţi pe aceeaşi linie cu ei. care să implementeze algoritmul Gauss-Seidel pentru exemplul de mai jos: 4  A = 1 1  −2 3 −1 1  0 . j ⋅ x j − ∑ ai . i = 1. i =1. j ⋅ x j . Scopul este de a corecta succesiv soluţia iniţială până la obţinerea soluţiei reale a sistemului. i  j = 1 j= i+ 1   xi(k ) = (2.11) Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java). adică este îndeplinită condiţia: xi( k ) − xi( k −1) ≤ ε .9) În cazul metodei Gauss-Seidel algoritmul porneşte de la o soluţie a sistemului aleasă în mod arbitrar. n  ai .4. j =1 j≠i n i = 1.10) Algoritmul se încheie atunci când diferenţa dintre două soluţii determinate succesiv este mai mică decât o valoare impusă iniţial. Relaţia utilizată este cea de mai jos: 1  j= i− 1 (k ) j = n (k − 1)  ⋅ bi − ∑ ai. 5  3   B =  4 . Metoda Gauss-Seidel Aceste metode sunt convergente numai pentru sistemele de ecuaţii a căror matrice de coeficienţi este dominant diagonală. n (2.2. n (2. Acest lucru se exprimă matematic astfel: | aii | ≥ ∑ | aij |. de obicei soluţia nulă. 5    13 .

.ce este un sistem de ecuaţii liniare şi cum se poate exprima cu ajutorul matricilor .care este cea mai bună metodă de rezolvare şi în ce condiţii se poate folosi? Rezumat In acest capitol am văzut: . . ca de exemplu: .Să ne reamintim.cum putem găsi soluţia sistemelor de ecuaţii liniare cu ajutorul a două metode numerice simple şi eficiente (metoda de eliminare a lui Gauss şi metoda Gauss-Seidel)..ce este un sistem de ecuaţii liniare? .calculul unor probleme de câmp electromagnetic 14 . Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice.cum putem alege cea mai bună şi mai rapidă metodă de rezolvare .calculul circuitelor şi reţelelor electrice în timp real .

3. INTERPOLAREA ŞI APROXIMAREA FUNCŢIILOR 3. Competenţele unităţii de învăţare După parcurgerea materialului studentul va fi capabil să identifice şi să explice în ce anume constă interpolarea şi regresia funcţiilor şi să testeze rezolvarea acestora cu ajutorul calculatorului .1.2. Introducere La ora actuală foarte multe tehnologii utilizează noţiuni digitale. 15 . mai exact partea de interpolare şi de aproximare a funcţiilor vor fi tratate în acest capitol. Durata medie de parcurgere a unităţii de învăţare este de 2 ore. Unele din aceste metode. de aceea conversia mărimilor şi funcţiilor analogice în mărimi şi funcţii digitale şi invers necesită metode adecvate.3.

. y2). dar este cea mai rapidă pentru că efectuează cele mai puţine calcule. Cea mai simplă metodă este interpolarea liniară. Se pune problema de a determina valoarea funcţiei şi pentru alte valori intercalate între punctele date. 5. Ea prezintă dezavantajul că aproximează cel mai grosolan o funcţie prin segmente de dreaptă. Algoritmul de programare se poate reprezenta astfel: 1. Se calculează y cu relaţia de mai sus unde x1 = x[k]. 2. Aceasta constituie interpolarea. 4. se poate calcula valoarea ei pentru orice x din domeniul de definiţie. pentru a şti în care subinterval ne aflăm. Dacă se dau două puncte (x1.n-1. ci doar câteva puncte prin care trece funcţia respectivă. Se citeşte valoarea lui x în care vrem să determinăm funcţia y. y1 = y[k]. 3.3. Se declară valorile lui x şi y pentru punctele cunoscute: x[i] şi y[i] pentru i = 0.3. se procedează la liniarizarea pe porţiuni. Interpolarea liniară Atunci când se cunoaşte expresia analitică a unei funcţii y = f(x) unde x ia valori pe un domeniu. Valoarea lui j pentru care se satisface condiţia se memorează într-o variabilă k. y1) şi (x2. ecuaţia dreptei care trece prin aceste puncte este: y − y1 y2 − y1 = x − x1 x2 − x1 Cu această relaţie se poate calcula valoarea y pentru orice punct x aflat între cele două puncte x1 şi x2: y = y1 + x − x1 ⋅ ( y 2 − y1 ) x 2 − x1 In cazul în care se dau mai multe puncte. x2 = x[k+1]. In realitate de multe ori apar cazuri când nu se cunoaşte expresia analitică. STOP 16 . Se declară numărul de puncte cunoscute n. Se scrie y 7. y2 = y[k+1]. Intr-un ciclu for cu j luând valori de la 0 la n-2 se compară dacă x > x[j] şi x < x[j+1]. Astfel se iau două câte două puncte şi se aplică formula de mai sus. 6.

urmând ca în final să se treacă la coordonatele x şi y. Din cele patru condiţii se obţin coeficienţii:  a = − 2 P(1) + P ′ (1) + P ′ (0) + 2 P(0)  b = 3 P(1) − P ′ (1) − 2 P ′ (0) − 3 P(0)    c = P ′ (0)  d = P(0)  care se pot scrie sub formă matricială: 2 −2 P ′(1) ]  1  1 −3 3 −2 −1 0 0 1 0 1 0  0  0 [a b c d ] = [ P ( 0) P (1) P ′( 0) In aceste condiţii polinomul P devine: 17 . pentru a se obţine racordarea graficului.4.3. P(1). iar în spaţiu intervine şi coordonata z(t). Gradul polinomului care se obţine este cu atât mai mare cu cât numărul de puncte este mai mare. iar pentru al doilea punct să-i corespundă lui t valoarea 1. Acest lucru se poate scrie sub formă matricială astfel: t 3   2 t d] ⋅  t    1 P =[ a b c In plan un punct este reprezentat prin coordonatele x(t) şi y(t). Spre deosebire de polinoamele Lagrange. Forma generală a unui polinom de gradul III este: P(t) = at3 + bt2 + ct + d. P'(0) şi P'(1). în cazul funcţiilor Spline se lucrează cu un polinom de gradul trei pentru a accelera viteza de calcul. Interpolarea cu funcţii Spline O metodă mai precisă de interpolare este interpolarea Lagrange. Aceasta înseamnă că se cunosc P(0). Coeficienţii a. unde P'(t) este polinomul derivat: P'(t) = 3at2 + 2bt + c. c. şi din acest motiv nu se utilizează prea des. Se pot aranja lucrurile astfel încât pentru cele două puncte de la capetele unui interval să se obţină o reprezentare astfel: pentru primul punct să-i corespundă lui t valoarea 0. b. Aceasta implică un număr mare de calcule. In continuare se va lucra doar în funcţie de parametrul t. d se obţin din 4 condiţii şi anume la capetele intervalului se dau şi valorile coordonatelor punctelor şi derivatele.

3. 2. se aplică acelaşi algoritm pentru fiecare interval luat în parte. obţinându-se unghiul α . 5. Componentele polinomului derivat vor fi x' = k·cos(α ) şi y' = k·sin (α ). Valorile uzuale sunt între 1 şi 3. y(t) şi z(t). La reprezentarea în plan polinomul P este de fapt un vector cu două componente x(t) şi y(t). Se calculează x(t) şi y(t) cu ultima relaţie. iar pentru t = 1 va fi cel cu indicele i+1. Pentru punctele extreme vom avea doar un singur vecin. 6. Se calculează t = j / m 8.P ( t ) = [ P ( 0) P (1) P ′( 0) 2 −2 P ′(1) ] ⋅  1  1 −3 3 −2 −1 0 0 1 0 1 t 3  0 t 2  ⋅   0  t     0  1  In practică această relaţie se foloseşte astfel: • se dau punctele de la marginea intervalului. Se dau n puncte în care se cunoaşte funcţia Se dă numărul de puncte m în care vrem să determinăm funcţia interpolată Se calculează derivatele în punctele cunoscute Se deschide un ciclu for cu i de la 0 până la n-1 Punctul corespunzător lui t = 0 va fi cel cu indicele i. unde x(t) şi y(t) sunt componentele polinomului P(t) 9. Se închide ciclul cu i. iar la reprezentarea în spaţiu este un vector cu trei componente x(t). şi se ia unghiul respectiv. unde k se alege în urma unor încercări. (Observaţie: pentru valoarea k=0 se obţine chiar interpolarea liniară). Se deschide un ciclu for cu j de la 0 până la m 7. Se închide ciclul cu j 10. Algoritmul de interpolare cu funcţii Spline va fi următorul: 1. 11.1] • Se calculează polinomul P(t) în aceste puncte Dacă avem mai multe intervale. şi se vor lua ca atare polinoamele P şi P'. din stânga şi din dreapta. 4. Pentru calculul derivatei într-un punct se consideră dreptele care se obţin unind punctul respectiv cu cele două puncte vecine. Se face media unghiurilor acestor drepte cu axa Ox orizontală. adică P(0) şi P(1) • se dau sau se calculează derivatele la capetele intervalului P'(0) şi P'(1) • se alege un număr de puncte în care vrem să interpolăm funcţia dându-i valori echidistante lui t în intervalul [0. STOP 18 .

3).9).5. (8. y = f ( xi ) .5). Metoda celor mai mici pătrate Acest procedeu este utilizat atunci când se doreşte determinarea valorii funcţiei în interiorul sau în afara domeniului de valori pentru care au fost efectuate măsurători experimentale şi ca urmare au fost obţinute un număr de n de perechi de coordonate: ( x1 . calculate cu funcţia de aproximare: i Ca urmare se produc abaterile: d i = y i − y i . (7. logaritmică.) depinde de forma graficului funcţiei reale fiind în concordanţă cu acesta. (9. Metoda permite stabilirea unei expresii analitice pentru funcţia necunoscută. trigonometrică.8).6). i = 1. y1 ) ⋅ ⋅ ⋅ ( xn . Să se scrie un program care să implementeze algoritmul de interpolare Spline pentru exemplul de mai sus. yn ) . Metoda celor mai mici pătrate constă în determinarea valorilor acestor coeficienţi astfel încât să se obţină valoarea minimă a sumei pătratelor abaterilor. (2. n Forma funcţiei alese (polinomială. (6.2). (3. xn cât şi în afara lui. • Valorile aproximative. Principiul metodei este următorul: se presupune că s-a ales o aproximare f ( x ) a funcţiei necunoscute. i = 1. Să se calculeze funcţia interpolată pentru m = 50 şi să se reprezinte grafic punctele obţinute. (5. etc. (4. (10. 3. În acest caz se consideră două categorii ale valorilor funcţiei şi anume: • Valorile exacte. Alegerea unei expresii pentru f ( x ) presupune utilizarea unor coeficienţi reali în expresia acesteia. Regresia funcţiilor.4). care poate [ ] fi utilizată atât în interiorul intervalului conţinând determinări experimentale x1 .Exemplu: Se dau punctele: (1. adică a sumei: S = ∑ d i2 = ∑ ( yi − yi ) i =1 i =1 n n 2 19 .8). obţinute în urma măsurătorilor: y1 ⋅ ⋅ ⋅ y n .1). n .5).

Regresia liniară Forma funcţiei este următoarea: f ( x ) = a1 ⋅ x + a0 Valorile coeficienţilor a 1 şi a 0 se vor obţine punând condiţia ca suma pătratelor abaterilor să fie minimă: S = ∑ d = ∑ ( yi − a1 ⋅ x − a0 ) i =1 2 i i =1 n n 2 Condiţia de minim se obţine prin rezolvarea următorului sistem de ecuaţii:  ∂S  ∂a  1  ∂S   ∂ a0  n = 0 ∑ ( yi − a1 ⋅ xi − a0 ) ⋅ xi  ⇒  i =1 n ∑ ( yi − a1 ⋅ xi − a0 ) = 0  i =1  = 0 = 0 care este echivalent cu sistemul: n  a0 ⋅ ∑ xi   i =1   n ⋅ a0   + a1 ⋅ ∑ xi2 = + a1 ⋅ ∑ xi i =1 i =1 n n ∑x ⋅y ∑y i =1 i =1 n i i n i = ale cărui soluţii sunt:   n   n 2  n   n   ∑ yi  ⋅  ∑ xi  −  ∑ yi  ⋅  ∑ xi ⋅ yi     a0 =  i = 1   i = 1   i = 1   i = 1 2 n n   2  n ⋅ ∑ xi −  ∑ xi   i =1  i =1     n   n   n  n ⋅ ∑ xi ⋅ yi −  ∑ yi  ⋅  ∑ xi   i =1  i = 1   i =1  a = 1 2 n n   2   n ⋅ ∑ xi −  ∑ xi   i =1  i =1   20 .În continuare se prezintă modul de determinare a coeficienţilor pentru cazul unei drepte.1. 3.5.

exponenţială etc. 21 .În mod analog se procedează în cazul unei aproximări a funcţiei prin intermediul unui polinom de grad mai mare ca 1.) prin schimbări de variabile se poate aplica acelaşi procedeu pentru determinarea coeficienţilor funcţiilor. Pentru alte funcţii (logaritm. Să se determine coeficienţii dreptei de regresie prin aplicarea formulelor de mai sus pentru punctele de la exemplul anterior.

ce reprezintă interpolarea şi care sunt cele mai des utilizate metode.prelucrarea datelor experimentale obţinute în urma unor măsurători 22 . .Să ne reamintim.ce anume presupune interpolarea funcţiilor? . ca de exemplu: ..cum se pot obţine informaţii mai detaliate despre o funcţie atunci când nu se cunosc suficiente date iniţiale .cum se poate obţine o funcţie de regresie în cazul în care se doreşte obţinerea unei expresii analitice Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice.. .care este deosebirea dintre interpolare şi regresie? Rezumat In acest capitol am văzut: .citirea şi prelucrarea informaţiilor de pe caracteristicile unor dispozitive şi echipamente .

uneori imposibilă şi astfel apare necesitatea de a utiliza metodele de rezolvare numerică a integralelor definite. a valorilor efective.4. Competenţele unităţii de învăţare După parcurgerea materialului studentul va fi capabil să identifice. Durata medie de parcurgere a unităţii de învăţare este de 2 ore. METODE PENTRU INTEGRARE NUMERICĂ 4.1. In cazul în care se lucrează cu valori neregulate. 4. pentru prelucrarea graficelor de sarcină. să explice un model în care este nevoie de integrarea numerică a funcţiilor şi să testeze rezolvarea acesteia cu ajutorul calculatorului. rezolvarea pe cale analitică devine foarte greoaie. 23 . Introducere Foarte multe relaţii întâlnite în energetică utilizează integrala definită a unor mărimi electrice şi neelectrice pentru calculul valorilor medii.2.

Integrarea numerică prin metoda dreptunghiurilor 24 .In multe cazuri în care trebuie calculată integrala definită a unei funcţii. Integrala definită a unei funcţii f(x) pe un interval [a. Dacă intervalul corespunzător este [xi. Figura 4. aceasta nu se poate calcula analitic. Dezavantajele metodelor numerice de integrare constau în faptul că ele nu sunt exacte şi introduc erori. Dacă se alege valoarea din dreapta intervalului. Aceste variante se pot vedea în figura de mai jos. dar aceste erori pot fi evaluate şi minimizate pe cât posibil. O altă variantă este cea cu valoarea de la mijlocul intervalului f((xi+xi+1)/2). La metoda dreptunghiurilor se aproximează aria unei fâşii cu aria dreptunghiului corespunzător. doar numeric. echidistante pe intervalul dat.b] reprezintă aria de sub grafic. în formula de mai sus se va înlocui f(xi) cu f(xi+1). In cadrul metodelor numerice de integrare se aleg nişte puncte xi. Cea mai simplă dintre metodele de integrare este metoda dreptunghiurilor.1. şi aria graficului se împarte astfel în fâşii paralele. atunci aria dreptunghiului respectiv este: Si = ( xi +1 − xi ) ⋅ f ( xi ) în cazul în care înălţimea dreptunghiului este valoarea funcţiei din stânga intervalului. Aceste erori depind de metoda folosită. iar întreaga integrală va fi suma ariilor acestor fâşii. xi+1].

Algoritmul de integrare numerică este următorul: 1. Se deschide un ciclu for cu i de la 0 la n-1 inclusiv. Există însă o variantă de corecţie a erorii. dar va creşte şi timpul de calcul. 3. STOP Exemplu: Să se calculeze integralele următoare prin metoda dreptunghiurilor: 1. 4.b] de definiţie Se alege numărul de puncte n al reţelei şi se calculează pasul reţelei: h = (b-a) / n. In acest caz se obţine: Si = ( xi +1 − xi ) ⋅ f ( xi ) + f ( xi +1 ) 2 La metoda trapezelor precizia de calcul a integralei este mai bună decât la metoda dreptunghiurilor. Se iniţializează I = 0. O altă metodă este cea a trapezelor. 2. S declară funcţia care trebuie integrată şi intervalul [a. Se calculează xi = a + i * h şi xi+1 = xi + h. Se calculează integrala pentru două 25 . 5. Pentru a minimiza eroarea de calcul la metoda trapezelor se ţine cont de faptul că eroarea este proporţională cu h2. cu atât şi precizia va fi mai bună. Cu cât numărul de puncte alese este mai mare. ∫ sin xdx 0 π 2. ∫ 1 + x dx 0 2 1 Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java). 6. Se calculează I = I + S unde S se calculează cu una din formulele descrise mai sus. 8. Se închide ciclul. fără a efectua foarte multe calcule suplimentare. Se scrie I. caz în care aria fâşiei se înlocuieşte cu aria unui trapez. 9. 7. care să implementeze algoritmul prezentat pentru exemplul de mai sus.

n şi m. 26 . cu deosebirea că formula lui S trebuie adaptată la relaţia pentru trapeze. Algoritmul de calcul este identic cu cel de la metoda dreptunghiurilor.numere diferite de puncte. În acest mod precizia creşte simţitor. pe acelaşi interval şi pe baza celor două rezultate obţinute se calculează coeficientul de proporţionalitate al erorii. Cu valoarea obţinută se corectează rezultatul pentru una din cele două variante. Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java). care să implementeze algoritmul prezentat pentru exemplul de mai sus.

care metodă este mai bună din punct de vedere al simplităţii şi al preciziei de calcul .calculul energiei electrice în funcţie de graficul de sarcină al puterii electrice în funcţie de timp 27 .calculul valorii medii şi efective a mărimilor electrice importante (tensiunea.cum se pot corecta micile erori obţinute Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice. . ca de exemplu: .. .. - ce se înţelege prin integrala definită a unei funcţii şi care este semnificaţia ei geometrică? de ce nu se pot utiliza metodele clasice pentru majoritatea semnalelor şi funcţiilor întâlnite în energetică? în câte puncte trebuie divizat intervalul de integrare pentru a obţine o precizie suficientă? - cum se pot corecta erorile de integrare? Rezumat In acest capitol am văzut: . puterea).în ce constă rezolvarea numerică a integralei definite a unei funcţii în cazul în care expresia acesteia este neregulată sau foarte complicată. intensitatea curentului.Să ne reamintim.

2. In acest capitol vor fi abordate metodele numerice cele mai des întâlnite de rezolvare a ecuaţiilor şi a sistemelor de ecuaţii diferenţiale. Pentru aceste probleme rezolvarea.5. fără utilizarea calculatorului este imposibilă.1. uneori în timp real. Introducere In multe cazuri concrete întâlnite în energetică apar modele matematice bazate pe rezolvarea unor ecuaţii sau sisteme de ecuaţii diferenţiale. 5. O ecuaţie diferenţială se poate pune sub forma: 28 . Competenţele unităţii de învăţare După parcurgerea materialului studentul va fi capabil să identifice şi să explice un model bazat pe ecuaţii sau sisteme de ecuaţii diferenţiale şi să testeze rezolvarea acestora cu ajutorul calculatorului . Durata medie de parcurgere a unităţii de învăţare este de 3 ore. METODE NUMERICE PENTRU REZOLVAREA ECUAŢIILOR ŞI A SISTEMELOR DE ECUAŢII DIFERENŢIALE 5.

29 . 5. Metoda lui Euler Metoda constă în aproximarea graficului funcţiei într-un punct prin tangenta la grafic dusă în acel punct.3. precum şi de modul de efectuare al calculelor: .1. adică valoarea lui y la momentul t = 0. Astfel intervalul de definiţie al lui t se împarte într-un număr de subintervale cu pasul h.şi reprezintă tangenta la graficul funcţiei y(t) care trebuie determinată. Metode indirecte sau de tip predictor-corector. acest tip de metode utilizează informaţiile obţinute la două puncte determinate anterior iar calculul se efectuează printr-un proces iterativ în care relaţia de recurenţă este aplicată până la obţinerea valorii funcţiei cu o precizie impusă iniţial 5.Metode directe sau metode de tip Runge-Kutta. Metodele pot fi de două categorii. iar valorile discretizate ale lui t se vor nota cu ti. Pentru rezolvare trebuie cunoscute de asemenea condiţiile iniţiale. în funcţie de cantitatea de informaţie utilizată la deducerea valorii funcţiei într-un punct. la metodele numerice se determină valorile lui y pentru valorile discretizate ale lui t. Spre deosebire de metodele analitice la care rezolvarea înseamnă determinarea expresiei analitice. acest tip de metode utilizează numai informaţiile obţinute la punctul precedent iar calculul se efectuează prin aplicarea relaţiei de recurenţă. f (x) y m+1 L ym h xm xm+1 x Fig. Metoda lui Euler. Cunoscând tangenta la grafic se determină punctul următor şi procesul se repetă.

Aceasta determină o valoare semnificativă a erorii de trunchiere şi ca urmare gradul de precizie al metodei Euler este redus. Se calculează yi+1 cu relaţia de mai sus. Se calculează pasul h=(b-a)/n. Algoritmul de rezolvare prin această metodă se poate concretiza astfel: 1. k3.b] pentru t. k4. Se deschide un ciclu for cu i de la 0 la n-1 6.y) şi intervalul de definiţie [a. 2. 5. Metoda Runge-Kutta de ordinul IV Relaţia care determină valoarea yi+1 în funcţie de yi la metoda Runge-Kutta de ordinul IV este: unde: Eroarea la această metodă depinde h5.4. 11. Se calculează ti. Se închide ciclul. 8. 5. Se declară funcţia f(t.Formula de recurenţă se obţine din ecuaţia dreptei care trece printr-un punct şi care are tangenta cunoscută. Se calculează k1. 9. 7. 3. La metoda Euler eroarea de trunchiere poate fi apreciată ca fiind: eT = k ⋅ h 2 . Se scrie valoarea lui yi+1. STOP 30 . Se scrie condiţia iniţială y(0). Se alege numărul de puncte n 4. de aceea este foarte utilizată fiind o metodă foarte rapidă şi foarte precisă în acelaşi timp. 10. k2.

Astfel în relaţia care determină setul de valori la momentul următor de timp în funcţie de în funcţie de valorile la momentul actual de timp: yi +1 = yi + h ( k1 + 2 k 2 + 2 k 3 + k 4 ) 6 mărimile y şi k1. i = 1. k2. k4 vor fi nişte vectori: k 1. j = f j  t i + . j ) h h  k 2 . Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java). 2. dy = cos( t ) dt pe intervalul [0. dy 10 sin( 100 t ) − y = dt 0.. yi . la sistemele de ecuaţii diferenţiale.. Metoda Runge-Kutta pentru sisteme de ecuaţii diferenţiale Un sistem de ecuaţii diferenţiale se poate pune sub forma: dy i = f i (t . j   2 2 k 4 . y2 . y i . j   2 2 h h  k 3. yi .5.1] cu condiţia iniţială y(0) = 0. j = f j t i + h . j h ( ) 31 . n dt Spre deosebire de cazul unei singure ecuaţii diferenţiale.. yn ). care să implementeze algoritmul prezentat pentru exemplele de mai sus. j + k 3. k3. y1 . j = f j ( t i .01 pe intervalul [0. coeficienţii de la metoda Runge-Kutta vor fi nişte vectori cu mai multe valori (în general egal cu numărul de ecuaţii diferenţiale). 5.2π ] cu condiţia iniţială y(0) = 0. j = f j t i + . j + k 2 . j + k 1.0..Exemplu: Să se rezolve următoarele ecuaţii diferenţiale: 1. y i .

care să implementeze algoritmul prezentat pentru exemplul de mai sus. 7. Se deschide un ciclu for cu i de la 0 la n-1 6. Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java). STOP Exemplu: Să se rezolve sistemul de ecuaţii diferenţiale (corespunzătoare ecuaţiei unui circuit RLC serie alimentat cu tensiune sinusoidală la borne):  dy1 10 sin(314t ) − 5 y1 − y 2  dt =  0. Se calculează k2 10. Se închide ciclul pentru i.yj) şi intervalul de definiţie [a. 9.01   dy 2 = 1000 y 1  dt  şi să se reprezinte grafic mărimile y1 (curentul prin circuit) şi y2 (tensiunea pe condensator) în funcţie de timp. Se deschide un ciclu for cu j de la 1 la numărul de ecuaţii diferenţiale. Se calculează k3 12. Se deschide un ciclu for cu j de la 1 la numărul de ecuaţii diferenţiale. 2. Se deschide un ciclu for cu j de la 1 la numărul de ecuaţii diferenţiale.1s. Se calculează pasul h=(b-a)/n. Se scrie condiţia iniţială yi(0). Se scrie valoarea lui yi+1. 16. Se alege numărul de puncte n 4. 17. 13. pentru t de la 0 la 0.Algoritmul de rezolvare prin această metodă se poate concretiza astfel: 1. 32 . 14.b] pentru t. Se declară funcţiile fi(t. Se calculează k1 8. 11. 5. 3. 15. Se deschide un ciclu for cu j de la 1 la numărul de ecuaţii diferenţiale. Se calculează k4 Se calculează yi+1 cu relaţia de mai sus.

.rezolvarea ecuaţiilor de stare pentru sisteme dinamice 33 . - ce este o ecuaţie diferenţială fără derivate parţiale? ce rol au condiţiile iniţiale pentru rezolvarea pe cale numerică? prin ce se deosebeşte metoda de rezolvare a sistemelor de cea pentru o singură ecuaţie? Rezumat In acest capitol am văzut: .în ce constă rezolvarea pe cale numerică a ecuaţiilor şi a sistemelor de ecuaţii diferenţiale .Să ne reamintim.care este rolul condiţiilor iniţiale pentru rezolvarea acestora Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice.calculul circuitelor şi reţelelor electrice în regimuri tranzitorii . ca de exemplu: ..

Competenţele unităţii de învăţare După parcurgerea materialului studentul va fi capabil să identifice.2. rezolvarea este foarte greoaie.1. Metodele tradiţionale de rezolvare pot fi utilizate.6. REZOLVAREA NUMERICĂ A CIRCUITELOR ŞI REŢELELOR ELECTRICE IN REGIM STAŢIONAR SAU CVASISTAŢIONAR 6. dar în cazul real datorită numărului foarte mare de elemente de circuit care sunt de ordinul sutelor sau miilor. Introducere Rezolvarea circuitelor şi reţelelor electrice constituie unul din cele mai importante capitole ale ingineriei electrice şi energetice. 34 . Din această cauză se recurge la varianta numerică. 6. să explice un model de rezolvare a circuitelor sau reţelelor electrice şi să testeze rezolvarea cu ajutorul calculatorului. uneori imposibilă. Durata medie de parcurgere a unităţii de învăţare este de 3 ore.

Graful care are laturile orientate se numeşte graf orientat. Acestea din urmă alcătuiesc complementul unui arbore sau coarborele. aij = −1 • dacă latura j este incidentă la nodul i şi intră în nod. Arborele la care toate ramurile sunt incidente într-un nod comun se numeşte arbore stelat. pentru că pe fiecare coloană există un singur termen egal cu 1 şi un singur termen egal cu -1. dar nu conţine bucle. matricea completă de incidenţă A este o matrice de dimensiuni (n + 1) x l având valorile elementelor: aij = 1 • dacă latura j este incidentă la nodul i şi iese din nod. Din punct de vedere al prelucrării informaţiilor. Invers. Liniile acestei matrici nu sunt independente. iar arborele la care toate nodurile pot fi ordonate astfel încât arborele să prezinte o singură cale pornind de la primul şi terminând cu ultimul se numeşte arbore liniar. • niciun subgraf propriu al acestui subgraf cu aceleaşi noduri terminale nu are proprietăţile 1 şi 2. astfel că prin însumarea tuturor liniilor 35 . nodurile fiind unite prin laturi. Un subgraf este o submulţime de laturi şi noduri ale grafului. • cele două noduri numite terminale au incidentă o singură latură a subgrafului. Un arbore este un subgraf conex al unui graf conex care conţine toate nodurile grafului. Atunci când se dă un graf se poate spune precis care sunt laturile incidente la fiecare nod. precum şi care sunt orientările lor faţă de noduri. se poate spune despre un graf că este complet determinat dacă se cunosc aceste informaţii. Pentru un graf cu n + 1 noduri şi l laturi. Un graf poate fi reprezentat sub formă grafică sau matricială. toate celelalte noduri au câte două laturi incidente. O cale este un subgraf particular care constă dintr-o secvenţă ordonată de laturi cu următoarele proprietăţi: • cu excepţia a două noduri.Pentru a putea rezolva problemele de circuite sau reţele electrice la care numărul elementelor este ridicat trebuie să apelăm la elemente de teoria grafurilor. numite noduri. iar laturile care nu intervin în structura arborelui se numesc joncţiuni. Laturile care intervin în structura unui arbore se numesc ramuri. aij = 0 • dacă latura j nu este incidentă la nodul i. Un subgraf este conex dacă există cel puţin o cale între orice pereche de noduri. şi de segmente numite laturi. O buclă este un subgraf conex particular al grafului în care la fiecare nod sunt incidente câte două laturi ale subgrafului (sau o cale închisă). Fiecare latură a grafului are un sens şi se numeşte latură orientată. forma cea mai convenabila de prezentare este cea matricială. Laturile care intră sau ies dintr-un nod se numesc incidente la nodul respectiv. Un graf liniar este definit ca o mulţime de puncte.

bij = 0 • dacă latura j nu aparţine ochiului i. aceste relaţii între curenţi si tensiuni rezultă din legile câmpului electromagnetic. în care tensiunea este proporţională cu derivata curentului electric: u=L di dt Pentru condensatorul ideal se obţine tot o ecuaţie diferenţială în care curentul este proporţional cu derivata tensiunii electrice: i =C du dt 36 . Pentru a obţine o matrice independentă. din care l necunoscute sunt curenţii prin laturi şi l necunoscute sunt tensiunile la bornele laturilor. Cu ajutorul acestei matrici. O altă matrice care poate fi utilizată pentru a reprezenta un graf este matricea B. cea de-a doua teoremă a lui Kirchhoff se poate scrie sub formă matricială: unde matricea U este o matrice coloană ai cărei termeni sunt tensiunile electrice la capetele laturilor circuitului. cel puţin o linie poate fi eliminată.se obţine o linie cu toţi termenii egali cu 0. prima teoremă a lui Kirchhoff se poate exprima în formă matricială mult mai simplu: A⋅ I = 0 unde matricea I este o matrice coloană ai cărei termeni sunt curenţii prin laturile circuitului. unde o = l .2) se obţin în total l relaţii.n. Cu ajutorul matricei reduse. obţinându-se matricea redusă de incidenţă de dimensiuni n x l. cu dimensiunile o x l. bobina ideală sau condensatorul ideal. Pentru elemente ideale de circuit cum ar fi rezistorul ideal. Aceasta constituie închiderea sistemului de ecuaţii.1) şi (6. Pentru a putea rezolva acest sistem de ecuaţii este nevoie de relaţii între curenţii prin laturi şi tensiunile la bornele laturilor. şi are elementele: bij = 1 • dacă latura j aparţine ochiului i şi are acelaşi sens bij = −1 • dacă latura j aparţine ochiului i şi are sens contrar. Astfel pentru rezistorul ideal se obţine o relaţie de proporţionalitate între curentul prin rezistor şi tensiunea la bornele lui: B ⋅U = 0 u = R ⋅i Pentru bobina ideală se obţine o ecuaţie diferenţială. Cu ajutorul relaţiilor (6. dar numărul de necunoscute este 2l.

In cazul circuitelor de curent alternativ la care există cuplaje mutuale între laturi. Astfel dacă circuitul se află întrun regim staţionar sau cvasistaţionar. inutilă. prin alegerea convenabilă a unor mărimi drept variabile independente. şi de aceea nu este necesar să fie utilizate simultan la rezolvarea circuitelor. 37 . Dacă se consideră o singură latură a circuitului. iar restul termenilor sunt 0 .3. Rezolvarea sistemului se face însă cu ajutorul unor metode specifice. după care se pot determina şi celelalte variabile. deoarece utilizarea ambelor matrici A şi B este greoaie şi. de dimensiuni l × l şi care conţine pe diagonala principală conductanţele laturilor circuitului. 6. Aceste mărimi sunt potenţialele de noduri V’. cele două matrici fiind legate una de alta prin anumite relaţii. atunci trebuie rezolvate în primul rând ecuaţiile diferenţiale aferente circuitului. se poate scrie relaţia: B ⋅ At = 0 I k = Gk ⋅ (U ek + U k ) unde Gk reprezintă conductanţa laturii. caz în care sistemul de ecuaţii format din relaţiile obţinute pe baza teoremelor lui Kirchhoff poate fi rezolvat. Pentru circuitele electrice aflate în regim staţionar sau cvasistaţionar închiderea sistemului de ecuaţii se poate realiza deoarece între curenţii prin laturi şi tensiunile electrice la bornele laturilor există relaţii de proporţionalitate. De aceea. după cum se va arăta în continuare. (6. matricea U se poate exprima prin relaţia de mai jos: U = At ⋅V ' că vectorul V ' este un vector cu mărimi independente. sau curenţii ciclici I’.Pentru a putea efectua rezolvarea circuitelor sau reţelelor electrice se pot obţine simplificări dacă se ţine cont de regimul lor de funcţionare. care nu apar explicit ca derivate în funcţie de timp. Dacă circuitul se află în regim dinamic.2) şi ţinând cont Aceasta înseamnă cele două matrici A şi B nu sunt independente una faţă de cealaltă. care conţine o sursă de tensiune şi o rezistenţă. Această relaţie se poate generaliza sub formă matricială: I = G ⋅ (U e + U ) unde G este o matrice pătrată. rezultă: Inlocuind această relaţie în cea de-a doua teoremă a lui Kirchhoff. atunci termenii corespunzători acestor cuplaje din matricea G sunt diferiţi de 0 . atunci relaţiile diferenţiale se pot înlocui cu relaţii algebrice de proporţionalitate. se pot transforma relaţiile obţinute cu teoremele lui Kirchhoff şi se pot aşeza într-o formă echivalentă dar cu un număr mai mic de ecuaţii. Metoda potenţialelor de noduri Cu ajutorul matricii vector a potenţialelor de noduri V ' .

1) şi prin regruparea termenilor se va obţine un sistem de ecuaţii echivalent: G '⋅V ' = I ' sc unde: I ' sc = − A ⋅ G ⋅ U e G ' = A ⋅ G ⋅ At Acest sistem de ecuaţii are doar n ecuaţii şi se poate rezolva cu ajutorul metodelor numerice prezentate la unitatea de învăţare numărul 2. Se completeaza matricea A . 2. 3. Se completeaza matricile U e şi G . Se calculeaza matricea I ' cu relaţia mai sus. folosind conductanţe în locul rezistenţelor. Se calculeaza matricea G ' cu relaţia de mai sus. Un dezavantaj al metodei poate fi acela că. deoarece acest lucru conduce la o conductanţă infinită. 38 .Matricea U e va fi o matrice coloană cu l elemente care va conţine tensiunile electromotoare ale circuitului.9) şi (6. atunci termenul corespunzător matricii U e va fi 0 . Se rezolvă sistemul de acuaţii şi rezultă matricea V ' a potenţialelor de noduri. Algoritmul metodei este următorul: 1. nu poate fi utilizată pentru laturile care au rezistenţa nulă (cum ar fi de exemplu în cazul calculelor regimurilor de scurtcircuit). 5. Se calculează tensiunile la bornele laturilor U şi curenţii prin laturi şi rezultă matricea I . Aceste cazuri se pot evita însă prin reanalizarea circuitului. Prin înlocuirea relaţiilor (6. Avantajul acestei metode se poate observa în cazul circuitelor mari la care numărul nodurilor este de câteva sute sau mii. După determinarea potenţialelor nodurilor se pot obţine tensiunile la bornele laturilor şi curenţii electrici prin laturile circuitului. 6. 4. Dacă pe o latură nu există astfel de surse. deoarece termenii matricei A pot fi completaţi automat în momentul desenului circuitului.6) în relaţia (6.

V V Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java). R5 = 7. R4 = 5. 39 . . care să implementeze algoritmul prezentat pentru exemplul de mai sus. . U e5 = 1 2 . U e1 = 2 4 .Exemplu: Să se calculeze circuitul electric din figură: Valorile sunt următoarele: R1 = 2 0 R2 = 1 0 R3 = 2. R6 = 1 2 .

atunci termenii corespunzători acestor cuplaje din matricea R sunt diferiţi de 0.Dacă se utilizează ca mărimi independente curenţii ciclici I ' . Prin înlocuirea relaţiilor de mai sus în cea de-a doua teoremă a lui Kirchhoff în formă matricială şi prin regruparea termenilor se obţine un sistem de ecuaţii echivalent: R '⋅I ' =U e ' U = R ⋅ I −U e U k = Rk ⋅ I k − U ek unde: R’ = B ∙ R ∙ Bt Ue’ = B ∙ Ue Acest sistem de ecuaţii are doar o ecuaţii şi se poate rezolva cu ajutorul metodelor numerice prezentate în unitatea de învăţare numărul 2. de dimensiuni l × l şi care conţine pe diagonala principală rezistenţele laturilor circuitului. 40 . iar restul termenilor sunt 0. sau curenţii prin ochiuri. atunci matricea curenţilor prin laturi se poate exprima prin relaţia: Inlocuind această relaţie în prima teoremă a lui Kirchhoff. După determinarea curenţilor ciclici se pot obţine curenţii prin laturi şi tensiunile la bornele laturilor. In cazul circuitelor de curent alternativ la care există cuplaje mutuale între laturi. care conţine o sursă de tensiune şi o rezistenţă. nişte mărimi fictive care circulă prin ochiuri şi nu prin laturi. Această relaţie se poate generaliza sub formă matricială: unde R este o matrice pătrată. rezultă că: 6. şi ţinând cont că vectorul I ' este un vector cu mărimi independente. se poate scrie relaţia: unde Rk reprezintă rezistenţa laturii. atunci termenul corespunzător matricii U e este 0 . Metoda curenţilor ciclici I = Bt ⋅ I ' A ⋅ Bt = 0 Dacă se consideră o singură latură a circuitului. Matricea U e este o matrice coloană cu l elemente care conţine tensiunile electromotoare ale circuitului. Dacă pe o latură nu există astfel de surse.4.

4. t 6. Se rezolvă sistemul de acuaţii şi rezultă matricea I ' . Se calculează curenţii prin laturi cu ajutorul matricilor B şi I ' şi rezultă matricea I . 3. Se calculeaza matricea U e ' cu relaţia sus. Să se scrie un program de calcul (utilizând limbajul de programare C++ sau Java). 41 . Se calculeaza matricea R ' cu relaţia de mai sus. Se completeaza matricile U e şi R . 5. Se completeaza matricea B .Algoritmul metodei este următorul: 1. care să implementeze algoritmul prezentat pentru exemplul de mai sus. 2.

.. respectiv curent alternativ Cunoştinţele dobândite ne vor permite să abordăm numeroase probleme tehnice.care sunt particularităţile regimurilor staţionar şi cvasistaţionar faţă de regimul de funcţionare dinamic .Să ne reamintim.care sunt avantajele şi dezavantajele celor două metode de rezolvare a circuitelor în regim staţionar şi cvasistaţionar corespunzătoare cazurilor de curent continuu. - Care este principalul inconvenient în rezolvarea circuitelor şi reţelelor mari prin metode tradiţionale? Care este principalul avantaj al regimului de funcţionare staţionar sau cvasistaţionar faţă de regimul dinamic de funcţionare? Ce matrice este utilizată la metoda potenţialelor de noduri? Ce matrice este utilizată la metoda curenţilor ciclici? Rezumat In acest capitol am văzut: . calcul al pierderilor de energie etc. ca de exemplu rezolvarea numerică a circuitelor şi reţelelor electrice care stau la baza numeroaselor probleme de proiectare. dimensionare.în ce constă abordarea modernă a rezolvării circuitelor şi reţelelor electrice cu ajutorul calculatorului . 42 .

Editura Universităţii Transilvania din Braşov. A guide for Java Developers. Manning Publications Co. 1999. Eclipse in Action. 4. D.. Sorea. Gallardo. R. C. Lungoci. D.... Metode numerice. – Metode Numerice cu Aplicaţii în Ingineria Electrică. 2003. Popa M. Militaru R.. Scutaru G. ISBN 978-973-598507-3 2. Editura Universităţii Transilvania Braşov. Editura Sitech 2001. G. 1. McGovern. Popa A.. 2009. 3. Notiuni de Analiza Numerica. E. Greenwich. Scutaru.Bibliografie. 43 . Burnette.

In cazul în care sunt erori de compilare acestea sunt depistate imediat şi Eclipse 44 . In mediul de programare Eclipse există un compilator Java care realizează automat etapa de compilare. La pornire trebuie să se aleagă un folder în care se stochează fişierele (fişierele cu sursele programelor.org/downloads se alege Eclipse Classic pentru platforma Windows. care prezintă avantajul că este oferit gratuit utilizatorilor.eclipse. el poate fi descărcat de la adresa http://java. Pentru ca programul Eclipse să poată fi rulat. Fig.exe. cele rezultate în urma compilării etc).com/javase. Se despachetează fişierul .zip. Descărcarea şi instalarea De pe Internet. Lansarea programului eclipse.sun. de la adresa http://www. cu diverse facilităţi. Crearea unui proiect Java Un proiect Java conţine codul sursă şi fişierele aferente pentru un program Java. Se lansează aplicaţia Eclipse prin accesarea programului executabil eclipse. 1. Dacă acesta nu este instalat. pe măsură ce fişierele sursă sunt modificate. Unul dintre cele mai utilizate este Eclipse. cunoscut sub numele de Java SDK (Java Software Development Kit).Anexa 1 Instalarea mediului de programare Eclipse Pentru programatorii Java există foarte multe medii integrate de programare.exe. este necesară existenţa mediului de dezvoltare Java.

45 . Fig. In fereastra care se va deschide. La al treilea pas nu se fac modificări.oferă totodată sugestii pentru remedierea lor. se face doar click pe Finish. In unele cazuri poate realiza automat repararea lor prin dublu click. Laborator1). Crearea unui nou proiect în Eclipse. 3. Fig. La al doilea pas se va da numele proiectului (ex. 2. Crearea unui proiect nou – pasul 1. şi se face click pe Next. la primul pas se lasă nemodificată opţiunea Java Project (figura 3) şi se face click pe Next.

Fig. Se recomandă ca numele pachetelor să fie scris cu litere mici. Crearea unui proiect nou – pasul 2. Fig. 5. Crearea unui nou pachet. Crearea unui pachet Un pachet (package) poate conţine una sau mai multe clase Java. In fereastra care se va deschide se tastează numele pachetului. 4. După tastarea numelui se apasă Finish. 46 . Apartenenţa mai multor clase Java la acelaşi pachet le oferă variabilelor interne mai multă vizibilitate între ele. In acest moment un proiect nou a fost creat şi urmează definirea programului Java. Acesta poate fi organizat într-unul sau mai multe pachete (pentru programele mari şi complexe).

De aici se accesează Tutorials. Cel mai uşor exemplu se află în secţiunea Help a mediului Eclipse. Accesarea tutorialului – pasul 2. Se alege submeniul Welcome. 6. Accesarea tutorialului – pasul 1. Fig. Din fereastra care se va deschide se alege Create a Hello World application. 47 . 7. Fig.Crearea unei clase Pentru a scrie primul program trebuie definită prima clasă.

48 . Accesarea tutorialului – pasul 3.Fig. 8.

e100: c=(a+b)/2. scanf("%lf". &a). Program bisectie -Metoda bisectiei . double f(double x) { return log(x)+x. if (f(a)*f(c)<0) b=c. de iteratii este m = %d\n\n". printf("\n\n Nr. } } void main() { printf("\n a="). if (fabs(b-a)>e) goto e100. &b). if (f(a)*f(c)==0) return. bisect(). } 49 . if (f(a)*f(c)>0) a=c. printf("\n\n Radacina calculata este x = %f\n".c. exit(1). m++.h> #include <stdlib. } if (f(a)*f(b)<=0) { m=0.c).injumatatirea intervalului.1.h> #include <stdio.m). scanf("%lf". printf("\n b=").h> double e=1e-7.Anexa 2 Programele în C++ 1.h> #include <math.a. #include <conio. int m.b. } void bisect() { if (f(a)*f(b)>0) { printf("\n Interval gresit!").

else b=c. if (f(c)==0) { cout<<"Radacina exacta este:"<<c.h> #include <conio. cin>>a. } else while (fabs(f(c))>=error) { c=a-f(a)*(b-a)/(f(b)-f(a)). float f(float x) { return x+log(x).2.h> float a. c=a. if (f(a)*f(b)>0) { cout<<"Intervalul este gresit!". getch(). } 50 .coarda variabila. exit(1). error=1e-7.error.c. } cout<<"Radacina (cu eroarea data "<<error<<") este:"<<c.b. #include <stdlib. cout<<"b=". cin>>b. } else if (f(a)*f(c)>0) a=c. exit(1).1.h> #include <math. } void main() { cout<<"a=".h> #include <iostream. Program secanta -Metoda secantei .

1.h> #include <math.float A[10][10]. for (i=1.int colB. clrscr().j<=coloana.Aux[10][10]. void produs_matrici(int linA.Bux[10].k.i++) cout<<X[i]<<" ".i++) //linA-nr linii mat A for (j=1.i++) { for (j=1.2.h> float A[10][10]. Program sisteme ecuatii liniare -Metoda Gauss-Jordan. cout<<"Matrix A:". float X[10][10]) { int i.int coloana.j++) //colB-nr linii in B M[linA][colB] { M[i][j]=0. } } void afisare_sir(int limita. cout<<endl.j.M[10][10]. } void main () { int i.j++) cout<<X[i][j]<<" ". for (i=1.i++) 51 .B[10].X[10]. } } void afisare_matrici(int linie. cout<<"\nNumber of equations:".n.i<=limita.i<=linA.h> #include <conio. for (k=1.int colA.j. for (i=1.float M[10][10]) { int i.float X[10]) { int i.k++) M[i][j]+=A[i][k]*B[k][j].i<=linie. cin>>n.k. //colA-nr coloane mat A = nr de linii din mat B for (i=1.float B[10] [10].j<=colB.j.i<=n. #include <iostream.k<=colA. cout<<endl.

i<=n. //Se inchide ciclul col } //Calcul solutie X for(i=n. //Inmultire M A produs_matrici(n.j<=n.i<=n.i+3).i++) for(j=1.i<=n.i<=n. //Inmultire M B for(i=1.j++) A[i][j]=Aux[i][j].Aux).col<=n.j++) 52 .j<=n.n.A.k++) Bux[i]+=M[i][k]*B[k]. } //Atribuire rezultat lui B for(i=1.j++) M[j][col]=-A[j][col]/A[col][col].col++) { //Construire matrice M for(i=1.i>=1.k<=n.j<=n.j<=n.i++) B[i]=Bux[i].i++) { gotoxy (j*5+1. cin>>A[i][j]. for (k=1. cin>>B[i].i--) { X[i]=B[i].i+6+n). for (i=1.i++) { Bux[i]=0. } cout<<"Matrix B: "<<endl. } for(int col=1.n.M.i++) for(j=1. for(j=i+1.j++) M[i][j]=(i==j)?1:0. //Atribuire rezultat lui A for(i=1.j<=n. for(j=col+1.j++) { gotoxy (j*5+1.i<=n. M[col][col]=1/A[col][col].for (j=1.

X[i]-=A[i][j]*X[j]. } 53 .i<=n. } //Afisare X for(i=1.i++) cout<<"X"<<i<<"="<<X[i]<<endl.

480y[i+1]/y_max*480).j++) { if((xx[i]>x[j])&&(xx[i]<x[j+1])) k=j.7. int i. gmode. } 54 .9.h> #include <conio.h> #include <math.24. initgraph(&gdriver.7. double xx[5]={1.8.4.9.h> int x[10]={1.480-yy*48. yy=y[k]+(xx[i]-x[k])/(x[k+1]-x[k])*(y[k+1]-y[k]). getch().h> #include <stdio.j.5. } double x_max=10.5.3. "c:\\Borlandc\\bgi").i<=4.1}.5.h> #include <stdlib. for(i=0.3. errorcode.1. &gmode. } circle(xx[i]*64.yy.2.x[i+1]/x_max*640.2).6.8. void main(void) { int gdriver = DETECT. int y[10]={9.2. closegraph(). Program interpolare – Interpolarea liniara.i++) line(x[i]/x_max*640. #include <graphics.8.i<=n-2.6.j<=n-2.8.y_max=10.i++) { for(j=0.k.63.480-y[i]/y_max*480. for(i=0.5.4.31}.4.3.10}.25.n=10.

eroare. i<=n.h> #include <conio. y[5]= 4. alfa2. x[6]= 6. i++) { if(i>1) v1=(y[i]-y[i-1])/(x[i]-x[i-1]). x[3]= 3. double xt[100]. dx. #include <stdio.h> #include <stdlib. yd[i]=k*sin(alfa). x[4]= 4. y[9]= 5. dy. double ax. y[11]. yd[11]. y[1]= 9. x[5]= 5. ay. x[2]= 2.h> #include <graphics. v2. double alfa1. xd[i]=k*cos(alfa). y[3]= 5. x[10]= 10. cy. yt[100].h> int i. void main() { //Declarare puncte cunoscute: x[1]= 1. double x[11]. v1. else v1=(y[i+1]-y[i])/(x[i+1]-x[i]). bx. double t. m=50. k=2. //Calcul derivate in punctele cunoscute: for(i=1. y[8]= 3. y[7]= 2. x[9]= 9.j. alfa2=atan(v2). mode.3. else v2=(y[i]-y[i-1])/(x[i]-x[i-1]). Program interpolare – Interpolarea Spline.color. if(i<n) v2=(y[i+1]-y[i])/(x[i+1]-x[i]). cx. y[2]= 8. x[7]= 7. alfa1=atan(v1). } // GRAFICE: //Cerere auto-detectare driver mod grafic: int driver = DETECT. xd[11]. y[4]= 8.2. n=10. y[6]= 6. alfa.h> #include <math. y[10]= 1. x[8]= 8. by. //Initializare mod grafic: 55 . alfa=(alfa1+alfa2)/2.

} //j } //i //Inchidere mod grafic: getch(). dy = y[i]. &mode. exit(1).initgraph(&driver. x(t): ax = -2*x[i+1] + xd[i+1] + xd[i] +2*x[i]. bx = 3*x[i+1] . 480-yt[j]/10*480. xt[j]=ax*t*t*t + bx*t*t + cx*t +dx. getch(). dx = x[i].2*xd[i] -3*x[i]. yt[j]=ay*t*t*t + by*t*t + cy*t +dy. closegraph(). //Citire rezultat initializare: eroare = graphresult(). by = 3*y[i+1] . //Calcul coeficienti pt.xd[i+1] . cy = yd[i]. "C:\\borlandc\\bgi").yd[i+1] . //terminare cu eroare de cod } //Algoritmul de interpolare: for(i=1. j++) { t=(double)j/m. putpixel(xt[j]/10*640. WHITE). }//main 56 . if (eroare != grOk) //aparitie eroare { printf("Eroare grafice: %s\n". j<=m. i++) { //Calcul coeficienti pt. i<10.2*yd[i] -3*y[i]. printf("Apasa orice tasta pentru oprire:"). y(t): ay = -2*y[i+1] + yd[i+1] + yd[i] +2*y[i]. for (j=0. grapherrormsg(eroare)). cx = xd[i].

cout<<"\nMetoda trapezului: Valoare integrala:"<<integral2. } 57 . S1[i]=(x[i+1]-x[i])*funct(x[i]). n=50. } cout<<"\nMetoda dreptunghiului: Valoare integrala:"<<integral1. } for(i=0. i. } void main(void) { double h. cout<<"\nLimita maxima a domeniului". int n. integral1. integral1=integral1+S1[i]. x[i+1]=x[i]+h. for(i=0. integral2=0.h> double funct(double x) { return sin(x). S2[i]=0. integral2. integral1=0. #include <stdio. getch().1. S2[i]=(x[i+1]-x[i])*((funct(x[i])+funct(x[i+1]))/2).i<n. cout<<"\nLimita minima a domeniului:". cin>>a. integral2=integral2+S2[i].h> #include <iostream. cin>>b.4. x[60].h> #include <conio. Program integrare – Integrare numerica.h> #include <math. b. a.i<n.i++) { S1[i]=0.i++) { x[i]=a+i*h. S1[60]. h=(b-a)/n. S2[60].

Program ecuatii diferentiale -Metoda Runge-Kutta ordin 4. //Pas de calcul for(int i=0. double h. } 58 . k1=f(t.h> double f(double t. k4.1. } getch(). k1. //Pentru verificare se afiseaza si solutia analitica sin(t+h) // Daca e corect calculul atunci ele trebuie sa fie egale (cel putin // 5 sau 6 zecimale cout<<y<<sin(t+h)<<endl. #include<iostream. k2=f(t+h/2.y+k1*h/2). //Valoare initiala y=0 //Numarul de puncte de esantionare n=100. k4=f(t+h. } void main() { //Definire interval [a. n. double y) { return cos(t). k2.b] double a=0. y+k3*h).y+k2*h/2).y). k3. h=(b-a)/n. t. y+=h/6*(k1+2*k2+2*k3+k4).5. y. k3=f(t+h/2.i++) { t=a+i*h.h> #include<math. b=M_PI .h> #include<conio.i<n.

k32.k42.i++) { t=i*h.t.5.h> float a=0. float y2) { return 1000*y1. //Returnare cu cod de eroare } h=(b-a)/n. grapherrormsg(errorcode)).h> #include<graphics.k21.i<n-1. exit(1). float h. for(i=0.k41. } float f2(float t.float y1.float y1.1.h> #include<conio.k22. int i.k31. &gmode.y2[100]. //Citire rezultat intializare errorcode = graphresult(). Program sistem de 2 ecuatii diferentiale -Metoda Runge-Kutta ordin 4.n=90. y2[0]=0. int gdriver=DETECT.2. float b=0. //Initializare mod grafic initgraph(&gdriver. } void main() { clrscr(). getch(). "c:\\borlandc\\bgi").01. float y1[100]. 59 . gmode.h> #include<iostream.h> #include<stdlib. errorcode. y1[0]=0. float y2) { return (10*sin(100*M_PI*t)-5*y1-y2)/0. #include<math.h> #include<stdio.k11.k12. printf("Press any key to halt:"). if (errorcode != grOk) //Aparitie eroare { printf("Graphics error: %s\n". float f1(float t.

} } getch(). line(t/b*640.y1[i]+k21*(h/2).y1[i]+k31*h.y1[i]. 240-y1[i]/50*240.y2[i]+k32*h). 240-y2[i]/100*240. if(i>0) { line(t/b*640.y1[i]+k21*(h/2). 240-y1[i+1]/50*240).y2[i]+k22*(h/2)). k42=f2(t+h. k31=f1(t+h/2. 240-y2[i+1]/100*240). k12=f2(t. y2[i+1]=y2[i]+h/6*(k12+2*k22+2*k32+k42).y2[i]). } 60 .k11=f1(t.y2[i]+k12*(h/2)). k41=f1(t+h.y1[i]+k11*(h/2).y2[i]+k12*(h/2)). k22=f2(t+h/2.y2[i]+k32*h).y1[i]. (t+h)/b*640. y1[i+1]=y1[i]+h/6*(k11+2*k21+2*k31+k41). k21=f1(t+h/2. (t+h)/b*640.y2[i]+k22*(h/2)). closegraph().y1[i]+k11*(h/2).y2[i]).y1[i]+k31*h. k32=f2(t+h/2.

Metoda injumatatirii intervalului package ecuatiineliniare.Anexa 3. } else { a=c. c. public class Bisectie { public static double f(double x){ return Math.toString(c)).1. } else { System. System.out. } } while(Math.001. Ecuatii neliniare. } } } 61 .println("Radacina = "+Double. if(f(a)*f(c)<0){ b=c. System. eps = 1e-6.println("Interval ales gresit!!!"). b=2.log(x) + x.println("Metoda injumatatirii intervalului").out.abs(f(c))>eps). Programe în Java 1. if(f(a)*f(b) < 0){ do{ c = (a + b)/2.out. } public static void main(String[] args) { // TODO Auto-generated method stub double a = 0.

001. eps = 1e-6.out. System.println("Interval ales gresit!!!"). c. } else { System.f(a)/(f(b)-f(a))*(b-a). System. if(f(a)*f(c)<0){ b=c.2. } } } 62 . Metoda coardei variabile package ecuatiineliniare. } public static void main(String[] args) { // TODO Auto-generated method stub double a = 0.toString(c)).abs(f(c))>eps).println("Radacina = "+Double. public class SecantaVariabila { /** * @param args */ public static double f(double x){ return Math.out. } else { a=c.out.println("Metoda coardei variabile"). b=2. if(f(a)*f(b) < 0){ do{ c = a .log(x) + x.1. } } while(Math. Ecuatii neliniare.

j<n. 5. double[] b = {11. 32. double[] x= new double[5]. x. 9. j. i<n. 4. a_aux. i++){ for(j=0. 7}}. 8}. j++){ a_aux[i][j] = 0. pas++){ // se construieste matricea m pentru pasul pas for(i=0. // pentru pas de la primul pana la ultimul for(pas=0. 0. } m[pas][pas]=1/a[pas][pas]. Sisteme ecuatii. 63 . // se declara variabilele m. k. 4}. for(i=pas+1. 8}. i++) for(j=0. {2. i++) m[i][pas] = -a[i][pas] / a[pas][pas]. 18. for(k=0.2. n int i. pas. j<n. 6. 3}. n=5. // se inmulteste matricea m cu a for(i=0. pas<n. j++) a[i][j] = a_aux[i][j]. {5. {7. i++) for(j=0. j++) m[i][j] = 0. Metoda eliminării lui Gauss package sisteme. k. k<n. 2. 8. k++) a_aux[i][j] += m[i][k] * a[k][j]. i<n. 4. pas. b_aux double[][] m= new double[5][5]. j.1. } // rezultatul se va atribui lui a for(i=0. j<n. double[] b_aux= new double[5]. 1. 3. 3. 25. 5. 23}. double[][] a_aux=new double[5][5]. 1. 9. i<n. 2. i<n. m[i][i] = 1. // se declara variabilele i. public class EliminareGauss { public static void main(String[] args) { // se declara matricile a si b ca date de intrare double[][] a = {{1. {2.

for(i=0. i<n.out.dupa pasul "+ Integer.println("\nMatricea A .toString(a[i][j])). i++) System. j<n.out. // se calculeaza vectorul x for(i=n-1.println("\nMatricea A . j++) System.forma finala:"). i<n. k<n.println(b[i]). k++) b_aux[i] += m[i][k] * b[k].out. for(i=0. i--){ x[i] = b[i].out.print("\n").println("\nMatricea B . for(j=i+1. for(i=0.print(a[i][j] + "\t"). } } 64 . i<n.out.System. // se trece la pasul urmator } // se afiseaza matricile a si b transformate System.out. } // se afiseaza vectorul x System. i++) System.out. j<n.out. i++) b[i] = b_aux[i]. i<n. i++){ for(j=0.println(x[i]).println("Solutia sistemului:\n").print("\t"+ Double. for(i=0.toString(pas)). System. j++) System. i++){ b_aux[i] = 0.print("\n").forma finala:"). System. j<n. } System. i++){ for(j=0. i<n. for(k=0.out. } // rezultatul se va atribui lui b for(i=0. } // se inmulteste matricea m cu b for(i=0. i<n. i>=0. j++) x[i] -= a[i][j] * x[j].out.

i++){ 65 . k=0. // se incepe procesul iterativ pana cand se ajunge intr-o vecinatate // in jurul solutiei mai mica decat eps do{ k++. for(j = 0.out. i<3. // se afiseaza solutia ecuatiei System. public class GaussSeidel { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub double[][] a = {{4.2. j++){ if(i!=j){ x[i] -= a[i][j] / a[i][i] * x[j]. j. } } System. -2. } } // se evalueaza diferenta valorilor dintre doua iteratii // si se compara cu eroarea maxima if(eroare < Math.toString(eroare)).toString(k)+ ": Eroarea maxima: "+ Double. {1. double[] b = {3. x_aux. i<3.println("Iteratia "+Integer. for(i=0. 3. for(i = 0. 5}. j<3. double[] x = {0. } while(eroare > eps).println("Solutia sistemului. -1. Metoda Gauss-Seidel package sisteme. 0}. int i. 1}.x_aux). i++){ // se pastreaza valoarea de la iteratia precedenta x_aux = x[i].abs(x[i] .abs(x[i] . 0. 5}}.2. 0}. Metoda Gauss . // se calculeaza valoarea lui x pentru noua iteratie x[i] = b[i]/a[i][i]. Sisteme ecuatii. eroare = 0. {1.x_aux)){ eroare = Math. 4.out. double eps = 1e-9. eroare=0.Seidel:").

out. } } } 66 .println(x[i]).System.

2. 0. } public Spline(){ bodySpline(). -2. double xx. 3. } int getNrPuncte(){ return nrPuncte. Interpolare Spline package interpolare. bodySpline(). {1. double[] M23 = new double[4]. 0}}. 1}. Se da numarul de puncte m în care determinam functia interpolata int m=50. 0. 10}. yy. int nrPuncte. -3. 8. double[] M3 = new double[4]. 6. } public void bodySpline(){ double[][] M1 = new double[2][4].3. 6. // Se calculeaza derivatele în punctele cunoscute 67 // . 5. public class Spline { // Se dau n puncte în care se cunoaste functia double[] x = {1. {-2. 2. double[] y = {9. 0}. 1. 4. int n=10. double[] yArray = new double[500]. -1. 0. 8. 3.1. 5. 5. double[][] M2 = {{2. double coef=2. } public Spline(double s){ setCoef(s). } void setCoef(double s){ coef = s. } double getCoef(){ return coef. 0}. 1}. 3. int crt=0. {1. 7. 8. double[] xArray = new double[500]. 9. void setNrPuncte(int nr){ nrPuncte = nr. 4.

// Se deschide un ciclu for cu j de la 0 pâna la m for(int j=0. } // Se deschide un ciclu for cu i de la 0 pâna la n-1 for(int i=0. M1[1][2]=yp[i]. unde x(t) si y(t) sunt componentele // polinomului P(t) for(int k=0. M1[0][1]=x[i+1]. else alfa = (alfa1 + alfa2)/2. yy += M1[1][k]*M23[k]. i++){ if(i>0) alfa1 = Math. M1[1][0]=y[i]. } xArray[crt] = xx. k<4. iar pentru t = 1 // va fi cel cu indicele i+1. k<4. for(int i=0. double[] xp = new double[10]. M1[0][3]=xp[i+1]. M1[0][2]=xp[i].cos(alfa).double alfa1=0. l++){ M23[k] += M2[k][l]* M3[l]. i<n. M1[1][3]=yp[i+1].(x[i]-x[i-1])). double alfa=0. M1[0][0]=x[i]. // Se calculeaza x(t) si y(t) cu ultima relatie. yy = 0.atan2((y[i]-y[i-1]). j++){ // Se calculeaza t = j / m double t=(double)j/m. i++){ // Punctul corespunzator lui t = 0 va fi cel cu indicele i. for(int l=0. k++){ xx += M1[0][k]*M23[k]. double alfa2=0. k++){ M23[k]=0. M3[3] = 1.sin(alfa). M1[1][1]=y[i+1]. yp[i] = coef*Math.(x[i+1]-x[i])). for(int k=0. si se vor lua ca atare polinoamele P si P'. if(i==0) alfa = alfa2. M3[2] = t. 68 . M3[0] = t*t*t. } } xx = 0. else if(i==(n-1)) alfa = alfa1. double[] yp = new double[10]. if(i<(n-1)) alfa2 = Math. i<(n-1).atan2((y[i+1]-y[i]). l<4. j<m. xp[i] = coef*Math. M3[1] = t*t.

crt++. } setNrPuncte(crt).toString(sp. i<sp. // Se închide ciclul cu j } // Se închide ciclul cu i.getNrPuncte(). } public static void main(String[] args) { // TODO Auto-generated method stub Spline sp = new Spline(). for(int i=0.println(Double.toString(sp.yArray[i])). } } } 69 .yArray[crt] = yy.out. i++){ System.xArray[i])+"\t"+ Double.

System.println("Rezultatul = "+ Double. } } 70 . i++){ x = a + i*h.toString(integrala)). if((i%2)==0){ integ2 += (fct(x) + fct(x+2*h)) / 2. i<n. return rez. integ2 *= 2*h.out.integ2)/3)). double integ2 = 0.println("Rezultatul corectat = "+ Double. System. double integrala=0.sin(x).4. public class Trapez { /** * @param args */ public static double fct(double x){ double rez.println("Rezultatul 2 = "+ Double. rez = Math.out. } public static void main(String[] args) { // TODO Auto-generated method stub int n=500. double a=0. } } integrala *= h.out.toString(integrala + (integrala . double h=(b-a)/n.PI. double x. Integrala prin metoda trapezelor package integrare. integrala += (fct(x) + fct(x+h)) / 2. for(int i=0.toString(integ2)). double b=Math. System.

yArray[i] = y.5. tf = 0. L = 0.t) / n. y += h/6 * (k1+2*k2+2*k3+k4). y=0. k4.println(Double. h = (tf . Metoda Runge-Kutta pentru o ecuatie package ecuatiidiferentiale.1. y+k3*h).1. i++){ System. } } public static void main(String[] args) { // TODO Auto-generated method stub RungeKutta rk = new RungeKutta(). y). Ecuatii diferentiale.001.toString(RungeKutta. k2 = f(t+h/2.toString(RungeKutta. i++){ t = i*h. k2. y+k1*h/2). k1 = f(t. k3 = f(t+h/2. return (u(t) . i<n.1. k1. static double[] yArray = new double[100]. xArray[i] = t+h. i<rk. h.yArray[i])). double y){ double R = 0.xArray[i])+"\t"+ Double. double t = 0. } public static double f(double t. for(int i=0. public class RungeKutta { int n=100. k4 = f(t+h. } public RungeKutta(){ int i. return 10*Math.sin(2*Math.R*y)/L. k3. static double[] xArray = new double[100]. y+k2*h/2). for(i=0. public static double u(double t){ double frecventa = 50.out.n. } } } 71 .PI*frecventa*t).

j<nrEc.002. double[] y={0. L = 0. double[] k1=new double[2]. y[1]+k2[1]*h/2). i<n. double. C=0. j++){ k2[j] = f(j. static double[][] yArray = new double[2][100]..002.a[1])/L.2. t+h/2. } public static double f(int nrFct. double t = 0. j<nrEc. y[1]).1. } for(int j=0. case 1: rez = (u(a[0]) . for(i=0.5. } 72 . j++){ k3[j] = f(j. static double[] xArray = new double[100]. h. tf = 0. j++){ k1[j] = f(j. int n=100. double[] k4=new double[2]. switch(nrFct){ case 0: rez = a[2]/C. for(int j=0. i++){ t = i*h.sin(2*Math. } return rez. double[] k3=new double[2]. static int nrEc = 2.PI*frecventa*t).t) / n.R*a[2] . a ){ double rez=0. double[] k2=new double[2]. j<nrEc. break. public class SistemRK { /** * apelul functiei cu numar variabil de parametri (necesita JRE > 1. return 10*Math.5) */ static double R = 1. h = (tf . y[0]+k1[0]*h/2. break. t+h/2. } for(int j=0.. 0}. public static double u(double t){ double frecventa = 50. y[0]+k2[0]*h/2. Metoda Runge-Kutta pentru sistem de 2 ecuatii diferentiale package ecuatiidiferentiale. y[0]. } public SistemRK(){ int i. t. y[1]+k1[1]*h/2).

} } public static void main(String[] args) { // TODO Auto-generated method stub SistemRK srk = new SistemRK(). j++){ k4[j] = f(j. y[1]+k3[1]*h).toString(SistemRK.out. i<srk.yArray[0][i])+"\t"+ Double. i++){ System.for(int j=0. } for(int j=0. t+h. j<nrEc. j<nrEc.xArray[i])+"\t"+ Double. j++){ y[j] += h/6 * (k1[j]+2*k2[j]+2*k3[j]+k4[j]). for(int i=0.toString(SistemRK.yArray[1][i])).n. } xArray[i] = t+h.toString(SistemRK.println(Double. } } } 73 . yArray[j][i] = y[j]. y[0]+k3[0]*h.

public class Complex { private double real.clasa pentru numere complexe package calcule. } public double getReal() { return real. imag = 0.real = real. public Complex() { real = 0. faza). faza). } public String toString() { if (imag == 0) return real + "". } public void setImag(double imag) { this. this." + (-imag) + "j". boolean polar){ if(polar){ real = Complex. } 74 . } public Complex(double modul.XCart(modul.imag = imag. double imag) { this. imag = Complex. double faza.YCart(modul. private double imag.imag = imag.6. } public Complex(double real.1. if (imag < 0) return real + " . return real + " + " + imag + "j". if (real == 0) return imag + "j". Metoda potenţialelor de noduri . } } public double getImag() { return imag.

result.getImag() + a.getImag() . Complex b) { Complex result = new Complex(0.getImag() * b.getImag()).getReal() + a.getReal() + b.0). 75 .getImag()) ). Complex b) { Complex result = new Complex(0. return result.getReal()*b. return result.public void setReal(double real) { this.getImag() + b.getImag()*b.a.setImag(a.0). } public static Complex Prod(Complex a. result.getImag()*b.getReal() . } public static Complex Diff(Complex a. } public static Complex Sum(Complex a.getReal() * b.setReal(a.getReal()). return result.getImag()). result.setReal((a.getReal()).getReal() + b.getImag()). result.getReal()*b.getReal()). result. Complex b) { Complex result = new Complex(0.getImag() * b.b.setReal(a. result.setReal(a.getReal()*b.setImag(a.getImag())/ (b.0). } public static Complex Div(Complex a.0).getReal() . Complex b) { Complex result = new Complex(0.b.real = real. result.setImag(a.

} public static double XCart(double modul. double faza){ return modul * Math. } } ). double faza){ return modul * Math.sqrt(real*real + imag*imag).getImag() * b.cos(faza).result. } public double Phase() { return Math.setImag((a. 76 .getImag())/ (b. } public double Abs() { return Math.getReal() + b.getImag()) return result.getImag()*b. } public static double YCart(double modul. real).atan2(imag.getReal() – a.sin(faza).getReal()*b.getReal() * b.

n). k. int nMat){ if(checkN(nMat)){ a = aMat. k. pas++){ // se construieste matricea m pentru pasul pas for(i=0. b = bMat. j. } } public Complex[] Compute(Complex[][] a.out. pas. pas<n. b. n int i. public Complex[] getRezultat () { return rezultat. Complex[] bMat. private Complex[] rezultat = new Complex[50]. Complex[] x_aux= new Complex[50]. Complex nrCompInt. } public ElimGauss(Complex[][] aMat. pas.. n = nMat. public class ElimGauss { private Complex[][] a = new Complex[50][50]. private Complex[] b = new Complex[50]. i++){ 77 . else { System. int n) { // se declara matricile a si b ca date de intrare // se declara variabilele m.clasa pentru sisteme de ecuatii (metoda eliminarii Gauss in complex) package calcule. } } public boolean checkN( int n) { if(n<50) return true. b_aux Complex[][] m= new Complex[50][50]. Complex[] b. j. a_aux. x. Complex[][] a_aux=new Complex[50][50].println("Alegeti un numar mai mare de 50"). Complex[] b_aux= new Complex[50]. // pentru pas de la primul pana la ultimul for(pas=0. i<n. private int n=5. // se declara variabilele i. rezultat = Compute(a. return false.

j<n.Prod(m[i][k]. nrCompInt = new Complex(-a[i][pas]. i<n.println("\nMatricea A . } } // rezultatul se va atribui lui a for(i=0. for(i=0.Prod(m[i][k]. k<n.Sum(a_aux[i][j]. b_aux[i] = Complex.print("\t"+a[i][j]). i<n. i++) // // // 78 . System.getReal(). j++){ a_aux[i][j] = new Complex().out. 0). j<n. m[i][pas] = Complex. a[pas][pas]). a_aux[i][j] = Complex. for(k=0. i<n. j++) a[i][j] = a_aux[i][j]. i<n.dupa pasul "+ Integer. k++){ b_aux[i] += m[i][k] * b[k].out.getImag()). k++){ a_aux[i][j] += m[i][k] * a[k][j]. i<n. j<n. i<n. 0). nrCompInt).Div(nrCompInt.toString(pas)). j<n. } System. i++){ for(j=0.-a[i][pas].print("\n"). nrCompInt = Complex. // } m[pas][pas]=1/a[pas][pas]. i++) for(j=0. j++){ System. m[pas][pas] = Complex. nrCompInt = new Complex(1. k<n. } } // rezultatul se va atribui lui b for(i=0. } // se inmulteste matricea m cu a for(i=0. i++){ b_aux[i] = new Complex(). a[k][j]). m[i][i] = new Complex(1.Div(nrCompInt. nrCompInt = Complex.Sum(b_aux[i]. nrCompInt). i++){ m[i][pas] = -a[i][pas] / a[pas][pas]. i++) for(j=0.for(j=0. j++) m[i][j] = new Complex(). for(i=pas+1. a[pas][pas]). for(k=0. } // se inmulteste matricea m cu b for(i=0.out. b[k]).

j++){ System. for(i=0.out. int nrNoduri.print("\t"+a[i][j]). } System.forma finala:"). } // se calculeaza vectorul x for(i=n-1. } } // se afiseaza vectorul x System.out. Complex[] curenti = new Complex[50].Diff(x_aux[i]. i>=0.forma finala:"). x_aux[j]). i--){ x_aux[i] = b[i]. } System. int[][] Aredus = new int[50][50].Prod(a[i][j]. i++){ System.clasa pentru metoda potenţialelor de noduri package calcule.print("\n"). public class PotentialeNoduri { Complex[][] Y = new Complex[50][50]. for(j=i+1.b[i] = b_aux[i]. j<n.println("\nMatricea B . i++){ for(j=0. for(i=0. j<n. i++){ System. i<n.out. int nrLaturi.out.println(x_aux[i]). nrCompInt = Complex. } return x_aux.println("\nMatricea A . x_aux[i] = Complex.out.out. nrCompInt). Complex[] Ue = new Complex[50].println(b[i]).println("Solutia sistemului:\n"). i<n. for(i=0. j++){ x_aux[i] -= a[i][j] * x_aux[j]. i<n.out. //se trece la pasul urmator } // se afiseaza matricile a si b transformate System. } } // . 79 .

i++){ System. i<nrNoduri. nrCompInt). i<nrNoduri. for(int k=0. j<nrLaturi. // AY = A * Y Complex[][] AY = new Complex[50][50]. Y[k][j]). k<nrLaturi. Complex[][] Yprim = new Complex[50][50]. AY[i][j] = Complex. Y = yMat. TransformaMatrici(). } ElimGauss eg = new ElimGauss(Yprim. } public Complex[] getCurenti(){ return curenti. int noduri. j++) Atranspus[i][j] = Aredus[j][i]. Aredus = arMat.println("\n\nMatricea Iscc initiala: \n\n\n"). Complex[] Iscc = new Complex[50]. j++){ AY[i][j] = new Complex(). 0).Complex[] Vprim = new Complex[50]. i++) for(int j=0. i++){ for(int j=0.getRezultat(). j<nrNoduri. } public void TransformaMatrici(){ // A transpus for(int i=0. } } // 80 . i<nrLaturi. Complex[] ueMat.Sum(AY[i][j]. nrNoduri). int[][] Atranspus = new int[50][50]. CalculCurenti().println(Iscc[i]). for(int i=0. for(int i=0. Iscc. public PotentialeNoduri( Complex[][] yMat. int[][] arMat. nrLaturi = laturi. k++){ AY[i][j] += Aredus[i][k] * Y[k][j]. Complex nrCompInt. nrCompInt = Complex. Ue = ueMat. int laturi){ nrNoduri = noduri. nrCompInt = new Complex(Aredus[i][k].out. System.Prod(nrCompInt.out. Vprim = eg.

0). j<nrNoduri. nrCompInt = new Complex(Atranspus[k][j]. nrCompInt).Prod(nrCompInt.Sum(rezInterm[i].Sum(Yprim[i][j].Sum(rezInterm[i]. nrCompInt). } for(int i=0. nrCompInt).Prod(AY[i][j]. j++){ curenti[i] += Y[i][j] * rezInterm[j]. j<nrLaturi. } } } } // // // // // 81 .} // Iscc = . 0). Iscc[i] = Complex. } } // Yprim = AY * Atranspus for(int i=0.Prod(Y[i][j]. } } } } public void CalculCurenti(){ Complex[] rezInterm = new Complex[50]. nrCompInt). j++){ Iscc[i] -= AY[i][j] * Ue[j]. rezInterm[i] = Complex. i++){ curenti[i] = new Complex(). for(int j=0.AY * Ue for(int i=0. nrCompInt = new Complex(Atranspus[i][j]. j<nrNoduri. rezInterm[i] = Complex.Prod(AY[i][k]. i<nrLaturi. nrCompInt). for(int k=0. j++){ rezInterm[i] += Atranspus[i][j] * Vprim[j]. } rezInterm[i] += Ue[i]. nrCompInt = Complex. i<nrLaturi. Ue[i]). for(int j=0.Sum(curenti[i]. for(int j=0. nrCompInt = Complex. Yprim[i][j] = Complex.Diff(Iscc[i]. nrCompInt = Complex. Ue[j]). Vprim[j]). i++){ for(int j=0. for(int i=0. k<nrLaturi. j++){ Yprim[i][j] = new Complex(). curenti[i] = Complex. i<nrNoduri. j<nrLaturi. i++){ Iscc[i] = new Complex(). nrCompInt = Complex. rezInterm[j]). k++){ Yprim[i][j] += AY[i][k] * Atranspus[k][j]. i++){ rezInterm[i] = new Complex(). i<nrNoduri.

- clasa pentru definit circuitul pentru metoda potentialelor de noduri
package calcule; public class TestCircuit { public static int[][] a = {{-1, 1, 1, 0, 0, 0}, { 0, 0, -1, 1, 1, 0}, { 0, -1, 0, 0, -1, 1}}; private static double[] surse_real = {24, 0, 0, 0, 12, 0}; private static double[] surse_imag = {0, 0, 0, 0, 0, 0}; private static Complex[] Ue = new Complex[6]; public static double[] R = {20, 10, 2, 5, 7, 12}; public static double[] XL = {0, 0, 0, 0, 0, 0}; public static Complex[][] Z = new Complex[6][6]; public static Complex[][] Y = new Complex[6][6]; public static Complex[] curenti = new Complex[6]; public static int noduri = 3; public static int laturi = 6; public static void main(String[] args) { // TODO Auto-generated method stub System.out.println("\n\nTensiunile: \n\n\n"); for(int i=0; i<laturi; i++){ Ue[i] = new Complex(surse_real[i], surse_imag[i]); System.out.println(Double.toString(Ue[i].Abs()) +" e_j*"+ Double.toString(Ue[i].Phase())); } Complex nrCompInt = new Complex(1, 0); for(int i=0; i<laturi; i++){ for(int j=0; j<laturi; j++){ if(i!=j) Y[i][j] = new Complex(); } Z[i][i] = new Complex(R[i], XL[i]); Y[i][i] = Complex.Div(nrCompInt, Z[i][i]); } System.out.println("\n\nY: \n\n\n"); for(int i=0; i<laturi; i++){ System.out.println(Double.toString(Y[i][i].getReal()) +" +j*"+ Double.toString(Y[i][i].getImag())); } PotentialeNoduri pn = new PotentialeNoduri(Y, Ue, a, noduri, laturi); curenti = pn.getCurenti(); 82

System.out.println("\n\nTestCircuit\n\n\n"); for(int i=0; i<laturi; i++){ System.out.println(Double.toString(curenti[i].Abs()) +" e_j*"+ Double.toString(curenti[i].Phase())); } } }

83

6.2. Metoda curenţilor ciclici
package calcule; public class CurentiCiclici { Complex[][] Z = new Complex[50][50]; Complex[] Ue = new Complex[50]; int[][] B = new int[50][50]; int nrOchiuri; int nrLaturi; Complex[] curenti = new Complex[50]; Complex[] Iprim = new Complex[50]; int[][] Btranspus = new int[50][50]; Complex[] UePrim = new Complex[50]; Complex[][] Zprim = new Complex[50][50]; Complex nrCompInt; public CurentiCiclici( Complex[][] zMat, Complex[] ueMat, int[][] bMat, int ochiuri, int laturi){ nrOchiuri = ochiuri; nrLaturi = laturi; Z = zMat; Ue = ueMat; B = bMat; TransformaMatrici(); System.out.println("\n\nMatricea UePrim initiala: \n\n\n"); for(int i=0; i<nrOchiuri; i++){ System.out.println(UePrim[i]); } ElimGauss eg = new ElimGauss(Zprim, UePrim, nrOchiuri); Iprim = eg.getRezultat(); CalculCurenti(); } public Complex[] getCurenti(){ return curenti; } public void TransformaMatrici(){ // B transpus for(int i=0; i<nrLaturi; i++) for(int j=0; j<nrOchiuri; j++) Btranspus[i][j] = B[j][i]; // BZ = B * Z Complex[][] BZ = new Complex[50][50]; 84

for(int i=0; i<nrOchiuri; i++){ for(int j=0; j<nrLaturi; j++){ BZ[i][j] = new Complex(); for(int k=0; k<nrLaturi; k++){ nrCompInt = new Complex(B[i][k], 0); nrCompInt = Complex.Prod(nrCompInt, Z[k][j]); BZ[i][j] = Complex.Sum(BZ[i][j], nrCompInt); } } } // Zprim = BZ * Btranspus for(int i=0; i<nrOchiuri; i++){ for(int j=0; j<nrOchiuri; j++){ Zprim[i][j] = new Complex(); for(int k=0; k<nrLaturi; k++){ nrCompInt = new Complex(Btranspus[k][j], 0); nrCompInt = Complex.Prod(BZ[i][k], nrCompInt); Zprim[i][j] = Complex.Sum(Zprim[i][j], nrCompInt); } } } // UePrim = B * Ue for(int i=0; i<nrOchiuri; i++){ UePrim[i] = new Complex(); for(int j=0; j<nrLaturi; j++){ nrCompInt = new Complex(B[i][j], 0); nrCompInt = Complex.Prod(nrCompInt, Ue[j]); UePrim[i] = Complex.Sum(UePrim[i], nrCompInt); } } } public void CalculCurenti(){ for(int i=0; i<nrLaturi; i++){ curenti[i] = new Complex(); for(int j=0; j<nrOchiuri; j++){ nrCompInt = new Complex(Btranspus[i][j], 0); nrCompInt = Complex.Prod(nrCompInt, Iprim[j]); curenti[i] = Complex.Sum(curenti[i], nrCompInt); } } } }

85

public static Complex[] curenti = new Complex[6]. { 0. 0}.out. public static double[] XL = {0.Phase())). -1. 0. i++){ System. 0}. } for(int i=0. i++){ 86 . -1. 0. 0}. for(int i=0.println(Z[i][i]). 1.. 0.println("\n\nTestCircuit\n\n\n"). i<laturi. public class TestCircuit2 { public static int[][] b = {{ 1. 1. i<laturi. 2. public static Complex[][] Z = new Complex[6][6].noduri. 0. System. 0. 0. 1}}.out. for(int i=0. 0. public static void main(String[] args) { // TODO Auto-generated method stub System. 0. i++){ Ue[i] = new Complex(surse_real[i]. 10.println("\n\nZ: \n\n\n"). b. private static double[] surse_imag = {0. laturi). } System. 12}. 0. 0}. 0. j++){ if(i!=j) Z[i][j] = new Complex(). 0. } Z[i][i] = new Complex(R[i]. public static double[] R = {20. 0. public static int laturi = 6. private static Complex[] Ue = new Complex[6]. 1.out. 1. i++){ for(int j=0. XL[i]). 5. i<laturi. curenti = cc. 7. i<laturi. System. 0. private static double[] surse_real = {24. } CurentiCiclici cc = new CurentiCiclici(Z. for(int i=0. Ue. 0.out. ochiuri.clasa pentru definit circuitul pentru metoda curentilor ciclici package calcule. 0.toString(Ue[i].getCurenti(). 1. 0}. 12.out.println(Double.println("\n\nTensiunile: \n\n\n"). 0. public static int noduri = 3. surse_imag[i]). { 0.Abs()) +" e_j*"+ Double.toString(Ue[i]. public static int ochiuri = laturi . j<laturi.

toString(curenti[i].toString(curenti[i].out.Abs()) +" e_j*"+ Double.System. } } } 87 .Phase())).println(Double.