Bacharelado em Engenharia Civil

Cálculo Numérico Computacional

Professor Aldair Forster

Avaliação 3 – Métodos iterativos para resolução de sistemas lineares

Estudantes: Brenda Santos e Gabriel Silva

1. Usando aço reciclado, uma fábrica produz peças de aço tipo A que devem conter 4
quilos de cromo, 8 quilos de tungstênio e 7 quilos de carbono por tonelada de aço produzido.
O fabricante tem três fontes de aço reciclado:
Fonte 1: Cada tonelada contém 2 quilos de cromo, 8 quilos de tungstênio e 6 quilos de
carbono.
Fonte 2: Cada tonelada contém 3 quilos de cromo, 9 quilos de tungstênio e 6 quilos de
carbono.
Fonte 3: Cada tonelada contém 12 quilos de cromo, 6 quilos de tungstênio e 12 quilos de
carbono.
a) Sejam x, y e z a percentagem de aço reciclado utilizado das fontes 1, 2 e 3,
respectivamente, para cada tonelada de aço produzido. Encontre um sistema linear em x, y
e z cuja solução diz qual a percentagem que deve ser utilizada de cada fonte para atender às
exigências do produto final.

b) Resolva o sistema usando o método de Gauss com pivotamento parcial numa

linguagem de programação.
%reset -f
import numpy as np

A = np.array([[2,3,12,4],[8,9,6,8],[6,6,12,7]],dtype = 'double')

n = len(A)
k=0
for k in range (0,n,1):
pivo = max(min(A[k:n,k]), max(A[k:n,k]), key=abs) #encontra o pivo da coluna k
loc = np.where(A[k:n,k]==pivo) #encontra a linha do pivô
loc = loc[0]
aux = np.copy(A[k,:])
if abs(A[k,k])<abs(pivo):
A[k,:]=A[loc[0]+k,:]
A[loc[0]+k,:]=aux
 #esse for executa a eliminação
for j in range (k+1,n,1):
m = -A[j,k]/A[k,k]
A[j,:]=m*A[k,:]+A[j,:]

# print (A)

###resolve o sistema tringular superior (a=u)

U = A[:,0:n]
b = A[:,-1]

n = len(U)-1
x = np.zeros(n+1)
x[n] = b[n]/U[n,n]

for k in range (n-1,-1,-1):

soma = 0
for j in range (k+1,n+1,1):
soma = soma + U[k,j]*x[j]
x[k]=(b[k]-soma)/U[k,k]

print("Resultado em porcentagem:")
print(x * 100)

Resultado em porcentagem:
[50%. 33.33333333% 16.66666667%]

c) Resolva o sistema usando o método de Gauss-Jacobi parcial numa linguagem de

programação, com erro de 0,001.
import numpy as np
#métodos de Gauss - Jacobi
##entradas

A = np.array([[2,3,12],
[8,9,6],
[6,6,12]])

b = np.transpose(np.array([[4,8,7]]))
x = np.transpose(np.array([[0,0,0]]))

erro = 0.001
nmax = 20 #numero maximo de interações

#processamento
#montar matriz

linha,coluna = np.shape(A)

H = np.zeros((linha,coluna))
g = np.zeros((linha,1))
 for i in range(linha):
H[i,:]=(-A[i,:])/(A[i,i])
H[i,i]=0
g[i,:]=b[i,:]/A[i,i]

#calcular os próximos x's

er = 10
k = 0 #numero de interações inicial
while er > erro or k == nmax:
x1 = np.dot(H,x)+g
d = x1-x

maxd = max(min(d[:,:]), max(d[:,:]), key = abs)

maxx1 = max(min(x1[:,:]), max(x1[:,:]), key = abs)

er = abs(maxd)/abs(maxx1)
x = x1
k=k+1

errogeral = np.dot(A,x)-b
#saída

print ('A solução é:\n',x)

print ("o numero de interações é:",k)
print('Os erros são \n', errogeral)

A solução é:
[[ -inf]
[-1.14048621e+308]
[-7.58552467e+307]]
o numero de interações é: 796
Os erros são
[[-inf]
[-inf]
[-inf]]
d) Ele converge? Quantas iterações são necessárias? Qual o vetor diferença da solução
dos dois métodos?
Não, ele não converge, logo, não é possível definir o número de interações necessárias.
e) Para esse sistema, qual método é o mais indicado para a solução. Baseie sua resposta
em exatidão do resultado e número de operações.
Pivotamento Parcial
f) Imagine que outra peça de aço (tipo B) necessite de 9,7 quilos de cromo, 12,9 de
tungstênio e 13,8 de carbono. Qual a porcentagem de material de cada uma das fontes seria
necessária?
%reset -f
import numpy as np

A = np.array([[2,3,12,9.7],[8,9,6,12.9],[6,6,12,13.8]],dtype = 'double')

n = len(A)
k=0
 for k in range (0,n,1):
pivo = max(min(A[k:n,k]), max(A[k:n,k]), key=abs) #encontra o pivo da coluna k
loc = np.where(A[k:n,k]==pivo) #encontra a linha do pivô
loc = loc[0]
aux = np.copy(A[k,:])
if abs(A[k,k])<abs(pivo):
A[k,:]=A[loc[0]+k,:]
A[loc[0]+k,:]=aux

#esse for executa a eliminação

for j in range (k+1,n,1):
m = -A[j,k]/A[k,k]
A[j,:]=m*A[k,:]+A[j,:]

# print (A)

###resolve o sistema tringular superior (a=u)

U = A[:,0:n]
b = A[:,-1]

n = len(U)-1
x = np.zeros(n+1)
x[n] = b[n]/U[n,n]

for k in range (n-1,-1,-1):

soma = 0
for j in range (k+1,n+1,1):
soma = soma + U[k,j]*x[j]
x[k]=(b[k]-soma)/U[k,k]

print("Resultado em porcentagem:")
print(x * 100)

Resultado em porcentagem:
[73.33333333% 38.88888889% 58.88888889%]
g) Para esse novo sistema, existe garantia de convergência para o método de Gauss-
Seidel?
Não, pois a diagonal principal irá ser a mesma da anterior que não funcionou, logo, não
será possível pelo método indicado.

h) Resolva, a mão, o mesmo sistema usando o método de Gauss-Seidel com erro de

0,01. Quantas iterações são necessárias?
Não é convergível, logo, não há interações
i) Resolva o mesmo sistema com Gauss com pivotamento.
%reset -f
import numpy as np

A = np.array([[2,3,12,9.7],[8,9,6,12.9],[6,6,12,13.8]],dtype = 'double')

n = len(A)
k=0
for k in range (0,n,1):
pivo = max(min(A[k:n,k]), max(A[k:n,k]), key=abs) #encontra o pivo da coluna k
loc = np.where(A[k:n,k]==pivo) #encontra a linha do pivô
loc = loc[0]
aux = np.copy(A[k,:])
if abs(A[k,k])<abs(pivo):
A[k,:]=A[loc[0]+k,:]
A[loc[0]+k,:]=aux

#esse for executa a eliminação

for j in range (k+1,n,1):
m = -A[j,k]/A[k,k]
A[j,:]=m*A[k,:]+A[j,:]

# print (A)

###resolve o sistema tringular superior (a=u)

U = A[:,0:n]
b = A[:,-1]

n = len(U)-1
x = np.zeros(n+1)
x[n] = b[n]/U[n,n]

for k in range (n-1,-1,-1):

soma = 0
for j in range (k+1,n+1,1):
soma = soma + U[k,j]*x[j]
x[k]=(b[k]-soma)/U[k,k]
print (x)

[0.73333333 0.38888889 0.58888889]

 j) É possível, com as quantidades disponíveis nas fontes 1, 2 e 3 produzir o aço tipo A
e tipo B?
Sim, é possível, uma vez que foi encontrado, usando gauss com pivotamento, valores reais
que atendiam ao produto final.

2. Use a implementação do método de Gauss-Joacob para resolver o sistema da treliça

da Avaliação 2 – Parte 2 com erro de 0,0001.

import numpy as np
#métodos de Gauss - Jacobi
##entradas

A = np.array([[-1,0,-0.7071,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,-1,-0.7071,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0.7071,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,-1,0,-0.7071,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,-1,0,0,0.7071,1,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,-1,-0.7071,0,0,1,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0.7071,0,1,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,-1,0,-0.7071,0,0,0.9806,0.7071,0,0,0,0,0,0],
[0,0,0,0,0,0,0,-1,0,0,0.7071,0,1,0.1961,0.7071,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,-1,-0.7071,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0.7071,1,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,-0.9806,0,0,0,0.9806,0.7433,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,-0.1961,0,0,1,0.1961,0.669,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,-0.7071,-1,0,0,0,1,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,-0.7071,0,-1,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-0.7433,-1,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-0.669,0,-1],
[0,0,0,0,0,0,0,0,0,0,0.9806,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-0.1961,0,0,1],], dtype='double') # Define a matriz A

b = np.transpose(np.array([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,8000,0,0,-5000,0,5000,866.25]]))
x = np.transpose(np.array([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]))

erro = 0.0001
nmax = 200 #numero maximo de interações

#processamento
#montar matriz

linha,coluna = np.shape(A)

H = np.zeros((linha,coluna))
g = np.zeros((linha,1))

for i in range(linha):
H[i,:]=(-A[i,:])/(A[i,i])
H[i,i]=0
g[i,:]=b[i,:]/A[i,i]

#calcular os próximos x's

er = 10
k = 0 #numero de interações inicial
while er > erro or k == nmax:
x1 = np.dot(H,x)+g
d = x1-x

maxd = max(min(d[:,:]), max(d[:,:]), key = abs)

maxx1 = max(min(x1[:,:]), max(x1[:,:]), key = abs)

er = abs(maxd)/abs(maxx1)
x = x1
k=k+1

errogeral = np.dot(A,x)-b
#saída

print ('A solução é:\n',x)

print ("o numero de interações é:",k)
print('Os erros são \n', errogeral)

A solução é:
[[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]]
o numero de interações é: 2
Os erros são
[[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]
[nan]]

##Eliminação de Gauss com pivotamento parcial

%reset -f
import numpy as np

A = np.array([[-1,0,-0.7071,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,-1,-0.7071,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0.7071,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,-1,0,-0.7071,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,-1,0,0,0.7071,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,-1,-0.7071,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0.7071,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,-1,0,-0.7071,0,0,0.9806,0.7071,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,-1,0,0,0.7071,0,1,0.1961,0.7071,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,-1,-0.7071,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0.7071,1,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,-0.9806,0,0,0,0.9806,0.7433,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,-0.1961,0,0,1,0.1961,0.669,0,0,8000],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,-0.7071,-1,0,0,0,1,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,-0.7071,0,-1,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-0.7433,-1,0,-5000],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-0.669,0,-1,0],
[0,0,0,0,0,0,0,0,0,0,0.9806,0,0,0,0,0,0,0,0,0,0,5000],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-0.1961,0,0,1,866.25],], dtype='double') # Define a
matriz A

n = len(A)
k=0
for k in range (0,n,1):
pivo = max(min(A[k:n,k]), max(A[k:n,k]), key=abs) #encontra o pivo da coluna k
loc = np.where(A[k:n,k]==pivo) #encontra a linha do pivô
loc = loc[0]
 aux = np.copy(A[k,:])
if abs(A[k,k])<abs(pivo):
A[k,:]=A[loc[0]+k,:]
A[loc[0]+k,:]=aux

#esse for executa a eliminação

for j in range (k+1,n,1):
m = -A[j,k]/A[k,k]
A[j,:]=m*A[k,:]+A[j,:]

# print (A)

###resolve o sistema tringular superior (a=u)

U = A[:,0:n]
b = A[:,-1]

n = len(U)-1
x = np.zeros(n+1)
x[n] = b[n]/U[n,n]

for k in range (n-1,-1,-1):

soma = 0
for j in range (k+1,n+1,1):
soma = soma + U[k,j]*x[j]
x[k]=(b[k]-soma)/U[k,k]
print (x)
[-43292.16642131 -90189.77848814 61224.95604767 38031.36206683
-43292.16642131 -46897.61206683 61224.95604767 -5260.80435448
-43292.16642131 -3605.44564552 5098.91902917 -3605.44564552
0. -39286.76963134 -1643.49381317 -3605.44564552
1162.11447529 -49247.56926505 13140.80468292 -4767.56012082
-8791.19833288]
a) O método converge?
Não
b) Qual o número de iterações necessárias?
Nenhum, pois não converge.
c) Qual a diferença entre o resultado com Gauss-Jacob e Gauss com pivotamento
parcial?
Podemos observar a diferença dos resultados analisando os códigos que estão acima.
Gauss-Jacob deu uma solução que não existe, tendo em vista que temos um 0(zero) na
diagonal principal, fazendo com que o critério de convergência não seja satisfeito. Gauss
com pivotamento parcial deu o vetor resultado para o sistema das treliças
d) Qual método é mais adequado para esse problema? Justifique.

Pivotamento parcial, umas vezes que a diagonal principal possui um número zero, não
sendo possível a aplicação do método de Gauss Jacobi e não tendo resultado real.