some improvements in the bit-string based benchmark problems

Author: thomasWeise

moptipy/algorithms/so/ffa/__init__.py

@@ -16,8 +16,9 @@
    https://dx.doi.org/10.1109/TEVC.2020.3032090
 2. Thomas Weise, Zhize Wu, Xinlu Li, Yan Chen, and Jörg Lässig. Frequency
    Fitness Assignment: Optimization without Bias for Good Solutions can be
-   Efficient. *IEEE Transactions on Evolutionary Computation (TEVC)*. 2022.
-   Early Access. https://dx.doi.org/10.1109/TEVC.2022.3191698
+   Efficient. *IEEE Transactions on Evolutionary Computation (TEVC)*.
+   27(4):980-992. August 2023.
+   doi: https://doi.org/10.1109/TEVC.2022.3191698
 3. Thomas Weise, Mingxu Wan, Ke Tang, Pu Wang, Alexandre Devert, and Xin
    Yao. Frequency Fitness Assignment. *IEEE Transactions on Evolutionary
    Computation (IEEE-EC),* 18(2):226-243, April 2014.

moptipy/algorithms/so/ffa/eafea.py

@@ -3,8 +3,9 @@
 
 1. Thomas Weise, Zhize Wu, Xinlu Li, Yan Chen, and Jörg Lässig. Frequency
    Fitness Assignment: Optimization without Bias for Good Solutions can be
-   Efficient. *IEEE Transactions on Evolutionary Computation (TEVC)*. 2022.
-   Early Access. https://dx.doi.org/10.1109/TEVC.2022.3191698
+   Efficient. *IEEE Transactions on Evolutionary Computation (TEVC)*.
+   27(4):980-992. August 2023.
+   doi: https://doi.org/10.1109/TEVC.2022.3191698
 """
 from collections import Counter
 from typing import Callable, Final

moptipy/algorithms/so/ffa/fea1plus1.py

@@ -63,8 +63,9 @@
    https://dx.doi.org/10.1109/TEVC.2020.3032090
 2. Thomas Weise, Zhize Wu, Xinlu Li, Yan Chen, and Jörg Lässig. Frequency
    Fitness Assignment: Optimization without Bias for Good Solutions can be
-   Efficient. *IEEE Transactions on Evolutionary Computation (TEVC)*. 2022.
-   Early Access. https://dx.doi.org/10.1109/TEVC.2022.3191698
+   Efficient. *IEEE Transactions on Evolutionary Computation (TEVC)*.
+   27(4):980-992. August 2023.
+   doi: https://doi.org/10.1109/TEVC.2022.3191698
 3. Thomas Weise, Mingxu Wan, Ke Tang, Pu Wang, Alexandre Devert, and Xin
    Yao. Frequency Fitness Assignment. *IEEE Transactions on Evolutionary
    Computation (IEEE-EC),* 18(2):226-243, April 2014.

moptipy/algorithms/so/ffa/ffa_fitness.py

@@ -28,8 +28,9 @@
    https://dx.doi.org/10.1109/TEVC.2020.3032090
 2. Thomas Weise, Zhize Wu, Xinlu Li, Yan Chen, and Jörg Lässig. Frequency
    Fitness Assignment: Optimization without Bias for Good Solutions can be
-   Efficient. *IEEE Transactions on Evolutionary Computation (TEVC)*. 2022.
-   Early Access. https://dx.doi.org/10.1109/TEVC.2022.3191698
+   Efficient. *IEEE Transactions on Evolutionary Computation (TEVC)*.
+   27(4):980-992. August 2023.
+   doi: https://doi.org/10.1109/TEVC.2022.3191698
 3. Thomas Weise, Mingxu Wan, Ke Tang, Pu Wang, Alexandre Devert, and Xin
    Yao. Frequency Fitness Assignment. *IEEE Transactions on Evolutionary
    Computation (IEEE-EC),* 18(2):226-243, April 2014.

moptipy/examples/bitstrings/__init__.py

@@ -8,40 +8,44 @@
 
 The following benchmark problems are provided:
 
-1.  :mod:`~moptipy.examples.bitstrings.ising1d`, the one-dimensional
-    Ising model, where the goal is that all bits should have the same value as
-    their neighbors in a ring.
-2.  :mod:`~moptipy.examples.bitstrings.ising2d`, the two-dimensional
-    Ising model, where the goal is that all bits should have the same value as
-    their neighbors on a torus.
-3.  The :mod:`~moptipy.examples.bitstrings.jump` problem is equivalent
-    to :mod:`~moptipy.examples.bitstrings.onemax`, but has a deceptive
-    region right before the optimum.
-4.  The :mod:`~moptipy.examples.bitstrings.leadingones` problem,
+1.  The :mod:`~moptipy.examples.bitstrings.onemax` problem, where the
+    goal is to find a bit string with the maximum number of ones.
+2.  The :mod:`~moptipy.examples.bitstrings.leadingones` problem,
     where the goal is to find a bit string with the maximum number of leading
     ones.
-5.  The :mod:`~moptipy.examples.bitstrings.linearharmonic` problem,
+3.  The :mod:`~moptipy.examples.bitstrings.linearharmonic` problem,
     where the goal is to find a bit string with the all ones, like in
     :mod:`~moptipy.examples.bitstrings.onemax`, but this time all bits have
     a different weight (namely their index, starting at 1).
-6.  The :mod:`~moptipy.examples.bitstrings.nqueens`, where the goal is to
-    place `k` queens on a `k * k`-sized chess board such that no queen can
-    beat any other queen.
-7.  The :mod:`~moptipy.examples.bitstrings.onemax` problem, where the
-    goal is to find a bit string with the maximum number of ones.
-8.  The :mod:`~moptipy.examples.bitstrings.plateau` problem similar to the
-    :mod:`~moptipy.examples.bitstrings.jump` problem, but this time the
-    optimum is surrounded by a region of neutrality.
-9.  The :mod:`~moptipy.examples.bitstrings.trap` problem, which is like
+4.  The :mod:`~moptipy.examples.bitstrings.binint` problem,
+    is again similar to :mod:`~moptipy.examples.bitstrings.onemax`, but the
+    bits have exponential weight. Basically, we just decode the bit string
+    into an integer.
+5.  The :mod:`~moptipy.examples.bitstrings.trap` problem, which is like
     OneMax, but with the optimum and worst-possible solution swapped. This
     problem is therefore highly deceptive.
-10. The :mod:`~moptipy.examples.bitstrings.twomax` problem has the global
+6.  The :mod:`~moptipy.examples.bitstrings.twomax` problem has the global
     optimum at the string of all `1` bits and a local optimum at the string
     of all `0` bits. Both have basins of attraction of about the same size.
-11. The :mod:`~moptipy.examples.bitstrings.w_model`, a benchmark
+7.  :mod:`~moptipy.examples.bitstrings.ising1d`, the one-dimensional
+    Ising model, where the goal is that all bits should have the same value as
+    their neighbors in a ring.
+8.  :mod:`~moptipy.examples.bitstrings.ising2d`, the two-dimensional
+    Ising model, where the goal is that all bits should have the same value as
+    their neighbors on a torus.
+9.  The :mod:`~moptipy.examples.bitstrings.jump` problem is equivalent
+    to :mod:`~moptipy.examples.bitstrings.onemax`, but has a deceptive
+    region right before the optimum.
+10. The :mod:`~moptipy.examples.bitstrings.plateau` problem similar to the
+    :mod:`~moptipy.examples.bitstrings.jump` problem, but this time the
+    optimum is surrounded by a region of neutrality.
+11. The :mod:`~moptipy.examples.bitstrings.nqueens`, where the goal is to
+    place `k` queens on a `k * k`-sized chess board such that no queen can
+    beat any other queen.
+12. The :mod:`~moptipy.examples.bitstrings.w_model`, a benchmark
     problem with tunable epistasis, uniform neutrality, and
     ruggedness/deceptiveness.
-12. The :mod:`~moptipy.examples.bitstrings.zeromax` problem, where the
+13. The :mod:`~moptipy.examples.bitstrings.zeromax` problem, where the
     goal is to find a bit string with the maximum number of zeros. This is the
     opposite of the OneMax problem.
 
@@ -53,3 +57,53 @@
 Hefei, Anhui, China (中国安徽省合肥市) under the supervision of
 Prof. Dr. Thomas Weise (汤卫思教授).
 """
+from itertools import chain
+from typing import Callable, Iterator, cast
+
+from moptipy.examples.bitstrings.binint import BinInt
+from moptipy.examples.bitstrings.bitstring_problem import BitStringProblem
+from moptipy.examples.bitstrings.ising1d import Ising1d
+from moptipy.examples.bitstrings.ising2d import Ising2d
+from moptipy.examples.bitstrings.jump import Jump
+from moptipy.examples.bitstrings.leadingones import LeadingOnes
+from moptipy.examples.bitstrings.linearharmonic import LinearHarmonic
+from moptipy.examples.bitstrings.nqueens import NQueens
+from moptipy.examples.bitstrings.onemax import OneMax
+from moptipy.examples.bitstrings.plateau import Plateau
+from moptipy.examples.bitstrings.trap import Trap
+from moptipy.examples.bitstrings.twomax import TwoMax
+from moptipy.examples.bitstrings.w_model import WModel
+
+
+def default_instances(
+        class_scales: Callable[[
+            type], Iterator[int]] = lambda s: cast(Iterator[int], ())) \
+        -> Iterator[Callable[[], BitStringProblem]]:
+    """
+    Get the default bit-string based benchmark instances.
+
+    :param class_scales: a function that can override the minimum and
+        maximimum problem scales on a per-benchmark-function-class
+        basis. If this function returns an empty iterator, then the default
+        scales are used.
+    :return: an :class:`Iterator` with the default bit-string
+        benchmark instances
+
+    >>> len(list(default_instances()))
+    963
+    """
+    return chain(
+        BinInt.default_instances(*class_scales(BinInt)),  # type: ignore
+        Ising1d.default_instances(*class_scales(Ising1d)),  # type: ignore
+        Ising2d.default_instances(*class_scales(Ising2d)),  # type: ignore
+        Jump.default_instances(*class_scales(Jump)),  # type: ignore
+        LeadingOnes.default_instances(  # type: ignore
+            *class_scales(LeadingOnes)),
+        LinearHarmonic.default_instances(  # type: ignore
+            *class_scales(LinearHarmonic)),
+        NQueens.default_instances(*class_scales(NQueens)),  # type: ignore
+        OneMax.default_instances(*class_scales(OneMax)),  # type: ignore
+        Plateau.default_instances(*class_scales(Plateau)),  # type: ignore
+        Trap.default_instances(*class_scales(Trap)),  # type: ignore
+        TwoMax.default_instances(*class_scales(TwoMax)),  # type: ignore
+        WModel.default_instances(*class_scales(WModel)))  # type: ignore

moptipy/examples/bitstrings/binint.py

@@ -0,0 +1,155 @@
+"""
+The BinInt problem maximizes the binary value of a bit string.
+
+The BinInt problem is similar to the OneMax and LinearHarmonic in that it
+tries to maximize the number of `True` bits in a string.
+Different from these problems, however, it assigns exponentially increasing
+weights to the bits.
+The bit at index `1` has weight `2 ** (n - 1)`.
+The bit at the last position has weight 1.
+The upper bound for the objective function, reached when all bits are `False`,
+therefore is `2 ** n - 1`. The lower bound, reached when all bits are `True`,
+is `0`.
+
+1. William Michael Rudnick. Genetic Algorithms and Fitness Variance with an
+   Application to the Automated Design of Artificial Neural Networks.
+   PhD thesis, Oregon Graduate Institute of Science & Technology: Beaverton,
+   OR, USA, 1992. UMI Order No.: GAX92-22642.
+2. Dirk Thierens, David Edward Goldberg, and Ângela Guimarães Pereira. Domino
+   Convergence, Drift, and the Temporal-Salience Structure of Problems. In
+   CEC'98, pages 535-540, 1998.
+   doi: https://doi.org/10.1109/ICEC.1998.700085.
+3. Kumara Sastry and David Edward Goldberg. Let's Get Ready to Rumble Redux:
+   Crossover versus Mutation Head to Head on Exponentially Scaled Problems.
+   In GECCO'07-I, pages 1380-1387, 2007.
+   doi: https://doi.org10.1145/1276958.1277215.
+4. Kumara Sastry and David Edward Goldberg. Let's Get Ready to Rumble Redux:
+   Crossover versus Mutation Head to Head on Exponentially Scaled Problems.
+   IlliGAL Report 2007005, Illinois Genetic Algorithms Laboratory (IlliGAL),
+   Department of Computer Science, Department of General Engineering,
+   University of Illinois at Urbana-Champaign: Urbana-Champaign, IL, USA,
+   February 11, 2007.
+"""
+
+from typing import Callable, Final, Iterator, cast
+
+import numba  # type: ignore
+import numpy as np
+
+from moptipy.examples.bitstrings.bitstring_problem import BitStringProblem
+
+
+@numba.njit(nogil=True, cache=True)
+def binint(x: np.ndarray) -> int:
+    """
+    Get the binint objective value: decode the inverted bit string as integer.
+
+    :param x: the np array
+    :return: the inverted bit string represented as integer
+
+    >>> binint(np.array([0]))
+    1
+    >>> binint(np.array([1]))
+    0
+
+    >>> binint(np.array([0, 0]))
+    3
+    >>> binint(np.array([0, 1]))
+    2
+    >>> binint(np.array([1, 0]))
+    1
+    >>> binint(np.array([1, 1]))
+    0
+
+    >>> binint(np.array([0, 0, 0]))
+    7
+    >>> binint(np.array([0, 0, 1]))
+    6
+    >>> binint(np.array([0, 1, 0]))
+    5
+    >>> binint(np.array([0, 1, 1]))
+    4
+    >>> binint(np.array([1, 0, 0]))
+    3
+    >>> binint(np.array([1, 0, 1]))
+    2
+    >>> binint(np.array([1, 1, 0]))
+    1
+    >>> binint(np.array([1, 1, 1]))
+    0
+    """
+    n: Final[int] = len(x)
+    weight: int = 1 << n
+    result: int = weight - 1
+    for xx in x:
+        weight >>= 1
+        if xx:
+            result -= weight
+    return result
+
+
+class BinInt(BitStringProblem):
+    """Maximize the binary value of a bit string."""
+
+    def __init__(self, n: int) -> None:  # +book
+        """
+        Initialize the binint objective function.
+
+        :param n: the dimension of the problem
+
+        >>> print(BinInt(2).n)
+        2
+        >>> print(BinInt(4).evaluate(np.array([True, True, False, True])))
+        2
+        """
+        super().__init__(n)
+        self.evaluate = binint  # type: ignore
+
+    def __str__(self) -> str:
+        """
+        Get the name of the binint objective function.
+
+        :return: `binint_` + length of string
+
+        >>> BinInt(13)
+        binint_13
+        """
+        return f"binint_{self.n}"
+
+    def upper_bound(self) -> int:
+        """
+        Get the upper bound of the :class:`BinInt` problem.
+
+        :returns: `(1 << n) - 1`
+
+        >>> BinInt(4).upper_bound()
+        15
+        >>> BinInt(4).evaluate(np.array([0, 0, 0, 0]))
+        15
+        """
+        return (1 << self.n) - 1
+
+    @classmethod
+    def default_instances(
+            cls: type, scale_min: int = 2, scale_max: int = 30) \
+            -> Iterator[Callable[[], "BinInt"]]:
+        """
+        Get the 29 default instances of the :class:`BinInt` problem.
+
+        :param scale_min: the minimum permitted scale, by default `2`
+        :param scale_max: the maximum permitted scale, by default `32`
+        :returns: a sequence of default :class:`BinInt` instances
+
+        >>> len(list(BinInt.default_instances()))
+        29
+
+        >>> [x() for x in BinInt.default_instances()]
+        [binint_2, binint_3, binint_4, binint_5, binint_6, binint_7, \
+binint_8, binint_9, binint_10, binint_11, binint_12, binint_13, binint_14, \
+binint_15, binint_16, binint_17, binint_18, binint_19, binint_20, binint_21, \
+binint_22, binint_23, binint_24, binint_25, binint_26, binint_27, binint_28, \
+binint_29, binint_30]
+        """
+        return cast(Iterator[Callable[[], "BinInt"]],
+                    super().default_instances(  # type: ignore
+                        scale_min, scale_max))