deploy: 448b0ef

.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 2235ec6bcef007102f03f0942c5b4516
+tags: 645f666f9bcd5a90fca523b33c5a78b7

_sources/api/classes/branch-and-bound/BranchAndBound.rst.txt

@@ -0,0 +1,31 @@
+.. _api_BranchAndBound:
+
+BranchAndBound
+==============
+
+This class is an optimizer factory which creates a new branch-and-bound algorithm.
+It can be used to create customized branch-and-bound algorithms with a large degree of freedom.
+
+.. seealso::
+
+    If you are not familiar with optimizers and optimizer factories, please refer to :ref:`this page <api_optimizers>`.
+
+.. admonition:: Example
+
+    Here, we create a simple branch-and-bound algorithm where branching is done on integer variables which are being
+    relaxed. Each node is solved by the external solver GLPK. Nodes are selected according to the "best-bound"
+    rule while variables are selected according to the "most-infeasible" branching rule.
+
+    The created algorithm also incorporates sub-tree exploration of maximum depth 2.
+
+    .. code-block::
+
+        model.use(
+            BranchAndBound()
+                .with_node_optimizer( GLPK::ContinuousRelaxation() )
+                .with_branching_rule( MostInfeasible() )
+                .with_node_selection_rule( BestBound() )
+                .with_subtree_depth(2)
+        );
+
+.. doxygenclass:: idol::BranchAndBound

_sources/api/classes/branch-and-bound/BranchAndBoundCallback.rst.txt

@@ -0,0 +1,72 @@
+BranchAndBoundCallback
+======================
+
+This class can be used to create callbacks to run on idol's :ref:`branch-and-bound implementation <api_BranchAndBound>`.
+
+.. warning::
+
+    BranchAndBoundCallback-s is an *advanced* feature.
+
+    Please, make sure that what you are trying do cannot be done with
+    a :ref:`solver-independent callback <api_Callback>` first, or with pre-existing callbacks, e.g.,
+    :ref:`UserCutCallback <api_UserCutCallback>` or :ref:`LazyCutCallback <api_LazyCutCallback>`.
+
+    The advantage of using a :ref:`BranchAndBoundCallback <api_BranchAndBoundCallback>` instead of a standard
+    solver-independent :ref:`Callback <api_Callback>` lies in the possibility to access specific information regarding
+    the execution of the branch-and-bound algorithm. For instance, accessing a node's information, or the current
+    relaxation model being solved.
+
+.. admonition:: Example
+
+    Here is an example of callback which prints out the event triggering it and, when the event corresponds to `NodeLoaded`,
+    prints the node's model to be solved.
+
+    .. code-block::
+
+        class MyCallback : public BranchAndBoundCallbackFactory<NodeInfo> {
+        public:
+            class Strategy : public BranchAndBoundCallback<NodeInfo> {
+            protected:
+                void operator()(CallbackEvent t_event) override {
+
+                    std::cout << "MyCallback is called for " << t_event << std::endl;
+
+                    if (t_event != NodeLoaded) {
+                        return;
+                    }
+
+                    std::cout << "The problem being solve at node " << node().id() << std::endl;
+                    std::cout << relaxation() << std::endl;
+
+                }
+            };
+
+            BranchAndBoundCallback<NodeInfo> *operator()() override {
+                return new Strategy();
+            }
+
+            [[nodiscard]] BranchAndBoundCallbackFactory<NodeInfo> *clone() const override {
+                return new MyCallback(*this);
+            }
+        };
+
+    Then, this callback can be used as follows.
+
+    .. code-block::
+
+        model.use(
+            BranchAndBound()
+                .with_node_optimizer(GLPK::ContinuousRelaxation())
+                .with_branching_rule(MostInfeasible())
+                .with_node_selection_rule(DepthFirst())
+                .with_callback(MyCallback());
+        );
+
+.. hint::
+
+    By default, most of the objects returned by BranchAndBoundCallback methods are const. If you wish to access non-const
+    versions (e.g., if you want to perform non-standard updates to the relaxed model or want to change the node's current
+    information manually), you should use the advanced interface obtained by calling ``BranchAndBoundCallback::advanced_interface``.
+
+.. doxygenclass:: idol::BranchAndBoundCallback
+    :protected-members:

_sources/api/classes/branch-and-bound/BranchAndBoundCallbackFactory.rst.txt

@@ -0,0 +1,5 @@
+BranchAndBoundCallbackFactory
+=============================
+
+.. doxygenclass:: idol::BranchAndBoundCallbackFactory
+    :protected-members:

_sources/api/classes/branch-and-bound/cuts/KnapsackCover.rst.txt

@@ -0,0 +1,4 @@
+Cuts::KnapsackCover
+===================
+
+.. doxygenclass:: idol::Cuts::KnapsackCover

_sources/api/classes/branch-and-bound/cuts/index.rst.txt

@@ -0,0 +1,10 @@
+Cutting Planes
+==============
+
+.. toctree::
+    :maxdepth: 1
+    :glob:
+
+    *
+
+

_sources/api/classes/branch-and-bound/heuristics/LocalBranching.rst.txt

@@ -0,0 +1,4 @@
+Heuristics::LocalBranching
+==========================
+
+.. doxygenclass:: idol::Heuristics::LocalBranching

_sources/api/classes/branch-and-bound/heuristics/RENS.rst.txt

@@ -0,0 +1,4 @@
+Heuristics::RENS
+================
+
+.. doxygenclass:: idol::Heuristics::RENS

_sources/api/classes/branch-and-bound/heuristics/SimpleRounding.rst.txt

@@ -0,0 +1,4 @@
+Heuristics::SimpleRounding
+==========================
+
+.. doxygenclass:: idol::Heuristics::SimpleRounding

_sources/api/classes/branch-and-bound/heuristics/index.rst.txt

@@ -0,0 +1,10 @@
+Heuristics
+==========
+
+.. toctree::
+    :maxdepth: 1
+    :glob:
+
+    *
+
+

_sources/api/classes/branch-and-bound/index.rst.txt

@@ -0,0 +1,12 @@
+Branch-and-Bound Algorithm
+==========================
+
+.. toctree::
+    :maxdepth: 2
+    :glob:
+
+    *
+    variable-selection/index
+    node-selection/index
+    heuristics/index
+    cuts/index

_sources/api/classes/branch-and-bound/node-selection/BestBound.rst.txt

@@ -0,0 +1,4 @@
+BestBound
+=========
+
+.. doxygenclass:: idol::BestBound

_sources/api/classes/branch-and-bound/node-selection/BestEstimate.rst.txt

@@ -0,0 +1,6 @@
+BestEstimate
+============
+
+The "best estimate" node selection rule was introduced in *J. J. H. Forrest, J. P. H. Hirst, J. A. Tomlin, (1974) Practical Solution of Large Mixed Integer Programming Problems with Umpire. Management Science 20(5):736-773*.
+
+.. doxygenclass:: idol::BestEstimate

_sources/api/classes/branch-and-bound/node-selection/BreadthFirst.rst.txt

@@ -0,0 +1,4 @@
+BreadthFirst
+============
+
+.. doxygenclass:: idol::BreadthFirst

_sources/api/classes/branch-and-bound/node-selection/DepthFirst.rst.txt

@@ -0,0 +1,4 @@
+DepthFirst
+==========
+
+.. doxygenclass:: idol::DepthFirst

_sources/api/classes/branch-and-bound/node-selection/WorstBound.rst.txt

@@ -0,0 +1,4 @@
+WorstBound
+==========
+
+.. doxygenclass:: idol::WorstBound

_sources/api/classes/branch-and-bound/node-selection/index.rst.txt

@@ -0,0 +1,10 @@
+Node Selection Rules
+====================
+
+.. toctree::
+    :maxdepth: 1
+    :glob:
+
+    *
+
+

_sources/api/classes/branch-and-bound/variable-selection/FirstInfeasibleFound.rst.txt

@@ -0,0 +1,4 @@
+FirstInfeasibleFound
+====================
+
+.. doxygenclass:: idol::FirstInfeasibleFound

_sources/api/classes/branch-and-bound/variable-selection/LeastInfeasible.rst.txt

@@ -0,0 +1,4 @@
+LeastInfeasible
+===============
+
+.. doxygenclass:: idol::LeastInfeasible

_sources/api/classes/branch-and-bound/variable-selection/MostInfeasible.rst.txt

@@ -0,0 +1,4 @@
+MostInfeasible
+==============
+
+.. doxygenclass:: idol::MostInfeasible

_sources/api/classes/branch-and-bound/variable-selection/PseudoCost.rst.txt

@@ -0,0 +1,4 @@
+PseudoCost
+==========
+
+.. doxygenclass:: idol::PseudoCost

_sources/api/classes/branch-and-bound/variable-selection/StrongBranching.rst.txt

@@ -0,0 +1,4 @@
+StrongBranching
+===============
+
+.. doxygenclass:: idol::StrongBranching

_sources/api/classes/branch-and-bound/variable-selection/UniformlyRandom.rst.txt

@@ -0,0 +1,4 @@
+UniformlyRandom
+===============
+
+.. doxygenclass:: idol::UniformlyRandom

_sources/api/classes/branch-and-bound/variable-selection/index.rst.txt

@@ -0,0 +1,10 @@
+Branching Rules
+===============
+
+.. toctree::
+    :maxdepth: 1
+    :glob:
+
+    *
+
+

_sources/api/classes/column-and-constraint-generation/ColumnAndConstraintGeneration.rst.txt

@@ -0,0 +1,6 @@
+.. _api_Robust_ColumnAndConstraintGeneration_doxygen:
+
+Robust::ColumnAndConstraintGeneration
+=====================================
+
+.. doxygenclass:: idol::Robust::ColumnAndConstraintGeneration

_sources/api/classes/column-and-constraint-generation/Optimizers_ColumnAndConstraintGeneration.rst.txt

@@ -0,0 +1,4 @@
+Optimizers::Robust::ColumnAndConstraintGeneration
+=================================================
+
+.. doxygenclass:: idol::Optimizers::Robust::ColumnAndConstraintGeneration

_sources/api/classes/column-and-constraint-generation/index.rst.txt

@@ -0,0 +1,8 @@
+Column-and-Constraint Generation Algorithm
+==========================================
+
+.. toctree::
+    :maxdepth: 1
+    :glob:
+
+    *

_sources/api/classes/column-generation/ArtificialCosts.rst.txt

@@ -0,0 +1,4 @@
+DantzigWolfe::ArtificialCosts
+=============================
+
+.. doxygenclass:: idol::DantzigWolfe::ArtificialCosts

_sources/api/classes/column-generation/DantzigWolfeDecomposition.rst.txt

@@ -0,0 +1,9 @@
+DantzigWolfeDecomposition
+=========================
+
+.. hint::
+
+    This page documents on the `DantzigWolfeDecomposition` optimizer factory. Note that there are also
+    :ref:`Dantzig-Wolfe Decomposition tutorials <tutorials_dantzig_wolfe>`.
+
+.. doxygenclass:: idol::DantzigWolfeDecomposition

_sources/api/classes/column-generation/FarkasPricing.rst.txt

@@ -0,0 +1,4 @@
+DantzigWolfe::FarkasPricing
+===========================
+
+.. doxygenclass:: idol::DantzigWolfe::FarkasPricing

_sources/api/classes/column-generation/IntegerMaster.rst.txt

@@ -0,0 +1,9 @@
+Heuristics::IntegerMaster
+=========================
+
+.. warning::
+
+    This heuristic can only be used with a :code:`BranchAndBound<NodeVarInfo>` optimizer in which nodes are solved by
+    :code:`DantzigWolfeDecomposition`.
+
+.. doxygenclass:: idol::Heuristics::IntegerMaster

_sources/api/classes/column-generation/Optimizers_DantzigWolfeDecomposition.rst.txt

@@ -0,0 +1,4 @@
+Optimizers::DantzigWolfeDecomposition
+=====================================
+
+.. doxygenclass:: idol::Optimizers::DantzigWolfeDecomposition

_sources/api/classes/column-generation/index.rst.txt

@@ -0,0 +1,10 @@
+Column Generation Algorithm
+===========================
+
+.. toctree::
+    :maxdepth: 1
+    :glob:
+
+    *
+    stabilization/index
+

_sources/api/classes/column-generation/stabilization/Neame.rst.txt

@@ -0,0 +1,4 @@
+DantzigWolfe::Neame
+===================
+
+.. doxygenclass:: idol::DantzigWolfe::Neame

_sources/api/classes/column-generation/stabilization/Wentges.rst.txt

@@ -0,0 +1,4 @@
+DantzigWolfe::Wentges
+=====================
+
+.. doxygenclass:: idol::DantzigWolfe::Wentges

_sources/api/classes/column-generation/stabilization/index.rst.txt

@@ -0,0 +1,8 @@
+Stabilization
+=============
+
+.. toctree::
+    :maxdepth: 1
+    :glob:
+
+    *

_sources/api/classes/common/Annotation.rst.txt

@@ -0,0 +1,27 @@
+Annotation
+==========
+
+Annotations are additional information associated to an optimization object (e.g., a constraint or a variable).
+The Annotation class takes two template arguments: an optimization object type and a value type. For instance, we
+can create an annotation for constraints of type :code:`unsigned int` as follows.
+
+.. code:: cpp
+
+    Env env;
+
+    const unsigned int default_value = 0;
+
+    Annotation<Ctr, unsigned int> annotation(env, "my_annotation", default_value);
+
+Note that annotations are global, i.e., they do not relate to a given optimization model and can, therefore, be accessed
+anywhere in the code. Thus, given a constraint called :code:`constraint`, the value of the annotation can be accessed
+by calling the :code:`Ctr::get` method.
+
+.. code:: cpp
+
+    std::cout << "My annotation is " << constraint.get(annotation) << std::endl; // "0", i.e., the default_value value
+
+Annotations are, in particular, used to give decomposition instructions to idol when designing a Branch-and-Price algorithm.
+To learn more, check our `Branch-and-Price tutorials <tutorials_dantzig_wolfe>`_.
+
+.. doxygenclass:: idol::Annotation

_sources/api/classes/common/Column.rst.txt

@@ -0,0 +1,6 @@
+.. _api_Column:
+
+Column
+======
+
+.. doxygenclass:: idol::Column

_sources/api/classes/common/Constant.rst.txt

@@ -0,0 +1,6 @@
+.. _api_Constant:
+
+Constant
+========
+
+.. doxygenclass:: idol::Constant

_sources/api/classes/common/Ctr.rst.txt

@@ -0,0 +1,6 @@
+.. _api_Ctr:
+
+Ctr
+===
+
+.. doxygenclass:: idol::Ctr

_sources/api/classes/common/Env.rst.txt

@@ -0,0 +1,6 @@
+.. _api_Env:
+
+Env
+===
+
+.. doxygenclass:: idol::Env

_sources/api/classes/common/Expr.rst.txt

@@ -0,0 +1,6 @@
+.. _api_Expr:
+
+Expr
+====
+
+.. doxygenclass:: idol::Expr