import unittest
import numpy as np
import importlib

# --- Defining Constants ---
X_MIN, X_MAX = 0, 6
TARGET_X = 3.0
TARGET_FITNESS = 10.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 TestGeneticAlgorithm(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        """Importing the user's code and running the GA."""
        global user_code
        try:
            user_code = importlib.import_module("user_code")
            # Running the GA to get the results for testing
            cls.best_x, cls.best_fitness = user_code.genetic_algorithm()
        except ImportError:
            cls.fail("Could not import user_code.py. Make sure the file exists.")
        except Exception as e:
            cls.fail(f"Error running genetic_algorithm(): {e}")

    def test_return_types(self):
        """Checking if the GA 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_x` is a float.",
            f"The returned `best_x` should be a float, but got {type(self.best_x)}."
        )
        
        # Checking best_fitness type
        condition_f = isinstance(self.best_fitness, (float, np.float64))
        _dynamic_test(
            self,
            condition_f,
            "The returned `best_fitness` is a float.",
            f"The returned `best_fitness` should be a float, but got {type(self.best_fitness)}."
        )

    def test_solution_in_range(self):
        """Checking if the solution `best_x` is within the valid [0, 6] range."""
        condition = X_MIN <= self.best_x <= X_MAX
        _dynamic_test(
            self,
            condition,
            f"The solution `best_x` ({self.best_x:.4f}) is within the [{X_MIN}, {X_MAX}] range.",
            f"The solution `best_x` ({self.best_x:.4f}) is outside the valid [{X_MIN}, {X_MAX}] range."
        )

    def test_solution_optimality(self):
        """Checking if the solution is very close to the known optimum (x=3, f=10)."""
        # Due to random seeds, the result is deterministic and should be very close.
        
        # Checking x value
        # We allow a small tolerance
        condition_x = np.isclose(self.best_x, TARGET_X, atol=0.01)
        _dynamic_test(
            self,
            condition_x,
            f"The solution `best_x` ({self.best_x:.4f}) is very close to the target {TARGET_X}.",
            f"The solution `best_x` ({self.best_x:.4f}) is not close enough to the target {TARGET_X}."
        )
        
        # Checking fitness value
        # The fitness should be *very* close to 10.0
        condition_f = np.isclose(self.best_fitness, TARGET_FITNESS, atol=1e-4)
        _dynamic_test(
            self,
            condition_f,
            f"The solution `best_fitness` ({self.best_fitness:.4f}) is very close to the target {TARGET_FITNESS}.",
            f"The solution `best_fitness` ({self.best_fitness:.4f}) is not close enough to the target {TARGET_FITNESS}."
        )
        
    def test_fitness_function_correctness(self):
        """Checking if the fitness_function calculates the correct value at the peak."""
        # This test checks the helper function directly
        peak_fitness = user_code.fitness_function(3.0)
        condition = np.isclose(peak_fitness, 10.0)
        _dynamic_test(
            self,
            condition,
            "The `fitness_function(3.0)` correctly returns 10.0.",
            f"The `fitness_function(3.0)` returned {peak_fitness}, but should be 10.0."
        )

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

test_main.py

Udforsk grundlæggende principper og praktiske anvendelser af bio-inspirerede algoritmer i Python. Dette kursus dækker evolutionær beregning, sværmintelligens og andre naturinspirerede optimeringsteknikker ved brug af standard Python og tilladte videnskabelige biblioteker.

Forstå motivationen, historien og de centrale principper bag bio-inspireret beregning, herunder evolution, tilpasning og sværmintelligens.

Udforsk strukturen, operatorerne og parameterjusteringen i genetiske algoritmer.

Undersøg algoritmer inspireret af kollektiv adfærd i naturen, herunder myrer, partikler og andre sværme.

Undersøg principper og algoritmer inspireret af det biologiske immunsystem, herunder negativ selektion og klonal selektion.

Challenge: Build a Genetic Algorithm

Løsning

Challenge: Build a Genetic Algorithm

Løsning