<jupyter_start><jupyter_text>Análise Numérica - 1  Questão 1  Mostre quantos termos são necessários para calcular e corretamente até a décima casa decimal (ie, acurácia 11) usando a expansão em série de Taylor de $f(x) = e^x$ Sabemos que $:$$f(x) \approx \sum_{k=0}^\infty \frac{f^{(k)}(c)}{k!}(x - c)^{k} $$e^x  = \sum_{n=0}^\infty \frac{x^n}{n!} $$e^x$ é $C^{\infty}$Assim dado um $I = [a,b]$ podemos usar o $Teorema$ $de$ $Taylor$ $:$$f(x+h) = \sum_{k=0}^\infty \frac{f^{(k)}(c)}{k!}(h)^{k} +E_{n+1} $$E_{n+1} := \frac{f^{(n+1)}(\xi)}{(n+1)!}h^{n+1}$Dado $e^{1+h}$ vamos computar $e^{1,00001}$ $:$Se $f(x) = e^x$ temos que $f^{(n)}(x) = e^{x}$ $\forall$ $n$ $\ni$ $\mathbb{N} $ , usando $x=1$ e $n=13$ $:$$e + eh + \frac{e}{2}h^2 + \; ... \; \frac{e^{\xi}}{14!}h^{14}$$1 \le \xi \le 1+h$$\frac{e^{\xi}}{14!}h^{14}$ < $10^{-10}$Logo, com grau 14, conseguimos aproximar $e^{x}$ com $x = 1$ com acurácia $11$ (i.e até a décima casa decimal)  Testando numéricamente com $x = 1$ $:$<jupyter_code>import math
print(u'e = {}'.format(math.e))
taylorn = 2
n1 = 1
n2 = 2
print(u'<NAME> {} : {}'.format(1,1))
print(u'<NAME> {} : {}'.format(2,2))
while math.e - taylorn > 10**-10:
    n1 = n1 + 1
    n2 = n2 + 1
    taylorn = taylorn + 1/(math.factorial(n1))
    print(u'<NAME> grau {} : {}'.format(n2,taylorn))<jupyter_output><NAME> 1 : 1
<NAME> 2 : 2
<NAME> 3 : 2.5
<NAME> 4 : 2.6666666666666665
<NAME> 5 : 2.708333333333333
<NAME> 6 : 2.7166666666666663
<NAME> 7 : 2.7180555555555554
<NAME> 8 : 2.7182539682539684
Taylor de grau 9 : 2.71827876984127
<NAME> grau 10 : 2.7182815255731922
<NAME> 11 : 2.7182818011463845
<NAME> grau 12 : 2.718281826198493
<NAME> grau 13 : 2.7182818282861687
<NAME> grau 14 : 2.7182818284467594<jupyter_text>Questão 2  Implemente um programa que calcule o valor de um polinômio qualquer em um ponto $x_0$ (ambos fornecidos pelo usuário), utilizando o algoritmo de Horner. Coloque o código completo, dizendo em qual programa/linguagem foi escrito e coloque um exemplo numérico simples do funcionamento.<jupyter_code>#Pseudocódigo do Livro
integer n, k, j ; real r ; real array (ai )0:n
    for k = 0 to n - 1 do
        for j = n - 1 to k do
        aj <- aj + raj+1
        end for
    end for
#Algoritimo Horner em Python:
# p = [Lista de Coeficientes do Polinômio]
# x = Valor de x do Polinômio
# Polinômio = a[0]*(x**0) + a[1]*(x**1) + a[2]*(x**2) + a[3]*(x**3) ....

def horner(x, p):
    stack = 0 
    for i in range(len(p)-1, -1, -1):
        stack = p[i] + (x * stack) #Recurssão
    return stack<jupyter_output><empty_output><jupyter_text>Testando em $P(5) = 1\,(5^0) + 2\,(5^{1}) + 3\,(5^{2})$ $:$<jupyter_code>horner(5,[1,2,3]) 
#Verificando Usando Numpy
import numpy as np
#P.s np.polyval lê os coeficientes ao contrário
np.polyval([3,2,1],5)<jupyter_output><empty_output>
StarcoderdataJupyterStructuredCleanDedup