1.4.2 Taylor-Polinomio con gráfico animado

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

El ejercicio se presenta como un complemento para la sección 1.4 para animar la gráfica. Solo como referencia a lo realizado para exponer el tema:

# 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):
    i = 0
    polinomio = 0
    while (i <= n):
        derivada   = funcionx.diff(x,i)
        derivadax0 = derivada.subs(x,x0)
        divisor   = np.math.factorial(i)
        terminoi  = (derivadax0/divisor)*(x-x0)**i
        polinomio = polinomio + terminoi
        i = i + 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()


# 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)


# SALIDA
# GRAFICA CON ANIMACION ------------
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Parametros de trama/foto
narchivo = 'Taylor01' # nombre archivo
retardo = 700   # milisegundos entre tramas
tramas = len(px_lineas)
ymax = 2*np.max(np.abs(fi))

# GRAFICA figura
figura, ejes = plt.subplots()

# Función Base
fx_linea, = ejes.plot(xi,fi,'r')

# Polinomios de tablapoli grado = 0
px_unalinea, = ejes.plot(xi, px_lineas[0],
                         '-.', label='grado: 0')

# Configura gráfica
plt.xlim([a,b])
plt.ylim([-ymax,ymax])
plt.axhline(0, color='k')  # Linea horizontal en cero
plt.title('Polinomio Taylor: '+'f(x) = ' + str(funcionx))
plt.xlabel('x')
plt.ylabel('y')
plt.grid()

# cuadros de texto en gráfico
txt_x = (b+a)/2
txt_y = ymax*(1-0.1)
texto_poli = ejes.text(txt_x, txt_y*(1),
                      'p(x):',
                      horizontalalignment='center')
texto_grado = ejes.text(txt_x, txt_y*(1-0.1),
                        'grado:',
                        horizontalalignment='center')

# Nueva Trama
def unatrama(i,xi,pxi):
    
    # actualiza cada linea
    px_unalinea.set_xdata(xi)
    px_unalinea.set_ydata(pxi[i])
    etiquetap = 'p'+str(i)+'(x) = '+str(px_tabla[i])
    px_unalinea.set_label(etiquetap)
    
    # actualiza texto
    texto_poli.set_text(etiquetap)
    texto_grado.set_text('Grado: '+str(i))
    
    # color de la línea
    if (i<=9):
        lineacolor = 'C'+str(i)
    else:
        numerocolor = i%10
        lineacolor = 'C'+str(numerocolor)
    px_unalinea.set_color(lineacolor)
    
    return (px_unalinea, texto_poli, texto_grado)

# Limpia Trama anterior
def limpiatrama():
    
    px_unalinea.set_ydata(np.ma.array(xi, mask=True))
    px_unalinea.set_label('')
    
    texto_poli.set_text('')
    texto_grado.set_text('')
    
    return (px_unalinea,texto_poli, texto_grado)

# Trama contador
i = np.arange(0,tramas,1)
ani = animation.FuncAnimation(figura,
                              unatrama,
                              i ,
                              fargs = (xi,px_lineas),
                              init_func = limpiatrama,
                              interval = retardo,
                              blit=True)
# Graba Archivo GIFAnimado y video
ani.save(narchivo+'_GIFanimado.gif', writer='imagemagick')
# ani.save(narchivo+'_video.mp4')
plt.draw()
plt.show()

1.2.1 Máximo en intervalo-Ejercicio

Referencia: Burden Capítulo 1.1 Ejercicio 3a p15, pdf 25

Demuestre que f'(x) se anula al menos una vez en los intervalos dados.

f(x) = 1 - e^{x} + (e-1)sen(\frac{\pi}{2}x)

en el intervalo [0,1]


Desarrollo analítico

Se usa el «teorema de Rolle«, si los extremos del intervalo son iguales, existe un punto intermedio c en el que la derivada es cero, en donde la función tiene un máximo.

f(0) = 1 - e^{0} + (e-1)sen(\frac{\pi}{2}0) = = 1 - 1 + (e-1)(0) = 0 f(1) = 1 - e^{1} + (e-1)sen(\frac{\pi}{2}1) = = 1 - e + (e-1)(1) = 0 f(0) = f(1)

por el teorema, debe existir un máximo, o existe un c tal que f'(c) = 0.


Desarrollo numérico y gráfico

Para encontrar el máximo, se evalúa en los extremos, se aplica Rolle y como comprobación se muestra la gráfica.

Puntos en extremos de intervalo
(xi,fi)
0 0.0
1 0.0


Las instrucciones para obtener el resultado con Python son:

# Burden Capítulo 1.1 Ejercicio 3a p15, pdf 25

import numpy as np
import matplotlib.pyplot as plt

funcionx = lambda x: 1 - np.exp(x) + (np.exp(1)-1)*np.sin((np.pi/2)*x)

# INGRESO
a = 0
b = 1
muestras = 51

# PROCEDIMIENTO
fa = funcionx(a)
fb = funcionx(b)

xi = np.linspace(a,b,muestras)
fi = funcionx(xi)

# SALIDA
print('Puntos en extremos de intervalo')
print('(xi,fi)')
print(a,fa)
print(b,fb)

# GRAFICA
plt.plot(xi,fi)
plt.xlabel('x')
plt.ylabel('f(x)')
plt.axhline(0,color='g')
plt.show()

añada las instrucciones para encontrar el punto donde f'(x) pasa por cero, que es donde existe el máximo. use como referencia:

1.2 Máximo en intervalo-Ejemplo01

1.3.1 Raices en intervalo-Ejercicio02

Referencia: Capítulo 1.1 Ejercicio 1. Burden p15, pdf 25

Demuestre que las siguientes ecuaciones tienen al menos una solución en los intervalos dados

x \cos (x) - 2 x^{2} + 3 x -1 = 0

en el intervalo [0.2, 0.3] y [1.2, 1.3]


Desarrollo analítico

Del «teorema del valor intermedio«, si hay cambio de signo al evaluar la función en los puntos x=0.2 y x=0.3, debe existir un punto c donde se cumple la expresión.

f(x) = x \cos (x) - 2 x^{2} + 3 x -1 f(0.2) = 0.2 \cos (0.2) - 2 (0.2)^2 +3(0.2) -1 = -0.2839 f(0.3) = 0.2 \cos (0.3) - 2 (0.3)^2 +3(0.3) -1 = 0.00660094

Hay cambio de signo de la función en el intervalo, por lo que la ecuación debe pasar por cero, y se cumple la igualdad.


Desarrollo numérico con Python

Por simplicidad se usa la ventana iteractiva. Se evalua la función en los puntos extremos del intervalo y con los resultados se continua de forma semejante a la sección de desarrollo analítico.

>>> import numpy as np
>>> fx = lambda x: x*np.cos(x) - 2*(x**2) + 3*x -1
>>> fx(0.2)
-0.28398668443175157
>>> fx(0.3)
0.0066009467376817454

es decir, por cambio de signo, debe haber un cruce por cero de la función en el intervalo.


Desarrollo con gráfica

Como existen varios intervalos, [0.2, 0.3] y [1.2, 1.3] se unifican los intervalos entre los extremos x=[0.2, 1.3].

Para la gráfica se crean 100 tramos (pasos o divisiones) en el intervalo que equivalen a 101 muestras en el intervalo

>>> muestras=101
>>> xi = np.linspace(0.2,1.3,muestras)
>>> fi = fx(xi)
>>> xi
array([ 0.2 , 0.211, 0.222, 0.233, 0.244, 0.255, 0.266, 0.277, ... 1.256, 1.267, 1.278, 1.289, 1.3 ])
>>> fi
array([-0.28398668, -0.24972157, -0.21601609, -0.18287411, -0.15029943, ...,  -0.13225152])

Una gráfica permite observar mejor la función en el intervalo.
Se necesita llamar a la librería matplotlib.pyplot que se resume como plt.

>>> import matplotlib.pyplot as plt
>>> plt.plot(xi,fi)
[<matplotlib.lines.Line2D object at 0x0000020C67820E80>]
>>> plt.axhline(0,color='g')
<matplotlib.lines.Line2D object at 0x0000020C678204E0>
>>> plt.show()

plt.plot() crea la gráfica con los vectores xi y fi , añadiendo como referencia en este caso una linea horizontal que pasa por cero, usando plt.axhline(). Finalmente se muestra la gráfica con plt.show().

De la gráfica, fácilmente se puede observar que existen dos puntos «c» que cumplen con la igualdad y que se encuentran en los intervalos de evaluación, con lo que se comprueba que existe solución en los intervalos presentados en el problema.


Resumen de instrucciones Python

import numpy as np
import matplotlib.pyplot as plt

fx = lambda x: x*np.cos(x) - 2*(x**2) + 3*x -1

# INGRESO
a = 0.2
b = 1.3
muestras = 101

# PROCEDIMIENTO
xi = np.linspace(a,b,muestras)
fi = fx(xi)

# SALIDA - GRAFICA
plt.plot(xi,fi)
plt.axhline(0,color='g')
plt.show()

Tarea: continúe con el ejercicio usando la función de scipy.optimize.fsolve() y compare resultados.

1.4.1 Taylor-Polinomio Ejercicio02 calcular error

Referencia: Capítulo 1.1 Ejercicio 8. Burden p15, pdf 25

Obtenga el tercer polinomio de Taylor P3(x) para la función:

f(x) = \sqrt{x+1}

en torno a x0=0.

Aproxime el resultado para x=0.5, 0.75, 1.25 y 1.75 usando P3(x) y calcule los errores reales.


Desarrollo numérico

    • Determine el polinomio de Taylor, realice los pasos y verifique su respuesta con:
P_3(x) = 1 + \frac{1}{2}x - \frac{1}{8} x^2 +\frac{1}{16} x^3
  • luego calcule los valores de la tabla:
x P3(x) \sqrt{x+1} |diferencia ó error|
0.5  1.22656250000000  1.22474487139159  0.00181762860841106
0.75
1.25
1.5

Realice las observaciones a los resultados obtenidos.


Desarrollo con Python

Puede reutilizar la función del polinomio de Taylor con la fórmula simbólica usada en el enlace del ejemplo 1.1.3.

Con la función politaylor() se crea el polinomio y se evalua para calcular el error respecto al valor real de la expresión.

# Aproximación Polinomio de Taylor alrededor de x0
# función en forma simbólica con sympy

import numpy as np
import sympy as sym

# Calcula n términos del polinomio de Taylor
# funcionx es simbólica
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.1 Ejecicio 8, Burden p15, pdf 25
# Calcule el error por aproximación
# con polinomio de Taylor grado 3

# variable x es simbólica
x = sym.Symbol('x')
funcionx = sym.sqrt(x+1)

# INGRESO
x0 = 0
xi = 0.5
n  = 3

# PROCEDIMIENTO
# Referencia
fxi = funcionx.subs(x,xi)
# con Taylor
polinomio = politaylor(funcionx,x0,n)
pxi = polinomio.subs(x,xi)

error_real = fxi-pxi

# SALIDA
print(' Taylor:     ', polinomio)
print(' xi:         ', xi)
print(' estimado  : ', pxi)
print(' real:       ', fxi)
print(' error real: ', error_real)

cuyo resultado para xi=0.5 es:

 Taylor:      x**3/16 - x**2/8 + x/2 + 1
 xi:          0.5
 estimado  :  1.22656250000000
 real:        1.22474487139159
 error real:  -0.00181762860841106

complete la tabla usando también el algoritmo en Python

1.4 Taylor-Polinomio Ejercicio01

Referencia: Burden, Capítulo 1.1 Ejemplo 3.  p11, pdf 21. 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)
>>> 

1.3 Raíces en intervalo-Ejercicio01

Referencia:  Burden Capítulo 1.1 Ejemplo 2 p11, pdf 21

Para la expresión mostrada encuentre una solución en el intervalo [0,1],

x^5 -2x^3 + 3x^2 -1 = 0

considere nombrar a la parte izquierda de la ecuación como f(x), para encontrar la solucion como f(x) = 0.

f(x) = x^5 -2x^3 + 3x^2 -1

dado que al evaluar en los extremos del intervalo [0,1]:

f(0) = (0)^5 -2(0)3 + 3(0)^2 -1 = -1 f(1) = 1^5 -2(1)^3 + 3(1)^2 -1 = 1

Los valores de la función en los extremos son -1 y 1, existe cambio de signo, y dado que f es contínua, por el teorema del valor intermedio existe un valor de x en el intervalo, tal que se satisface que el valor de la función es cero.

La gráfica de la ecuación muestra el punto o raíz a buscar:

Se pueden dividir en muchas muestras el intervalo x=[a,b] y buscar los puntos xi donde la funcion f(xi) cambia de signo.

Usando un algoritmo con muestras = 1001 se encuentra que existen dos raíces.

raices en posiciones i:  [ 479.  480.]
entre los valores: 
 [ xi, fi]
[[ 0.7185     -0.00162876]
 [ 0.72        0.00219576]]

Algoritmo en Python

En el intervalo [a,b] se crean nuevos puntos de muestras para realizar la gráfica. Las muestras se usan para buscar un nuevo intervalo entre x[i] y x[i+1] donde ocurre un cambio de signo en f(x[i]).

# Burden Capítulo 1.1 Ejemplo 2 p11, pdf 21
# raices del polinomio en [a,b]

import numpy as np
import matplotlib.pyplot as plt

funcionx = lambda x: x**5 - 2*(x**3) + 3*(x**2) -1

# INGRESO
a = 0
b = 1.5
muestras = 1001

# PROCEDIMIENTO
xi = np.linspace(a,b,muestras)
fi = funcionx(xi)

# Busca cambios de signo
donde=[] # donde[i,xi,fi]
for i in range(0,muestras-1,1):
    antes = fi[i]
    despues = fi[i+1]
    signo = (np.sign(antes))*(np.sign(despues))
    if (signo<0):
        donde.append([i,xi[i],antes])
        donde.append([i+1,xi[i+1],despues])
        
donde = np.array(donde)
  
# SALIDA
print('raices en posiciones i: ', donde[:,0])
print('entre los valores: ')
print(' [ xi, fi]')
print(donde[:,1:])
      
# GRAFICA
plt.plot(xi,fi)
plt.xlabel('x')
plt.ylabel('fx')
plt.axhline(y=0, color='g')
plt.show()

Al observar los resultados, realice sus comentarios y recomendaciones relacionadas con la respuesta obtenida para mejorar la respuesta


Usando Scipy.Optimize

Continuando con el uso de funciones de scipy se obtiene una de las raices, empezando la búsqueda desde 0.4.

raices en :  [ 0.71913933]
>>>

para la otra raíz usar un nuevo punto de partida. Compare respuestas con el método anterior.

las instrucciones usadas son:

# Burden Capítulo 1.1 Ejemplo 2 p11, pdf 21
# raices del polinomio en [a,b]

import numpy as np
import scipy.optimize as opt

fx = lambda x: x**5 - 2*(x**3) + 3*(x**2) -1

# INGRESO
a = 0
b = 1.5
x0 = 0.4

# PROCEDIMIENTO
# fx pasa por cero, cerca de x0
donde = opt.fsolve(fx,x0)
  
# SALIDA
print('raices en : ', donde)

1.2 Máximo en intervalo-Ejemplo01

Referencia: Burden capítulo 1.1-ejemplo 1 p6, pdf16

Sea:

f(x) = 5 \cos(2x) - 2x \sin(2x)

Determine el valor máximo de |f(x)|  en los intervalos:

  • [1, 2]
  • [0.5, 1]

Desarrollo

Existen dos opciones, la analítica y la numérica.

Solución analítica

Se determina la derivada de f(x) y se determina el valor de x cuando f'(x) vale cero.

f(x) = 5 \cos(2x) - 2x \sin(2x) f'(x) = 5 (- 2 \sin(2x)) - [2x (2 \cos(2x)) + 2 \sin(2x) ] f'(x) = - 12 \sin(2x) - 4x \cos(2x)

f'(x) en el rango [1,2] toma el valor de cero en:

0 = - 12 \sin(2x) - 4x \cos(2x)

y requiere un poco de trabajo para encontrar el punto buscado…

Solución numérica

Otra forma es determinar el valor usando un método numérico, cuya precisión dependerá de la cantidad de muestras que se utilicen en la evaluación.

Para observar la función, se obtiene la gráfica en el rango [0.5, 2]

# Burden capítulo 1.1-ejemplo 1 p6, pdf16
# Determine el maximo entre [a,b] para fx
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
fx = lambda x: 5*np.cos(2*x)-2*x*np.sin(2*x)
a = 0.5
b = 2
muestras = 1001

# PROCEDIMIENTO
xi = np.linspace(a,b,muestras)
fi = fx(xi)

fiabs = np.abs(fi)
donde = np.argmax(fiabs)

# SALIDA
print('el máximo se encuentra en: ', xi[donde])
print('con el valor f(x): ', fiabs[donde])

# GRAFICA
plt.plot(xi,fi, label='f(x)')
plt.plot(xi,fiabs, label='|f(x)|')
plt.axhline(y=0, color='g')
plt.xlabel('x')
plt.ylabel('fx')
plt.legend()
plt.title('f(x) y |f(x)|')
plt.show()


La gráfica permite estimar las intersecciones con los ejes y extremos de las funciones.

el máximo se encuentra en: 1.358
con el valor f(x) de: 5.67530054527

El valor máximo de |fx| en magnitud se cumple cuando la derivada es cero en un punto del intervalo.


Puede revisar el tutorial de gráficas2D en la sección de recursos de estudio/resumen Python, o consultar en el sitio de matplotlib.org


Usando Scipy.Optimize

La libreria Scipy dispone de varios algoritmos de optimización que se desarrollarán durante el curso. La comprensión de cada uno de ellos permite una aplicación efectiva de los algoritmos para obtener el resultado.

Por ejemplo, usando el resultado de la derivada de la función, y buscando cuándo su valor es mínimo con la instrucción fsolve() se obtiene:

[ 1.35822987]
>>>

las instrucciones del algoritmo son:

# Burden capítulo 1.1-ejemplo 1 p6, pdf16
# Determine el maximo entre [a,b] para fx
# Encontrar el máximo cuando f'(x) pasa por cero

import numpy as np
import scipy.optimize as opt

# INGRESO
fx = lambda x: 5*np.cos(2*x)-2*x*np.sin(2*x)
dfx = lambda x: -12*np.sin(2*x)-4*x*np.cos(2*x)
a = 0.5
b = 2
muestras = 1001
x0 = 1

# PROCEDIMIENTO
dondemax  = opt.fsolve(dfx,x0)

# SALIDA
print(dondemax)

compare con los resultados anteriores.

1.1 Error y Precisión en computadoras

Imágenes

En el uso cotidiano de computadoras para el manejo de imágenes permite que las personas tengan un conocimiento previo acerca de la precisión y error.

Para tratar el tema en lenguaje común, observe las siguientes imágenes:

ESPOL Monumento 01
ESPOL Monumento 01
ESPOL Monumento 02
ESPOL Monumento 02

Con lo observado, describa lo siguiente:

  1. Sinónimos de precisión usados en imagenes de computadora
  2. Sinónimos de error usados en imagenes de computadora

Audio

Para el caso de manejo de archivos de audio, tenemos los siguientes archivos de referencia:

Archivo01 – Karla Kanora – Invernal 01

Archivo02 – Karla Kanora – Invernal 02

Con lo observado, describa lo siguiente:

  1. Sinónimos de precisión usados en audio de computadora
  2. Sinónimos de error usados en audio de computadora

Video

Este caso es más sencillo, pues implica unificar las observaciones anteriores. Para este caso se usará un video de Youtube.

Cambie la resolución del video entre las opciones que se muestran en el menú de configuración

Con lo observado, describa lo siguiente:

  1. Sinónimos de precisión usados en video digital
  2. Sinónimos de error usados en video digital

Otra perspectiva

Observe el siguiente video:

Observar el video siguiente, primer minuto (0:00-01:00), primer experimento:


Preguntas

  1. Escriba su definición de precisión
  2. Escriba su definición de error
  3. Describa la diferencia entre: precisión y error
  4. Para el estudio académico, ¿se enfocaría en la precisión o en el error?.
  5. ¿Cómo valora si  el error es tolerable o la precisión es buena o suficiente?

1.1.2 Error-por tipos en computador

Referencia: Chapra 3.3 p.56/pdf.80, Burden definición 1.15 p.20/pdf.30

Error absoluto

Es la magnitud (sin signo) entre el valor real X conocido y el valor estimado Xk.

E = |X-X_k|

El valor dependerá de la magnitud de X, por ejemplo:
– Un error al contar monedas de 1 centavo, si una persona al contar Xk = 98 y el valor real X = 100, el error absoluto es de 2 centavos ó 0.02 dólares.

¿Que pasaría si el conteo fuese con monedas de 1 dólar y se mantienen las mismas cantidades de monedas?

Error relativo

Continuando el tema del ejemplo anterior, parecería mejor dimensionar proporcionalmente los errores, es decir  ponderarlos respecto a la magnitud.

e = \frac{|X-X_k|}{X}

Ponderar el error, calculando el error relativo para ambos ejemplos anteriores, se hacen comparables cuando las monedas son de un centavs o un dolar:

e = \frac{|100-98|}{100} = 0.02

Error de redondeo

Aparece cuando se usa una calculadora o computadora para los cálculos con números reales. La calculadora usa una cantidad finita de dígitos.
Por ejemplo:

  • el número π tiene un número infinito de dígitos,
  • si el número resultante de \sqrt{3} se eleva al cuadrado, se debería obtener 3

Sin embargo podemos comprobar que lo enunciado no se cumple al usar el computador,  así obtenemos el error de redondeo.

Usando Python se obtiene:

>>> import numpy as np
>>> numeropi=np.pi
>>> numeropi
3.141592653589793

>>> b=np.sqrt(3)
>>> b
1.7320508075688772
>>> b**2
2.9999999999999996
>>> 

Error de redondeo absoluto

si X_k es una aproximación de X, el error absoluto es

E = |X-X_k|

Este error se enfoca solo en la magnitud de las diferencias, no importa el signo.

Error de redondeo relativo

El error relativo es más significativo al usar la proporción del error en lugar del tamaño del valor.

e = \frac{|X-X_k|}{X}

Error de truncamiento

Resultan al usar una aproximación en lugar de un procedimiento matemático exacto. Es la diferencia entre una respuesta esperada y el valor calculado con una fórmula iterativa. Ejemplo, al usar un polinomio de Taylor en lugar de la función original.