Ramaproy

[gitrmora]

Tuvimos muchos problemas y no logramos resolverlo.

[lbenet]

Hola @gitrmora @ravioaraiza @H-Cote,

son conscientes de que se trata del 70% de la calificación?

EDIT: Corregí un error en un usuario.

[ghost]

Hola Luis, tuvimos el problema de que no logramos implementar el algoritmo para determinar las Ymin

[lbenet]

No me queda claro cuál es tu punto con el comentario. Le eché un ojo a lo que subieron y creo que es muy pobre. Por ejemplo, respecto al péndulo, ¿checaron la conservación de la energía? La cosa es estar realmente seguros de que su integrador funciona. Y una vez que funciona hacer preguntas concretas. En clase hablamos de hacer un mapeo estroboscópico, es decir, graficar (x,y) cada periodo de la parte forzante (2pi). Y de ahí, ver qué es interesante.

[lbenet]

Unos comentarios rápidos del notebook Ecpendulo.ipynb: Un detalle que puede ser importante: f3 (la aceleración del péndulo), creo que tiene un signo equivocado. Otra cosa: dónde está definida ω? Adivino que en la primer figura las gráficas del lado izquierdo usan el método de Taylor. Es correcto? Respecto al péndulo, no entiendo por qué en las primeras gráficas, la escala es distinta en las figuras superiores (escala y); lo mismo se ve en el eje x del espacio fase. Si se trata de las mismas condiciones iniciales, deberían dar soluciones cercanas! Tampoco entiendo la última gráfica; si se trata de errores, son brutalmente grandes!

[lbenet]

Estuve jugando un poco con el módulo AT en Taylo0.jl. Aquí te mando algunas líneas de código que estuve probando.

julia> include("Taylor0.jl"); using AT

julia> t = Taylor([0.0, 1.0, 0.0, 0, 0, 0], 5)
AT.Taylor{Float64}([0.0,1.0,0.0,0.0,0.0,0.0],5)

julia> sin(t)
AT.Taylor{Float64}([0.0,1.0,0.0,-0.166667,0.0,0.00833333],5)

Hasta aquí todo va bien.

Algo "incómodo" es lo siguiente:

julia> t  # OK: t es de orden 5
AT.Taylor{Float64}([0.0,1.0,0.0,0.0,0.0,0.0],5)

julia> t*t
AT.Taylor{Float64}([0.0,0.0,1.0],2)

julia> t^2
AT.Taylor{Float64}([0.0,0.0,1.0],2)

julia> t^6
AT.Taylor{Float64}([0.0,0.0,0.0,0.0,0.0,0.0,1.0],6)

Esto es incómodo e inconsistente hasta cierto punto, en el sentido de que no es evidente
el órden (grado) del polinomio del resultado. Eso puede meter ruido según como plantees las cosas. Lo idea es definir una convención y apegarse a ella. Una que es útil, según mi experiencia, es que el resultado sea del mismo grado que el polinomio. Entonces, t^2 debería dar como resultado AT.Taylor{Float64}([0.0,0.0,1.0,0.0,0.0,0.0],5), que es un polinomio de 5o grado,
y t^6 debería ser el polinomio cero: AT.Taylor{Float64}([0.0,0.0,0.0,0.0,0.0,0.0],5).

Siguiendo con esto, obtengo:

julia> julia> cos(t)  # CORRECTO
AT.Taylor{Float64}([1.0,0.0,-0.5,-0.0,0.0416667,0.0],4)

julia> sin(t-pi/2) # INCORRECTO !!!
AT.Taylor{Float64}([0.0,6.12323e-17,0.0,-1.02054e-17,0.0,5.10269e-19,0.0],5)

Lo que quiero que notes es que sin(pi/2-t) es prácticamente cero, cuando debería ser cercano a lo que tienes en cos(t). Sin revisar Taylor0.jl aún, es claro que hay algo raro, y me parece que está en la condición inicial de la recursión, o que simplemente está mal la recursión.

Otras cosas a notar:

julia> exp(-t)  # Por qué sólo orden 1?
AT.Taylor{Int64}([1,-1],1)

julia> log(1-t) # Esto es correcto!
AT.Taylor{Float64}([0.0,-1.0,-0.5,-0.333333,-0.25,-0.2,-0.166667],6)

julia> exp(1-t)  # Esto parece correcto, pero por qué ahora el resultado es de orden 6!?
AT.Taylor{Float64}([2.71828,-2.71828,1.35914,-0.453047,0.113262,-0.0226523,0.00377539],6)

Un punto importante para que funcione la integración de Taylor es que tengas control del órden (fijándolo al principio y manteniéndolo). Esto es importante porque, esencialmente lo que está haciendo la computadora, es calcular las relaciones de recurrencia de la solución cerca de la condición inicial. Mover la condición inicial y tener resultados congruentes es importante (ejemplo con sin(pi/2-t).

[lbenet]

Algunos de los comentarios anteriores parecen resueltos en Taylor.jl...