Haz un programa en python que simule un sistema planetario de n cuerpos. Este preguntara…

¡Claro! Para simular un sistema planetario de n cuerpos en Python, podemos utilizar el método de integración numérica de Verlet, que es una técnica para resolver ecuaciones diferenciales. Para mostrar las trayectorias de los cuerpos, utilizaremos la biblioteca de Python Matplotlib. A continuación, se presenta un ejemplo de código que simula un sistema planetario de n cuerpos:

import numpy as np
import matplotlib.pyplot as plt

#Pedimos al usuario el número de cuerpos
n = int(input("Número de cuerpos: "))

#Definimos las constantes
G = 6.67430e-11 # Constante gravitacional
dt = 1 # Tamaño del paso de tiempo
num_steps = 10000 # Número de pasos de tiempo

#Creamos las listas para almacenar la masa, posición y velocidad de los cuerpos
m = np.zeros(n)
x = np.zeros((n, 2))
v = np.zeros((n, 2))

#Pedimos al usuario la masa, posición y velocidad inicial de cada cuerpo
for i in range(n):
    m[i] = float(input(f"Masa del cuerpo {i+1}: "))
    x[i] = np.array([float(input(f"Posición inicial en x del cuerpo {i+1}: ")),
                     float(input(f"Posición inicial en y del cuerpo {i+1}: "))])
    v[i] = np.array([float(input(f"Velocidad inicial en x del cuerpo {i+1}: ")),
                     float(input(f"Velocidad inicial en y del cuerpo {i+1}: "))])

#Creamos una función que calcule la aceleración de los cuerpos
def acceleration(x):
    a = np.zeros((n, 2))
    for i in range(n):
        for j in range(n):
            if i != j:
                r = x[j] - x[i]
                a[i] += G * m[j] / np.linalg.norm(r)**3 * r
    return a

#Creamos listas vacías para almacenar las trayectorias de los cuerpos
x_traj = [[] for i in range(n)]
y_traj = [[] for i in range(n)]

#Simulamos el sistema planetario
for i in range(num_steps):
    a = acceleration(x)
    x += v * dt + 0.5 * a * dt**2
    a_new = acceleration(x)
    v += 0.5 * (a + a_new) * dt
    for j in range(n):
        x_traj[j].append(x[j][0])
        y_traj[j].append(x[j][1])

#Mostramos las trayectorias de los cuerpos
for i in range(n):
    plt.plot(x_traj[i], y_traj[i], label=f"Cuerpo {i+1}")
plt.legend()
plt.show()

En este ejemplo de código, primero pedimos al usuario el número de cuerpos y luego solicitamos su masa, posición y velocidad inicial. A continuación, creamos una función llamada acceleration que calcula la aceleración de cada cuerpo en función de su posición. Luego, simulamos el sistema planetario durante 10000 pasos de tiempo utilizando el método de Verlet y almacenamos las trayectorias de cada cuerpo en listas. Finalmente, mostramos las trayectorias de los cuerpos utilizando la biblioteca Matplotlib.

¡Espero que este ejemplo de código sea útil para simular sistemas planetarios en Python!

¡Esta bien! Aquí te muestro un ejemplo de un programa en Python que simula un sistema planetario de n cuerpos y muestra las trayectorias de los cuerpos usando la biblioteca matplotlib.

import numpy as np
import matplotlib.pyplot as plt

# Pedimos el número de cuerpos al usuario
n = int(input("Ingrese el número de cuerpos: "))

# Creamos arrays para las masas, posiciones y velocidades iniciales
m = np.zeros(n)
pos = np.zeros((n, 2))
vel = np.zeros((n, 2))

# Pedimos al usuario la información para cada cuerpo
for i in range(n):
    m[i] = float(input("Ingrese la masa del cuerpo {}: ".format(i+1)))
    pos[i] = np.array([float(input("Ingrese la posición inicial en x del cuerpo {}: ".format(i+1))),
                       float(input("Ingrese la posición inicial en y del cuerpo {}: ".format(i+1)))])

    vel[i] = np.array([float(input("Ingrese la velocidad inicial en x del cuerpo {}: ".format(i+1))),
                       float(input("Ingrese la velocidad inicial en y del cuerpo {}: ".format(i+1)))])

# Definimos una función que calcula la aceleración en cada cuerpo
def get_acceleration(masses, positions):
    G = 6.67408e-11
    n = len(masses)
    accels = np.zeros((n, 2))
    for i in range(n):
        for j in range(n):
            if i != j:
                r = positions[j] - positions[i]
                accels[i] += G * masses[j] / np.linalg.norm(r)**3 * r
    return accels

# Simulamos el movimiento de los cuerpos durante 10000 pasos de un segundo
dt = 1
posiciones = np.zeros((n, 2, 10000))
posiciones[:, :, 0] = pos

for i in range(1, 10000):
    aceleracion = get_acceleration(m, posiciones[:, :, i-1])
    vel += aceleracion * dt
    pos += vel * dt
    posiciones[:, :, i] = pos

# Mostramos las trayectorias de los cuerpos en diferentes colores usando matplotlib
colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k']

for i in range(n):
    plt.plot(posiciones[i, 0, :], posiciones[i, 1, :], colors[i % len(colors)])

plt.xlabel("Posición en x")
plt.ylabel("Posición en y")
plt.title("Trayectorias de los cuerpos")
plt.show()

En este programa, primero pedimos al usuario el número de cuerpos, así como su masa, velocidad y posición inicial. Luego, utilizamos una función para calcular la aceleración de cada cuerpo, y simulamos el movimiento de los cuerpos durante 10000 pasos de un segundo. Finalmente, mostramos las trayectorias de los cuerpos en diferentes colores utilizando matplotlib.Ten en cuenta que este es solo un ejemplo básico de una simulación de sistema planetario. Para hacer una simulación más precisa y realista, se requerirían cálculos adicionales y ajustes en el programa.