Ejercicio: 3Eva2026PAOI_T2 Pista para vehículo seguidor de línea

Las ecuaciones y los intervalos del ejercicio son:

x(t) = 2\cos(t) +2 y(t) = 2\sin(2t) +2

Intervalos = [ [0, π],
[ π, 47/64(2π)],
[7/8(2π), 2π]]

literal a

Para el planteamiento del ejercicio se selecciona el primer intervalo de tiempo [0, π]. En el intervalo se seleccionan al menos 3 tramos o 4 muestras para obtener un polinomio de grado 3. Con el algoritmo se podrá revisar el resultado en la gráfica y observar si es necesario aumentar el número de muestras

Solo 2 tramos o 3 muestras para un polinomio de grado 2 será una parábola que no representa el intervalo. Adicionalmente el resultado sería una línea horizontal al tener valor igual a los extremos en el centro del intervalo.

El tamaño de paso h = (π-0)/3 = π/3

literal b

Con lo que se obtienen los valores para interpolar y obtener el polinomio p(x) usando las coordenadas x,y.

Las expresiones siguiendo el algoritmo para el método de Lagrange son:

La simplificación de la expresión realizada con sym.expand()

literal c

La gráfica del polinomio obtenido, junto a la gráfica paramétrica x(t),y(t) permite observar el nivel de aproximación para el grado 3 de polinomio.

Los resultados del algoritmo para el ejercicio son:

    valores de xi:  [4. 3. 1. 0.]
    valores de yi:  [2.         3.73205081 0.26794919 2.        ]
divisores en L[i]:  [ 12.  -6.   6. -12.]

Interpolación Lagrange Pista concurso
0.166666666666667*x*(x - 3.0)*(x - 1.0) +
0.0446581987385205*x*(x - 4.0)*(x - 3.0) +
-0.166666666666667*(x - 4.0)*(x - 3.0)*(x - 1.0) +
-0.622008467928146*x*(x - 4.0)*(x - 1.0)

Polinomio de Lagrange: 
-0.577350269189626*x**3 + 3.46410161513775*x**2 - 4.61880215351701*x + 2.0
p(x):
                     3                     2                           
- 0.577350269189626⋅x  + 3.46410161513775⋅x  - 4.61880215351701⋅x + 2.0

Algoritmo en Python

Usando el algoritmo base de la unidad 5 para interpolación con el método de Lagrange:

# Pista para vehículo autonomo
import numpy as np
import sympy as sym

# INGRESO
fx = lambda t: 2*np.cos(t)+2
fy = lambda t: 2*np.sin(2*t)+2
ttramo = [[0,np.pi],[np.pi,47/64*(2*np.pi)],[7/8*(2*np.pi),2*np.pi]]
a = ttramo[0][0]
b = ttramo[0][1]
muestras = 4

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

# Interpolacion de Lagrange
# divisoresL solo para mostrar valores denominador
titulo = 'Interpolación Lagrange Pista concurso'
 
# PROCEDIMIENTO
# Vectores como arreglo, numeros reales
xi = np.array(xi,dtype=float)
fi = np.array(fi,dtype=float)
n = len(xi)
 
# Polinomio de Lagrange
x = sym.Symbol('x')
polinomio = 0*x   # sym.S.Zero en Sympy
divisorL = np.zeros(n, dtype = float)
for i in range(0,n,1):
     
    # Termino de Lagrange
    numerador = 1
    denominador = 1
    for j  in range(0,n,1):
        if (j!=i):
            numerador = numerador*(x-xi[j])
            denominador = denominador*(xi[i]-xi[j])
    terminoLi = numerador/denominador
 
    polinomio = polinomio + terminoLi*fi[i]
    divisorL[i] = denominador
 
polisimple = polinomio.expand() # simplifica los (x-xi)
px = sym.lambdify(x,polisimple) # evaluación numérica
 
# SALIDA
print('    valores de xi: ',xi)
print('    valores de yi: ',fi)
print('divisores en L[i]: ',divisorL)
print()
print(titulo)
#print(polinomio)
terminos = sym.Add.make_args(polinomio)
n_term = len(terminos)
for i in range(0,n_term,1):
    if i<(n_term-1):
        print(terminos[i],'+')
    else:
        print(terminos[i])
print()
print('Polinomio de Lagrange: ')
print(polisimple)
print('p(x):')
sym.pprint(polisimple)

# Gráfica --------------
import matplotlib.pyplot as plt
 
muestras2 = 4*muestras   # resolución gráfica

tk = np.linspace(a,b,muestras2)
xf = fx(tk)
yf = fy(tk)

a = np.min(xi)  # intervalo [a,b]
b = np.max(xi)
xk = np.linspace(a,b,muestras2)
yk = px(xk)

plt.plot(xi,fi,'o', label = '[xi,fi]')
plt.plot(xk,yk, label = 'p(x)')
plt.plot(xf,yf, label = '[xf,yf]')
plt.legend()
plt.xlabel('xi')
plt.ylabel('fi')
plt.title(titulo)
plt.tight_layout()
plt.show()

literal d

Para determinar la cota de error, será necesario aumentar el número de muestras y calcular el error entre las que no se usan para generar el polinomio. por ejemplo con tamaño de paso π/6 en t

Los valores de la tabla se pueden obtener como:

>>> tk = np.linspace(0,np.pi,7)
>>> tk
array([0.        , 0.52359878, 1.04719755, 1.57079633, 2.0943951 ,  2.61799388, 3.14159265])

>>> fy(tk)-px(fx(tk))
array([ 1.03028697e-13,  7.32050808e-01,  6.12843110e-14,  2.88657986e-14,
        8.65973959e-15, -7.32050808e-01, -4.44089210e-16])

Nota: considere los valores de e-12 como casi cero por ser muy pequeños, de orden de magnitud muy bajo.

Considerando el error =max | p(x)-y(t) | = 0.73205081

literal e

Para los siguientes intervalos se cambia la selección usando solo el índice de fila de tramo en el algoritmo. Con los resultados es posible comentar y mejorar los resultados cambiando el grado del polinomio para que exista un mejor ajuste a la curva original de la pista.

a = ttramo[1][0]
b = ttramo[1][1]

    valores de xi:  [0.         0.23615747 0.88885953 1.80396572]
    valores de yi:  [2.         3.66293922 3.84775907 2.39018064]
divisores en L[i]:  [-0.37867192  0.2416627  -0.53090842  2.58816951]

Interpolación Lagrange Pista concurso
15.1572388033053*x*(x - 1.80396571934088)*(x - 0.888859533960796) +
0.923502358637029*x*(x - 0.888859533960796)*(x - 0.23615747130329) +
-7.24750058330231*x*(x - 1.80396571934088)*(x - 0.23615747130329) +
-5.28161682322365*(x - 1.80396571934088)*(x - 0.888859533960796)*(x - 0.23615747130329)

Polinomio de Lagrange: 
3.55162375541638*x**3 - 11.5991928303255*x**2 + 9.58281483750129*x + 2.0
p(x):
                  3                     2                           
3.55162375541638⋅x  - 11.5991928303255⋅x  + 9.58281483750129⋅x + 2.0

a = ttramo[2][0]
b = ttramo[2][1]

   valores de xi:  [3.41421356 3.73205081 3.93185165 4.        ]
    valores de yi:  [0.         0.26794919 1.         2.        ]
divisores en L[i]:  [-0.09637632  0.01701589 -0.00704821  0.01069663]

Interpolación Lagrange Pista concurso
15.7470023202161*(x - 4.0)*(x - 3.93185165257814)*(x - 3.41421356237309) +
186.974724475551*(x - 3.93185165257814)*(x - 3.73205080756888)*(x - 3.41421356237309) +
-141.879981884845*(x - 4.0)*(x - 3.73205080756888)*(x - 3.41421356237309)

Polinomio de Lagrange: 
60.8417449109225*x**3 - 668.562419392989*x**2 + 2446.6806568994*x - 2981.59559160881
p(x):
                  3                     2                                       
60.8417449109225⋅x  - 668.562419392989⋅x  + 2446.6806568994⋅x - 2981.59559160881