#Interfaz del programa

#-------------------------------------------------------------------------------

print ("---------------------------------------------------------")
print ("---------- MÉTODO MULTIPASO DE ADAMS - MOULTON ----------")
print ("---------------------------------------------------------")

# Visualización de la ecuación diferencial

#------------------------------------------------------------------------------
print ("")

print ("")

ODE = (input ("Introduce la ecuación (dy/dx): "))

h = (input("Ingresa el salto permitido (h): "))
xf = (input ("Ingresa el número de saltos requeridos (xf): "))
e = (input ("Ingresa el error permitido (e): "))

print ("")

# Visualización de la tabla obtenida del Método Rounge Kutta

#-------------------------------------------------------------------------------
print ("")
print ("Se utilizan los tres valores de las tres primeras repeticiones obtenidas
del método Runge Kutta")
print ("Los valores obtenidos se presentan en la siguiente tabla:")

print (" -----------------------------------------------------")

print (" | i | xi | yi | yi+1 | f(x,y) |")
print (" |-------|--------|----------|----------|------------|")
print (" | 0| 0| 5| 4,156637| -93|")
print (" |-------|--------|----------|----------|------------|")
print (" | 1| 0,01| 4,156637| 3,465888| -76,16765|")
print (" |-------|--------|----------|----------|------------|")
print (" | 2| 0,02| 3,465888| 2,900081| -62,38741|")
print (" |-------|--------|----------|----------|------------|")
print (" | 3| 0,03| 2,900081| 2,436561| -51,10583|")
print (" -----------------------------------------------------")
print ("")

# Asignación en matríz de la tabla obtenida del Método Rounge Kutta

#-------------------------------------------------------------------------------

matrizRK = [["i", "xi", "yi", "yi+1", "f(x,y)"], ["0","0","5","4,156637","-93"],

["1","0,01","4,156637","3,465888","-76,16765"],["2","0,02","3,465888","2,900081","-
62,38741"],["3","0,03","2,900081","2,436561","-51,10583"]]

#Modificar matriz para comodidad de operación

#-------------------------------------------------------------------------------
print ("Se plantea la siguiente tabla para facilidad en la operación")
print ("Los valores 'yi' y 'f(x,y)' los obtendremos al final de la primera
iteración")
print ("")

print (" ------------------------------------------")

print (" | i | xi | yi | f(x,y) |")
print (" |-------|--------|----------|------------|")
print (" | i-3 | 0| 5| -93|")
print (" |-------|--------|----------|------------|")
print (" | i-2 | 0.01| 4.156637| -76.16765|")
print (" |-------|--------|----------|------------|")
print (" | i-1 | 0.02| 3.465888| -62.38741|")
print (" |-------|--------|----------|------------|")
print (" | i | 0.03| 2.900081| -51.10583|")
print (" ------------------------------------------")
print (" | i+1 | 0.04 | | |")
print (" ------------------------------------------")
print (" ")

# Asignación en matríz corregida de la tabla obtenida del Método Rounge Kutta

#-------------------------------------------------------------------------------

matrizRKcor = [["i", "xi", "yi", "f(x,y)"], ["i-3","0","5","-93"], ["i-

2","0.01","4.156637","-76.16765"],["i-1","0.02","3.465888","-62.38741"],
["i","0.03","2.900081","-51.10583"]]

#PASO 1
#Primera iteración con la ecuación predictora - correctora
#-------------------------------------------------------------------------------

#1. Hallar Yi+1 = R1

#yi = ai = (matrizRKcor [4][2])

#f(x,y)i = bi = (matrizRKcor [4][3])
#f(x,y)i-1 = ci = (matrizRKcor [4][2])
#f(x,y)i-2 = di =(matrizRKcor [4][1])
#f(x,y)i-3 = ei = (matrizRKcor [4][0])

ai = float (matrizRKcor [4][2])

bi = float (matrizRKcor [4][3])
ci = float (matrizRKcor [3][3])
di = float (matrizRKcor [2][3])
ei = float (matrizRKcor [1][3])

R1 = ai+(float (h)/24)*((55*bi)-(59*ci)+(37*di)-(9*ei))

#2. f(x,y)+1 = f1 = Evaluar la función con Xi y Yi+1

xi = (float (matrizRKcor [4][1])+ (float (h)))

f1 = eval(ODE, {"x": xi, "y": R1})

#3. Hallar Y corregida

Ycor = ai+((float (h)/24)*((9*f1)+(19*bi)-(5*ci)+di))

#4. Evaluar xi y Ycor en f(x,y)

f2 = eval(ODE, {"x": xi, "y": Ycor})

#5. Error <0.00001

error = abs (Ycor-R1)

print ("El error tiene un valor igual", error, "por lo tanto se requiere iterar
nuevamente")

#Segunda iteración con la ecuación predictora - correctora

#-------------------------------------------------------------------------------

#1. Yi+1 = Ycor

Ycor2 = Ycor

#2. Evaluar la función con Xi y Ycor

f3 = eval(ODE, {"x": xi, "y": Ycor2})

#3. Hallar Ycorregida

Ycor3 = ai+((float (h)/24)*((9*f3)+(19*bi)-(5*ci)+di))

#4. Evaluar xi y Ycor en f(x,y)

f4 = eval(ODE, {"x": xi, "y": Ycor3})

#5. Error <0.00001

error = abs (Ycor3-Ycor2)

print ("El error tiene un valor igual", error, "por lo tanto se requiere iterar
nuevamente")

#Tercera iteración con la ecuación predictora - correctora

#-------------------------------------------------------------------------------

#1. Yi+1 = Ycor

Ycor4 = Ycor3

#2. Evaluar la función con Xi y Ycor

f3 = eval(ODE, {"x": xi, "y": Ycor4})

#3. Hallar Ycorregida

Ycor4 = ai+((float (h)/24)*((9*f3)+(19*bi)-(5*ci)+di))

#4. Evaluar xi y Ycor en f(x,y)

f4 = eval(ODE, {"x": xi, "y": Ycor4})

#5. Error <0.00001

error = abs (Ycor4-Ycor3)

print ("El error tiene un valor igual", error, "por lo tanto se requiere iterar
nuevamente")

#Cuarta iteración con la ecuación predictora - correctora

#-------------------------------------------------------------------------------

#1. Yi+1 = Ycor

Ycor5 = Ycor4

#2. Evaluar la función con Xi y Ycor

f3 = eval(ODE, {"x": xi, "y": Ycor5})

#3. Hallar Ycorregida

Ycor5 = ai+((float (h)/24)*((9*f3)+(19*bi)-(5*ci)+di))

#4. Evaluar xi y Ycor en f(x,y)

f4 = eval(ODE, {"x": xi, "y": Ycor5})

#5. Error <0.00001

error = abs (Ycor5-Ycor4)

print ("El error tiene un valor igual", error, "por lo tanto se se procede al
siguiente paso")

#PASO 2
#Actualización de tabla de operación
#-------------------------------------------------------------------------------
print ("Se actualiza la tabla de operación teniendo en cuenta los valores obtenidos
en las cuatro iteraciones del primer paso")
print ("")
print (" ------------------------------------------")
print (" | i | xi | yi | f(x,y) |")
print (" |-------|--------|----------|------------|")
print (" | i-3 | 0| 5| -93|")
print (" |-------|--------|----------|------------|")
print (" | i-2 | 0.01| 4.156637| -76.16765|")
print (" |-------|--------|----------|------------|")
print (" | i-1 | 0.02| 3.465888| -62.38741|")
print (" |-------|--------|----------|------------|")
print (" | i | 0.03| 2.900081| -51.10583|")
print (" ------------------------------------------")
print (" | i+1 | 0.04 | 2.416128| -47.36073|")
print (" ------------------------------------------")
print (" ")

# Asignación en matríz corregida de la tabla obtenida del Método Rounge Kutta

#-------------------------------------------------------------------------------

matrizRKcor = [["i", "xi", "yi", "f(x,y)"], ["i-3","0","5","-93"], ["i-

2","0.01","4.156637","-76.16765"],["i-1","0.02","3.465888","-62.38741"],
["i","0.03","2.900081","-51.10583"]]