import unittest
import numpy as np
import importlib
import math

# --- Constants for Testing ---
# We know the true minimum is approx -3.51
# We will check that the algorithm finds a solution better than -3.0
OPTIMALITY_THRESHOLD = -3.0

def _dynamic_test(test_case, condition, success_message, failure_message):
    """Helper function to dynamically pass/fail tests."""
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestPSOSimulation(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        """Importing the user's code and running the PSO."""
        global user_code
        try:
            user_code = importlib.import_module("user_code")
            # Running the PSO to get the results for testing
            cls.best_x, cls.best_value = user_code.run_pso()
        except ImportError:
            cls.fail("Could not import user_code.py. Make sure the file exists.")
        except Exception as e:
            cls.fail(f"Error running run_pso(): {e}")

    def test_return_types(self):
        """Checking if the PSO returns values with the correct types."""
        # Checking best_x type
        condition_x = isinstance(self.best_x, (float, np.float64))
        _dynamic_test(
            self,
            condition_x,
            "The returned `best_position` is a float.",
            f"The returned `best_position` should be a float, but got {type(self.best_x)}."
        )
        
        # Checking best_value type
        condition_f = isinstance(self.best_value, (float, np.float64))
        _dynamic_test(
            self,
            condition_f,
            "The returned `best_value` is a float.",
            f"The returned `best_value` should be a float, but got {type(self.best_value)}."
        )

    def test_fitness_function_correctness(self):
        """Checking if the fitness_function calculates a known value correctly."""
        # This test checks the helper function 'f' directly
        test_val = user_code.f(math.pi)
        expected_val = math.pi ** 2 + 5 * math.sin(math.pi) # sin(pi) is 0
        
        condition = np.isclose(test_val, math.pi ** 2)
        _dynamic_test(
            self,
            condition,
            "The `f(pi)` function correctly returns pi^2.",
            f"The `f(pi)` function returned {test_val}, but should be {math.pi ** 2}."
        )

    def test_solution_in_range(self):
        """Checking that the `best_position` is within the allowed bounds."""
        condition = user_code.xmin <= self.best_x <= user_code.xmax
        _dynamic_test(
            self,
            condition,
            f"The solution `best_position` ({self.best_x:.4f}) is within the [{user_code.xmin}, {user_code.xmax}] range.",
            f"The solution `best_position` ({self.best_x:.4f}) is outside the allowed [{user_code.xmin}, {user_code.xmax}] range."
        )
        
    def test_solution_is_consistent(self):
        """Checking that f(best_position) matches the reported `best_value`."""
        # This checks if the user's logic correctly paired the position and value
        calculated_value = user_code.f(self.best_x)
        condition = np.isclose(calculated_value, self.best_value)
        _dynamic_test(
            self,
            condition,
            "The reported `best_value` matches the result of `f(best_position)`.",
            f"The reported `best_value` ({self.best_value:.6f}) does not match `f(best_position)` ({calculated_value:.6f})."
        )

    def test_solution_is_optimal(self):
        """Checking that the algorithm found a good solution (value < -3.0)."""
        # This proves the optimization worked without being brittle
        condition = self.best_value < OPTIMALITY_THRESHOLD
        _dynamic_test(
            self,
            condition,
            f"The solution `best_value` ({self.best_value:.6f}) is less than the threshold ({OPTIMALITY_THRESHOLD}), indicating a successful optimization.",
            f"The solution `best_value` ({self.best_value:.6f}) is not less than the threshold ({OPTIMALITY_THRESHOLD}). The optimization may have failed."
        )

if __name__ == "__main__":
    unittest.main(argv=['first-arg-is-ignored'], exit=False)


test_main.py

Explorez les bases et les applications pratiques des algorithmes bio-inspirés en Python. Ce cours couvre le calcul évolutionnaire, l'intelligence en essaim et d'autres techniques d'optimisation inspirées de la nature, en utilisant uniquement Python standard et les bibliothèques scientifiques autorisées.

Comprendre la motivation, l'histoire et les principes fondamentaux de l'informatique bio-inspirée, y compris l'évolution, l'adaptation et l'intelligence collective.

Explorez la structure, les opérateurs et l'ajustement des paramètres des algorithmes génétiques.

Étude des algorithmes inspirés par le comportement collectif dans la nature, y compris les fourmis, les particules et d'autres essaims.

Explorer les principes et algorithmes inspirés du système immunitaire biologique, y compris la sélection négative et la sélection clonale.

Défi : Implémenter l’Optimisation par Essaim Particulaire

Solution