def executar(self, A, B):
#cria uma copia
Ac = Utils().copiaMatriz(A)
Bc = list(B)
n = len(Ac[0])
G = Utils().inicializaMatriz(n)
passos = 0
for i in range(n):
soma = 0
#gera a diagonal principal da matriz G
for j in range(i + 1):
passos += 1
if (j != i):
#soma os quadrados do que nao for da diagonal principal
soma += G[i][j]**2
else:
#tira raiz quadrada da diferenca do item da diagonal principal de A
#com a soma do que esta na G
G[i][j] = m.sqrt(Ac[i][i] - soma)
#gera elementos fora da diagonal principal
for i in range(j + 1):
soma = 0
for k in range(j - 1):
passos += 1
soma += G[i][k] * G[j][k]
G[i][j] = (Ac[i][j] - soma) / G[j][j]
#o resultado e uma matriz diagonal superior
#que eu acho que e a G transposta
Gt = Utils().copiaMatriz(G)
G = Utils().transposicao(
G) #transposta da transposta resulta na matriz original
#imprimeMatriz(Gt, [0] * n)
#imprimeMatriz(G, [0] * n)
# Gy=b
retrosub1 = RetroSubstituicao().executar(G, Bc)
passos += retrosub1[1]
#o resultado de cima e o vetor b do abaixo
#Gtx=y
retrosub2 = RetroSubstituicao().executar(Gt, retrosub1[0])
return [retrosub2[0], retrosub2[1] + passos]
def executar(self, M, B, dataType):
if(len(M)==0):
return 0
self.dataType = dataType
Ma = Utils().copiaMatriz(M)
Ba = list(B)
ordem = len(M[0])
#percorre os pivos da matriz zerando as linhas abaixo
for k in range(0, ordem):
t = k + 1
#percorre os elementos abaixo do pivo para extrair o multiplicador
for i in range(t, ordem):
mult = Ma[i][k] / Ma[k][k]
if(mult == 0 or np.isnan(mult)):
print("************** PIVO NULO!!!!!")
if(mult >= 1):
print("MULTIPLICADOR MAIOR OU IGUAL A 1", mult)
#usa o multiplicador pra zerar o elemento da linha
for j in range(t, ordem):
Ma[i][j] = Ma[i][j] - mult * Ma[k][j]
#usa o multiplicador pra mudar o elemento no vetor fonte
Ba[i] = Ba[i] - mult * Ba[k]
#agora que tem uma matriz diagonal superior, usa retroSubstituicao
retrosub = RetroSubstituicao().executar(Ma, Ba)
return retrosub[0]
def executar(self, M, B):
if(len(M)==0):
return 0
Ma = Utils().copiaMatriz(M)
Ba = list(B)
ordem = len(M[0])
passos = 0
#percorre os pivos da matriz zerando as linhas abaixo
for k in range(0, ordem):
t = k + 1
#percorre os elementos abaixo do pivo para extrair o multiplicador
for i in range(t, ordem):
mult = Ma[i][k] / Ma[k][k]
#usa o multiplicador pra zerar o elemento da linha
for j in range(t, ordem):
Ma[i][j] = Ma[i][j] - mult * Ma[k][j]
passos+=1
#usa o multiplicador pra mudar o elemento no vetor fonte
Ba[i] = Ba[i] - mult * Ba[k]
#agora que tem uma matriz diagonal superior, usa retroSubstituicao
retrosub = RetroSubstituicao().executar(Ma, Ba)
return [retrosub[0], retrosub[1] + passos]
def executar2(self, M, B):
#cria uma copia
A = Utils().copiaMatriz(M)
B = np.array(B, np.float64)
passos = 0
### Codigo copiado da Internet ###
### Fonte: https://rosettacode.org/wiki/Cholesky_decomposition#Python3.X_version_using_extra_Python_idioms
### Esse codigo retorna a matriz L
L = [[0.0] * len(A) for _ in range(len(A))]
for i in range(len(A)):
for j in range(i + 1):
passos += 1
s = sum(L[i][k] * L[j][k] for k in range(j))
L[i][j] = m.sqrt(A[i][i] - s) if (i == j) else \
(1.0 / L[j][j] * (A[i][j] - s))
#Resolucao do sistema baseado no link
#https://math.stackexchange.com/questions/2422012/solving-a-linear-system-with-cholesky-factorization
#transposta da matriz L
Lt = Utils().transposicao(L)
#resolve o primeiro passo do metodo
retrosub1 = RetroSubstituicao().executar(L, B)
passos += retrosub1[1]
#vetor resposta Y
Y = retrosub1[0]
#resolve o segundo passo do metodo
retrosub2 = RetroSubstituicao().executar(Lt, Y)
passos += retrosub2[1]
#vetor resposta X
X = retrosub2[0]
return [X, passos]
'''
def executarComPivoteamento(self, M, B):
ordem = len(M[0])
passos = 0
Ma = np.array(M, dtype=np.float128, copy=True) #Utils().copiaMatriz(M)
Ba = np.array(B, dtype=np.float128, copy=True) #list(B)
#loop do pivoteamento
for a in range(0, ordem):
#armazena pivo em modulo
maior_elemento = abs(Ma[a][a])
linha_a = a
linha_b = a
#percorre as colunas a procura do maior valor
for b in range(a, ordem):
passos += 1
elemento = abs(Ma[b][a])
if (elemento > maior_elemento):
maior_elemento = elemento
linha_b = b
#se os indices das linhas a e b forem diferentes, faz a troca de linha
if (linha_a != linha_b):
Utils().trocarLinhas(Ma, Ba, linha_a, linha_b)
#percorre os elementos abaixo do pivo para extrair o multiplicador
for i in range(a + 1, ordem):
mult = Ma[i][a] / Ma[a][a]
if (mult == 0 or np.isnan(mult)):
print("************** PIVO NULO!!!!!")
if (mult >= 1):
print("MULTIPLICADOR MAIOR OU IGUAL A 1", mult)
#usa o multiplicador pra zerar o elemento da linha
for j in range(a, ordem):
passos += 1
Ma[i][j] = Ma[i][j] - mult * Ma[a][j]
#if(passos % 100000 == 0):
#print("Passos percorridos: " + str(passos))
#usa o multiplicador pra mudar o elemento no vetor fonte
Ba[i] = Ba[i] - mult * Ba[a]
#agora que tem uma matriz diagonal superior, usa retroSubstituicao
retrosub = RetroSubstituicao().executar(Ma, Ba)
return [retrosub[0], retrosub[1] + passos]