Python - Ecuaciones y Funciones Caóticas Recursivas
#35 Ejemplos de Ecuaciones y Funciones Caóticas Recursivas
#1. Función logística:
def logistic_map(r, x):
return r * x * (1 - x)
x = 0.5
r = 3.5
for i in range(100):
x = logistic_map(r, x)
print(x)
#2. Ecuación del mapa cuadrático:
x(n+1) = 1 - ax(n)^2
#2. Ecuación del mapa logístico cuadrático:
def logistic_quad_map(x, r, a):
return r * x * (1 - x) + a * x ** 2
x = 0.5
r = 3.5
a = 0.01
for i in range(100):
x = logistic_quad_map(x, r, a)
print(x)
#3. Función de Henon:
def henon(x, y, a, b):
xn = y + 1 - a * x ** 2
yn = b * x
return xn, yn
#3. Ecuación de Hénon:
def henon_map(a, b, x, y):
return y + 1 - a * x ** 2, b * x
a = 1.4
b = 0.3
x = 0.1
y = 0.1
for i in range(100):
x, y = henon_map(a, b, x, y)
print(x, y)
#4. Ecuación del mapa de Hénon-Heiles:
x(n+1) = y(n)
y(n+1) = -x(n) - ay(n) - by(n)^2 - cy(n)^3
#4. Ecuación del mapa de Henon-Heiles:
def henon_heiles_map(x, y, p_x, p_y, alpha=1.0):
x_new = x + p_x
y_new = y + p_y
p_x_new = p_x - alpha * x - 2 * x * y
p_y_new = p_y - alpha * y - (y ** 2 - x ** 2)
return x_new, y_new, p_x_new, p_y_new
# parámetros del mapa
alpha = 1.0
num_steps = 10000
# condiciones iniciales
x0 = 0.1
y0 = 0.1
p_x0 = 0.0
p_y0 = 0.0
# almacenamiento de resultados
x_values = [x0]
y_values = [y0]
p_x_values = [p_x0]
p_y_values = [p_y0]
# iteración del mapa
for i in range(num_steps):
x, y, p_x, p_y = henon_heiles_map(x0, y0, p_x0, p_y0, alpha)
x_values.append(x)
y_values.append(y)
p_x_values.append(p_x)
p_y_values.append(p_y)
x0, y0, p_x0, p_y0 = x, y, p_x, p_y
#5. Ecuación del mapa de May:
x(n+1) = axn(1-xn-kyn)
y(n+1) = byn(1-yn-lxn)
#6. Función de Lorenz:
def lorenz(x, y, z, sigma, rho, beta):
dx = sigma * (y - x)
dy = x * (rho - z) - y
dz = x * y - beta * z
return dx, dy, dz
#6. Ecuación de Lorenz:
def lorenz_map(x, y, z, sigma=10, rho=28, beta=8/3):
dx_dt = sigma * (y - x)
dy_dt = x * (rho - z) - y
dz_dt = x * y - beta * z
return x + dx_dt, y + dy_dt, z + dz_dt
x = 0.1
y = 0.1
z = 0.1
for i in range(100):
x, y, z = lorenz_map(x, y, z)
print(x, y, z)
#7. Función de Rossler:
def rossler(x, y, z, a, b, c):
dx = -y - z
dy = x + a * y
dz = b + z * (x - c)
return dx, dy, dz
#8. Ecuación de Rossler:
def rossler_map(x, y, z, a=0.2, b=0.2, c=5.7):
dx_dt = -y - z
dy_dt = x + a * y
dz_dt = b + z * (x - c)
return x + dx_dt, y + dy_dt, z + dz_dt
x = 0.1
y = 0.1
z = 0.1
for i in range(100):
x, y, z = rossler_map(x, y, z)
print(x, y, z)
#9. Función de Ikeda:
import math
def ikeda(x, y, u):
t = 0.4 - 6 / (1 + x ** 2 + y ** 2)
xn = 1 + u * (x * math.cos(t) - y * math.sin(t))
yn = u * (x * math.sin(t) + y * math.cos(t))
return xn, yn
#9. Ecuación de Ikeda:
import math
def ikeda_map(u, v):
x = 0.85 * (u * math.cos(v) - v * math.sin(u))
y = 0.85 * (u * math.sin(v) + v * math.cos(u))
return x, y
u = 1.0
v = 1.0
for i in range(100):
u, v = ikeda_map(u, v)
print(u, v)
#10. Función de Tinkerbell:
def tinkerbell(x, y, a, b, c, d):
xn = x ** 2 - y ** 2 + a * x + b * y
yn = 2 * x * y + c * x + d * y
return xn, yn
#11. Función de Gingerbreadman:
def gingerbreadman(x, y):
xn = 1 - y + abs(x)
yn = x
return xn, yn
#12. Función de Clifford:
def clifford(x, y, a, b, c, d):
xn = math.sin(a * y) + c * math.cos(a * x)
yn = math.sin(b * x) + d * math.cos(b * y)
return xn, yn
#13. Función de Bedhead:
def bedhead(x, y):
xn = math.sin(x * y / 10) * y + math.cos(x / 10) * 10
yn = x + math.sin(y / 10) * 10 - math.cos(y / 10) * x
return xn, yn
#14. Función de De Jong:
def de_jong(x, y, a, b, c, d):
xn = math.sin(a * y) - math.cos(b * x)
yn = math.sin(c * x) - math.cos(d * y)
return xn, yn
#15. Función de Thomas:
def thomas(x, y, z, a, b, c, d):
dx = math.sin(y) - a * x
dy = math.sin(z) - b * y
dz = math.sin(x) - c * z
return dx, dy, dz
#16. Función de Aizawa:
def aizawa(x, y, z, a, b, c, d, e):
dx = z - b * x + d * math.sin(y)
dy = b * x + z - d * math.sin(y)
dz = c + a * z - z ** 3 / 3 - x ** 2 + e * z * x ** 2
return dx, dy, dz
#17. Función de Halvorsen:
def halvorsen(x, y, z, a):
dx = -a * x - 4 * x ** 3 - 4 * y ** 2 - 4 * z ** 2 + z
dy = -a * y - 4 * y ** 3 - 4 * z ** 2 - 4 * x ** 2 + x
dz = -a * z - 4 * z ** 3 - 4 * x ** 2 - 4 * y ** 2 + y
return dx, dy, dz
#18. Función de Rabinovich-Fabrikant:
def rabinovich_fabrikant(x, y, z, a):
dx = y * (z - 1 + x ** 2) + a * x
dy = x * (3 * z + 1 - x ** 2) + a * y
dz = -2 * z * (a + x * y)
return dx, dy, dz
#19. Función de Chua:
def chua(x, y, z, a, b, c, m0, m1):
if x > m1:
dx = -a * (x - m1) + b * (y - math.sqrt(x - m1))
elif x < -m1:
dx = -a * (x + m1) + b * (y - math.sqrt(-x - m1))
else:
dx = b * (y - x)
dy = x - y + z
dz = -c * y
return dx, dy, dz
#20. Función de Hadley:
def hadley(x, y, z, a, b, c):
dx = -a * y - z * x
dy = x + b * y
dz = c + x * z
return dx, dy, dz
#21. Función de Rössler modificada:
def rossler_mod(x, y, z, a, b, c, d):
dx = -y - z
dy = x + a * y
dz = b + z * (x - c) + d * x ** 2
return dx, dy, dz
#22. Función de Thomas modificada:
def thomas_mod(x, y, z, a, b, c, d, e):
dx = math.sin(y) - a * x + e * math.sin(b * z)
dy = math.sin(z) - b * y + e * math.sin(c * x)
dz = math.sin(x) - c * z + e * math.sin(d * y)
return dx, dy, dz
#23. Función de Chen:
def chen(x, y, z, a, b, c):
dx = a * (y - x)
dy = x * (b - z) - y
dz = x * y - c * z
return dx, dy, dz
#24. Función de Sprott:
def sprott(x, y, z, a, b, c, d, e, f):
dx = y
dy = z
dz = a * x + b * y + c * z + d * x ** 2 + e * y ** 2 + f * z ** 2 + x * y * z
return dx, dy, dz
#25. Función de Liu Chen:
def liu_chen(x, y, z, a, b, c, d):
dx = -a * x + y * y - z * z + a * b
dy = -x * y + b * y + x * z - c
dz = -x * z + c * y + d * z
return dx, dy, dz
#26. Función de Sine Circle:
def sine_circle(x, y, a, b, c, d):
xn = math.sin(a * y) + c * math.sin(a * x)
yn = math.sin(b * x) + d * math.sin(b * y)
return xn, yn
#27. Función de Newton-Leipnik:
def newton_leipnik(x, y, a):
dx = y
dy = -x + a * y - y ** 2
return dx, dy
#28. Función de Duffing:
def duffing(x, y, a, b, c, d):
dx = y
dy = -a * x - b * y - c * x ** 3 + d * math.cos(x)
return dx, dy
#29. Función de Rössler caótica:
def rossler_caotica(x, y, z, a, b, c):
dx = -y - z
dy = x + y * (a + z)
dz = b + z * (x - c * z)
return dx, dy, dz
#30. Función de Lorenz modificada:
def lorenz_mod(x, y, z, a, b, c, d):
dx = -a * x + a * y
dy = b * x - y - x * z
dz = x * y - c * z + d * z ** 2
return dx, dy, dz
#30. Ecuación de Lorenz modificada:
def lorenz_mod_map(x, y, z, sigma=10, rho=28, beta=8/3, a=0.25):
dx_dt = sigma * (y - x)
dy_dt = x * (rho - z) - y
dz_dt = x * y - beta * z + a * z ** 2
return x + dx_dt, y + dy_dt, z + dz_dt
x = 0.1
y = 0.1
z = 0.1
for i in range(100):
x, y, z = lorenz_mod_map(x, y, z)
print(x, y, z)
#31. Función de Halvorsen:
def halvorsen(x, y, z, a):
dx = -a * x - 4 * y - 4 * z - y ** 2
dy = -a * y - 4 * z - 4 * x - z ** 2
dz = -a * z - 4 * x - 4 * y - x ** 2
return dx, dy, dz
#32. Ecuación del mapa de círculo:
import math
def circle_map(theta, k):
return theta + k * math.sin(2 * math.pi * theta)
theta = 0.1
k = 0.4
for i in range(100):
theta = circle_map(theta, k)
print(theta)
#33. Función de Sine Logistic:
def sine_logistic(x, y, a, b, c, d):
xn = a * y * math.sin(b * x) + c * math.sin(d * x)
yn = x
return xn, yn
#34. Función de Sine Quadratic:
def sine_quadratic(x, y, a, b, c, d):
xn = a * y * math.sin(b * x) + c * x * math.cos(d * y)
yn = x * x - y * y
return xn, yn
#35. Función de Burgers:
def burgers(x, y, a, b):
dx = -a * x + y * x
dy = b - y * x
return dx, dy