Ministerul Educaţiei Republicii Moldova

Universitatea Tehnică a Moldovei

Facultatea Calculatoare, Informatică şi Microelectronică.
Departamentul Informatică și Ingineria Sistemelor

Raport la
Lucrare de laborator Nr.2
la Metode și Modele de Calcul

A efectuat: st. gr. IA-181 Paniș Iulian

A verificat: lect.univ. Moraru Vasile

Chișinau, 2019
 Rezolvarea numerică a ecuațiilor neliniare

Sarcini de lucru:
1. Să se separe toate rădăcinile reale ale ecuației f(x)=0 , unde y=f(x) este o funcție
reală de variabilă reală.
2. Să se determine o rădăcină reală a ecuației date cu ajutorul metodei injumătățirii
intervalului cu o eroare mai mică decît ε=10-2 .
3. Să se precizeze rădăcina obținută cu exactitatea ε=10-6 , utilizînd:
 Metoda aproximațiilor succesive;
 Metoda tangentelor(Newton);
 Metoda secantelor.
4. Să se compare rezultatele luînd în considerație numărul de iterații,evaluările pentru funcții
și derivată.

Varianta:
8 2 −3 6
A= 2 9 −4 b = −7
−3 −4 8 1
1. Metoda Cholesky
from __future__ import print_function
from math import sqrt

def cholesky(A):
L = [[0.0] * len(A) for _ in range(len(A))]
for i in range(len(A)):
for j in range(i+1):
s = sum(L[i][k] * L[j][k] for k in range(j))
L[i][j] = sqrt(A[i][i] - s) if (i == j) else \
(1.0 / L[j][j] * (A[i][j] - s))
return L

A = [[ 8, 2, -3 ],
[ 2, 9, -4 ],
[ -3, -4, 8 ]]

b = [6, -7, 1]

Q = cholesky(A)

print ("Matricea L:")

for i in range(len(Q)):
print ("{:>7.3f}{:>7.3f}{:>7.3f}".format(Q[i][0],Q[i][1],Q[i][2]))

y0 = b[0] / Q[0][0]
y1 = (b[1] - Q[1][0] * y0) / Q[1][1]
y2 = (b[2] - Q[2][0] * y0 - Q[2][1] * y1) / Q[2][2]

print ("\nSolutia(y):\n y0={:>7.3f}\n y1={:>7.3f}\n y2={:>7.3f}".format(y0, y1,

y2))

x3 = y2 / Q[2][2]
x2 = (y1 - Q[2][1] * x3) / Q[1][1]
x1 = (y0 - Q[2][0] * x3 - Q[1][0] * x2) / Q[0][0]

print ("\nSolutia(x):\n x1={:>7.3f}\n x2={:>7.3f}\n

x3={:>7.3f}".format(x1,x2,x3))
Rezultatul:
2. Metoda Jacobi:
import numpy as np

ITERATION_LIMIT = 1000

A = np.array([[ 8., 2., -3. ],

[2., 9., -4. ],
[-3., -4., 8. ]])

b = np.array([6., -7., 1. ])

x = np.zeros_like(b)
for it_count in range(ITERATION_LIMIT):
x_new = np.zeros_like(x)
for i in range(A.shape[0]):
s1 = np.dot(A[i, :i], x[:i])
s2 = np.dot(A[i, i + 1:], x[i + 1:])
x_new[i] = (b[i] - s1 - s2) / A[i, i]
if np.allclose(x, x_new, atol=0.01):
break
x = x_new
print("Solutia curenta",x)

print("\nSolutia:")
print(x)
error = np.dot(A, x) - b
print("\nErori:")
print(error)
print("\nIteratii: ", (it_count))

Rezultat
3. Metoda Gauss-Seidel:
def seidel(a, x ,b):
#Finding length of a(3)
n = len(a)
# for loop for 3 times as to calculate x, y , z
for j in range(0, n):
# temp variable d to store b[j]
d = b[j]

# to calculate respective xi, yi, zi

for i in range(0, n):
if(j != i):
d-=a[j][i] * x[i]
# updating the value of our solution
x[j] = d / a[j][j]
# returning our updated solution
return x

# int(input())input as number of variable to be solved

n = 3
a = []
b = []
# initial solution depending on n(here n=3)
x = [0, 0, 0]
a = [[8, 2, -3],
[2, 9, -4],
[-3, -4, 8]]
b = [6,-7,1]
print(x)

#loop run for m times depending on m the error value

for i in range(0, 25):
x = seidel(a, x, b)
#print each time the updated solution
print(x)
Rezultat:
 Concluzie:

În lucrarea de laborator nr2 am avut ca sarcina de a exersa asupra rezolvării sistemelor de

ecuații liniare. În urma calculului manual al diferitor metode precum: Metoda Cholesky,
Metoda iterativă Jacobi, Metoda iterativă a lui Gauss-Seidel, am elaborat programe care
rezolvă aceste metode și am observat ca prin diferite metode rezultatul sistemelor de ecuații
este același, dar numărul de iterații pentru fiecare metodă este diferit. Metoda Jacobi are
nevoie de 8 iterații, iar metoda Gauss-Seidel are nevoie de mai puține iteratii pentru a calcula
exemplul dat- o iterație.