Repository: N-Wouda/ALNS (language: python)

Issue:
Generalize on_best to on_outcome
ALNS currently supports a callback function to be called when ALNS finds a new global best solution state:

https://github.com/N-Wouda/ALNS/blob/55e5cfc8b77609b825512e4622478f48f1102183/alns/ALNS.py#L254-L267

Since we use the notion of outcomes in ALNS, we can generalize this hook to work for other outcomes such as better, accepted, and rejected as well. 

A simple proposal is to replace `on_best` with a new method:
```
def on_best(self, func: _OperatorType, outcome: Outcome):
     self._on_outcome[outcome] = func
```

I am not aware of any papers that do this. Maybe it's just a redundant addition.


Discussion / hints:
I think that makes sense. To not break the current code, I think we should consider an addition:
```python

def on_best(self, func):
    self.on_outcome(func, Outcome.BEST)

def on_outcome(self, func, outcome):
    self._on_outcome[outcome] = func
```

Since the actual amount of code needed for this is very small, we could also just do `on_best`, `on_better`, `on_accept`, `on_reject` as explicit methods, rather than expose the `Outcome` enum to the users.

This comment is relevant here:

> Should we create an IntEnum for the evaluation outcome, and pass that to `update`, rather than a meaningless integer `s_idx`?
> 
> I'm thinking of
> 
> ```python
> import enum
> 
> class Outcome(enum.IntEnum):
>     BEST = 0
>     BETTER = 1
>     ACCEPTED = 2
>     REJECTED = 3
> ```
> 
> _Originally posted by @N-Wouda in https://github.com/N-Wouda/ALNS/issues/74#issuecomment-1300368691_
      
This one's pretty easy as well. I will try to finish this one tonight, so we can submit our JOSS paper (#58). @leonlan could you review the resulting PR? 

Fix patch:
diff --git a/README.md b/README.md
index 8838c44..55234a9 100644
--- a/README.md
+++ b/README.md
@@ -18,6 +18,10 @@ showing how the ALNS library may be used. These include:
 - The travelling salesman problem (TSP), [here][2]. We solve an instance of 131
   cities in one minute to a 2% optimality gap, using very simple destroy and
   repair heuristics.
+- The capacitated vehicle routing problem (CVRP), [here][8]. We solve an 
+  instance with 241 customers to within 3% of optimality using a combination
+  of a greedy repair operator, and a _slack-induced substring removal_ destroy
+  operator.
 - The cutting-stock problem (CSP), [here][4]. We solve an instance with
   180 beams over 165 distinct sizes to within 1.35% of optimality in
   only a very limited number of iterations.
@@ -58,3 +62,4 @@ in the documentation.
 [5]: https://alns.readthedocs.io/en/latest/examples/alns_features.html
 [6]: https://alns.readthedocs.io/en/latest/examples/resource_constrained_project_scheduling_problem.html
 [7]: https://alns.readthedocs.io/en/latest/
+[8]: https://alns.readthedocs.io/en/latest/examples/capacitated_vehicle_routing_problem.html
diff --git a/alns/ALNS.py b/alns/ALNS.py
index c13795e..3ee933d 100644
--- a/alns/ALNS.py
+++ b/alns/ALNS.py
@@ -4,22 +4,18 @@
 
 import numpy.random as rnd
 
+from alns.Outcome import Outcome
 from alns.Result import Result
 from alns.State import State
 from alns.Statistics import Statistics
 from alns.accept import AcceptanceCriterion
-from alns.stop import StoppingCriterion
 from alns.select import OperatorSelectionScheme
+from alns.stop import StoppingCriterion
 
-# Potential candidate solution consideration outcomes.
-_BEST = 0
-_BETTER = 1
-_ACCEPT = 2
-_REJECT = 3
-
-# TODO this should become a Protocol to allow for kwargs. See also this issue:
+# TODO these should become Protocol to allow for kwargs. See also this issue:
 #  https://stackoverflow.com/q/61569324/4316405.
 _OperatorType = Callable[[State, rnd.RandomState], State]
+_CallbackType = Callable[[State, rnd.RandomState], None]
 
 logger = logging.getLogger(__name__)
 
@@ -30,6 +26,18 @@ class ALNS:
     The implementation optimises for a minimisation problem, as explained
     in the text by Pisinger and Røpke (2010).
 
+    .. note::
+
+        Like the operators passed into the ALNS instance, any registered
+        callback functions (registered via :meth:`~alns.ALNS.ALNS.on_best`,
+        :meth:`~alns.ALNS.ALNS.on_better`, :meth:`~alns.ALNS.ALNS.on_accept`,
+        or :meth:`~alns.ALNS.ALNS.on_reject`) should take a candidate
+        :class:`~alns.State.State` and :class:`~numpy.random.RandomState` as
+        arguments. Unlike the operators, no solution should be returned: if
+        desired, the given candidate solution should be modified in-place
+        instead. Note that this solution is **not** evaluated again (so a
+        rejected candidate solution will stay rejected!).
+
     Parameters
     ----------
     rnd_state
@@ -46,14 +54,13 @@ class ALNS:
     """
 
     def __init__(self, rnd_state: rnd.RandomState = rnd.RandomState()):
+        self._rnd_state = rnd_state
+
         self._d_ops: Dict[str, _OperatorType] = {}
         self._r_ops: Dict[str, _OperatorType] = {}
 
-        # Optional callback that may be used to improve a new best solution
-        # further, via e.g. local search.
-        self._on_best: Optional[_OperatorType] = None
-
-        self._rnd_state = rnd_state
+        # Registers callback for each possible evaluation outcome.
+        self._on_outcome: Dict[Outcome, _CallbackType] = {}
 
     @property
     def destroy_operators(self) -> List[Tuple[str, _OperatorType]]:
@@ -147,8 +154,8 @@ def iterate(
             The stopping criterion to use for stopping the iterations.
             See also the ``alns.stop`` module for an overview.
         **kwargs
-            Optional keyword arguments. These are passed to the operators,
-            including callbacks.
+            Optional keyword arguments. These are passed to the operators and
+            any registered callbacks.
 
         Raises
         ------
@@ -194,36 +201,56 @@ class of vehicle routing problems with backhauls. *European
             destroyed = d_operator(curr, self._rnd_state, **kwargs)
             cand = r_operator(destroyed, self._rnd_state, **kwargs)
 
-            best, curr, s_idx = self._eval_cand(
+            best, curr, outcome = self._eval_cand(
                 accept, best, curr, cand, **kwargs
             )
 
-            op_select.update(cand, d_idx, r_idx, s_idx)
+            op_select.update(cand, d_idx, r_idx, outcome)
 
             stats.collect_objective(curr.objective())
-            stats.collect_destroy_operator(d_name, s_idx)
-            stats.collect_repair_operator(r_name, s_idx)
+            stats.collect_destroy_operator(d_name, outcome)
+            stats.collect_repair_operator(r_name, outcome)
             stats.collect_runtime(time.perf_counter())
 
         logger.info(f"Finished iterating in {stats.total_runtime:.2f}s.")
 
         return Result(best, stats)
 
-    def on_best(self, func: _OperatorType):
+    def on_best(self, func: _CallbackType):
         """
         Sets a callback function to be called when ALNS finds a new global best
-        solution state.
-
-        Parameters
-        ----------
-        func
-            A function that should take a solution State as its first argument,
-            and a numpy RandomState as its second (cf. the operator signature).
-            It should return a (new) solution State. The returned solution
-            state replaces the passed-in state.
+        solution state. The solution returned by the callback is *not*
+        evaluated again.
         """
         logger.debug(f"Adding on_best callback {func.__name__}.")
-        self._on_best = func
+        self._on_outcome[Outcome.BEST] = func
+
+    def on_better(self, func: _CallbackType):
+        """
+        Sets a callback function to be called when ALNS finds a better solution
+        than the current incumbent. The solution returned by the callback is
+        *not* evaluated again.
+        """
+        logger.debug(f"Adding on_better callback {func.__name__}.")
+        self._on_outcome[Outcome.BETTER] = func
+
+    def on_accept(self, func: _CallbackType):
+        """
+        Sets a callback function to be called when ALNS accepts a new solution
+        as the current incumbent (that is not a new global best, or otherwise
+        improving). The solution returned by the callback is *not* evaluated
+        again.
+        """
+        logger.debug(f"Adding on_accept callback {func.__name__}.")
+        self._on_outcome[Outcome.ACCEPT] = func
+
+    def on_reject(self, func: _CallbackType):
+        """
+        Sets a callback function to be called when ALNS rejects a new solution.
+        The solution returned by the callback is *not* evaluated again.
+        """
+        logger.debug(f"Adding on_reject callback {func.__name__}.")
+        self._on_outcome[Outcome.REJECT] = func
 
     def _eval_cand(
         self,
@@ -232,7 +259,7 @@ def _eval_cand(
         curr: State,
         cand: State,
         **kwargs,
-    ) -> Tuple[State, State, int]:
+    ) -> Tuple[State, State, Outcome]:
         """
         Considers the candidate solution by comparing it against the best and
         current solutions. Candidate solutions are accepted based on the
@@ -246,18 +273,40 @@ def _eval_cand(
             A tuple of the best and current solution, along with the weight
             index.
         """
-        w_idx = _REJECT
+        outcome = self._determine_outcome(accept, best, curr, cand)
+        func = self._on_outcome.get(outcome)
+
+        if callable(func):
+            func(cand, self._rnd_state, **kwargs)
+
+        if outcome == Outcome.BEST:
+            return cand, cand, outcome
+
+        if outcome == Outcome.REJECT:
+            return best, curr, outcome
+
+        return best, cand, outcome
+
+    def _determine_outcome(
+        self,
+        accept: AcceptanceCriterion,
+        best: State,
+        curr: State,
+        cand: State,
+    ) -> Outcome:
+        """
+        Determines the candidate solution's evaluation outcome.
+        """
+        outcome = Outcome.REJECT
 
         if accept(self._rnd_state, best, curr, cand):  # accept candidate
-            w_idx = _BETTER if cand.objective() < curr.objective() else _ACCEPT
-            curr = cand
+            outcome = Outcome.ACCEPT
+
+            if cand.objective() < curr.objective():
+                outcome = Outcome.BETTER
 
         if cand.objective() < best.objective():  # candidate is new best
             logger.info(f"New best with objective {cand.objective():.2f}.")
+            outcome = Outcome.BEST
 
-            if self._on_best:
-                cand = self._on_best(cand, self._rnd_state, **kwargs)
-
-            return cand, cand, _BEST
-
-        return best, curr, w_idx
+        return outcome
diff --git a/alns/Outcome.py b/alns/Outcome.py
new file mode 100644
index 0000000..66f6b1d
--- /dev/null
+++ b/alns/Outcome.py
@@ -0,0 +1,14 @@
+from enum import IntEnum
+
+
+class Outcome(IntEnum):
+    """
+    Enum of evaluation outcomes. A candidate solution can be a new global best,
+    a better solution than the current incumbent, just accepted (but not
+    improving anything), or rejected.
+    """
+
+    BEST = 0  #: Candidate solution is a new global best.
+    BETTER = 1  #: Candidate solution is better than the current incumbent.
+    ACCEPT = 2  #: Candidate solution is accepted.
+    REJECT = 3  #: Candidate solution is rejected.
diff --git a/alns/Statistics.py b/alns/Statistics.py
index eae4f5e..68f577c 100644
--- a/alns/Statistics.py
+++ b/alns/Statistics.py
@@ -3,6 +3,8 @@
 
 import numpy as np
 
+from alns.Outcome import Outcome
+
 
 class Statistics:
     """
@@ -97,7 +99,7 @@ def collect_runtime(self, time: float):
         """
         self._runtimes.append(time)
 
-    def collect_destroy_operator(self, operator_name: str, s_idx: int):
+    def collect_destroy_operator(self, operator_name: str, outcome: Outcome):
         """
         Collects a score (index) for a used destroy operator. This maintains
         count of the number of times this operator was used, and what result
@@ -108,12 +110,12 @@ def collect_destroy_operator(self, operator_name: str, s_idx: int):
         operator_name
             Operator name. This was set when the operator was passed to the
             ALNS instance.
-        s_idx
-            Score indices used for the various iteration outcomes.
+        outcome
+            Score enum value used for the various iteration outcomes.
         """
-        self._destroy_operator_counts[operator_name][s_idx] += 1
+        self._destroy_operator_counts[operator_name][outcome] += 1
 
-    def collect_repair_operator(self, operator_name: str, s_idx: int):
+    def collect_repair_operator(self, operator_name: str, outcome: Outcome):
         """
         Collects a score (index) for a used repair operator. This maintains
         count of the number of times this operator was used, and what result
@@ -124,7 +126,7 @@ def collect_repair_operator(self, operator_name: str, s_idx: int):
         operator_name
             Operator name. This was set when the operator was passed to the
             ALNS instance.
-        s_idx
-            Score indices used for the various iteration outcomes.
+        outcome
+            Score enum value used for the various iteration outcomes.
         """
-        self._repair_operator_counts[operator_name][s_idx] += 1
+        self._repair_operator_counts[operator_name][outcome] += 1
diff --git a/alns/select/AlphaUCB.py b/alns/select/AlphaUCB.py
index 8d3f678..3604e34 100644
--- a/alns/select/AlphaUCB.py
+++ b/alns/select/AlphaUCB.py
@@ -109,7 +109,7 @@ def __call__(self, rnd, best, curr):
         action = np.argmax(self._values())
         return tuple(np.unravel_index(action, self.op_coupling.shape))
 
-    def update(self, candidate, d_idx, r_idx, s_idx):
+    def update(self, candidate, d_idx, r_idx, outcome):
         """
         Updates the average reward of the given destroy and repair operator
         combination ``(d_idx, r_idx)``.
@@ -120,14 +120,14 @@ def update(self, candidate, d_idx, r_idx, s_idx):
         .. math::
 
             \\bar r_a (t) = \\frac{T_a(t - 1) \\bar r_a(t - 1)
-                            + \\text{scores}[\\text{s_idx}]}{T_a(t - 1) + 1},
+                            + \\text{scores}[\\text{outcome}]}{T_a(t - 1) + 1},
 
         and :math:`T_a(t) = T_a(t - 1) + 1`.
         """
         # Update everything for the next iteration (t + 1)
         t_a = self._times[d_idx, r_idx]
         r = self._avg_rewards[d_idx, r_idx]
-        avg_reward = (t_a * r + self.scores[s_idx]) / (t_a + 1)
+        avg_reward = (t_a * r + self.scores[outcome]) / (t_a + 1)
 
         self._avg_rewards[d_idx, r_idx] = avg_reward
         self._times[d_idx, r_idx] += 1
diff --git a/alns/select/OperatorSelectionScheme.py b/alns/select/OperatorSelectionScheme.py
index 365f79d..8cbc6ca 100644
--- a/alns/select/OperatorSelectionScheme.py
+++ b/alns/select/OperatorSelectionScheme.py
@@ -4,6 +4,7 @@
 import numpy as np
 from numpy.random import RandomState
 
+from alns.Outcome import Outcome
 from alns.State import State
 
 
@@ -78,7 +79,9 @@ def __call__(
         return NotImplemented
 
     @abstractmethod
-    def update(self, candidate: State, d_idx: int, r_idx: int, s_idx: int):
+    def update(
+        self, candidate: State, d_idx: int, r_idx: int, outcome: Outcome
+    ):
         """
         Updates the selection schame based on the outcome of the applied
         destroy (d_idx) and repair (r_idx) operators.
@@ -91,8 +94,8 @@ def update(self, candidate: State, d_idx: int, r_idx: int, s_idx: int):
             Destroy operator index.
         r_idx
             Repair operator index.
-        s_idx
-            Score index.
+        outcome
+            Score enum value used for the various iteration outcomes.
         """
         return NotImplemented
 
diff --git a/alns/select/RandomSelect.py b/alns/select/RandomSelect.py
index 9a7dd2b..dab21c1 100644
--- a/alns/select/RandomSelect.py
+++ b/alns/select/RandomSelect.py
@@ -18,5 +18,5 @@ def __call__(self, rnd, best, curr):
 
         return tuple(allowed[idx])
 
-    def update(self, candidate, d_idx, r_idx, s_idx):
+    def update(self, candidate, d_idx, r_idx, outcome):
         pass  # pragma: no cover
diff --git a/alns/select/RouletteWheel.py b/alns/select/RouletteWheel.py
index 14d3c0f..9e00fe8 100644
--- a/alns/select/RouletteWheel.py
+++ b/alns/select/RouletteWheel.py
@@ -112,9 +112,9 @@ def select(op_weights):
 
         return d_idx, r_idx
 
-    def update(self, cand, d_idx, r_idx, s_idx):
+    def update(self, cand, d_idx, r_idx, outcome):
         self._d_weights[d_idx] *= self._decay
-        self._d_weights[d_idx] += (1 - self._decay) * self._scores[s_idx]
+        self._d_weights[d_idx] += (1 - self._decay) * self._scores[outcome]
 
         self._r_weights[r_idx] *= self._decay
-        self._r_weights[r_idx] += (1 - self._decay) * self._scores[s_idx]
+        self._r_weights[r_idx] += (1 - self._decay) * self._scores[outcome]
diff --git a/alns/select/SegmentedRouletteWheel.py b/alns/select/SegmentedRouletteWheel.py
index fab1600..fabe1f0 100644
--- a/alns/select/SegmentedRouletteWheel.py
+++ b/alns/select/SegmentedRouletteWheel.py
@@ -84,9 +84,9 @@ def __call__(self, rnd_state, best: State, curr: State):
 
         return super().__call__(rnd_state, best, curr)
 
-    def update(self, cand, d_idx, r_idx, s_idx):
-        self._d_seg_weights[d_idx] += self._scores[s_idx]
-        self._r_seg_weights[r_idx] += self._scores[s_idx]
+    def update(self, cand, d_idx, r_idx, outcome):
+        self._d_seg_weights[d_idx] += self._scores[outcome]
+        self._r_seg_weights[r_idx] += self._scores[outcome]
 
     def _reset_segment_weights(self):
         self._d_seg_weights = np.zeros_like(self._d_weights)
diff --git a/docs/source/alns.rst b/docs/source/alns.rst
index 27ad4c1..52118d9 100644
--- a/docs/source/alns.rst
+++ b/docs/source/alns.rst
@@ -22,5 +22,8 @@ The :class:`~alns.Statistics.Statistics` object is also presented below, but it
 .. automodule:: alns.Result
    :members:
 
+.. automodule:: alns.Outcome
+   :members:
+
 .. automodule:: alns.Statistics
    :members:
diff --git a/docs/source/conf.py b/docs/source/conf.py
index dc36678..be117ed 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -52,6 +52,8 @@
 intersphinx_mapping = {
     "python": ("https://docs.python.org/3/", None),
     "sphinx": ("https://www.sphinx-doc.org/en/master/", None),
+    "numpy": ("https://numpy.org/doc/stable/", None),
+    "matplotlib": ("https://matplotlib.org/stable/", None),
 }
 intersphinx_disabled_domains = ["std"]
 
diff --git a/docs/source/examples/alns_features.ipynb b/docs/source/examples/alns_features.ipynb
index 191e5c0..042a970 100644
--- a/docs/source/examples/alns_features.ipynb
+++ b/docs/source/examples/alns_features.ipynb
@@ -67,7 +67,7 @@
    "source": [
     "# ALNS features\n",
     "\n",
-    "The `alns` package offers a number of different operator selection schemes, and acceptance and stopping criteria. In this notebook, we show these in action solving a toy knapsack problem. Along the way we explain how they work, and show how you can use them in your ALNS heuristic.\n",
+    "The `alns` package offers a number of different operator selection schemes, and acceptance and stopping criteria. In this notebook, we show some these in action solving a toy knapsack problem. Along the way we explain how they work, and show how you can use them in your ALNS heuristic.\n",
     "\n",
     "In our toy [0/1-knapsack problem](https://en.wikipedia.org/wiki/Knapsack_problem), there are $n = 100$ items $i$ with profit $p_i > 0$ and weight $w_i > 0$. The goal is to find a subset of the items that maximizes the profit, while keeping the total weight below a given limit $W$. The problem then reads follows:\n",
     "\n",
@@ -305,7 +305,9 @@
    "source": [
     "## Operator selection schemes\n",
     "\n",
-    "We now have everything set-up for solving the problem. We will now look at the operator selection schemes the `alns` package offers. Here, we use the `HillClimbing` acceptance criterion, which only accepts better solutions."
+    "We now have everything set-up for solving the problem. We will now look at several of the operator selection schemes the `alns` package offers. The list is not exhaustive: for a complete overview, head over to `alns.select` in the documentation.\n",
+    "\n",
+    "Here, we use the `HillClimbing` acceptance criterion, which only accepts better solutions."
    ]
   },
   {
@@ -764,7 +766,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1200x600 with 1 Axes>"
       ]
@@ -778,6 +780,13 @@
     "res.plot_objectives(ax=ax, lw=2)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Other stopping criteria are available in `alns.stop`."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {
diff --git a/docs/source/other single-trajectory heuristics.rst b/docs/source/other single-trajectory heuristics.rst
index 786197c..bacc40b 100644
--- a/docs/source/other single-trajectory heuristics.rst
+++ b/docs/source/other single-trajectory heuristics.rst
@@ -90,10 +90,9 @@ Then, a high-level implementation could look like:
        return <improved solution>
 
 
-   def on_best(sol: State, rnd_state, neighbourhood: Neighbourhood) -> State:
+   def on_best(sol: State, rnd_state, neighbourhood: Neighbourhood):
        # New best solution: start again from first neighbourhood.
        neighbourhood.k = 1
-       return sol
 
 
    neighbourhood = Neighbourhood(<neighbourhoods>, 1)


Test patch:
diff --git a/alns/select/tests/test_alpha_ucb.py b/alns/select/tests/test_alpha_ucb.py
index bb196a9..275ccd4 100644
--- a/alns/select/tests/test_alpha_ucb.py
+++ b/alns/select/tests/test_alpha_ucb.py
@@ -5,6 +5,7 @@
 from numpy.testing import assert_equal, assert_raises
 from pytest import mark
 
+from alns.Outcome import Outcome
 from alns.select import AlphaUCB
 from alns.tests.states import Zero
 
@@ -68,14 +69,14 @@ def test_update_with_two_operator_pairs():
     state = rnd.RandomState()
 
     # Avg. reward for (0, 0) after this is 2, for (1, 0) is still 1 (default).
-    select.update(Zero(), 0, 0, s_idx=0)  # accepted
+    select.update(Zero(), 0, 0, outcome=Outcome.BEST)
 
     # So now (0, 0) is selected again.
     selected = select(state, Zero(), Zero())
     assert_equal(selected, (0, 0))
 
     # One more update. Avg. reward goes to 1, and number of times to 2.
-    select.update(Zero(), 0, 0, s_idx=3)  # rejected
+    select.update(Zero(), 0, 0, outcome=Outcome.REJECT)
 
     # The Q value of (0, 0) is now approx 1.432, and that of (1, 0) is now
     # approx 1.74. So (1, 0) is selected.
diff --git a/alns/tests/test_alns.py b/alns/tests/test_alns.py
index 1ddd6d3..9bc8901 100644
--- a/alns/tests/test_alns.py
+++ b/alns/tests/test_alns.py
@@ -7,11 +7,11 @@
 )
 from pytest import mark
 
-from alns import ALNS, State
+from alns import ALNS
 from alns.accept import HillClimbing, SimulatedAnnealing
-from alns.stop import MaxIterations, MaxRuntime
 from alns.select import RouletteWheel
-from .states import One, Zero
+from alns.stop import MaxIterations, MaxRuntime
+from .states import One, VarObj, Zero
 
 
 # HELPERS ---------------------------------------------------------------------
@@ -36,18 +36,6 @@ def get_alns_instance(
     return alns
 
 
-class ValueState(State):
-    """
-    Helper state for testing random values.
-    """
-
-    def __init__(self, value):
-        self._value = value
-
-    def objective(self):
-        return self._value
-
-
 def get_repair_operators(n):
     """
     Get a list of n dummy repair operators.
@@ -84,17 +72,46 @@ def test_on_best_is_called():
     Tests if the callback is invoked when a new global best is found.
     """
     alns = get_alns_instance(
-        [lambda state, rnd: Zero()], [lambda state, rnd: Zero()]
+        [lambda state, rnd_state: Zero()], [lambda state, rnd_state: Zero()]
     )
 
     # Called when a new global best is found. In this case, that happens once:
-    # in the only iteration below. It returns a state with value 10, which
-    # should then also be returned by the entire algorithm.
-    alns.on_best(lambda *args: ValueState(10))
+    # in the only iteration below. We change the objective, and test whether
+    # that is indeed the solution that is returned
+    def callback(state, rnd_state):
+        state.obj = 1
+
+    alns.on_best(callback)
 
     select = RouletteWheel([1, 1, 1, 1], 0.5, 1, 1)
-    result = alns.iterate(One(), select, HillClimbing(), MaxIterations(1))
-    assert_equal(result.best_state.objective(), 10)
+    result = alns.iterate(VarObj(10), select, HillClimbing(), MaxIterations(1))
+
+    assert_equal(result.best_state.objective(), 1)
+
+
+def test_other_callbacks_are_called():
+    alns = get_alns_instance(
+        [lambda state, rnd: state],
+        [lambda state, rnd: VarObj(rnd.random())],
+        seed=1,
+    )
+
+    registry = dict(on_better=False, on_accept=False, on_reject=False)
+
+    def mock_callback(state, rnd, key):
+        registry[key] = True
+
+    alns.on_better(lambda state, rnd: mock_callback(state, rnd, "on_better"))
+    alns.on_accept(lambda state, rnd: mock_callback(state, rnd, "on_accept"))
+    alns.on_reject(lambda state, rnd: mock_callback(state, rnd, "on_reject"))
+
+    select = RouletteWheel([1, 1, 1, 1], 0.5, 1, 1)
+    accept = SimulatedAnnealing(1_000, 1, 0.05)
+    alns.iterate(VarObj(10), select, accept, MaxIterations(1_000))
+
+    assert_(registry["on_better"])
+    assert_(registry["on_accept"])
+    assert_(registry["on_reject"])
 
 
 # OPERATORS -------------------------------------------------------------------
@@ -294,7 +311,7 @@ def test_fixed_seed_outcomes(seed: int, desired: float):
     'random' acceptance criterion (here SA).
     """
     alns = get_alns_instance(
-        [lambda state, rnd: ValueState(rnd.random_sample())],
+        [lambda state, rnd: VarObj(rnd.random_sample())],
         [lambda state, rnd: None],
         seed,
     )