def sustitucionHaciaAtrasRedondeo(matriz, terminos_independientes,
cifras_redondeo):
if cifras_redondeo < 2:
raise NumeroCifrasRedondeoExcepcion
#Inicializa cada elemento en 0.
vector_soluciones = [[0] for renglon in matriz]
numero_ecuaciones = len(matriz)
#Contador que permite saber que solución se está calculando.
posicion_solucion = numero_ecuaciones - 1
x_provisional = redondear(
terminos_independientes[numero_ecuaciones - 1][0] /
matriz[numero_ecuaciones - 1][numero_ecuaciones - 1], cifras_redondeo)
vector_soluciones[posicion_solucion][0] = x_provisional
posicion_solucion = posicion_solucion - 1
for i in range(numero_ecuaciones - 2, -1, -1):
suma_x_anteriores = 0
for j in range(numero_ecuaciones - 1, i, -1):
suma_x_anteriores = redondear(
suma_x_anteriores + redondear(
matriz[i][j] * vector_soluciones[j][0], cifras_redondeo),
cifras_redondeo)
x_provisional = redondear(
redondear(terminos_independientes[i][0] - suma_x_anteriores,
cifras_redondeo) / matriz[i][i], cifras_redondeo)
vector_soluciones[posicion_solucion][0] = x_provisional
posicion_solucion = posicion_solucion - 1
return vector_soluciones
def operacionElementalRenglonRedondeo(matriz, i_operado, escalar, i_operante,
cifras_redondeo):
for j in range(0, len(matriz[i_operado])):
matriz[i_operado][j] = redondear(matriz[i_operado][j], cifras_redondeo)
matriz[i_operante][j] = redondear(matriz[i_operante][j],
cifras_redondeo)
matriz[i_operado][j] = redondear(
matriz[i_operado][j] +
redondear(escalar * matriz[i_operante][j], cifras_redondeo),
cifras_redondeo)
def verificarErrorIdentidad(identidad_aproximada, tolerancia, cifras_redondeo):
#Crea la matriz identidad exacta.
identidad = [[0 for columna in identidad_aproximada]
for renglon in identidad_aproximada]
for i in range(0, len(identidad)):
identidad[i][i] = 1
#Revisa entrada a entrada el error en la matriz identidad aproximada.
i = 0
for renglon in identidad:
j = 0
for columna in identidad:
if abs(
redondear(identidad[i][j] - identidad_aproximada[i][j],
cifras_redondeo)) > tolerancia:
return False
j = j + 1
i = i + 1
return True
def eliminacionGaussianaSimple(matriz, vector_b, tolerancia, cifras_redondeo,
maximo_iteraciones, area_texto):
if maximo_iteraciones < 1:
raise IteracionesInvalidasExcepcion
if cifras_redondeo < 2:
raise NumeroCifrasRedondeoExcepcion
matriz_auxiliar = copiarMatriz(
matriz) #Guarda la matriz original para su uso posterior.
vector_b_auxiliar = copiarMatriz(vector_b)
vector_soluciones = [[0] for renglon in matriz]
vector_soluciones_aux = [[0] for renglon in matriz]
for numero_iteraciones in range(1, maximo_iteraciones + 1):
#Realiza la eliminación simple.
for i in range(0, len(matriz) - 1):
p = encontrarRenglonMenor(matriz, i)
if p == -1:
raise NoHaySolucionUnicaExcepcion
elif p != i:
permutarRenglones(matriz, i, p, len(matriz) + 1)
permutarRenglones(vector_b, i, p, len(matriz) + 1)
for j in range(i + 1, len(matriz)):
multiplicador = redondear(
redondear(matriz[j][i], cifras_redondeo) /
redondear(matriz[i][i], cifras_redondeo), cifras_redondeo)
operacionElementalRenglonRedondeo(matriz, j, -multiplicador, i,
cifras_redondeo)
operacionElementalRenglonRedondeo(vector_b, j, -multiplicador,
i, cifras_redondeo) # !!!!!!
area_texto.insert(
'end', "Matriz después de eliminación simple en la iteración " +
str(numero_iteraciones) + ".\n")
imprimirMatriz(matriz, area_texto)
area_texto.insert(
'end',
"Términos independientes después de eliminación simple en la iteración "
+ str(numero_iteraciones) + ".\n")
imprimirMatriz(vector_b, area_texto)
if matriz[len(matriz) - 1][len(matriz) - 1] == 0:
raise NoHaySolucionUnicaExcepcion
vector_soluciones_aux = sustitucionHaciaAtrasRedondeo(
matriz, vector_b, cifras_redondeo)
#Calcula el vector b aproximado.
for i in range(0, len(vector_soluciones_aux)):
vector_soluciones[i][0] = vector_soluciones_aux[i][0] # !!!!
vector_b_aproximado = multiplicarMatricesRedondeo(
matriz_auxiliar, vector_soluciones, cifras_redondeo)
vector_errores = restarMatricesRedondeo(vector_b_aproximado,
vector_b_auxiliar,
cifras_redondeo)
area_texto.insert(
'end',
"\nAproximación de las soluciones del SEL actual en la iteración "
+ str(numero_iteraciones) + "\n")
imprimirMatriz(vector_soluciones, area_texto)
area_texto.insert('end',
"\nVector de errores de la iteración actual:\n")
imprimirMatriz(vector_errores, area_texto)
if encontrarNumeroMayorMatriz(vector_errores) <= tolerancia:
return vector_soluciones
#Resetea la matriz.
matriz = copiarMatriz(matriz_auxiliar)
#Reemplaza los términos independientes de la matriz actual con los errores nuevos.
for i in range(0, len(vector_b)):
vector_b[i][0] = vector_errores[i][0]
area_texto.insert(
'end', "\nMatriz que se usará en la siguiente iteración.\n")
imprimirMatriz(matriz, area_texto)
area_texto.insert('end', '\n')
raise MetodoFallidoExcepcion