better tests and minor bug fixes

Author: thomasWeise

moptipy/algorithms/mo/nsga2.py

@@ -41,7 +41,7 @@
 from moptipy.api.mo_process import MOProcess
 from moptipy.api.operators import Op0, Op1, Op2
 from moptipy.utils.logger import KeyValueLogSection
-from moptipy.utils.strings import num_to_str
+from moptipy.utils.strings import num_to_str_for_name
 from moptipy.utils.types import type_error
 
 
@@ -201,7 +201,8 @@ def __init__(self, op0: Op0, op1: Op1, op2: Op2,
         :param pop_size: the population size
         :param cr: the crossover rate
         """
-        super().__init__(f"nsga2_{pop_size}_{num_to_str(cr)}", op0, op1, op2)
+        super().__init__(
+            f"nsga2_{pop_size}_{num_to_str_for_name(cr)}", op0, op1, op2)
         if not isinstance(pop_size, int):
             raise type_error(pop_size, "pop_size", int)
         if pop_size < 3:

moptipy/algorithms/so/ea.py

@@ -34,7 +34,7 @@
 from moptipy.api.operators import Op0, Op1, Op2
 from moptipy.api.process import Process
 from moptipy.utils.logger import KeyValueLogSection
-from moptipy.utils.strings import float_to_str
+from moptipy.utils.strings import num_to_str_for_name
 from moptipy.utils.types import type_error
 
 
@@ -265,7 +265,7 @@ def __init__(self, op0: Op0,
             br = 0.2
 
         super().__init__(
-            f"ea_{mu}_{lambda_}_{float_to_str(br).replace('.', 'd')}"
+            f"ea_{mu}_{lambda_}_{num_to_str_for_name(br)}"
             if 0 < br < 1 else f"ea_{mu}_{lambda_}", op0, op1, op2)
 
         if not isinstance(mu, int):

moptipy/api/_mo_process_no_ss.py

@@ -197,6 +197,11 @@ def register(self, x, f: Union[int, float]) -> None:
     def get_archive(self) -> List[MORecord]:
         return self._archive[0:self._archive_size]
 
+    def get_copy_of_best_fs(self, fs: np.ndarray) -> None:
+        if self._current_fes > 0:
+            return copyto(fs, self._current_best_fs)
+        raise ValueError('No current best available.')
+
     def _log_own_parameters(self, logger: KeyValueLogSection) -> None:
         super()._log_own_parameters(logger)
         logger.key_value(KEY_ARCHIVE_MAX_SIZE, self._archive_max_size)

moptipy/api/mo_process.py

@@ -64,6 +64,30 @@ def check_in(self, x: Any, fs: np.ndarray,
             entered the archive, `False` if it has not entered the archive
         """
 
+    def get_copy_of_best_fs(self, fs: np.ndarray) -> None:
+        """
+        Get a copy of the objective vector of the current best solution.
+
+        This always corresponds to the best-so-far solution based on the
+        scalarization of the objective vector. It is the best solution that
+        the process has seen *so far*, the current best solution.
+
+        You should only call this method if you are either sure that you
+        have invoked :meth:`~moptipy.api.process.Process.evaluate`, have
+        invoked :meth:`~moptipy.api.mo_problem.MOProblem.f_evaluate`, or
+        have called :meth:`~moptipy.api.process.Process.has_best` before
+        and it returned `True`.
+
+        :param fs: the destination vector to be overwritten
+
+        See also:
+            - :meth:`~moptipy.api.process.Process.has_best`
+            - :meth:`~moptipy.api.process.Process.get_best_f`
+            - :meth:`~moptipy.api.process.Process.get_copy_of_best_x`
+            - :meth:`~moptipy.api.process.Process.get_copy_of_best_y`
+            - :meth:`~moptipy.api.mo_problem.MOProblem.f_evaluate`
+        """
+
     def __str__(self) -> str:
         """
         Get the name of this process implementation.

moptipy/api/process.py

@@ -231,7 +231,7 @@ def get_copy_of_best_x(self, x) -> None:  # +book
         the process has seen *so far*, the current best solution.
 
         You should only call this method if you are either sure that you
-        have invoked meth:`evaluate` before :meth:`register` of if you called
+        have invoked :meth:`evaluate` before :meth:`register` of if you called
         :meth:`has_best` before and it returned `True`.
 
         :param x: the destination data structure to be overwritten

moptipy/examples/bitstrings/onemax.py

@@ -14,7 +14,8 @@ def onemax(x: np.ndarray) -> int:
     Get the length of a string minus the number of ones in it.
 
     :param x: the np array
-    :return: the number of ones
+    :return: the length of the string minus the number of ones, i.e., the
+        number of zeros
 
     >>> print(onemax(np.array([True, True, False, False, False])))
     3

moptipy/examples/bitstrings/zeromax.py

@@ -0,0 +1,101 @@
+"""
+An objective function counting the number of zeros in a bit string.
+
+This problem exists mainly for testing purposes as counterpart of
+:class:`~moptipy.examples.bitstrings.onemax.OneMax`.
+"""
+from typing import Final
+
+import numba  # type: ignore
+import numpy as np
+
+from moptipy.api.objective import Objective
+from moptipy.utils.types import type_error
+
+
+@numba.njit(nogil=True, cache=True)
+def zeromax(x: np.ndarray) -> int:
+    """
+    Get the length of a string minus the number of zeros in it.
+
+    :param x: the np array
+    :return: the length of the string minus the number of zeros, i.e., the
+        number of ones
+
+    >>> print(zeromax(np.array([True, True, False, False, False])))
+    2
+    >>> print(zeromax(np.array([True, False, True, False, False])))
+    2
+    >>> print(zeromax(np.array([False, True,  True, False, False])))
+    2
+    >>> print(zeromax(np.array([True, True, True, True, True])))
+    5
+    >>> print(zeromax(np.array([False, True, True, True, True])))
+    4
+    >>> print(zeromax(np.array([False, False, False, False, False])))
+    0
+    """
+    return int(x.sum())
+
+
+class ZeroMax(Objective):
+    """Maximize the number of zeros in a bit string."""
+
+    def __init__(self, n: int) -> None:
+        """
+        Initialize the zeromax objective function.
+
+        :param n: the dimension of the problem
+
+        >>> print(ZeroMax(2).n)
+        2
+        >>> print(ZeroMax(4).evaluate(np.array([True, True, False, True])))
+        3
+        """
+        super().__init__()
+        if not isinstance(n, int):
+            raise type_error(n, "n", int)
+        #: the upper bound = the length of the bit strings
+        self.n: Final[int] = n
+        self.evaluate = zeromax  # type: ignore
+
+    def lower_bound(self) -> int:
+        """
+        Get the lower bound of the zeromax objective function.
+
+        :return: 0
+
+        >>> print(ZeroMax(10).lower_bound())
+        0
+        """
+        return 0
+
+    def upper_bound(self) -> int:
+        """
+        Get the upper bound of the zeromax objective function.
+
+        :return: the length of the bit string
+
+        >>> print(ZeroMax(7).upper_bound())
+        7
+        """
+        return self.n
+
+    def is_always_integer(self) -> bool:
+        """
+        Return `True` because :func:`zeromax` always returns `int` values.
+
+        :retval True: always
+        """
+        return True
+
+    def __str__(self) -> str:
+        """
+        Get the name of the zeromax objective function.
+
+        :return: `zeromax_` + length of string
+
+        >>> print(ZeroMax(13))
+        zeromax_13
+        """
+        return f"zeromax_{self.n}"

moptipy/mo/problem/basic_mo_problem.py

@@ -51,8 +51,9 @@ def __init__(self, objectives: Iterable[Objective],
                  get_scalarizer: Callable[
                      [bool, int, List[Union[int, float]],
                       List[Union[int, float]]],
-                     Callable[[np.ndarray], Union[int, float]]] = None) \
-            -> None:
+                     Callable[[np.ndarray], Union[int, float]]] = None,
+                 domination: Optional[Callable[[np.ndarray, np.ndarray], int]]
+                 = dominates) -> None:
         """
         Create the basic multi-objective optimization problem.
 
@@ -65,6 +66,11 @@ def __init__(self, objectives: Iterable[Objective],
             with the lower and upper bounds of the objective functions. It can
             use this information to dynamically create and return the most
             efficient scalarization function.
+        :param domination: a function reflecting the domination relationship
+            between two vectors of objective values. It must obey the contract
+            of :meth:`~moptipy.api.mo_problem.MOProblem.f_dominates`, which is
+            the same as :func:`moptipy.api.mo_utils.dominates`, to which it
+            defaults. `None` overrides nothing.
         """
         if not isinstance(objectives, Iterable):
             raise type_error(objectives, "objectives", Iterable)
@@ -209,7 +215,11 @@ def __init__(self, objectives: Iterable[Objective],
         #: the internal temporary array
         self._temp: Final[np.ndarray] = self.f_create() \
             if temp is None else temp
-        self.f_dominates = dominates  # type: ignore
+
+        if domination is not None:
+            if not callable(domination):
+                raise type_error(domination, "domination", call=True)
+            self.f_dominates = domination  # type: ignore
 
     def f_dimension(self) -> int:
         """

moptipy/mo/problem/weighted_sum.py

@@ -17,6 +17,7 @@
 
 import numpy as np
 from numpy import sum as npsum
+from moptipy.api.mo_utils import dominates
 
 from moptipy.api.objective import Objective
 from moptipy.mo.problem.basic_mo_problem import BasicMOProblem
@@ -64,11 +65,18 @@ def __init__(self, objectives: Iterable[Objective],
                       List[Union[int, float]], Callable[
                           [Union[None, np.dtype, Tuple[
                               Union[int, float], ...]]], None]],
-                     Callable[[np.ndarray], Union[int, float]]]) -> None:
+                     Callable[[np.ndarray], Union[int, float]]],
+                 domination: Optional[Callable[[np.ndarray, np.ndarray], int]]
+                 = dominates) -> None:
         """
         Create the sum-based scalarization.
 
         :param objectives: the objectives
+        :param domination: a function reflecting the domination relationship
+            between two vectors of objective values. It must obey the contract
+            of :meth:`~moptipy.api.mo_problem.MOProblem.f_dominates`, which is
+            the same as :func:`moptipy.api.mo_utils.dominates`, to which it
+            defaults. `None` overrides nothing.
         """
         holder: List[Any] = []
         super().__init__(
@@ -77,7 +85,8 @@ def __init__(self, objectives: Iterable[Objective],
                            List[Union[int, float]]], Callable[
                 [np.ndarray], Union[int, float]]],
                 lambda ai, n, lb, ub, fwd=holder.append:
-                get_scalarizer(ai, n, lb, ub, fwd)))
+                get_scalarizer(ai, n, lb, ub, fwd)),
+            domination)
         if len(holder) != 2:
             raise ValueError(
                 f"need weights and weights dtype, but got {holder}.")
@@ -242,14 +251,20 @@ class WeightedSum(BasicWeightedSum):
     """Scalarize objective values by computing their weighted sum."""
 
     def __init__(self, objectives: Iterable[Objective],
-                 weights: Optional[Iterable[Union[int, float]]] = None) \
-            -> None:
+                 weights: Optional[Iterable[Union[int, float]]] = None,
+                 domination: Optional[Callable[[np.ndarray, np.ndarray], int]]
+                 = dominates) -> None:
         """
         Create the sum-based scalarization.
 
         :param objectives: the objectives
         :param weights: the weights of the objective values, or `None` if all
             weights are `1`.
+        :param domination: a function reflecting the domination relationship
+            between two vectors of objective values. It must obey the contract
+            of :meth:`~moptipy.api.mo_problem.MOProblem.f_dominates`, which is
+            the same as :func:`moptipy.api.mo_utils.dominates`, to which it
+            defaults. `None` overrides nothing.
         """
         use_weights: Optional[Tuple[Union[int, float], ...]] \
             = None if weights is None else tuple(try_int(w) for w in weights)
@@ -263,15 +278,17 @@ def __init__(self, objectives: Iterable[Objective],
                           Union[int, float], ...]]], None]],
                  Callable[[np.ndarray], Union[int, float]]],
                  lambda ai, n, lb, ub, cb, uw=use_weights:
-                 _make_sum_scalarizer(ai, n, lb, ub, uw, cb)))
+                 _make_sum_scalarizer(ai, n, lb, ub, uw, cb)),
+            domination)
 
     def __str__(self):
         """
         Get the string representation of the weighted sum scalarization.
 
         :returns: `"weightedSum"`
         """
-        return "weightedSum"
+        return "weightedSum" if self.f_dominates is dominates \
+            else "weightedSumWithDominationFunc"
 
 
 def _prioritize(always_int: bool,
@@ -332,18 +349,26 @@ def _prioritize(always_int: bool,
 class Prioritize(BasicWeightedSum):
     """Prioritize the first objective over the second and so on."""
 
-    def __init__(self, objectives: Iterable[Objective]) -> None:
+    def __init__(self, objectives: Iterable[Objective],
+                 domination: Optional[Callable[[np.ndarray, np.ndarray], int]]
+                 = dominates) -> None:
         """
         Create the sum-based prioritization.
 
         :param objectives: the objectives
+        :param domination: a function reflecting the domination relationship
+            between two vectors of objective values. It must obey the contract
+            of :meth:`~moptipy.api.mo_problem.MOProblem.f_dominates`, which is
+            the same as :func:`moptipy.api.mo_utils.dominates`, to which it
+            defaults. `None` overrides nothing.
         """
-        super().__init__(objectives, _prioritize)
+        super().__init__(objectives, _prioritize, domination)
 
     def __str__(self):
         """
         Get the name of the weighted sum-based prioritization.
 
         :returns: `"weightBasedPrioritization"`
         """
-        return "weightBasedPrioritization"
+        return "weightBasedPrioritization" if self.f_dominates is dominates \
+            else "weightBasedPrioritizationWithDominationFunc"

moptipy/tests/algorithm.py

@@ -17,8 +17,8 @@
 
 
 def validate_algorithm(algorithm: Algorithm,
-                       solution_space: Optional[Space] = None,
-                       objective: Optional[Objective] = None,
+                       solution_space: Space,
+                       objective: Objective,
                        search_space: Optional[Space] = None,
                        encoding: Optional[Encoding] = None,
                        max_fes: int = 100,