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

Utforska grunderna och praktiska tillämpningar av bioinspirerade algoritmer i Python. Kursen behandlar evolutionär beräkning, svärmintelligens och andra naturinspirerade optimeringstekniker med enbart standard-Python och tillåtna vetenskapliga bibliotek.

Förstå motivationen, historien och de grundläggande principerna bakom bioinspirerad beräkning, inklusive evolution, anpassning och svärmintelligens.

Utforska strukturen, operatorerna och parameterinställningen för genetiska algoritmer.

Undersök algoritmer inspirerade av kollektivt beteende i naturen, inklusive myror, partiklar och andra svärmar.

Utforska principer och algoritmer inspirerade av det biologiska immunsystemet, inklusive negativ selektion och klonal selektion.

Utmaning: Bygg en Genetisk Algoritm

Lösning