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

Tutustu bioinspiroitujen algoritmien perusteisiin ja käytännön sovelluksiin Pythonilla. Kurssi kattaa evoluutiolaskennan, parviälyn sekä muut luonnosta inspiroituneet optimointitekniikat käyttäen ainoastaan Pythonin vakiokirjastoja ja sallittuja tieteellisiä kirjastoja.

Motivaation, historian ja bioinspiroitujen laskentamenetelmien keskeisten periaatteiden ymmärtäminen, mukaan lukien evoluutio, sopeutuminen ja parviäly.

Syvenny geneettisten algoritmien rakenteeseen, operaattoreihin ja parametrien säätöön.

Tutki luonnon kollektiivisesta käyttäytymisestä inspiroituneita algoritmeja, mukaan lukien muurahaiset, partikkelit ja muut parvet.

Tutustu biologisen immuunijärjestelmän inspiroimiin periaatteisiin ja algoritmeihin, mukaan lukien negatiivinen valinta ja kloonivalinta.

Haaste: Toteuta partikkeliparvien optimointi

Ratkaisu