Bacharelado em Engenharia Civil

Cálculo Numérico Computacional

Semestre 2023/1
Professor Aldair Forster
12 de junho de 2023 ❤

Estudantes: Brenda Angélica Santos Borges e Gabriel de Sousa Silva

Avaliação 6: Solução de equações e sistemas de equações não lineares
1. (3 pontos) Use o método da bissecção, de Newton e da falsa posição para
determinar as raízes de cada uma das funções abaixo com erro
−6
¿ f ( x )∨¿10
Antes de aplicar os métodos encontre um intervalo que contenha uma raiz
única.
Complete a tabela comparativa abaixo e indique qual método foi mais
eficiente.

Método de Valor Nº de Raiz Valor da função

Bissecção / inicial iterações
Função
x-sex(x) (-0.3,0.2) 3 0.012500000 3.25518290211
000000011 76815e-07
sen(x)-x-1 (-2,-1.8) 17 - -
1.934562683 7.15381560989
1054688 492e-07
2x-e^(-x) (0.2,0.4) 13 0.351733398 -
43749996 8.45676263572
237e-07

Método da Valor Nº Raiz Valor da função

falsa inicial de
posição / itera
Função ções
x-sex(x) (-0.3,0.2) 117 0.018147622853194 9.960951683034291e-
476 07
sen(x)-x-1 (-2,-1.8) 4 - -
1.934563177921368 4.4511708874317435
3 e-08
2x-e^(-x) (0.2,0.4) 4 0.351733719456882 2.2189213799705954
6 e-08

Método de Valor Nº de Raiz Valor da função

Newton / inicial iteraç
Função ões
x-sex(x) (0.2) 6 0.017537393384880556 8.989534480349781e-
07
sen(x)-x-1 (-2) 2 -1.9345638738197013 8.989854658469909e-
07
2x-e^(-x) (0.2) 3 0.3517337112489698 -
6.110667527536862e-
13
 2. (1 ponto) Use o python para desenhar um gráfico para cada uma das
funções da questão anterior. Destaque a raiz que foi encontrada. Cole aqui a
imagem de cada função com −5 ≤ x ≤ 5. Se você identificar outras raízes além
daquela encontrada na 1 nesse intervalo, use o método de newton para
determiná-las. Escreva uma conclusão, indicando as funções com as raízes
encontradas.

MÉTODO DA FALSA POSIÇÃO

Equação a) – Conclui-se que, ao observar-se o gráfico, este passa apenas uma vez
no eixo x, notando-se que há apenas uma raiz no intervalo dado de -5 e 5.
Equação b) – Conclui-se que, ao observar-se o gráfico, este passa apenas uma vez
no eixo x, notando-se que há apenas uma raiz no intervalo dado de -5 e 5.
Equação c) – Conclui-se que, ao observar-se o gráfico, este passa apenas uma vez
no eixo x, notando-se que há apenas uma raiz no intervalo dado de -5 e 5.

3. (2 pontos) A Figura 1 (a) mostra uma viga uniforme sujeita a uma carga
distribuída de forma linearmente crescente. A equação para a curva elástica
resultante é (ver Figura 1(b))
ω0 5 2 3 4
y= (−x +2 L x −L x )
120 EIL
Use o método de Newton-Raphson para determinar o ponto de deflexão máxima. A
seguir substitua esse valor na equação anterior para determinar a deflexão
máxima. Use os seguintes parâmetros nos seus cálculos:
L=450 cm , E=35000 kN /cm² , I =30000 c m e ω 0=1 , 75 kN /cm .
4

Seu relatório deve conter o script, o critério de parada usado e as saídas do código.
Todos os cálculos de raízes e valores da função devem ser dados como saída no
algoritmo usando a função print, com 4 casas decimais. Não esqueça da unidade de
medida.
Apresente um gráfico da deflexão (curva elástica) com 0 ≤ x ≤ 450 .
 Figura 1

import numpy as np
import matplotlib.pyplot as plt

# Função
def f(x):
return ((1.75/120*35000*30000*450)*(-5*x**4 + 1215000*x**2 -
41006250000))

# Derivada da função
def d(x):
return ((1.75/120*35000*30000*450)*(-20*x**3 + 2430000*x))

# Entradas
a = float(input("Entre com o primeiro valor de x: "))
erro = float(input("Entre com o erro: "))

# Intervalo de valores de x para o gráfico

x_vals = np.linspace(-100, 100, 1000)

# Valores de f(x) para o gráfico

y_vals = f(x_vals)

# Plotar o gráfico da função

plt.plot(x_vals, y_vals)
plt.axhline(0, color='red', linestyle='--') # Linha horizontal em
y=0

# Método de Newton para encontrar a raiz

k = 0
x = a - (f(a)/d(a))

while np.abs(f(x)) > erro and k < 100:

k += 1
x = a - (f(a)/d(a))
if np.abs(f(x)) < erro:
print("A raiz é aproximadamente:", x)
print("O número de iterações é:", k)
print("O valor da função é:", f(x))
else:
a = x

# Marcar a raiz encontrada no gráfico

plt.plot(x, f(x), 'ro')

# Configurar os eixos
plt.xlabel('x')
plt.ylabel('f(x)')

# Mostrar o gráfico
plt.show()

*OBS: A unidade de medida da raiz encontrada é (cm)

A deflexão máxima é no ponto (201.24611797498108,0), o ponto de deflexão
máxima está representado no gráfico pela bolinha vermelha

4. (2,5 pontos) Use o método de Newton para encontrar uma raiz para o
sistema de equações abaixo com ¿ f ( x ( k ) ) ∨¿ 10−5.

{
2
x + y−2 xy=0
2 2
x + y −4 x−4 y=1
RESPOSTA:
0#método de newton para solução de sistemas não lineares
import numpy as np
from numpy import linalg

#entradas (edite só aqui)

x = np.array([[0.3],[0]])
def F(x): return np.array ([x[0]**2+x[1]-2*x[0]*x[1],
x[0]**2+x[1]**2-4*x[0]-4*x[1]-1],dtype
= 'double') #escreva aqui as funções
def J(x): return np.array([[2*x[0]-2*x[1],1-2*x[0]],
[2*x[0]-4,2*x[1]-4]],dtype = 'double')
erro = 0.00001

# processamento (NÃO EDITE)

k = 0
f= F(x)
j= J(x)
e=1
j=np.reshape(j,(2,2))
while e > erro:
s = np.linalg.solve(j,-f)
x = s + x
maxs = max(min(s),max(s), key = abs)
maxx = max(min(x),max(x), key = abs)
e = abs(maxs)/abs(maxx)
j = J(x)
j=np.reshape(j,(2,2))
f = F(x)
k = k+1

print ("A solução é x = ", x)

print ("O valor da função é f(x) = ", f)
print ("O número de iterações é = ", k)

5. (1,5 pontos) Use o python para construir um gráfico das funções da

questão anterior com −10 ≤ x ≤ 10 e −10 ≤ y ≤ 10.
Analise o gráfico e verifique se existem outras soluções nesse intervalo. Em
caso positivo, determine-as usando o método de Newton dando novas
 entradas no algoritmo. Escreva todas as respostas encontradas e o número
de iterações para cada uma.
#método de newton para solução de sistemas não lineares
import numpy as np
from numpy import linalg
import matplotlib.pyplot as plt

#entradas (edite só aqui)

x = np.array([[0.3],[0]])
def F(x): return np.array ([x[0]**2+x[1]-2*x[0]*x[1],
x[0]**2+x[1]**2-4*x[0]-4*x[1]-1],dtype
= 'double') #escreva aqui as funções
def J(x): return np.array([[2*x[0]-2*x[1],1-2*x[0]],
[2*x[0]-4,2*x[1]-4]],dtype = 'double')
erro = 0.00001

# processamento (NÃO EDITE)

k = 0
f= F(x)
j= J(x)
e=1
j=np.reshape(j,(2,2))
while e > erro:
s = np.linalg.solve(j,-f)
x = s + x
maxs = max(min(s),max(s), key = abs)
maxx = max(min(x),max(x), key = abs)
e = abs(maxs)/abs(maxx)
j = J(x)
j=np.reshape(j,(2,2))
f = F(x)
k = k+1

print ("A solução é x = ", x)

print ("O valor da função é f(x) = ", f)
print ("O número de iterações é = ", k)

#__________________________________________________________________
___
#fazendo os gráficos:

# Funções
def f1(x, y):
return x**2 + y - 2*x*y

def f2(x, y):

 return x**2 + y**2 - 4*x - 4*y - 1

# Cria uma matriz de coordenadas para x e y

x = np.linspace(-10, 10, 400)
y = np.linspace(-10, 10, 400)
X, Y = np.meshgrid(x, y)

# Calcula os valores correspondentes das equações

Z1 = f1(X, Y)
Z2 = f2(X, Y)

# Plotar as equações no mesmo gráfico

plt.contour(X, Y, Z1, levels=[0], colors='blue', label='x^2+y-
2xy=0')
plt.contour(X, Y, Z2, levels=[0], colors='red', label='x^2+y^2-4x-
4y=1')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Gráfico das Equações')
plt.legend()
plt.grid(True)
plt.xlim(-10, 10)
plt.ylim(-10, 10)
plt.axis('equal') # Define a mesma escala nos eixos x e y
plt.show()
OBS: Nota-se que há duas raízes na circunferência, uma vez que passa duas vezes
pela origem.