In [14]:
import numpy as np
import matplotlib.pyplot as plt
% matplotlib inline
O Método da Bisseção é utilizado para encontrar a raíz de uma função dentro de um intervalo definido, de forma iterativa. A cada iteração o método encontra uma nova aproximação para o local da raíz da função dada.
Dado um intervalo inicial $[A, B]$, utilize o Método da Bisseção para encontrar as $10$ primeiras aproximações para a raíz da função:
$$ f(x) = \frac{x^4 - 10x^3 - x^2 + 5x}{x^4 + 1} $$A entrada consiste de dois valores reais $-10^4 \leq A < B \leq 10^4$ que indicam os limites inferior e superior do intervalo, respectivamente.
Na saída devem ser impressos 10 valores reais com 6 casas de precisão. Após cada valor deve ser impressa uma quebra de linha. Caso a raíz seja encontrada, esta deve ser a última linha impressa, também com 6 casas decimais de precisão. Por fim, caso o intervalo inicial não seja válido, a mensagem "Intervalo invalido" deve ser impressa.
$\texttt{8.00}$
$\texttt{12.00}$
$\texttt{10.000000}$
$\texttt{11.000000}$
$\texttt{10.500000}$
$\texttt{10.250000}$
$\texttt{10.125000}$
$\texttt{10.062500}$
$\texttt{10.031250}$
$\texttt{10.046875}$
$\texttt{10.054688}$
$\texttt{10.050781}$
In [4]:
def f(x):
return (x**4 - 10 * x ** 3 - x**2 + 5 * x) / (x**4 + 1)
A = 8.00
B = 12.00
xa = A
xb = B
ga = f(xa)
gb = f(xb)
for i in range(10):
xmed = (xa + xb) / 2
gmed = f(xmed)
if gmed < 0:
xa, ga = xmed, gmed
elif gmed > 0:
xb, gb = xmed, gmed
elif:
print('%.6f' % xmed)
break
print('%.6f' % xmed)
Em zeros de funções, o Método da Newton é um método iterativo utilizado para encontrar a raíz de uma função, dado um ponto inicial. A cada iteração o método encontra uma nova aproximação para o local da raíz da função desejada.
Dado um ponto inicial $x_0$, utilize o Método de Newton para encontrar as 10 primeiras aproximações para a raíz da função:
$$ f(x) = x^4 - 10x^3 + 8x $$A entrada consiste de um valor real $-10^4 \leq x_0 \leq 10^4$ que indica o ponto inicial.
Na saída devem ser impressos 10 valores reais com 6 casas de precisão, cada valor representa uma aproximação para a raíz da função $f(x)$ dada. Após cada valor deve ser impressa uma quebra de linha.
$\texttt{8.00}$
$\texttt{8.000000}$
$\texttt{15.058824}$
$\texttt{12.524640}$
$\texttt{10.923665}$
$\texttt{10.137268}$
$\texttt{9.932064}$
$\texttt{9.918737}$
$\texttt{9.918683}$
$\texttt{9.918683}$
$\texttt{9.918683}$
In [7]:
def g(x):
return x**4 - 10 * x**3 + 8 * x
def g_linha(x):
return 4*x**3 - 30*x**2 + 8
x0 = 8.00
x = x0
for i in range(10):
value = g(x)
diff = g_linha(x)
print('%.6f' % x)
x = x - value / diff
O Método da Posição Falsa é um método iterativo utilizado para encontrar a raíz de uma função, dado um intervalo inicial. A cada iteração o método encontra uma nova aproximação para o local da raíz da função desejada.
Dado um intervalo inicial $[A,B]$, utilize o Método da Posição Falsa para encontrar as 10 primeiras aproximações para a raíz da função:
$$ f(x) = \frac{x^2 + 3x - 3}{x^2 + 1} $$A entrada consiste de dois valores reais $-10^4 \leq A < B \leq 10^4$ que indicam os limites inferior e superior do intervalo inicial, respectivamente.
Na saída devem ser impressos 10 valores reais com 6 casas de precisão. Após cada valor deve ser impressa uma quebra de linha. Caso a raíz seja encontrada, esta deve ser a última linha impressa, também com 6 casas decimais de precisão. Caso o intervalo inicial não seja válido, a mensagem "Intervalo invalido" deve ser impressa.
$\texttt{-1.00}$
$\texttt{10.00}$
$\texttt{6.318841}$
$\texttt{3.733514}$
$\texttt{1.971825}$
$\texttt{0.908998}$
$\texttt{0.702668}$
$\texttt{0.799252}$
$\texttt{0.791794}$
$\texttt{0.791320}$
$\texttt{0.791290}$
$\texttt{0.791288}$
In [8]:
def y(x):
return (x**2 + 3*x - 3)/(x**2 + 1)
A = -1.00
B = 10.00
if A >= B:
print("Intervalo invalido")
else:
xa = A
xb = B
ga = y(xa)
gb = y(xb)
for i in range(10):
x_pfalse = (gb * xa - ga * xb) / (gb - ga)
g_pfalse = y(x_pfalse)
if g_pfalse < 0:
xa = x_pfalse
ga = g_pfalse
elif g_pfalse > 0:
xb = x_pfalse
gb = g_pfalse
elif g_pfalse == 0:
print('%.6f' % x_pfalse)
break
print('%.6f' % x_pfalse)
O Método da Secante é um método iterativo utilizado para encontrar a raíz de uma função, dados dois pontos iniciais. A cada iteração o método encontra uma nova aproximação para o local da raíz ($x_i$) da função desejada.
Dados dois pontos iniciais $x_0$ e $x_1$, utilize o Método da Secante para encontrar as aproximações $x_2, x_3, ..., x_9$ para a raíz da função:
$$ f(x) = x^4 - 10x^3 + 8x $$A entrada consiste de dois valores reais $-10^4 \leq x_0, x_1 \leq 10^4$ que indicam os pontos iniciais.
Na saída devem ser impressas dez linhas, cada uma com a seguinte mensagem "$f(x_i) = y_i$", com $0 \leq i \leq 9$. Onde $x_i$ é a i-ésima aproximação para o local da raíz e $y_i$ é o valor da função $f(x)$ no ponto $x_i$. Ambos os valores $x_i$ e $y_i$ devem ser impressos com 6 casas de precisão.
$\texttt{8.00}$
$\texttt{10.00}$
$\texttt{f(-5.000000) = 1835.000000}$
$\texttt{f(5.000000) = -585.000000}$
$\texttt{f(2.582645) = -107.113005}$
$\texttt{f(2.040822) = -51.325848}$
$\texttt{f(1.542328) = -18.691334}$
$\texttt{f(1.256817) = -7.302917}$
$\texttt{f(1.073731) = -2.460008}$
$\texttt{f(0.980731) = -0.662019}$
$\texttt{f(0.946488) = -0.104578}$
$\texttt{f(0.940064) = -0.006059}$
In [23]:
def k(x):
return x ** 4 - 10 * x**3 + 8 * x
x0 = -5.00
x1 = 5.00
xa = x0
xb = x1
ga = k(xa)
gb = k(xb)
for i in range(10):
xi = (xa * gb - xb * ga) / (gb - ga)
xa = xb
xb = xi
# xa, xb = xb, (xa * gb - xb * ga) / (gb - ga)
# ga, gb = gb, k(xb)
# xb = (xa * gb - xb * ga) / (gb - ga)
# xa = xb
# ga = gb
# gb = k(xb)
print ('f(%.6f) = %.6f' % (xi, k(xi)))
O Método da Busca Ternária é um método para encontrar pontos críticos de uma função dentro de um intervalo definido, de forma iterativa. A cada iteração o método encontra uma nova aproximação para o local do ponto crítico da função.
Dado um intervalo inicial $[A, B]$, utilize o Método da Busca Ternária para encontrar as 10 primeiras aproximações para o ponto de mínimo da função:
$$ f(x) = x(x - 1)(x + 1)(x - 2) $$A entrada consiste de dois valores reais $-10^4 \leq A < B \leq 10^4$ que indicam os limites inferior e superior do intervalo, respectivamente.
Na saída devem ser impressos 10 valores reais com 6 casas de precisão. Após cada valor deve ser impressa uma quebra de linha.
$\texttt{0.00}$
$\texttt{10.00}$
$\texttt{3.333333}$
$\texttt{2.222222}$
$\texttt{1.481481}$
$\texttt{0.987654}$
$\texttt{1.646091}$
$\texttt{1.426612}$
$\texttt{1.280293}$
$\texttt{1.475385}$
$\texttt{1.605446}$
$\texttt{1.562092}$
In [10]:
def g(x):
return x * (x - 1) * (x + 1) * (x - 2)
A = 0.00
B = 10.0
for i in range(10):
xa = A + (B - A) / 3
xb = A + (B - A) * 2 / 3
fa = g(xa)
fb = g(xb)
if fa > fb:
A = xa
else:
B = xb
print('%.6f' % (xa if fa < fb else xb))
O Método da Busca pela Razão Áurea é um método para encontrar pontos críticos de uma função dentro de um intervalo definido, de forma iterativa. A cada iteração o método encontra uma nova aproximação para o local do ponto crítico (máximo ou mínimo) da função.
Dado um polinômio de quarta ordem e um intervalo inicial $[A, B]$, utilize o Método da Busca pela Razão Áurea para encontrar as 10 primeiras aproximações para o ponto de mínimo do polinômio dado.
A entrada é composta por duas linhas. A primeira linha contêm cinco valores reais $-10^4 \leq a,b,c,d,e \leq 10^4$ que indicam os coeficientes do polinômio de quarta ordem abaixo.
$$ p(x) = ax^4 + bx^3 + cx^2 + dx + e $$A segunda linha consiste de dois valores reais $-10^4 \leq A,B \leq 10^4$ que indicam os limites inferior e superior do intervalo, respectivamente.
Na saída devem ser impressos 10 valores reais com 6 casas de precisão. Após cada valor deve ser impressa uma quebra de linha.
$\texttt{1.00 0.00 -1.00 0.00 1.00}$
$\texttt{0.00}$
$\texttt{10.00}$
$\texttt{3.819660}$
$\texttt{2.360680}$
$\texttt{1.458980}$
$\texttt{0.901699}$
$\texttt{0.557281}$
$\texttt{0.344419}$
$\texttt{0.557281}$
$\texttt{0.688837}$
$\texttt{0.638587}$
$\texttt{0.688837}$
In [21]:
a = 1.0
b = 0.0
c = -1.0
d = 0.0
e = 1.0
def h(x):
return a * x**4 + b * x**3 + c * x**2 + d * x + np.e
A = 0.0
B = 10.0
golden = (1 + 5 ** 0.5) / 2
xa = B - (B - A)/golden
xb = A + (B - A)/golden
fa = h(xa)
fb = h(xb)
print('%.6f' % (xa if fa < fb else xb))
for i in range(9):
if fa > fb:
A = xa
xa = xb
fa = fb
xb = A + (B - A)/golden
fb = h(xb)
else:
B = xb
xb = xa
fb = fa
xa = B - (B - A)/golden
fa = h(xa)
print('%.6f' % (xa if fa < fb else xb))
O Método da Descida de Gradiente é um método iterativo utilizado para encontrar o ponto crítico de uma função, dado um ponto inicial. A cada iteração o método encontra uma nova aproximação para o local do ponto crítico da função desejada. Esta nova aproximação pode ser encontrada utilizando duas abordagens: passo contante e passo variável.
Dado um ponto inicial $x_0$, utilize o Método da Descida de Gradiente com Passo Constante para encontrar as 10 primeiras aproximações para o ponto crítico da função:
$$ f(x) = -xe^{-x} $$A entrada consiste de dois números reais. O primeiro valor é $-10^4 \leq x_0 \leq 10^4$ que indica o ponto inicial. O segundo valor é $0 < k \leq 10$ que indica o passo constante $k$ do método.
Na saída devem ser impressas dez linhas com a seguinte mensagem "$i\texttt{: }f(x_i)\texttt{ = }y_i$", onde $i$ é o número da iteração, $x_i$ é o local da aproximação atual para o ponto crítico da função e $y_i$ é o valor de $f(x)$ no ponto $x_i$.
$\texttt{7.50}$
$\texttt{1.00}$
$\texttt{0: f(7.500000) = -0.004148}$
$\texttt{1: f(6.500000) = -0.009772}$
$\texttt{2: f(5.500000) = -0.022477}$
$\texttt{3: f(4.500000) = -0.049990}$
$\texttt{4: f(3.500000) = -0.105691}$
$\texttt{5: f(2.500000) = -0.205212}$
$\texttt{6: f(1.500000) = -0.334695}$
$\texttt{7: f(0.500000) = -0.303265}$
$\texttt{8: f(1.500000) = -0.334695}$
$\texttt{9: f(0.500000) = -0.303265}$
In [25]:
def l(x):
return -x * np.e ** -x
def l_linha(x):
return np.e**-x * (x - 1)
x0 = 7.5
k = 1.0
for i in range(9):
print('%d: f(%.6f) = %.6f' % (i, x0, l(x0)))
dx = l_linha(x0)
if dx > 0:
x0 -= k
else:
x0 += k
print('%d: f(%.6f) = %.6f' % (9, x0, l(x0)))
O Método da Newton é um método iterativo utilizado para encontrar o ponto crítico de uma função, dado um ponto inicial. A cada iteração o método encontra uma nova aproximação para o local do ponto crítico da função desejada.
Dado um ponto inicial $x_0$, utilize o Método de Newton para encontrar as 10 primeiras aproximações para o ponto crítico da função:
$$ f(x) = x^4 - 10x^3 + 8x $$A entrada consiste de um valor real $-10^4 \leq x_0 \leq 10^4$ que indica o ponto inicial.
Na saída devem ser impressas dez linhas com a seguinte mensagem "$i\texttt{: }f(x_i)\texttt{ = }y_i$", onde $i$ é o número da iteração, $x_i$ é o local da aproximação atual para o ponto crítico da função e $y_i$ é o valor de $f(x)$ no ponto $x_i$.
$\texttt{8.00}$
$\texttt{0: f(8.000000) = -960.000000}$
$\texttt{1: f(7.527778) = -994.378043}$
$\texttt{2: f(7.465168) = -994.830507}$
$\texttt{3: f(7.464102) = -994.830633}$
$\texttt{4: f(7.464102) = -994.830633}$
$\texttt{5: f(7.464102) = -994.830633}$
$\texttt{6: f(7.464102) = -994.830633}$
$\texttt{7: f(7.464102) = -994.830633}$
$\texttt{8: f(7.464102) = -994.830633}$
$\texttt{9: f(7.464102) = -994.830633}$
In [29]:
def w(x):
return x**4 - 10 * x**3 + 8 * x
def w_linha(x):
return 4 * x**3 - 30 * x**2 + 8
def w_2linha(x):
return 12 * x**2 - 60 * x
x0 = 8.00
xi = x0
for i in range(10):
xi = xi - w_linha(xi) / w_2linha(xi)
print('%d: f(%.6f) = %.6f' % (i, xi, w(xi)))
In [ ]: