6.2.4.1. Difference Between Stoppers and ExitConditions
*******************************************************

"Stoppers" and "ExitConditions" are small logic checks related to the
termination of an optimization. They behave similarly but have
different purposes and should not be confused.

+----------------------+--------------------------------+--------------------------------+
|                      | ExitConditions                 | Stoppers                       |
|======================|================================|================================|
| What does it do?     | Stops the entire optimization. | Stops one running optimizer.   |
+----------------------+--------------------------------+--------------------------------+
| What happens once    | The job ends.                  | Other optimizers are           |
| triggered?           |                                | unaffected  and keep running.  |
|                      |                                | If possible,  a new optimizer  |
|                      |                                | will be started  to replace    |
|                      |                                | the stopped one.               |
+----------------------+--------------------------------+--------------------------------+
| When is it           | Approximately every 10         | This is controlled by the      |
| evaluated?           | function  evaluations or more  | "CheckStopperInterval" key.    |
|                      | frequently.                    |                                |
+----------------------+--------------------------------+--------------------------------+
| Am I required to use | Yes                            | No                             |
| one?                 |                                |                                |
+----------------------+--------------------------------+--------------------------------+
| What is checked?     | Generally, global properties   | Generally, optimizer-specific  |
|                      | like total time used, or total | properties. Comparisons are    |
|                      | function calls made by *all*   | often  made between one        |
|                      | optimizers.                    | optimizer and  the best        |
|                      |                                | optimizer.                     |
+----------------------+--------------------------------+--------------------------------+
| Easy to set up?      | Yes. Generally determined by   | Generally, trickier to set up. |
|                      | resource limitations (like     | Requires problem-specific      |
|                      | time),  or specific goals      | information and a good guess   |
|                      | (like getting  a certain       | of how optimizers will behave  |
|                      | number of results.             | on the problem.                |
+----------------------+--------------------------------+--------------------------------+
| Good to know?        | None.                          | By default, won't trigger for  |
|                      |                                | the  best optimizer unless     |
|                      |                                | "ApplyStoppersToBestOptimizer  |
|                      |                                | Yes"  is used.                 |
+----------------------+--------------------------------+--------------------------------+


6.2.4.1.1. A note on combinations
=================================

You may use multiple "Stoppers" or "ExitConditions" in a single
optimization. If there is more than one specified then by default the
stop or exit will be triggered if any of them are triggered. You can
tailor exactly how to evaluate multiple "Stoppers" or "ExitConditions"
by specifying the "StopperBooleanCombination" and
"ExitConditionBooleanCombination" keys respectively (Optimizer
Stoppers or Exit Conditions for details).

When multiple conditions are used, they are evaluated *lazily*:

* Given "x | y", if "x" is True then "y" is *not* evaluated.

* Given "x & y", if "x" is False then "y" is *not* evaluated.
