Ejercicio: 3Eva2026PAOI_T1 Trayectoria paramétrica cerca a origen

La trayectoria de un objeto se describe por las ecuaciones paramétricas mostradas.

intervalo entre [π/2, 19π/32]

literal a

Realice el planteamiento:

Se empieza por determinar la distancia de cada punto en la trayectoria al origen [0,0]

d²= (x₂-x₁)² +(y₂-y₁)²

Para encontrar el punto mas cercano se observa el comportamiento de la gráfica dentro del intervalo dada en el enunciado del ejercicio:

Se observa que existen dos mínimos dentro del intervalo, por lo que para el análisis se reduce el intervalo a [π/2, 1.65] enfocando el algoritmo a la primera raíz.

Para encontrar el mínimo se obtienen la derivada de la distancia dfd que se puede simplificar usando las tablas trigonométricas. También es posible realizar la operación con asistencia de la instrucción sym.diff() de Sympy usadas desde la unidad 1 para el Polinómio de Taylor y simplificar la expresión con sym.simplify().

# trayectoria avion y distancia a origen
# literal a
import sympy as sym

# INGRESO
t = sym.Symbol('t')
fx = 2.3*sym.cos(10*t)+sym.cos(23*t)
fy = 2.3*sym.sin(10*t)-sym.sin(23*t)
fd = sym.sqrt(fx**2 + fy**2)

# PROCEDIMIENTO
fd_s = sym.simplify(fd)
dfd = sym.diff(fd_s,t,1)
dfd_s = sym.simplify(dfd)

# SALIDA
print('fd: ',fd)
print('fd simplificado:')
sym.pprint(fd_s)
print("fd':")
sym.pprint(dfd_s)

con lo que se obtiene la expresión para la búsqueda de raíces:

fd:  sqrt((2.3*sin(10*t) - sin(23*t))**2 + (2.3*cos(10*t) + cos(23*t))**2)
fd simplificado:
                   _______________________________________
8.57904423581089⋅╲╱ 0.0625⋅cos(33⋅t) + 0.0854619565217391 
fd':
      -8.84713936817998⋅sin(33⋅t)        
─────────────────────────────────────────
  _______________________________________
╲╱ 0.0625⋅cos(33⋅t) + 0.0854619565217391 

literal b

Se puede utilizar un método numérico, se escoge Bisección por ser el más básico que el estudiante aprendió en la primeras clases. Aunque se espera que seleccione uno más eficiente.

Siendo la fd' para obtener el cruce por cero, se tiene que:

Se valida el intervalo revisando el cambio de signo:

con lo que se comprueba el cambio de signo dentro del intervalo seleccionado. Se inician las iteraciones

itera 0

a=π/2, b = 1.65

cambio de signo a la derecha: a=1.6104,b =1.65

tramo = |1.65-1.6104| = 0.03960

itera 1

a=1.6104, b = 1.65

cambio de signo a la izquierda: a=1.6104,b =1.6302

tramo = |1.6302-1.6104| = 0.01980

itera 2

a=1.6104, b = 1.6302

cambio de signo a la izquierda: a=1.6104,b =1.6203

tramo = |1.6203-1.6104| = 0.0099

Aun el error o tramo es mayor que la tolerancia del ejercicio de 10^-3, por lo que el valor final se lo obtiene usando el algoritmo

literal c

Revisando los errores según los tramos en cada iteración, estos disminuyen, por lo que el método converge. Según la tabla de resultados.txt la raíz se encuentra en raíz en 1.6184 con error de 0.0006187

literal d

los resultados del algoritmo se presentan como:

método de la Bisección
i ['a', 'c', 'b'] ['f(a)', 'f(c)', 'f(b)']
   tramo
0 [1.5708 1.6104 1.65  ] [-30.2633 -14.5607  32.8955]
   0.03960183660255168
1 [1.6104 1.6302 1.65  ] [-14.5607  20.2057  32.8955]
   0.019800918301275727
2 [1.6104 1.6203 1.6302] [-14.5607   3.6532  20.2057]
   0.009900459150637753
3 [1.6104 1.6153 1.6203] [-14.5607  -5.8224   3.6532]
   0.004950229575318765
4 [1.6153 1.6178 1.6203] [-5.8224 -1.1031  3.6532]
   0.0024751147876593826
5 [1.6178 1.6191 1.6203] [-1.1031  1.2804  3.6532]
   0.0012375573938296913
6 [1.6178 1.6184 1.6191] [-1.1031  0.0888  1.2804]
   0.0006187786969147346
f: -8.84713936817998*sin(33*t)/sqrt(0.0625*cos(33*t) + 0.0854619565217391)
Método de la Bisección
iteraciones: 7
raíz en:  1.6184422864573413
errado: 0.0006187786969147346

la gráfica de búsqueda de raíz es:

Algoritmo en Python

Continua a partir de literal a y el método de la bisección publicado como función para observar la tabla y valores a usar en las iteraciones.

# Tema 1 trayectoria avion y distancia a origen
# Método de la Bisección
# [a,b] se seleccionan de la gráfica de f(x)
import numpy as np
# INGRESO
f = sym.lambdify(t,dfd)

# intervalo grafica
a0 = np.pi/2
b0 = np.pi*19/32

# intervalo bUsqueda de raiz
a = np.pi/2
b = 1.65
muestras = 41
tolera = 0.001
verdigitos=4

# PROCEDIMIENTO
def biseccion(fx,a,b,tolera,iteramax = 50,
                    vertabla=False, precision=6):
    '''Algoritmo de Bisección
    Los valores de [a,b] son seleccionados
    desde la gráfica de la función
    error = tolera
    '''
    fa = fx(a)
    fb = fx(b)
    tramo = np.abs(b-a)
    itera = 0
    cambia = np.sign(fa)*np.sign(fb)
    tabla=[]
 
    if cambia<0: # existe cambio de signo f(a) vs f(b)
        if vertabla==True:
            print('método de la Bisección')
            print('i', ['a','c','b'],[ 'f(a)', 'f(c)','f(b)'])
            print('  ','tramo')
            np.set_printoptions(precision)
              
        while (tramo>=tolera and itera<=iteramax):
            c = (a+b)/2
            fc = fx(c)
            cambia = np.sign(fa)*np.sign(fc)
            unafila = np.array([a,c,b,fa,fc,fb])
            if (cambia<0):
                b = c
                fb = fc
            else:
                a = c
                fa = fc
            tramo = np.abs(b-a)
            unafila = np.concatenate([unafila,[tramo]],axis=0)
            tabla.append(unafila)
            if vertabla==True:
                print(itera,unafila[0:3],unafila[3:6])
                print('  ',tramo)
            itera = itera + 1
        respuesta = c
        # Valida respuesta
        if (itera>=iteramax):
            respuesta = np.nan
  
    else: 
        print(' No existe cambio de signo entre f(a) y f(b)')
        print(' f(a) =',fa,',  f(b) =',fb) 
        respuesta=np.nan
    tabla = np.array(tabla,dtype=float)
    return(respuesta,tabla)
 
c,tabla = biseccion(f,a,b,tolera,
                    vertabla=True,
                    precision=verdigitos)
n = len(tabla)
errado = tabla[n-1,6]
 
# SALIDA
print('f:', dfd.simplify())
print('Método de la Bisección')
print('iteraciones:',n)
print('raíz en: ',c)
print('errado:',errado)

# GRAFICA
import matplotlib.pyplot as plt
tk = np.linspace(a0,b0,muestras)
fk = f(tk)
plt.plot(tk,fk)
plt.plot(a,f(a),'o',label='[a,f(a)]')
plt.plot(b,f(b),'o',label='[b,f(b)]')
plt.axhline(0)
plt.xlabel('t')
plt.ylabel('f(t)')
plt.title('Intervalo ['+str(a0)+','+str(b0)+']')
plt.legend()
plt.tight_layout()
plt.show()

literal e

Con el algoritmo completo, modifique los parámetros de la ecuaciones iniciales para acercar más la trayectoria al punto 0,0

Por ejemplo disminuya las amplitudes de las sinusoides de 2.3 a 0.9 y observe los resultados. Se adjunta solo la gráfica, realice los cambios como parte de la tarea.

Otras gráficas mostradas en el ejercicio, no obligatorias para el tema se obtienen con instrucciones adicionales:

# Distancia a origen
fdk = sym.lambdify(t,fd)
dk = fdk(tk)

plt.plot(tk,dk)
plt.xlabel('t')
plt.ylabel('d')
plt.title('trayectoria objeto: distancia a [0,0]')
plt.tight_layout()
plt.show()

# Trayectoria avion
fxk = sym.lambdify(t,fx)
fyk = sym.lambdify(t,fy)
xk = fxk(tk)
yk = fyk(tk)
plt.plot(xk,yk)
plt.plot([0],[0],'o')
plt.annotate('[0,0]',xy=[0,0],xytext=[0+0.1,0+0.1])
plt.plot(xk[0],yk[0],'o')
plt.annotate('t0',xy=[xk[0],yk[0]],xytext=[xk[0]+0.1,yk[0]-0.05])
plt.xlabel('x(t)')
plt.ylabel('y(t)')
plt.title('trayectoria objeto')
plt.tight_layout()
plt.show()

literal a (alterno)

A partir de la expresión de la distancia,

Si se separa de la magnitud física y se enfoca en la expresión, se puede considerar que los valores mínimos de mantienen al expresar f respecto a d².

Con lo que f ya no es distancia, pero mantiene la forma de la gráfica para encontrar el mínimo. La expresión derivada y simplificada con Sympy se convierte en:

fd:  (2.3*sin(10*t) - sin(23*t))**2 + (2.3*cos(10*t) + cos(23*t))**2
fd':
-151.8⋅sin(33⋅t)

Queda como tarea realizar los otros literales con ésta opción, el resultado debe ser el mismo que el presentado en el desarrollo anterior.