Añadir ejercicios resueltos de POO

Author: KernelPhilosopher

Ejercicio de las N partículas/Desarrollo del ejercicio/Complexity/Análisis de Complejidad en Simulación de Partículas.pdf

@@ -0,0 +1,19 @@
+# Configuraciones y constantes globales
+COLOR_FONDO = (0, 0, 0)
+COLORES = [
+    (255, 0, 0),
+    (0, 255, 0),
+    (0, 0, 255),
+    (255, 255, 0),
+    (255, 0, 255),
+    (0, 255, 255),
+    (255, 128, 0),
+    (128, 0, 255),
+    (0, 128, 255),
+    (128, 255, 0),
+]
+ANCHO = 800
+ALTO = 600
+FPS = 60
+G = 0.1
+MAX_PARTICULAS_NODO = 4

Ejercicio de las N partículas/Desarrollo del ejercicio/src/models/__pycache__/constants.cpython-313.pyc

@@ -0,0 +1,35 @@
+import pygame
+from pygame.locals import *
+
+
+class EventHandler:
+    @staticmethod
+    def procesar_eventos(particula_manager):
+        eventos = {
+            "salir": False,
+            "reiniciar": False,
+            "particula_seleccionada": None,
+            "mostrar_distancias": True,
+        }
+
+        for evento in pygame.event.get():
+            if evento.type == QUIT:
+                eventos["salir"] = True
+            elif evento.type == MOUSEBUTTONDOWN:
+                x, y = pygame.mouse.get_pos()
+                for i in range(particula_manager.num_particulas):
+                    dx = x - particula_manager.posiciones[i, 0]
+                    dy = y - particula_manager.posiciones[i, 1]
+                    if dx**2 + dy**2 <= particula_manager.radios[i] ** 2:
+                        eventos["particula_seleccionada"] = i
+                        break
+                else:
+                    eventos["particula_seleccionada"] = None
+            elif evento.type == KEYDOWN:
+                if evento.key == K_SPACE:
+                    eventos["mostrar_distancias"] = not eventos["mostrar_distancias"]
+                elif evento.key == K_r:
+                    eventos["reiniciar"] = True
+                elif evento.key == K_ESCAPE:
+                    eventos["particula_seleccionada"] = None
+        return eventos

Ejercicio de las N partículas/Desarrollo del ejercicio/src/models/__pycache__/event_handler.cpython-313.pyc

@@ -0,0 +1,87 @@
+import numpy as np
+from quadtree_node import QuadtreeNode
+from constants import G, MAX_PARTICULAS_NODO, ANCHO, ALTO
+
+
+# Clase que gestiona la física y el comportamiento de las partículas en la simulación
+class ParticulaManager:
+    # Constructor: inicializa el sistema con un número específico de partículas
+    def __init__(self, num_particulas):
+        self.num_particulas = num_particulas
+        self.min_distancia = float("inf")
+        self.par_mas_cercano = (
+            None,
+            None,
+        )  # Almacena los índices de las partículas más cercanas
+        self.inicializar_particulas()
+
+    # Método para crear y configurar las partículas iniciales
+    def inicializar_particulas(self):
+        # Genera posiciones aleatorias dentro de los límites de la pantalla
+        self.posiciones = np.random.rand(self.num_particulas, 2)
+        self.posiciones[:, 0] *= ANCHO
+        self.posiciones[:, 1] *= ALTO
+        # Genera velocidades aleatorias con componentes entre -2 y 2
+        self.velocidades = (np.random.rand(self.num_particulas, 2) - 0.5) * 4
+        # Genera masas aleatorias entre 5 y 15
+        self.masas = np.random.rand(self.num_particulas) * 10 + 5
+        # El radio de cada partícula es proporcional a su masa
+        self.radios = self.masas / 2
+
+    # Método para construir el árbol cuaternario (quadtree) para optimización espacial
+    def construir_quadtree(self):
+        root = QuadtreeNode(0, 0, ANCHO, ALTO, max_particulas=MAX_PARTICULAS_NODO)
+        for i in range(self.num_particulas):
+            part = {"id": i, "pos": tuple(self.posiciones[i])}
+            root.insertar(part)
+        return root
+
+    # Método principal que actualiza la física del sistema
+    def actualizar_fisica(self):
+        n = self.num_particulas
+        # Array para almacenar las aceleraciones de cada partícula
+        aceleraciones = np.zeros((n, 2))
+        self.min_distancia = float("inf")
+        self.par_mas_cercano = (None, None)
+
+        # Cálculo de fuerzas gravitacionales entre todas las partículas
+        for i in range(n):
+            for j in range(i + 1, n):
+                # Calcula la distancia entre partículas
+                dx = self.posiciones[j, 0] - self.posiciones[i, 0]
+                dy = self.posiciones[j, 1] - self.posiciones[i, 1]
+                dist = np.sqrt(dx**2 + dy**2)
+
+                # Actualiza el par más cercano si corresponde
+                if dist < self.min_distancia:
+                    self.min_distancia = dist
+                    self.par_mas_cercano = (i, j)
+
+                # Previene superposición excesiva estableciendo una distancia mínima
+                dist = max(dist, 2 * max(self.radios[i], self.radios[j]))
+                # Calcula la fuerza gravitacional
+                fuerza = G * self.masas[i] * self.masas[j] / (dist**2)
+                # Actualiza las aceleraciones según la ley de Newton
+                aceleraciones[i] += fuerza * np.array([dx, dy]) / (dist * self.masas[i])
+                aceleraciones[j] -= fuerza * np.array([dx, dy]) / (dist * self.masas[j])
+
+        # Actualiza velocidades y posiciones usando las aceleraciones calculadas
+        self.velocidades += aceleraciones
+        self.posiciones += self.velocidades
+
+        # Manejo de colisiones con los bordes de la pantalla
+        for i in range(n):
+            for dim in range(2):
+                limite = ANCHO if dim == 0 else ALTO
+                # Rebote en los bordes con pérdida de energía (factor 0.9)
+                if (
+                    self.posiciones[i, dim] < self.radios[i]
+                    or self.posiciones[i, dim] > limite - self.radios[i]
+                ):
+                    self.velocidades[i, dim] *= -0.9
+            # Asegura que las partículas permanezcan dentro de los límites
+            self.posiciones[i] = np.clip(
+                self.posiciones[i],
+                self.radios[i],
+                [ANCHO - self.radios[i], ALTO - self.radios[i]],
+            )

Ejercicio de las N partículas/Desarrollo del ejercicio/src/models/__pycache__/particula_manager.cpython-313.pyc

@@ -0,0 +1,82 @@
+import numpy as np
+
+
+class QuadtreeNode:
+    def __init__(self, x_min, y_min, x_max, y_max, profundidad=0, max_particulas=4):
+        self.limite = (x_min, y_min, x_max, y_max)
+        self.profundidad = profundidad
+        self.max_particulas = max_particulas
+        self.particulas = []
+        self.hijos = []
+
+    def insertar(self, particula):
+        if self.hijos:
+            for hijo in self.hijos:
+                if hijo.contiene(particula):
+                    hijo.insertar(particula)
+                    return
+        else:
+            self.particulas.append(particula)
+            if len(self.particulas) > self.max_particulas:
+                self.subdividir()
+                for p in self.particulas:
+                    for hijo in self.hijos:
+                        if hijo.contiene(p):
+                            hijo.insertar(p)
+                            break
+                self.particulas = []
+
+    def contiene(self, particula):
+        x, y = particula["pos"]
+        x_min, y_min, x_max, y_max = self.limite
+        return x_min <= x < x_max and y_min <= y < y_max
+
+    def subdividir(self):
+        x_min, y_min, x_max, y_max = self.limite
+        mx = (x_min + x_max) / 2
+        my = (y_min + y_max) / 2
+        self.hijos = [
+            QuadtreeNode(
+                x_min, y_min, mx, my, self.profundidad + 1, self.max_particulas
+            ),
+            QuadtreeNode(
+                mx, y_min, x_max, my, self.profundidad + 1, self.max_particulas
+            ),
+            QuadtreeNode(
+                x_min, my, mx, y_max, self.profundidad + 1, self.max_particulas
+            ),
+            QuadtreeNode(
+                mx, my, x_max, y_max, self.profundidad + 1, self.max_particulas
+            ),
+        ]
+
+    def buscar_vecinos(self, particula, distancia_minima=float("inf")):
+        x, y = particula["pos"]
+        vecino = None
+        if self.hijos:
+            for hijo in self.hijos:
+                if hijo.contiene(particula):
+                    vecino, distancia_minima = hijo.buscar_vecinos(
+                        particula, distancia_minima
+                    )
+                else:
+                    distancia_al_cuadrante = hijo.distancia_a_cuadrante(x, y)
+                    if distancia_al_cuadrante < distancia_minima:
+                        v, d = hijo.buscar_vecinos(particula, distancia_minima)
+                        if d < distancia_minima:
+                            vecino, distancia_minima = v, d
+        else:
+            for p in self.particulas:
+                if p["id"] != particula["id"]:
+                    dx = p["pos"][0] - x
+                    dy = p["pos"][1] - y
+                    dist = (dx**2 + dy**2) ** 0.5
+                    if dist < distancia_minima:
+                        vecino, distancia_minima = p, dist
+        return vecino, distancia_minima
+
+    def distancia_a_cuadrante(self, x, y):
+        x_min, y_min, x_max, y_max = self.limite
+        dx = max(x_min - x, 0, x - x_max)
+        dy = max(y_min - y, 0, y - y_max)
+        return (dx**2 + dy**2) ** 0.5