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

Explore the foundations and practical applications of bio-inspired algorithms in Python. This course covers evolutionary computation, swarm intelligence, and other nature-inspired optimization techniques, using only standard Python and permitted scientific libraries.

Understand the motivation, history, and core principles behind bio-inspired computation, including evolution, adaptation, and swarm intelligence.

Dive into the structure, operators, and parameter tuning of genetic algorithms.

Investigate algorithms inspired by collective behavior in nature, including ants, particles, and other swarms.

Explore the principles and algorithms inspired by the biological immune system, including negative selection and clonal selection.

Challenge: Implement Particle Swarm Optimization

Oplossing

Awesome!

Challenge: Implement Particle Swarm Optimization

Oplossing