1.4 Taylor-Polinomio Ejercicio01

Referencia: Burden 7Ed Capítulo 1.1 Ejemplo 3.  p11, pdf 21; 9Ed p11. Chapra, 4.1 p80, pdf104.   Taylor Series (Wikipedia)

Para la siguiente función trigonométrica:

f(x) = \cos (x)

alrededor de  x0 = 0, encontrar:

a) el segundo polinomio de Taylor (n=2),

b) el tercer polinomio de Taylor (n=3), para aproximar cos(0.01)

c) con el resultado anterior y su término residuo aproximar \int_{0}^{0.1} \cos(x) dx


Desarrollo analítico

Para el polinomio de Taylor:

P_{n}(x) = \sum_{k=0}^{n} \frac{f^{(k)}(x_0)}{k!} (x-x_0)^k P_{n}(x) = f(x_0)+\frac{f'(x_0)}{1!} (x-x_0) + + \frac{f''(x_0)}{2!}(x-x_0)^2 + + \frac{f'''(x_0)}{3!}(x-x_0)^3 + \text{...}

se desarrollan las derivadas y se se evalua en x0 =0

f(x) = cos(x) f(0) = 1
f'(x) = -sen(x) f'(0) = 0
f»(x) = -cos(x) f»(0) = -1
f»'(x) = sen(x)  f»'(0) = 0
f4(x) = cos(x)  f4(0) = 1

En el literal «a» para n=2 y x0=0:

cos(x) = 1 - \frac{1}{2}x^2 + \frac{1}{6}x^3 \sin(\xi(x))

El último término es el residuo (o error de truncamiento), ξ(x) está entre 0 y x

cos(0.01) = 1 - \frac{1}{2}(0.01)^2 + \frac{1}{6}(0.01)^3 \sin(\xi(x)) = 0.99995 + 0.16 x 10^-6 \sin(\xi(x))

donde 0<ξ(x) <0.01

donde la aproximación coincide por lo menos con los cinco primeros dígitos.

Observe que los términos impares evaluados en x0=0 se anulan, por lo que el polinomio solo cambia con términos pares.

Tarea: revisar y continuar con los siguientes literales.


Desarrollo con Python

Una forma de obtener los polinomios de Taylor es crear una función que resuelva el polinomio.

Luego el polinomio se evalúa en el rango [a, b] que incluya x0.

Por facilidad se usarán funciones matemáticas expresadas de forma simbólica con Sympy, con lo que se obtiene las derivadas y se crea el polinomio para cada grado.

Revisar: Funciones simbólicas Sympy

# Aproximación Polinomio de Taylor alrededor de x0
# f(x) en forma simbólica con sympy

import numpy as np
import sympy as sym

def politaylor(funcionx,x0,n):
    k = 0
    polinomio = 0
    while (k <= n):
        derivada   = funcionx.diff(x,k)
        derivadax0 = derivada.subs(x,x0)
        divisor   = np.math.factorial(k)
        terminok  = (derivadax0/divisor)*(x-x0)**k
        polinomio = polinomio + terminok
        k = k + 1
    return(polinomio)

# PROGRAMA  -------------
# Capitulo 1 Ejemplo 2, Burden p11, pdf 21
# INGRESO
x = sym.Symbol('x')
funcionx = sym.cos(x) 

x0 = 0          
n  = 10         # Grado polinomio Taylor
a  = -5 ; b = 5  # x entre [a,b]
muestras = 51

# PROCEDIMIENTO
# tabla polinomios
px_tabla = []
for grado in range(0,n,1):
    polinomio = politaylor(funcionx,x0,grado)
    px_tabla.append(polinomio)

# SALIDA
print('grado :  polinomio')
for grado in range(0,n,1):
    px = px_tabla[grado]
    print(str(grado)+ ' : '+str(px))
    
    # print('polinomio: ')
    # sym.pprint(px)
    # print()

Con lo que se obtiene los polinomios para cada grado calculado.

grado :  polinomio
0 : 1
1 : 1
2 : -x**2/2 + 1
3 : -x**2/2 + 1
4 : x**4/24 - x**2/2 + 1
5 : x**4/24 - x**2/2 + 1
6 : -x**6/720 + x**4/24 - x**2/2 + 1
7 : -x**6/720 + x**4/24 - x**2/2 + 1
8 : x**8/40320 - x**6/720 + x**4/24 - x**2/2 + 1
9 : x**8/40320 - x**6/720 + x**4/24 - x**2/2 + 1

Otra forma de presentar la salida es ¨pretty print¨ con sym.pprint(), borre los # de las tres últimas líneas de código para obtener:

grado :  polinomio
0 : 1
polinomio: 
1

1 : 1
polinomio: 
1

2 : -x**2/2 + 1
polinomio: 
   2    
  x     
- -- + 1
  2     

3 : -x**2/2 + 1
polinomio: 
   2    
  x     
- -- + 1
  2     

4 : x**4/24 - x**2/2 + 1
polinomio: 
 4    2    
x    x     
-- - -- + 1
24   2     

5 : x**4/24 - x**2/2 + 1
polinomio: 
 4    2    
x    x     
-- - -- + 1
24   2     

6 : -x**6/720 + x**4/24 - x**2/2 + 1
polinomio: 
    6    4    2    
   x    x    x     
- --- + -- - -- + 1
  720   24   2     


Grafica de resultados

La forma gráfica de cada polinomio se obtiene evaluando cada polinomio para obtener las líneas en el intervalo [a,b] para cada punto del vector xi . Se utiliza un cierto número de muestras en cada intervalo [a,b].

El resultado es una matriz, px_lineas, cuya fila representa el grado del polinomio, y la columna contiene los valores del polinomio de cado grado evaluado en cada punto xi

# GRAFICA - TABLA polinomios ------
xi = np.linspace(a,b,muestras)
# Forma lambda, simplifica evaluación
fx = sym.utilities.lambdify(x,funcionx,'numpy')
fi = fx(xi)

# lineas de cada grado de polinomio
px_lineas = np.zeros(shape=(n,muestras), dtype =float)
for grado in range(0,n,1):
    polinomio = px_tabla[grado]
    px = sym.utilities.lambdify(x,polinomio,'numpy')
    px_lineas[grado] = px(xi)

los valores se pueden graficar en con las siguientes instrucciones:

# SALIDA - GRAFICA
import matplotlib.pyplot as plt
plt.plot(xi,fi,'r',label=str(funcionx))
for grado in range(0,n,2):
    etiqueta = 'grado: '+str(grado)
    plt.plot(xi, px_lineas[grado],'-.',label = etiqueta)

ymax = 2*np.max(fi)
plt.xlim([a,b])
plt.ylim([-ymax,ymax])
plt.xlabel('x')
plt.ylabel('y')
plt.title('Aproximación con Polinomios de Taylor')
plt.legend()
plt.show()

Polinomio usando Sympy:

>>> import sympy as sym
>>> x = sym.Symbol('x')
>>> fx = sym.cos(x)
>>> polinomio = sym.series(fx,x,x0=0, n=3)
>>> polinomio
1 - x**2/2 + O(x**3)
>>>