Autor: Edison Del Rosario

Ejercicio: 3Eva_2024PAOII_T4 Sin()Cos() Integrar con Cuadratura de Gauss

A= \int_0^7 \Big( \sin(0.1t) \cos(0.7t) +3.7 \Big) dt

literal a

Para el planteamiento del integral es necesario observar la gráfica de la función a integrar dentro del intervalo.

La función tiene al menos dos «picos» y dos valles en el intervalo. Por lo que un solo tramo del integral podría aumentar el error de integración numérica con una figura trapezoidal equivalente como propone la cuadratura de Gauss.

Se plantea usar al menos dos tramos, y comparar el resultado con tres tramos para observar el error.

Para dos tramos se dispone de los segmentos entre los puntos
[0, 3.5, 7]

Para tres tramos se tiene los segmentos entre los puntos
[ 0, 7/3, 2(7/3), 7]

literal b

Si se usan dos tramos se tienen los segmentos entre los puntos [0,3.5,7]

tramo = [0, 3.5]

x_a = \frac{3.5+0}{2} - \frac{3.5-0}{2}\Big(\frac{1}{\sqrt{3}} \Big) = 0.7396 x_b = \frac{3.5+0}{2} + \frac{3.5-0}{2}\Big(\frac{1}{\sqrt{3}} \Big) = 2.7603 f(0.7396) =\sin(0.1(0.7396)) \cos(0.7(0.7396)) +3.7 =3.7642 f(2.7603) =\sin(0.1(2.7603)) \cos(0.7(2.7603)) +3.7 =3.6036 I \cong \frac{3.5-0}{2}(f(0.7396) + f(2.7603)) I \cong \frac{3.5-0}{2}(3.7642 + 3.6036) = 12.8937

tramo = [3.5, 7]

x_a = \frac{3.5+7}{2} - \frac{7-3.5}{2}\Big(\frac{1}{\sqrt{3}} \Big) = 4.2396 x_b = \frac{3.5+7}{2} + \frac{7-3.5}{2}\Big(\frac{1}{\sqrt{3}} \Big) = 6.2603 f(4.2396) =\sin(0.1(4.2396)) \cos(0.7(4.2396)) +3.7 =3.2948 f(6.2603) =\sin(0.1(6.2603)) \cos(0.7(6.2603)) +3.7 =3.5100 I \cong \frac{7-3.5}{2}(f(4.2396) + f(6.2603)) I \cong \frac{7-3.5}{2}(3.2948 + 3.5100) = 11.9085

literal c

Integral total : = 12.8937 + 11.9085 = 24.8022

Si de compara con 3 tramos, el error se estima como la diferencia entre los dos integrales calculados

[xa,xb,f(xa),f(xb)]
[0.49309135261210324, 1.8402419807212302, 3.7463820813248043, 3.75103137375189] 8.746982364256144
[xa,xb,f(xa),f(xb)]
[2.8264246859454367, 4.173575314054563, 3.5894184973574266, 3.304431611500099] 8.042825127000448
[xa,xb,f(xa),f(xb)]
[5.159758019278771, 6.506908647387897, 3.2601677912890605, 3.6049588227871885] 8.009314383088956
Integral:  24.79912187434555

Error usando 2 y 3 tramos, es del orden 10^(-3) :

>>> 24.802242263095337 - 24.79912187434555
0.003120388749788816

gráfica con dos tramos:

Ejercicio: 3Eva_2024PAOII_T3 EDO efecto Allee en poblaciones pequeñas

literal a

Dada la ecuación diferencial ordinaria, se reemplazan los valores de las constantes:

\frac{dx}{dt} = rx \Big(\frac{x}{K}-1 \Big) \Big(1-\frac{x}{A} \Big) \frac{dx}{dt} = 0.7 x \Big(\frac{x}{10}-1 \Big) \Big(1-\frac{x}{50} \Big)

siendo h = 0.2

K_1 = 0.2 f(t_i,x_i) = 0.2\Big(0.7 x \Big(\frac{x}{10}-1 \Big) \Big(1-\frac{x}{50} \Big) \Big) K_2 = 0.2 f(t_i+0.2, x_i + K_1) = 0.2\Big(0.7(x+K_1) \Big(\frac{x+K_1}{10}-1 \Big) \Big(1-\frac{x+K_1}{50} \Big) \Big) x_{i+1} = x_i + \frac{K_1+K_2}{2} t_{i+1} = t_i + 0.2

literal b

Para el desarrollo de las iteraciones se requieren valores iniciales. Para la variable independiente tiempo podría usar t = 0.

Para la variable dependiente población, según la descripción se encontraría entre el intervalo [10,50]. Si x₀<10 la población se extingue. Si la variable x₀>50 se encuentra saturada la capacidad del medio.

Por lo que se propone usar un valor mayor que el mínimo, por ejemplo x₀=11 y otro valor que se encuentre en el intervalo.

itera = 0 , t₀ = 0, x₀ = 11

K_1 = 0.2\Big(0.7 (11) \Big(\frac{11}{10}-1 \Big) \Big(1-\frac{11}{50} \Big) \Big) = 0.1201 K_2 = 0.2\Big(0.7(11+0.1201) \Big(\frac{11+0.1201}{10}-1 \Big) \Big(1-\frac{11+0.1201}{50} \Big) \Big) K_2= 0.1355 x_{i+1} = 11 + \frac{0.1201+0.1355}{2} = 11.1278 t_{i+1} = 0 + 0.2 = 0.2

itera = 1 , t₀ = 0.2, x₀ = 11.1278

K_1 = 0.2\Big(0.7 (11.1278) \Big(\frac{11.1278}{10}-1 \Big) \Big(1-\frac{11.1278}{50} \Big) \Big) = 0.1366 K_2 = 0.2\Big(0.7(11.1278+0.1366) \Big(\frac{11.1278+K_1}{10}-1 \Big) \Big(1-\frac{11.1278+0.1366}{50} \Big) \Big) K_2= 0.1544 x_{i+1} = 11.1278 + \frac{0.1366+0.1544}{2} =11.2734 t_{i+1} = 0.2 + 0.2 = 0.4

itera = 2 , t₀ = 0.4, x₀ = 11.2734

K_1 = 0.2\Big(0.7 (11.2734) \Big(\frac{11.2734}{10}-1 \Big) \Big(1-\frac{11.2734}{50} \Big) \Big) = 0.1556 K_2 = 0.2\Big(0.7(11.2734+0.1556) \Big(\frac{11.2734+0.1556}{10}-1 \Big) \Big(1-\frac{(11.2734+0.1556)}{50} \Big) \Big) K_2 = 0.1763 x_{i+1} = 11.2734 + \frac{0.1556+0.1763}{2} = 11.4394 t_{i+1} = 0.4 + 0.2 = 0.6

literal c

Según los resultados de las tres iteraciones anteriores, la población crece. El resultado es acorde al concepto descrito en el enunciado para poblaciones mayores al valor mínimo de extinción. En el ejercicio se usó 11 como valor inicial.

Esto se puede comprobar usando el algoritmo y teniendo los resultados presentados en el literal d

literal d

Los resultados tabulados con el algoritmo son:

EDO con Runge-Kutta 2 Orden
 [ti, xi, K1, K2]
[[ 0.         11.          0.          0.        ]
 [ 0.2        11.12785958  0.12012     0.13559915]
 [ 0.4        11.2734037   0.13660392  0.15448432]
 [ 0.6        11.43943235  0.15566412  0.17639319]
 [ 0.8        11.629282    0.17778585  0.20191345]
 [ 1.         11.84695218  0.20356688  0.23177349]
...
[ 5.6        48.42689825  1.26594886  0.67489419]
 [ 5.8        49.04060051  0.81966583  0.4077387 ]
 [ 6.         49.41989811  0.5143157   0.2442795 ]]

La gráfica del ejercicio para 30 muestras es:

Instrucciones en Python

# 3Eva_2024PAOII_T3 EDO efecto Allee en poblaciones pequeñas
# EDO. Método de RungeKutta 2do Orden 
# estima la solucion para muestras espaciadas h en eje x
# valores iniciales x0,y0, entrega tabla[xi,yi,K1,K2]
import numpy as np

def rungekutta2(d1y,x0,y0,h,muestras):
    # Runge Kutta de 2do orden
    tamano = muestras + 1
    tabla = np.zeros(shape=(tamano,2+2),dtype=float)
    
    # incluye el punto [x0,y0]
    tabla[0] = [x0,y0,0,0]
    xi = x0
    yi = y0
    for i in range(1,tamano,1):
        K1 = h * d1y(xi,yi)
        K2 = h * d1y(xi+h, yi + K1)

        yi = yi + (1/2)*(K1+K2)
        xi = xi + h
        
        tabla[i] = [xi,yi,K1,K2]
    return(tabla)
# PROGRAMA PRUEBA
# Ref Rodriguez 9.1.1 p335 ejemplo.
# prueba y'-y-x+(x**2)-1 =0, y(0)=1

# INGRESO
# d1y = y' = f, d2y = y'' = f'
r = 0.7
K = 10
A = 50
d1x = lambda t,x: r*x*(x/A-1)*(1-x/K)
t0 = 0
x0 = 11
h  = 0.2
muestras = 30

# PROCEDIMIENTO
tabla = rungekutta2(d1x,t0,x0,h,muestras)
xi = tabla[:,0]
yiRK2 = tabla[:,1]

# SALIDA
# np.set_printoptions(precision=4)
print( 'EDO con Runge-Kutta 2 Orden')
print(' [ti, xi, K1, K2]')
print(tabla)

# Gráfica
import matplotlib.pyplot as plt
plt.plot(xi,yiRK2)
plt.plot(xi[0],yiRK2[0],
         'o',color='r', label ='[t0,x0]')
plt.plot(xi[1:],yiRK2[1:],
         'o',color='m',
         label ='[ti,xi] Runge-Kutta 2 Orden')

plt.title('EDO: Solución con Runge-Kutta 2do Orden')
plt.xlabel('t')
plt.ylabel('x')
plt.legend()
plt.grid()
plt.show() #comentar para la siguiente gráfica

 

Ejercicio: 3Eva_2024PAOII_T2 Interpolar trayectoria helicóptero

xi = [0.  , 2.50, 3.75, 5.00, 6.25, 7.5 ]
yi = [3.7 , 3.25, 4.05, 4.33, 2.95, 3.22]

literal a

Según la gráfica presentada, los puntos a considerar para todo el intervalo, deberían ser al menos el primero y el último. Para un polinomio de grado 3 se requieren usar 4 muestras, por lo que faltarían dos muestras dentro del intervalo. Los puntos adicionales estarían entre los puntos intermedios, tratando de mantener una distancia equidistante entre ellos y tratar de mantener los cambios de dirección.

Los puntos seleccionados para el ejercicio serán

xi = [0. , 2.50, 5.00, 7.5 ]
fi = [3.7 , 3.25, 4.33, 3.22]

Se puede construir el polinomio con los cualquiera de los métodos para interpolación dado que tienen tamaños de paso iguales entre tramos.

Desarrollando con el método de Lagrange, el polinomio se construye como:

término 1

L_{0} (x) = \frac{(x-2.5)(x-5.0)(x-7.5)}{(0-2.5)(0-5.0)(0-7.5)}

término 2

L_{1} (x) = \frac{(x-0)(x-5.0)(x-7.5)}{(2.5-0)(2.5-5.0)(2.5-7.5)}

término 3

L_{2} (x) = \frac{(x-0)(x-2.5)(x-7.5)}{(5-0)(5-2.5)(5-7.5)}

término 4

L_{3} (x) = \frac{(x-0)(x-2.5)(x-5)}{(7.5-0)(7.5-2.5)(7.5-5)}

se construye el polinomio usando la fórmula para f_n(x) para cada valor fi,

p_3(x) = 3.7 \frac{(x-2.5)(x-5.0)(x-7.5)}{(0-2.5)(0-5.0)(0-7.5)} + 3.25 \frac{(x-0)(x-5.0)(x-7.5)}{(2.5-0)(2.5-5.0)(2.5-7.5)} + 4.33 \frac{(x-0)(x-2.5)(x-7.5)}{(5-0)(5-2.5)(5-7.5)} + 3.22 \frac{(x-0)(x-2.5)(x-5)}{(7.5-0)(7.5-2.5)(7.5-5)}

simplificando con Sympy:

Polinomio de Lagrange, expresiones
0.104*x*(x - 7.5)*(x - 5.0) - 0.13856*x*(x - 7.5)*(x - 2.5) + 0.0343466666666667*x*(x - 5.0)*(x - 2.5) - 0.0394666666666667*(x - 7.5)*(x - 5.0)*(x - 2.5)

Polinomio de Lagrange: 
-0.03968*x**3 + 0.42*x**2 - 0.982*x + 3.7

p_3(x) = 3.7 - 0.982x + 0.42 x^2 -0.03968 x^3

literal b

Para verificar que el polinomio pasa por los puntos, se puede usar una gráfica o al menos dos puntos usados para crear el polinomio:

p_3(2.5) = 3.7 - 0.982(2.5) + 0.42 (2.5)^2 -0.03968 (2.5)^3 = 3.25 p_3(5) = 3.7 - 0.982(5) + 0.42 (5)^2 -0.03968 (5)^3 = 4.33

>>> polisimple
-0.03968*x**3 + 0.42*x**2 - 0.982*x + 3.7
>>> polisimple.subs(x,2.5)
3.25000000000000
>>> polisimple.subs(x,5)
4.33000000000000
>>>

Se comprueba que los valores obtenidos corresponden a las muestras, por lo que el polinomio cumple con los criterios básicos de interpolación. La gráfica permite verificar también el resultado.

literal c

Error en puntos no usados de las muestras

p_3(3.75) = 3.7 - 0.982(3.75) + 0.42 (3.75)^2 -0.03968 (3.75)^3 = 3.83125

error = |3.83125 – 4.05| = 0.218

p_3(6.25) = 3.7 - 0.982(6.25) + 0.42 (6.25)^2 -0.03968 (6.25)^3 = 4.28125

error = |4.28125 – 4.05| = 1.3312

literal d

Observando las gráficas de la trayectoria construida junto a las funciones descritas en el tema 1 se tiene que:

Un polinomio de grado 3 es insuficiente para describir la trayectoria, se debe aumentar el grado del polinomio para ajustar mejor la curva.

Por ejemplo, usando todos los puntos, la trayectoria y el polinomio son mas cercanas aunque no iguales.

literal e

Encontrar el error en P(5), como x=5 y es parte de los puntos de muestra, el error debería ser cero. Siempre y cuando x=5 sea parte de los puntos seleccionados.

p_3(5) = 3.7 - 0.982(5) + 0.42 (5)^2 -0.03968 (5)^3 = 4.33

error = | 4.33-4.33| = 0

literal f

Los resultados con el algoritmo de Lagrange se muestran como:

    valores de fi:  [3.7  3.25 4.33 3.22]
divisores en L(i):  [-93.75  31.25 -31.25  93.75]

Polinomio de Lagrange, expresiones
0.104*x*(x - 7.5)*(x - 5.0) - 0.13856*x*(x - 7.5)*(x - 2.5) + 0.0343466666666667*x*(x - 5.0)*(x - 2.5) - 0.0394666666666667*(x - 7.5)*(x - 5.0)*(x - 2.5)

Polinomio de Lagrange: 
-0.03968*x**3 + 0.42*x**2 - 0.982*x + 3.7

Algoritmo en Python

# 3Eva_2024PAOII_T2 Interpolar trayectoria helicóptero
# Interpolacion de Lagrange
# divisoresL solo para mostrar valores
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO , Datos de prueba
# todos los datos
xj = [0.  , 2.50, 3.75, 5.00, 6.25, 7.5 ]
fj = [3.7 , 3.25, 4.05, 4.33, 2.95, 3.22]

# datos seleccionados
xi = [0.  , 2.50, 5.00, 7.5 ]
fi = [3.7 , 3.25, 4.33, 3.22]

# trayectoria
gx = lambda t: 0.5*t +0 *t
gy = lambda t: np.sin(0.10*t)*np.cos(0.7*t)+ 3.7

ta = 0 ; tb = 15
muestrast = 7
muestrasj = 4*muestrast

# PROCEDIMIENTO
# trayectoria
tj = np.linspace(ta,tb,muestrasj)
gxj = gx(tj)
gyj = gy(tj)

# Interpolación
xi = np.array(xi,dtype=float)
fi = np.array(fi,dtype=float)
# Polinomio de Lagrange
n = len(xi)
x = sym.Symbol('x')
polinomio = 0
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

# simplifica el polinomio
polisimple = polinomio.expand()

# para evaluación numérica
px = sym.lambdify(x,polisimple)

# Puntos para la gráfica
muestras = 101
a = np.min(xi)
b = np.max(xi)
pxi = np.linspace(a,b,muestras)
pfi = px(pxi)

# SALIDA
print('    valores de fi: ',fi)
print('divisores en L(i): ',divisorL)
print()
print('Polinomio de Lagrange, expresiones')
print(polinomio)
print()
print('Polinomio de Lagrange: ')
print(polisimple)

# Gráfica
plt.plot(gxj,gyj,color='orange', label = 'trayectoria')
plt.plot(xi,fi,'o', label = 'muestras')
plt.plot(pxi,pfi,color='green',linestyle='dashed', label = 'P(x)')
plt.legend()
plt.xlabel('xi')
plt.ylabel('fi')
plt.grid()
plt.title('Interpolación Lagrange')
plt.show()

Ejercicio: 3Eva_2024PAOII_T1 Accidente entre aeronaves

literal a

La distancia entre las aeronaves se determina a partir de las ecuaciones proporcionadas en el enunciado.

d = \sqrt{(x_2-x_1)^2 + (y_2-y_1)^2 + (z_2-z_1)^2}

La ecuación también mantiene la forma y el mínimo si se utiliza el cuadrado de la distancia:

D = d^2 = (x_2-x_1)^2 + (y_2-y_1)^2 + (z_2-z_1)^2

Las diferencias de distancia por eje pueden ser convergentes hacia el punto de impacto, dado que se conoce que el accidente ya ocurrió. Por lo que también se pueden revisar las distancias entre ejes en lugar de la distancia total en 3D, simplificando un poco el ejercicio. Observe la gráfica proporcionada:

Avión	Helicóptero	distancia por eje
Ax(t) = 5.1	Hx(t) = 0.5t	|0.5t-5.1|
Ay(t) = 0.4t	Hy(t) = sin(0.1t)cos(0.7t)+3.7	|sin(0.1t)cos(0.7t) + 3.7-0.4|
Az(t) = 0.5 e^{-0.2t} + 0.3	Hz(t) = 0.36	|0.36 – (0.5 e^{-0.2t} + 0.3)|

D = (0.5t-5.1)^2 + (sin(0.1t)cos(0.7t)+3.7-0.4t)^2 + (0.36-(0.5 e^{-0.2t} + 0.3))^2 dx =0.5t-5.1 dy = sin(0.1t)cos(0.7t) + 3.7-0.4 dz = 0.36 - (0.5 e^{-0.2t} + 0.3)

Se realiza la gráfica para la distancia al cuadrado Di y las distancias por cada eje dxi, dyi, dzi :

Por lo que el resultado también se podría determinar usando por ejemplo el eje y. La ecuación a buscar la distancia mínima, punto de choque o cruce por cero podría ser:

f(t) =dy(t)= sin(0.1t)cos(0.7t) + 3.7-0.4t = 0

literal b

Por la gráfica se puede obtener un intervalo de búsqueda entre [8, 12], que usando solo las distancias en el eje y, se tiene:

dy(8) =1.0563 dy(12) =-1.5839

literal c

Se pide usar un método de búsqueda de raíces, pudiendo seleccionar Bisección en el intervalo encontrado en el literal b.

iteración 1

a = 8, b=12 c = \frac{a+b}{2} = \frac{8+12}{2} = 10 f(8) = 1.0563 f(10) =sin(0.1(10))cos(0.7(10)) + 3.7-0.4(10) = 0.3343 f(12) = -1.5839

cambio de signo a la derecha

a = 10, b = 12 tramo = |12-10| =2

iteración 2

a = 10, b=12 c = \frac{10+12}{2} = 11 f(11) =sin(0.1(11))cos(0.7(11)) + 3.7-0.4(11) = -0.5633

cambio de signo a la izquierda

a = 10, b = 11 tramo = |11-10| = 1

iteración 3

a = 10, b=11 c = \frac{10+11}{2} = 10.5 f(10.5) =sin(0.1(10.5))cos(0.7(10.5)) + 3.7-0.4(10.5) = -0.0811

cambio de signo a la izquierda

a = 10, b = 10.5 tramo = |10.5-10| = 0.5

literal d

La variable independiente en el ejercicio es tiempo ‘t’, que podría ser segundos. Si la tolerancia se estima en milisegundos, tolera = 10-3 .

El error se ha calculado en cada iteración

literal e

El error disminuye en cada iteración, por lo que el método converge.

La distancia mínima entre las aeronaves no tiene que llegar a cero para que se produzca un accidente. Las dimensiones de las aeronaves muestran que se encuentran entre 70m y 4 m, por lo que se estima que debe existir una separación mayor a 70 metros en cualquiera de los ejes para evitar un accidente. Si las coordenadas se estiman en Km, la tolerancia sería de 0.070 Km al considerar más de 70 metros como la distancia segura.

literal f

Usando el algoritmo se encuentra la raíz en:

i ['a', 'c', 'b'] ['f(a)', 'f(c)', 'f(b)']
   tramo
0 [8, 10.0, 12] [ 1.0564  0.3344 -1.584 ]
   2.0
1 [10.0, 11.0, 12] [ 0.3344 -0.5633 -1.584 ]
   1.0
2 [10.0, 10.5, 11.0] [ 0.3344 -0.0811 -0.5633]
   0.5
3 [10.0, 10.25, 10.5] [ 0.3344  0.1368 -0.0811]
   0.25
4 [10.25, 10.375, 10.5] [ 0.1368  0.0302 -0.0811]
   0.125
5 [10.375, 10.4375, 10.5] [ 0.0302 -0.0249 -0.0811]
   0.0625
6 [10.375, 10.40625, 10.4375] [ 0.0302  0.0028 -0.0249]
   0.03125
7 [10.40625, 10.421875, 10.4375] [ 0.0028 -0.011  -0.0249]
   0.015625
8 [10.40625, 10.4140625, 10.421875] [ 0.0028 -0.0041 -0.011 ]
   0.0078125
9 [10.40625, 10.41015625, 10.4140625] [ 0.0028 -0.0007 -0.0041]
   0.00390625
10 [10.40625, 10.408203125, 10.41015625] [ 0.0028  0.001  -0.0007]
   0.001953125
11 [10.408203125, 10.4091796875, 10.41015625] [ 0.001   0.0002 -0.0007]
   0.0009765625
raíz en:  10.4091796875

Por lo que las coordenadas de choque entre aeronaves será:

Avión	Helicóptero	distancia por eje
Ax(t) = 5.1	Hx(t) = 0.5 (10.40) = 5.2	|5.1-5.2| = 0.1
Ay(t) = 0.4(10.4) = 4.16	Hy(t) = sin(0.1(10.40))cos(0.7(10.40))+3.7 = 4.168	|4.16 – 4.168| = 0.008
Az(10.4) = 0.5 e^{-0.2(10.4)} + 0.3 = 0.3624	Hz(t) = 0.36	|0.3624 – 0.36|  = 0.0024

Instrucciones en Python para Gráfica de distancias

import numpy as np
import matplotlib.pyplot as plt
import sympy as sym

# INGRESO
# Avión Aterriza
Ax = lambda t: 5.1 + 0*t
Ay = lambda t: 0.4*t
Az = lambda t: 0.5*np.exp(-0.2*t) + 0.3
# helicóptero
Hx = lambda t: 0.5*t + 0*t
Hy = lambda t: np.sin(0.10*t)*np.cos(0.7*t)+ 3.7
Hz = lambda t: 0.36 + 0*t

a = 0
b = 6/0.5 # x entre[0,6] usando gx(t)= 6
muestras = 41

# PROCEDIMIENTO
# Distancia por ejes
dx = lambda t: Hx(t) - Ax(t)
dy = lambda t: Hy(t) - Ay(t)
dz = lambda t: Hz(t) - Az(t)
# Distancia 3D
distancia2 = lambda t: dx(t)**2 + dy(t)**2 + dz(t)**2

# Simulacion en segmento t=[a,b]
ti = np.linspace(a,b,muestras)
dxi = dx(ti)
dyi = dy(ti)
dzi = dz(ti)

Di = distancia2(ti)

# SALIDA
print(dy(8))
print(dy(12))

plt.plot(ti,Di, label='Di')
plt.plot(ti,dxi,label='dxi')
plt.plot(ti,dyi,label='dyi')
plt.plot(ti,dzi,label='dzi')
plt.xlabel('ti')
plt.ylabel('distancia2')
plt.grid()
plt.legend()
plt.show()

Instrucciones en Python – Algoritmo Bisección

# 3Eva_2024PAOII_T1 Accidente entre aeronaves
# Algoritmo de Bisección
# [a,b] se escogen de la gráfica de la función
# error = tolera

import numpy as np
import matplotlib.pyplot as plt

# Algoritmo de Bisección
# [a,b] se escogen de la gráfica de la función
# error = tolera
import numpy as np

def biseccion(fx,a,b,tolera,iteramax = 20, vertabla=False, precision=4):
    '''
    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)
    if cambia<0: # existe cambio de signo f(a) vs f(b)
        if vertabla==True:
            print('método de 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)
            if vertabla==True:
                print(itera,[a,c,b],np.array([fa,fc,fb]))
            if (cambia<0):
                b = c
                fb = fc
            else:
                a = c
                fa = fc
            tramo = np.abs(b-a)
            if vertabla==True:
                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
    return(respuesta)

# INGRESO
fx = lambda t: np.sin(0.10*t)*np.cos(0.7*t)+ 3.7 - 0.4*t 
a = 8
b = 12
tolera = 0.001

# PROCEDIMIENTO
respuesta = biseccion(fx,a,b,tolera,vertabla=True)
# SALIDA
print('raíz en: ', respuesta)