metodi numerici teoria generale Flashcards
matrice grande o piccola
m < 50, m> 400
matrice sparsa
Sparsity > 0.33
diagonale strettamente dominante
Abs della diagonale maggiore di somma degli abs dei elementi della riga
formula condizionamento built in
np.linalg.cond(A)
codice matrice simmetrica e definita positiva
np.allClose(A, A.T)
try: scipy.linalg.cholesky(A)
except scipy.LinAlgError:
formula rank matrice
np.linalg.matrix_rank(A)
codice diagonale strettamente dominante
n, _ = A.shape
diagonally_dominant = True
for i in range(n):
# Calcola la somma dei valori assoluti degli elementi della riga, escluso l’elemento diagonale
sum_row = np.sum(np.abs(A[i, :])) - np.abs(A[i, i])
# Controlla se valore assoluto dell’elemento diagonale è strettamente maggiore della somma degli altri elementi della riga
if np.abs(A[i, i]) <= sum_row:
diagonally_dominant = False
break
if diagonally_dominant:
print("Matrice a Diagonale Strettamente Dominante")
codice residuo di sistema Ax = b
residuo_sol = np.linalg.norm(A @ x - b)
codice derivata
df = sym.diff(f, var, 1)
codice trasformare funz simbolica in numreica
f_numerica = sym.utilities.lambdify(var, f, np)
codice radice quadrata
sym.sqrt(expr)
o np.sqrt(valore)
codice matrice
sym.matrix
O
Np.array
Metodo python condizionamento
np.linalg.cond()
importare cholesky
scipy.linalg.cholesky(A)
vettore di zeri
np.zeros_like(vet)
scambiare costanti per numeri in funzione simbolica
f.subs(var, numero)
codice norma metodo built-in?
np.linalg.norm(A, 1)
come ricordare differenza tra numpy e sympy?
numpy riguarda operazioni NON simboliche, ma operazioni su array e matrici
cos’è norma uno e come si calcola non usando funzioni built-in?
norma 1 = MAX SOMMA DI OGNI COLONNA, CONSIDERANDO ABS DI OGNI ELEMENTO
c = np.sum(np.abs(B),axis=0) #equivale a sommare gli elementi di tutte le colonna
norma1 = np.max(c)
norma 2 cos’è e codice?
norma 2 è valore singolare massimo di matrice M = A * A.T
è necessario fare radice del massimo degli autovalori
def norma2EIGVALS(A):
M = A @ A.T
autovalori = np.linalg.eigvals(M)
norma2 = np.sqrt(np.max(autovalori))
return norma2
condizionamento in norma 1? non built-in
cond = norma(A) * norma(np.linalg.inv(A))
norma infinito cos’è e codice?
come norma 1 ma la somma riguarda le righe
c = np.sum(np.abs(B),axis=1) #equivale a sommare gli elementi di tutte le righe
normainf = np.max(c)
inversa di matrice
np.linalg.inv(A)
condizionamento in norma 2? non built-in
cond = norma2(A) / np.sqrt(np.min(autovalori))
matrice di vandermone codice?
mat = np.vander(x, increasing = True)[:,:n2]
lu solve quando applicabile?
per matrici n = m, piccole dimensioni, dense
E con determinante != 0 (rango max di tutte le sottomatrici)
condizione applicabilità lusolve? + codice
condizione: Il determinante di tutte le sottomatrici deve essere != 0 a.k.a. il rango di tutte le sottomatrici deve essere pieno
n, _ = A.shape
applicabile = True
for i in range(1, n):
sub_matrix = A[:i, :i]
if np.linalg.matrix_rank(sub_matrix) != i:
print(“NON APPLICABILE”)
applicabile = False
break
if applicabile:
print(“APPLICABILE”)
codice applicare lusolve?
applicare lu che ritorna PT, L, U, poi risolvere con due solve_triangular
Step 1: Fattorizzazione LU con permutazione
PT, L, U = lu(A)
P = PT.T.copy()
Step 2: CALCOLARE Pb
Pb = P @ b
Step 3: Risolvere L * y = P * b per y (sistema triangolare inferiore)
y = solve_triangular(L, Pb, lower=True)
Step 4: Risolvere U * x = y per x (sistema triangolare superiore)
x = solve_triangular(U, y)
norma 1, 2 e infinito built-in?
np.linalg.norm(A, 1)
np.linalg.norm(A, 2)
np.linalg.norm(A, np.inf)
calcolare perturbazione nei dati vettore b di Ax = b? codice
ERRORE_DATI = NORMAINF(b - bpert) / NORMAINF(b)
oppure
ERRORE_DATI = NORMA2(b - bpert) / NORMA2(b)
risoluzione con metodo build-in di sistema n == m
x = sym.solve(expr) per sistemi simbolici
x = numpy.linalg.solve(A) per sistemi numerici
risoluzione con metodo build-in di sistema n > m sovradeterminati
x = sym.linsolve(expr) per sistemi simbolici
c, residuals, rank, s = numpy.linalg.lstsq(A, b) per sistemi numerici
applicare cholesky? + codice
CHOLESKY
cholesky fa solo la fattorizzazione, serve poi applicare Lsolve, Usolve
cholesky restituisce solo L
L = cholesky(A, lower=True)
print(“Matrice triangolare inferiore L:\n”, L)
LSOLVE
z, flag = Lsolve(L, b)
if flag == 0:
print(“\nSoluzione intermedia z (dalla risoluzione di Lz = b):\n”, z)
# USOLVE
x, flag = Usolve(L.T, z)
if flag == 0:
print("\nSoluzione finale x (dalla risoluzione di L.T x = z):\n", x)
codice solve_triangular
scipy.linalg.solve_triangular
come importare metodo lu
scipy.linalg.lu
come importare metodo cholesky
scipy.linalg.cholesky
come importare per usare Lsolve e Usolve? cosa cambia da solve_triangular?
from solvetriangular import Lsolve, Usolve # Importa le funzioni definite nel file
la differenza è che restituiscono anche un flag che è =0 se va bene
solve_triangular(L, V, lower = True) == Lsolve(L, V)
solve_triangular(U, V, lower = False) == Lsolve(U, V)
come importare metodo qr?
np.linalg.qr(…)
[QR, Cholesky, Jacobi, Gauss seidel, SOR, steepest descent, conjugate descent, metodo equazioni normali, QRLS, SVDLS]
tra questi metodi quali senza scheletro non forniscono la soluzione diretta?
QR, cholesky
applicare metodo qr? + codice
qr restituisce Q, R tale che A = Q*R
risolta con metodo built-in solve
Q, R = np.linalg.qr(A)
y = Q.T @ b
x = scipy.linalg.solve(R, y)
codice hilbert?
H = scipy.linalg.hilbert(n)
quando si applica solve_nsis()?
in sistemi lineari Ax = b
CONDIZIONE: n == m
per sistemi con n vettori di termini noti b
utilizza lu, Lsolve, Usolve
codice solve_nsis?
solve_nsis usa lusolve all’interno di un ciclo che itera ogni COLONNA di B, inserendo ogni risulato in ogni COLONNA di X
def solve_nsis(A, B):
X = np.zeros(B)
n = A.shape[0]
#LU
PT, L, U = lu(A)
P = PT.T.copy()
for i in range(1, B.shape[1]):
#LSOLVE
y, flag = Lsolve(L, P @ B[:, i])
if flag != 0:
print("Errore: elemento diagonale nullo in L")
X = []
return X
#USOLVE
x, flag = Usolve(U, y)
if flag != 0:
print("Errore: elemento diagonale nullo in U")
X = []
return X
X[:, i] = x.reshape(n,)
return X
steps per fare condizionamento di funzione simbolica f?
1) definire funzione simbolica
2) calcolare la derivata simbolica
3) sostituire valori fissi se necessario
4) convertire funzione e derivata in numeriche
5) calcolare indice condizionamento: | c * df_numerica(c) / f_numerica(c) |
nell’applicare scheletri, valori di itmax, tol, x0?
itmax = 10000
tol = 1e-8
x0 = np.zeros_like(b)
creare mediante interpolazione un polinomio di grado n? cosa serve avere e creare?
Metodo per calcolare il polinomio interpolante in forma di Lagrange.
- x VETTORE dei nodi di interpolazione,
- y VETTORE dei valori della funzione nei nodi di interpolazione, y = y[x]
- xx VETTORE dei punti in cui si vuole valutare il polinomio interpolante. PIU’ FITTI. DA CREARE(es con np.linspace())
- yy VETTORE DA CALCOLARE CON interpL
yy = interpL(x, y, xx)
come costruire polinomio di regressione lineare di grado n?
si hanno due vettori di dati x e y
usare matrice di vandermone
con vander si crea una matrice A che poi è risolvibile come un qualsiasi sistema lineare.
dopo avere creato A con vander, si ha sistema Ac = y
valore di n è da decidere
n2 = n + 1
A = np.vander(x, increasing = True)[:, :n2]
polinomio di regressione con polyfit?
OSSERVO n
x = np.array([0, 1, 2, 3])
y = np.array([1, 2, 0, 5])
n = 2
coeffs_polyfit = np.polyfit(x, y, deg=n)
print(“Coefficiente con polyfit:”, coeffs_polyfit)
valori da passare in input per metodi di FUNZIONI O SISTEMI NON LINEARI?
tolx=1e-8
tolf=1e-8
nmax=10000
x0=1.0
FUNZIONI PASSATE COME NUMERICHE
valori da passare in input per metodi di FUNZIONI O SISTEMI LINEARI?
tol=1e-8
nmax=10000
x0=np.zeros_like(b)
in generale per plottare funzione cosa serve?
si fa plt.plot(x,y) con x e y 2 VETTORI DI PUNTI.
x sono valori con linspace, y è funz(x)
importare plot?
import matplotlib.pyplot as plt
soluzione di newton
radice più vicina a punto x0
soluzione di bisezione
unica radice all’interno
calcolare ordine di newton?
ordine è relativo ad una specifica radice verso cui newton converge.
per calcolarlo usare stima_ordine, poi per aumentarlo usare m = 2 o 3 o 4 in newtonmod
PLOTTARE FUNZ 3D
input a metodi mynewtonsys jac e x0?
jac è MATRICE numpy con derivate parziali come ogni riga
x0 non è solo un punto iniziale come gli altri metodi per equazioni non lineari, ma è np.array([0,0,0]) con tanti termini quante variabili.
DATO CHE X0 E’ ASCISSE DI UN PUNTO IPOTIZZATO NEL GRAFICO, OVVIAMENTE è UN ARRAY DI PUNTI ESSENDOCI PIU’ VARIABILI ASCISSE IN UN SISTEMA SYS
ARRAY E MATRICE CREARLI?
PLOTTARE ERRORE LOGARITMICO
come usare lstsq e quando
sistemi sovradeterminati :
x,residuals,rank,s
copiare vet1 in vet2
vet2=vet1.copy()
errore relativo di valori matematici
err_rel_x = np.abs(x - xreal)/np.abs(xreal)
dove e come sostituire valori fissi in equazione simbolica
f.subs(var,num) UNO PER VOLTA
valore input m a metodo corde?
df(x0)
valore input xm1 in metodo secanti?
valore precedente a x0
come introdurre stabilità in soluzione di equazione non lineare?
se funzione quadratica standard usare: x1new= c/a*x2_stabile
altrimenti: cnew= 2*c / (-b+radice(delta))
forma di fun,jacobiano e di gradiente,hessiana?
fun array monodimensionale
jacobiano matrice
gradiente array monodimensionale
hessiana matrice
come creare gradiente e hessiana
gradiente è ARRAY MONODIMENSIONALE.
funz_obb è somma dei quadrati di tutte le funzioni F numeriche
funz_obb= f1(x,y)^2 + f2(x,y)^2
gradiente è funzione(x) array monodimensionale delle derivate parziali della FUNZIONE OBBIETTIVO
dObj_dx = 2 * f1(x, y) * df1_dx + 2 * f2(x, y) * df2_dx
dObj_dy = 2 * f1(x, y) * df1_dy + 2 * f2(x, y) * df2_dy
return np.array([dObj_dx, dObj_dy])
hessiana è MATRICE delle derivate seconde e miste della FUNZIONE OBBIETTIVO
se è difficile si può usare:
(
hess_f = sympy.hessian(f_obbiettivo_simbolica, [x1, x2]) # Calcola la matrice Hessiana
Hess = sympy.lambdify((x1,x2), hess_f, np)
)
