def metodoDoolittle(A, B, n):
U = [[0.0] * n for j in range(n)]
L = [[float(i == j) for j in range(n)] for i in range(n)]
a = funciones.matrizAumentada(A, B, n)
for j in range(n):
a = funciones.pivot(a, j)
A = []
B = []
for i in range(n):
A.append(a[i][0:n])
B.append(a[i][n])
for k in range(n):
for i in range(k + 1):
U[i][k] = A[i][k] - sum(L[i][p] * U[p][k] for p in range(i))
for i in range(k + 1, n):
if U[k][k] == 0:
return L, U, ["NULL", "NULL"]
L[i][k] = (A[i][k] - sum(L[i][p] * U[p][k]
for p in range(k))) / float(U[k][k])
print "\n Resolucion por Algoritmo LU-Doolittle "
print " -------------------------------------------------"
print "\n Matriz U Triangular Superior"
funciones.imprimeMatriz(U)
print "\n Matriz L Triangular Inferior"
funciones.imprimeMatriz(L)
y = funciones.solucionL(L, B, n) #Ly = b "obtenemos y"
x = funciones.solucionU(U, y, n) #Ux = y "obtenemos x"
return [y, x]
def metodoCholesky(A, B, n):
#creamos matriz nula G
G = [[0.0] * n] * n
#creamos matriz nula G_T
for i in range(n):
suma = A[i][i]
for k in range(i):
suma = suma - A[k][i]**2
if suma < 0: #no es definida positiva
return ["NULL", "NULL"]
A[i][i] = math.sqrt(suma)
for j in range(i + 1, n):
suma = A[i][j]
for k in range(i):
suma = suma - A[k][i] * A[k][j]
A[i][j] = suma / A[i][i]
for j in range(n):
for i in range(n):
if (i > j):
A[i][j] = 0.0
G = A
Gt = funciones.transMatriz(G, n)
print "\n Resolucion por Algoritmo Cholesky "
print " -------------------------------------------------"
print "\n Matriz G Triangular Superior"
funciones.imprimeMatriz(G)
print "\n Matriz Gt Triangular Inferior"
funciones.imprimeMatriz(Gt)
y = funciones.solucionL(Gt, B, n) #Ly = b "obtenemos y"
x = funciones.solucionU(G, y, n) #Ux = y "obtenemos x"
return [y, x]
def LDLt(A, B, n):
Lt = [[0.0] * n] * n
for i in range(n):
suma = A[i][i]
for k in range(i):
suma = suma - A[k][i]**2
if suma < 0: #no es definida positiva
return ["NULL", "NULL"]
A[i][i] = math.sqrt(suma)
for j in range(i + 1, n):
suma = A[i][j]
for k in range(i):
suma = suma - A[k][i] * A[k][j]
A[i][j] = suma / A[i][i]
for j in range(n):
for i in range(n):
if (i > j):
A[i][j] = 0.0
Lt = A
L = funciones.transMatriz(Lt, n)
D = [[float(i == j) for j in range(n)] for i in range(n)]
for i in range(n):
D[i][i] = float(L[i][i])
for j in range(i + 1):
L[i][j] = L[i][j] / D[j][j]
for i in range(n):
for j in range(i, n):
Lt[i][j] = Lt[i][j] / D[i][i]
for i in range(n):
D[i][i] = D[i][i]**2
print "\n Resolucion por Algoritmo LDLt "
print " -------------------------------------------------"
print " Matriz L Triangular Inferior"
funciones.imprimeMatriz(L)
print " Matriz D Diagonal"
funciones.imprimeMatriz(D)
print " Matriz Lt Triangular Superior"
funciones.imprimeMatriz(Lt)
print "Para hallar el resultado de LDLt.x=b requerimos 3 ecuaciones:"
z = funciones.solucionL(L, B, n) #Lz = b "obtenemos z"
y = funciones.solucionL(D, z, n) #Dy = z "obtenemos y"
x = funciones.solucionU(Lt, y, n) #Ltx = y "obtenemos x"
return z, y, x
def LDMt(A, B, n):
L = []
for i in range(n):
L.append([0] * n)
Mt = []
for i in range(n):
Mt.append([0] * n)
#pivot
a = funciones.matrizAumentada(A, B, n)
for j in range(n):
a = funciones.pivot(a, j)
A = []
B = []
for i in range(n):
A.append(a[i][0:n])
B.append(a[i][n])
for j in range(0, n):
Mt[j][j] = 1.0
for i in range(j, n):
L[i][j] = A[i][j] - funciones.suma(Mt, L, i, j, j) #ultima j por i
for i in range(j + 1, n):
if L[j][j] == 0:
return ["NULL", "NULL", "NULL"]
Mt[j][i] = (A[j][i] - funciones.suma(Mt, L, j, i, j)) / L[j][j]
D = [[float(i == j) for j in range(n)] for i in range(n)]
for i in range(n):
D[i][i] = float(L[i][i])
for j in range(i + 1):
L[i][j] = L[i][j] / D[j][j]
print "\n Resolucion por Algoritmo LDMt "
print " -------------------------------------------------"
print " Matriz L Triangular Inferior"
funciones.imprimeMatriz(L)
print " Matriz D Diagonal"
funciones.imprimeMatriz(D)
print " Matriz Mt Triangular Superior"
funciones.imprimeMatriz(Mt)
print "Para hallar el resultado de LDMt.x=b requerimos 3 ecuaciones:"
z = funciones.solucionL(L, B, n) #Lz = b "obtenemos z"
y = funciones.solucionL(D, z, n) #Dy = z "obtenemos y"
x = funciones.solucionU(Mt, y, n) #Mtx = y "obtenemos x"
return z, y, x
def metodoLU1(A, B, n):
L = []
for i in range(n):
L.append([0] * n)
U = []
for i in range(n):
U.append([0] * n)
#pivot
a = funciones.matrizAumentada(A, B, n)
for j in range(n):
a = funciones.pivot(a, j)
A = []
B = []
for i in range(n):
A.append(a[i][0:n])
B.append(a[i][n])
#LU1
for j in range(0, n):
U[j][j] = 1.0
for i in range(j, n):
L[i][j] = A[i][j] - funciones.suma(U, L, i, j, j) #ultima j por i
for i in range(j + 1, n):
if L[j][j] == 0:
return ["NULL", "NULL"]
U[j][i] = (A[j][i] - funciones.suma(U, L, j, i, j)) / L[j][j]
print "\n Resolucion por Algoritmo LU1-Crout "
print " -------------------------------------------------"
print "\n Matriz U Triangular Superior"
funciones.imprimeMatriz(U)
print "\n Matriz L Triangular Inferior"
funciones.imprimeMatriz(L)
y = funciones.solucionL(L, B, n) #Ly = b "obtenemos y"
x = funciones.solucionU(U, y, n) #Ux = y "obtenemos x"
return [y, x]