desdeo 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

desdeo/emo/operators/crossover.py

@@ -7,7 +7,6 @@ in multiobjective optimization are defined here.
 import copy
 from abc import abstractmethod
 from collections.abc import Sequence
-from random import shuffle
 
 import numpy as np
 import polars as pl
@@ -19,15 +18,15 @@ from desdeo.tools.message import (
     Message,
     PolarsDataFrameMessage,
 )
-from desdeo.tools.patterns import Subscriber
+from desdeo.tools.patterns import Publisher, Subscriber
 
 
 class BaseCrossover(Subscriber):
     """A base class for crossover operators."""
 
-    def __init__(self, problem: Problem, **kwargs):
+    def __init__(self, problem: Problem, verbosity: int, publisher: Publisher):
         """Initialize a crossover operator."""
-        super().__init__(**kwargs)
+        super().__init__(verbosity=verbosity, publisher=publisher)
         self.problem = problem
         self.variable_symbols = [var.symbol for var in problem.get_flattened_variables()]
         self.lower_bounds = [var.lowerbound for var in problem.get_flattened_variables()]
@@ -61,7 +60,7 @@ class SimulatedBinaryCrossover(BaseCrossover):
     """
 
     @property
-    def provided_topics(self) -> dict[str, Sequence[CrossoverMessageTopics]]:
+    def provided_topics(self) -> dict[int, Sequence[CrossoverMessageTopics]]:
         """The message topics provided by the crossover operator."""
         return {
             0: [],
@@ -80,22 +79,30 @@ class SimulatedBinaryCrossover(BaseCrossover):
         return []
 
     def __init__(
-        self, *, problem: Problem, seed: int, xover_probability: float = 1.0, xover_distribution: float = 30, **kwargs
+        self,
+        *,
+        problem: Problem,
+        seed: int,
+        verbosity: int,
+        publisher: Publisher,
+        xover_probability: float = 1.0,
+        xover_distribution: float = 30,
     ):
         """Initialize a simulated binary crossover operator.
 
         Args:
             problem (Problem): the problem object.
             seed (int): the seed for the random number generator.
+            verbosity (int): the verbosity level of the component. The keys in `provided_topics` tell what
+                topics are provided by the operator at each verbosity level. Recommended to be set to 1.
+            publisher (Publisher): the publisher to which the operator will publish messages.
             xover_probability (float, optional): the crossover probability
                 parameter. Ranges between 0 and 1.0. Defaults to 1.0.
             xover_distribution (float, optional): the crossover distribution
                 parameter. Must be positive. Defaults to 30.
-            kwargs: Additional keyword arguments. These are passed to the Subscriber class. At the very least, the
-                publisher must be passed. See the Subscriber class for more information.
         """
         # Subscribes to no topics, so no need to stroe/pass the topics to the super class.
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         self.problem = problem
 
         if not 0 <= xover_probability <= 1:
@@ -135,7 +142,7 @@ class SimulatedBinaryCrossover(BaseCrossover):
 
         if to_mate is None:
             shuffled_ids = list(range(pop_size))
-            shuffle(shuffled_ids)
+            self.rng.shuffle(shuffled_ids)
         else:
             shuffled_ids = to_mate
         mating_pop = parent_decvars[shuffled_ids]
@@ -216,16 +223,17 @@ class SimulatedBinaryCrossover(BaseCrossover):
 class SinglePointBinaryCrossover(BaseCrossover):
     """A class that defines the single point binary crossover operation."""
 
-    def __init__(self, *, problem: Problem, seed: int, **kwargs):
+    def __init__(self, *, problem: Problem, seed: int, verbosity: int, publisher: Publisher):
         """Initialize the single point binary crossover operator.
 
         Args:
             problem (Problem): the problem object.
             seed (int): the seed used in the random number generator for choosing the crossover point.
-            kwargs: Additional keyword arguments. These are passed to the Subscriber class. At the very least, the
-                publisher must be passed. See the Subscriber class for more information.
+            verbosity (int): the verbosity level of the component. The keys in `provided_topics` tell what
+                topics are provided by the operator at each verbosity level.
+            publisher (Publisher): the publisher to which the operator will publish messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         self.seed = seed
 
         self.parent_population: pl.DataFrame
@@ -234,7 +242,7 @@ class SinglePointBinaryCrossover(BaseCrossover):
         self.seed = seed
 
     @property
-    def provided_topics(self) -> dict[str, Sequence[CrossoverMessageTopics]]:
+    def provided_topics(self) -> dict[int, Sequence[CrossoverMessageTopics]]:
         """The message topics provided by the single point binary crossover operator."""
         return {
             0: [],
@@ -273,7 +281,7 @@ class SinglePointBinaryCrossover(BaseCrossover):
 
         if to_mate is None:
             shuffled_ids = list(range(pop_size))
-            shuffle(shuffled_ids)
+            self.rng.shuffle(shuffled_ids)
         else:
             shuffled_ids = copy.copy(to_mate)
 
@@ -356,16 +364,17 @@ class SinglePointBinaryCrossover(BaseCrossover):
 class UniformIntegerCrossover(BaseCrossover):
     """A class that defines the uniform integer crossover operation."""
 
-    def __init__(self, *, problem: Problem, seed: int, **kwargs):
+    def __init__(self, *, problem: Problem, seed: int, verbosity: int, publisher: Publisher):
         """Initialize the uniform integer crossover operator.
 
         Args:
             problem (Problem): the problem object.
             seed (int): the seed used in the random number generator for choosing the crossover point.
-            kwargs: Additional keyword arguments. These are passed to the Subscriber class. At the very least, the
-                publisher must be passed. See the Subscriber class for more information.
+            verbosity (int): the verbosity level of the component. The keys in `provided_topics` tell what
+                topics are provided by the operator at each verbosity level. Recommended to be set to 1.
+            publisher (Publisher): the publisher to which the operator will publish messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         self.seed = seed
 
         self.parent_population: pl.DataFrame
@@ -374,7 +383,7 @@ class UniformIntegerCrossover(BaseCrossover):
         self.seed = seed
 
     @property
-    def provided_topics(self) -> dict[str, Sequence[CrossoverMessageTopics]]:
+    def provided_topics(self) -> dict[int, Sequence[CrossoverMessageTopics]]:
         """The message topics provided by the single point binary crossover operator."""
         return {
             0: [],
@@ -413,7 +422,7 @@ class UniformIntegerCrossover(BaseCrossover):
 
         if to_mate is None:
             shuffled_ids = list(range(pop_size))
-            shuffle(shuffled_ids)
+            self.rng.shuffle(shuffled_ids)
         else:
             shuffled_ids = copy.copy(to_mate)
 
@@ -485,16 +494,17 @@ class UniformMixedIntegerCrossover(BaseCrossover):
     stuff...
     """
 
-    def __init__(self, *, problem: Problem, seed: int, **kwargs):
+    def __init__(self, *, problem: Problem, seed: int, verbosity: int, publisher: Publisher):
         """Initialize the uniform integer crossover operator.
 
         Args:
             problem (Problem): the problem object.
             seed (int): the seed used in the random number generator for choosing the crossover point.
-            kwargs: Additional keyword arguments. These are passed to the Subscriber class. At the very least, the
-                publisher must be passed. See the Subscriber class for more information.
+            verbosity (int): the verbosity level of the component. The keys in `provided_topics` tell what
+                topics are provided by the operator at each verbosity level. Recommended to be set to 1.
+            publisher (Publisher): the publisher to which the operator will publish messages.
         """
-        super().__init__(problem, **kwargs)
+        super().__init__(problem, verbosity=verbosity, publisher=publisher)
         self.seed = seed
 
         self.parent_population: pl.DataFrame
@@ -503,7 +513,7 @@ class UniformMixedIntegerCrossover(BaseCrossover):
         self.seed = seed
 
     @property
-    def provided_topics(self) -> dict[str, Sequence[CrossoverMessageTopics]]:
+    def provided_topics(self) -> dict[int, Sequence[CrossoverMessageTopics]]:
         """The message topics provided by the single point binary crossover operator."""
         return {
             0: [],
@@ -542,7 +552,7 @@ class UniformMixedIntegerCrossover(BaseCrossover):
 
         if to_mate is None:
             shuffled_ids = list(range(pop_size))
-            shuffle(shuffled_ids)
+            self.rng.shuffle(shuffled_ids)
         else:
             shuffled_ids = copy.copy(to_mate)
 
@@ -634,15 +644,19 @@ class BlendAlphaCrossover(BaseCrossover):
         self,
         *,
         problem: Problem,
-        seed: int = 0,
+        verbosity: int,
+        publisher: Publisher,
+        seed: int,
         alpha: float = 0.5,
         xover_probability: float = 1.0,
-        **kwargs,
     ):
         """Initialize the blend alpha crossover operator.
 
         Args:
             problem (Problem): the problem object.
+            verbosity (int): the verbosity level of the component. The keys in `provided_topics` tell what
+                topics are provided by the operator at each verbosity level. Recommended to be set to 1.
+            publisher (Publisher): the publisher to which the operator will publish messages.
             seed (int): the seed used in the random number generator for choosing the crossover point.
             alpha (float, optional): non-negative blending factor 'alpha' that controls the extent to which
                 offspring may be sampled outside the interval defined by each pair of parent
@@ -650,10 +664,8 @@ class BlendAlphaCrossover(BaseCrossover):
                 parents range, larger alpha allows some outliers. Defaults to 0.5.
             xover_probability (float, optional): the crossover probability parameter.
                 Ranges between 0 and 1.0. Defaults to 1.0.
-            kwargs: Additional keyword arguments. These are passed to the Subscriber class. At the very least, the
-                publisher must be passed. See the Subscriber class for more information.
         """
-        super().__init__(problem=problem, **kwargs)
+        super().__init__(problem=problem, verbosity=verbosity, publisher=publisher)
 
         if problem.variable_domain is not VariableDomainTypeEnum.continuous:
             raise ValueError("BlendAlphaCrossover only works on continuous problems.")
@@ -666,6 +678,7 @@ class BlendAlphaCrossover(BaseCrossover):
         self.alpha = alpha
         self.xover_probability = xover_probability
         self.seed = seed
+        self.rng = np.random.default_rng(self.seed)
 
         self.parent_population: pl.DataFrame | None = None
         self.offspring_population: pl.DataFrame | None = None
@@ -695,7 +708,7 @@ class BlendAlphaCrossover(BaseCrossover):
         parent_decision_vars = population[self.variable_symbols].to_numpy()
         if to_mate is None:
             shuffled_ids = list(range(pop_size))
-            shuffle(shuffled_ids)
+            self.rng.shuffle(shuffled_ids)
         else:
             shuffled_ids = copy.copy(to_mate)
 
@@ -710,22 +723,20 @@ class BlendAlphaCrossover(BaseCrossover):
         parents1 = mating_pop[0::2, :]
         parents2 = mating_pop[1::2, :]
 
-        c_min = np.minimum(parents1, parents2)
-        c_max = np.maximum(parents1, parents2)
+        c_min = np.array(self.lower_bounds)
+        c_max = np.array(self.upper_bounds)
         span = c_max - c_min
 
         lower = c_min - self.alpha * span
         upper = c_max + self.alpha * span
 
-        rng = np.random.default_rng(self.seed)
-
-        unoform_1 = rng.random((mating_pop_size // 2, num_var))
-        uniform_2 = rng.random((mating_pop_size // 2, num_var))
+        uniform_1 = self.rng.random((mating_pop_size // 2, num_var))
+        uniform_2 = self.rng.random((mating_pop_size // 2, num_var))
 
-        offspring1 = lower + unoform_1 * (upper - lower)
+        offspring1 = lower + uniform_1 * (upper - lower)
         offspring2 = lower + uniform_2 * (upper - lower)
 
-        mask = rng.random(mating_pop_size // 2) > self.xover_probability
+        mask = self.rng.random(mating_pop_size // 2) > self.xover_probability
         offspring1[mask, :] = parents1[mask, :]
         offspring2[mask, :] = parents2[mask, :]
 
@@ -778,3 +789,494 @@ class BlendAlphaCrossover(BaseCrossover):
                 ]
             )
         return msgs
+
+
+class SingleArithmeticCrossover(BaseCrossover):
+    """Single Arithmetic Crossover for continuous problems."""
+
+    @property
+    def provided_topics(self) -> dict[int, Sequence[CrossoverMessageTopics]]:
+        """The message topics provided by the single arithmetic crossover operator."""
+        return {
+            0: [],  # No topics for 0
+            1: [
+                CrossoverMessageTopics.XOVER_PROBABILITY,  # Probability of crossover
+            ],
+            2: [
+                CrossoverMessageTopics.XOVER_PROBABILITY,  # Crossover probability
+                CrossoverMessageTopics.PARENTS,  # Parents involved in crossover
+                CrossoverMessageTopics.OFFSPRINGS,  # Offsprings created from crossover
+            ],
+        }
+
+    @property
+    def interested_topics(self):
+        """The message topics that the single arithmetic crossover operator is interested in."""
+        return []
+
+    def __init__(
+        self,
+        problem: Problem,
+        verbosity: int,
+        publisher: Publisher,
+        seed: int,
+        xover_probability: float = 1.0,
+    ):
+        """Initialize the single arithmetic crossover operator.
+
+        Args:
+            problem (Problem): the problem object.
+            verbosity (int): the verbosity level of the component. The keys in `provided_topics` tell what
+                topics are provided by the operator at each verbosity level. Recommended to be set to 1.
+            publisher (Publisher): the publisher to which the operator will publish messages.
+            xover_probability (float): probability of performing crossover.
+            seed (int): random seed for reproducibility.
+        """
+        super().__init__(problem=problem, verbosity=verbosity, publisher=publisher)
+
+        if not 0 <= xover_probability <= 1:
+            raise ValueError("Crossover probability must be in [0, 1].")
+
+        self.xover_probability = xover_probability
+        self.seed = seed
+        self.parent_population: pl.DataFrame | None = None
+        self.offspring_population: pl.DataFrame | None = None
+        self.rng = np.random.default_rng(self.seed)
+
+    def do(self, *, population: pl.DataFrame, to_mate: list[int] | None = None) -> pl.DataFrame:
+        """Perform Single Arithmetic Crossover.
+
+        Args:
+            population (pl.DataFrame): the population to perform the crossover with. The DataFrame
+                contains the decision vectors, the target vectors, and the constraint vectors.
+            to_mate (list[int] | None): the indices of the population members that should
+                participate in the crossover. If `None`, the whole population is subject
+                to the crossover.
+
+        Returns:
+            pl.DataFrame: the offspring resulting from the crossover.
+        """
+        self.parent_population = population
+        pop_size = population.shape[0]
+        num_vars = len(self.variable_symbols)
+
+        parents = population[self.variable_symbols].to_numpy()
+
+        if to_mate is None:
+            mating_indices = list(range(pop_size))
+            self.rng.shuffle(mating_indices)
+        else:
+            mating_indices = copy.copy(to_mate)
+
+        mating_pop_size = len(mating_indices)
+        original_pop_size = mating_pop_size
+
+        if mating_pop_size % 2 == 1:
+            mating_indices.append(mating_indices[0])
+            mating_pop_size += 1
+
+        mating_pool = parents[mating_indices, :]
+
+        parents1 = mating_pool[0::2, :]
+        parents2 = mating_pool[1::2, :]
+
+        mask = self.rng.random(mating_pop_size // 2) <= self.xover_probability
+        gene_pos = self.rng.integers(0, num_vars, size=mating_pop_size // 2)
+
+        # Initialize offspring as exact copies
+        offspring1 = parents1.copy()
+        offspring2 = parents2.copy()
+
+        # Apply crossover only for selected pairs
+        row_idx = np.arange(len(mask))[mask]
+        col_idx = gene_pos[mask]
+
+        avg = 0.5 * (parents1[row_idx, col_idx] + parents2[row_idx, col_idx])
+
+        # Use advanced indexing to set arithmetic crossover gene
+        offspring1[row_idx, col_idx] = avg
+        offspring2[row_idx, col_idx] = avg
+
+        for i, k in zip(row_idx, col_idx, strict=True):
+            offspring1[i, k + 1 :] = parents2[i, k + 1 :]
+            offspring2[i, k + 1 :] = parents1[i, k + 1 :]
+            offspring1[i, :k] = parents1[i, :k]
+            offspring2[i, :k] = parents2[i, :k]
+
+        offspring = np.vstack((offspring1, offspring2))
+        if original_pop_size % 2 == 1:
+            offspring = offspring[:-1, :]
+
+        self.offspring_population = pl.from_numpy(offspring, schema=self.variable_symbols).select(
+            pl.all().cast(pl.Float64)
+        )
+        self.notify()
+        return self.offspring_population
+
+    def update(self, *_, **__):
+        """Do nothing."""
+
+    def state(self) -> Sequence[Message]:
+        """Return the state of the single arithmetic crossover operator."""
+        if self.parent_population is None:
+            return []
+
+        msgs: list[Message] = []
+
+        # Messages for crossover probability
+        if self.verbosity >= 1:
+            msgs.append(
+                FloatMessage(
+                    topic=CrossoverMessageTopics.XOVER_PROBABILITY,
+                    source=self.__class__.__name__,
+                    value=self.xover_probability,
+                )
+            )
+
+        # Messages for parents and offspring
+        if self.verbosity >= 2:  # More detailed info
+            msgs.extend(
+                [
+                    PolarsDataFrameMessage(
+                        topic=CrossoverMessageTopics.PARENTS,
+                        source=self.__class__.__name__,
+                        value=self.parent_population,
+                    ),
+                    PolarsDataFrameMessage(
+                        topic=CrossoverMessageTopics.OFFSPRINGS,
+                        source=self.__class__.__name__,
+                        value=self.offspring_population,
+                    ),
+                ]
+            )
+
+        return msgs
+
+
+class LocalCrossover(BaseCrossover):
+    """Local Crossover for continuous problems."""
+
+    @property
+    def provided_topics(self) -> dict[int, Sequence[CrossoverMessageTopics]]:
+        """The message topics provided by the local crossover operator."""
+        return {
+            0: [],
+            1: [
+                CrossoverMessageTopics.XOVER_PROBABILITY,
+            ],
+            2: [
+                CrossoverMessageTopics.XOVER_PROBABILITY,
+                CrossoverMessageTopics.PARENTS,
+                CrossoverMessageTopics.OFFSPRINGS,
+            ],
+        }
+
+    @property
+    def interested_topics(self):
+        """The message topics that the local crossover operator is interested in."""
+        return []
+
+    def __init__(
+        self,
+        problem: Problem,
+        verbosity: int,
+        publisher: Publisher,
+        seed: int,
+        xover_probability: float = 1.0,
+    ):
+        """Initialize the local crossover operator.
+
+        Args:
+            problem (Problem): the problem object.
+            verbosity (int): the verbosity level of the component. The keys in `provided_topics` tell what
+                topics are provided by the operator at each verbosity level. Recommended to be set to 1.
+            publisher (Publisher): the publisher to which the operator will publish messages.
+            xover_probability (float): probability of performing crossover.
+            seed (int): random seed for reproducibility.
+        """
+        super().__init__(problem=problem, verbosity=verbosity, publisher=publisher)
+
+        if not 0 <= xover_probability <= 1:
+            raise ValueError("Crossover probability must be in [0, 1].")
+
+        self.xover_probability = xover_probability
+        self.seed = seed
+        self.rng = np.random.default_rng(self.seed)
+        self.parent_population: pl.DataFrame | None = None
+        self.offspring_population: pl.DataFrame | None = None
+
+    def do(self, *, population: pl.DataFrame, to_mate: list[int] | None = None) -> pl.DataFrame:
+        """Perform Local Crossover.
+
+        Args:
+            population (pl.DataFrame): the population to perform the crossover with. The DataFrame
+                contains the decision vectors, the target vectors, and the constraint vectors.
+            to_mate (list[int] | None): the indices of the population members that should
+                participate in the crossover. If `None`, the whole population is subject
+                to the crossover.
+
+        Returns:
+            pl.DataFrame: the offspring resulting from the crossover.
+        """
+        self.parent_population = population
+        pop_size = population.shape[0]
+        num_var = len(self.variable_symbols)
+
+        parent_decision_vars = population[self.variable_symbols].to_numpy()
+
+        if to_mate is None:
+            shuffled_ids = list(range(pop_size))
+            self.rng.shuffle(shuffled_ids)
+        else:
+            shuffled_ids = to_mate.copy()
+
+        mating_pop_size = len(shuffled_ids)
+        if mating_pop_size % 2 == 1:
+            shuffled_ids.append(shuffled_ids[0])
+            mating_pop_size += 1
+
+        mating_pop = parent_decision_vars[shuffled_ids]
+        parents1 = mating_pop[0::2]
+        parents2 = mating_pop[1::2]
+
+        offspring = np.empty((mating_pop_size, num_var))
+
+        for i in range(mating_pop_size // 2):
+            if self.rng.random() < self.xover_probability:
+                alpha = self.rng.random(num_var)
+
+                offspring[2 * i] = alpha * parents1[i] + (1 - alpha) * parents2[i]
+                offspring[2 * i + 1] = (1 - alpha) * parents1[i] + alpha * parents2[i]
+            else:
+                offspring[2 * i] = parents1[i]
+                offspring[2 * i + 1] = parents2[i]
+
+        self.offspring_population = pl.from_numpy(offspring, schema=self.variable_symbols).select(
+            pl.all().cast(pl.Float64)
+        )
+
+        self.notify()
+        return self.offspring_population
+
+    def update(self, *_, **__):
+        """Do nothing."""
+
+    def state(self) -> Sequence[Message]:
+        """Return the state of the local crossover operator."""
+        if self.parent_population is None:
+            return []
+
+        msgs: list[Message] = []
+
+        if self.verbosity >= 1:
+            msgs.append(
+                FloatMessage(
+                    topic=CrossoverMessageTopics.XOVER_PROBABILITY,
+                    source=self.__class__.__name__,
+                    value=self.xover_probability,
+                )
+            )
+        if self.verbosity >= 2:
+            msgs.extend(
+                [
+                    PolarsDataFrameMessage(
+                        topic=CrossoverMessageTopics.PARENTS,
+                        source=self.__class__.__name__,
+                        value=self.parent_population,
+                    ),
+                    PolarsDataFrameMessage(
+                        topic=CrossoverMessageTopics.OFFSPRINGS,
+                        source=self.__class__.__name__,
+                        value=self.offspring_population,
+                    ),
+                ]
+            )
+        return msgs
+
+
+class BoundedExponentialCrossover(BaseCrossover):
+    """Bounded‐exponential (BEX) crossover for continuous problems."""
+
+    @property
+    def provided_topics(self) -> dict[int, Sequence[CrossoverMessageTopics]]:
+        """The message topics provided by the bounded exponential crossover operator."""
+        return {
+            0: [],
+            1: [
+                CrossoverMessageTopics.XOVER_PROBABILITY,
+                CrossoverMessageTopics.LAMBDA,
+            ],
+            2: [
+                CrossoverMessageTopics.XOVER_PROBABILITY,
+                CrossoverMessageTopics.LAMBDA,
+                CrossoverMessageTopics.PARENTS,
+                CrossoverMessageTopics.OFFSPRINGS,
+            ],
+        }
+
+    @property
+    def interested_topics(self):
+        """The message topics provided by the bounded exponential crossover operator."""
+        return []
+
+    def __init__(
+        self,
+        *,
+        problem: Problem,
+        verbosity: int,
+        publisher: Publisher,
+        seed: int,
+        lambda_: float = 1.0,
+        xover_probability: float = 1.0,
+    ):
+        """Initialize the bounded‐exponential crossover operator.
+
+        Args:
+            problem (Problem): the problem object.
+            verbosity (int): the verbosity level of the component. The keys in `provided_topics` tell what
+                topics are provided by the operator at each verbosity level. Recommended to be set to 1.
+            publisher (Publisher): the publisher to which the operator will publish messages.
+            seed (int): random seed for the internal generator.
+            lambda_ (float, optional): positive scale λ for the exponential distribution.
+                Defaults to 1.0.
+            xover_probability (float, optional): probability of applying crossover
+                to each pair. Defaults to 1.0.
+        """
+        super().__init__(problem=problem, verbosity=verbosity, publisher=publisher)
+
+        if problem.variable_domain is not VariableDomainTypeEnum.continuous:
+            raise ValueError("BoundedExponentialCrossover only works on continuous problems.")
+        if lambda_ <= 0:
+            raise ValueError("lambda_ must be positive.")
+        if not 0 <= xover_probability <= 1:
+            raise ValueError("xover_probability must be in [0,1].")
+
+        self.lambda_ = lambda_
+        self.xover_probability = xover_probability
+        self.seed = seed
+        self.rng = np.random.default_rng(self.seed)
+
+        self.parent_population: pl.DataFrame | None = None
+        self.offspring_population: pl.DataFrame | None = None
+
+    def do(
+        self,
+        *,
+        population: pl.DataFrame,
+        to_mate: list[int] | None = None,
+    ) -> pl.DataFrame:
+        """Perform bounded‐exponential crossover.
+
+        Args:
+            population (pl.DataFrame): the population to perform the crossover with. The DataFrame
+                contains the decision vectors, the target vectors, and the constraint vectors.
+            to_mate (list[int] | None): the indices of the population members that should
+                participate in the crossover. If `None`, the whole population is subject
+                to the crossover.
+
+        Returns:
+            pl.DataFrame: the offspring resulting from the crossover.
+        """
+        self.parent_population = population
+        pop_size = population.shape[0]
+        num_var = len(self.variable_symbols)
+
+        parent_decision_vars = population[self.variable_symbols].to_numpy()
+        if to_mate is None:
+            shuffled_ids = list(range(pop_size))
+            self.rng.shuffle(shuffled_ids)
+        else:
+            shuffled_ids = copy.copy(to_mate)
+
+        mating_pop_size = len(shuffled_ids)
+        original_pop_size = mating_pop_size
+        if mating_pop_size % 2 == 1:
+            shuffled_ids.append(shuffled_ids[0])
+            mating_pop_size += 1
+
+        mating_pop = parent_decision_vars[shuffled_ids]
+
+        parents1 = mating_pop[0::2, :]
+        parents2 = mating_pop[1::2, :]
+
+        x_lower = np.array(self.lower_bounds)
+        x_upper = np.array(self.upper_bounds)
+        span = parents2 - parents1  # y_i - x_1
+
+        u_i = self.rng.random((mating_pop_size // 2, num_var))  # random integers
+        r_i = self.rng.random((mating_pop_size // 2, num_var))
+
+        exp_lower_1 = np.exp((x_lower - parents1) / (self.lambda_ * span))
+        exp_upper_1 = np.exp((parents1 - x_upper) / (self.lambda_ * span))
+
+        exp_lower_2 = np.exp((x_lower - parents2) / (self.lambda_ * span))
+        exp_upper_2 = np.exp((parents2 - x_upper) / (self.lambda_ * span))
+
+        beta_1 = np.where(
+            r_i <= 0.5,
+            self.lambda_ * np.log(exp_lower_1 + u_i * (1 - exp_lower_1)),
+            -self.lambda_ * np.log(1 - u_i * (1 - exp_upper_1)),
+        )
+
+        beta_2 = np.where(
+            r_i <= 0.5,
+            self.lambda_ * np.log(exp_lower_2 + u_i * (1 - exp_lower_2)),
+            -self.lambda_ * np.log(1 - u_i * (1 - exp_upper_2)),
+        )
+
+        offspring1 = parents1 + beta_1 * span
+        offspring2 = parents2 + beta_2 * span
+
+        mask = self.rng.random(mating_pop_size // 2) > self.xover_probability
+        offspring1[mask, :] = parents1[mask, :]
+        offspring2[mask, :] = parents2[mask, :]
+
+        children = np.vstack((offspring1, offspring2))
+        if original_pop_size % 2 == 1:
+            children = children[:-1, :]
+
+        self.offspring_population = pl.from_numpy(children, schema=self.variable_symbols).select(
+            pl.all().cast(pl.Float64)
+        )
+        self.notify()
+        return self.offspring_population
+
+    def update(self, *_, **__):
+        """Do nothing."""
+
+    def state(self) -> Sequence[Message]:
+        """Return the state of the crossover operator."""
+        if getattr(self, "parent_population", None) is None:
+            return []
+        msgs: list[Message] = []
+        if self.verbosity >= 1:
+            msgs.append(
+                FloatMessage(
+                    topic=CrossoverMessageTopics.XOVER_PROBABILITY,
+                    source=self.__class__.__name__,
+                    value=self.xover_probability,
+                )
+            )
+            msgs.append(
+                FloatMessage(
+                    topic=CrossoverMessageTopics.LAMBDA,
+                    source=self.__class__.__name__,
+                    value=self.lambda_,
+                )
+            )
+        if self.verbosity >= 2:
+            msgs.extend(
+                [
+                    PolarsDataFrameMessage(
+                        topic=CrossoverMessageTopics.PARENTS,
+                        source=self.__class__.__name__,
+                        value=self.parent_population,
+                    ),
+                    PolarsDataFrameMessage(
+                        topic=CrossoverMessageTopics.OFFSPRINGS,
+                        source=self.__class__.__name__,
+                        value=self.offspring_population,
+                    ),
+                ]
+            )
+        return msgs