references in rst

Former-commit-id: 25762c4 [formerly 3fd3cdd]
Former-commit-id: 58b9ea6

docs/bench.rst

@@ -7,7 +7,7 @@ This section presents computational experiments on the creation of Integer
 Programming models using different mathematical modelling packages. Gurobi is
 the default Gurobi :sup:`®` Python interface, which currently only supports the
 Python interpreter CPython. Pulp supports both CPython and also the
-just-in-time compiler Pypy. MIP also suports both. JuMP :cite:`DHL17` is the
+just-in-time compiler Pypy. MIP also suports both. JuMP [DHL17]_ is the
 Mathematical Programming package of the Julia programming language. Both
 Jump and Pulp use intermediate data structures to store the mathematical
 programming model before flushing it to the solver, so that the selected

docs/custom.rst

@@ -14,7 +14,7 @@ Cutting Planes
 ~~~~~~~~~~~~~~
 
 In many applications there are `strong formulations <https://www.researchgate.net/publication/227062257_Strong_formulations_for_mixed_integer_programming_A_survey>`_ 
-that may include an exponential number of constraints. These formulations cannot be direct handled by the MIP Solver: entering all these constraints at once is usually not practical, except for very small instances. In the `Cutting Planes <https://en.wikipedia.org/wiki/Cutting-plane_method>`_ :cite:`Dantz54` method the LP relaxation is solved and only constraints which are *violated* are inserted. The model is re-optimized and at each iteration a stronger formulation is obtained until no more violated inequalities are found. The problem of discovering which are the missing violated constraints is also an optimization problem (finding *the most* violated inequality) and it is called the *Separation Problem*.
+that may include an exponential number of constraints. These formulations cannot be direct handled by the MIP Solver: entering all these constraints at once is usually not practical, except for very small instances. In the `Cutting Planes <https://en.wikipedia.org/wiki/Cutting-plane_method>`_ [Dantz54]_ method the LP relaxation is solved and only constraints which are *violated* are inserted. The model is re-optimized and at each iteration a stronger formulation is obtained until no more violated inequalities are found. The problem of discovering which are the missing violated constraints is also an optimization problem (finding *the most* violated inequality) and it is called the *Separation Problem*.
 
 As an example, consider the Traveling Salesman Problem. The compact formulation (:numref:`tsp-label`) is a *weak* formulation: dual bounds produced
 at the root node of the search tree are distant from the optimal solution cost

docs/examples.rst

@@ -44,10 +44,10 @@ The Traveling Salesman Problem
 ------------------------------
 
 The traveling salesman problem (TSP) is one of the most studied combinatorial
-optimization problems, with the first computational studies dating back to the
-50s :cite:`Dantz54,Appleg06`.  To to illustrate this problem, consider that you
-will spend some time in Belgium and wish to visit some of its main tourist
-attractions, depicted in the map bellow:
+optimization problems, with the first computational studies dating back to
+the 50s [Dantz54]_, [Appleg06]_.  To to illustrate this problem, consider
+that you will spend some time in Belgium and wish to visit some of its
+main tourist attractions, depicted in the map bellow:
 
 .. image:: images/belgium-tourism-14.png
     :width: 60%
@@ -142,7 +142,7 @@ of channels for each cell, avoiding interference between calls in the same cell
 and in neighboring cells.  Also, for economical reasons, the total bandwidth in
 use must be minimized, i.e., the total number of different channels used. One
 of the first real cases discussed in literature are the Philadelphia
-:cite:`Ande73` instances, with the structure depicted bellow:
+[Ande73]_ instances, with the structure depicted bellow:
 
 
 .. image:: ./images/bmcpsmall.*
@@ -256,13 +256,13 @@ contains the jobs :math:`x_{0}` and :math:`x_{n+1}`. These jobs are dummy jobs a
 represent the beginning of the planning and the end of the planning. The
 processing time for the dummy jobs is zero and does not consume resources.
 
-A binary programming formulation was proposed by Pritsker et al.
-:cite:`PWW69`. In this formulation, decision variables :math:`x_{jt} = 1`
-if job :math:`j` is assigned a completion time at the end of time
-:math:`t`; otherwise, :math:`x_{jt} = 0`. All jobs must finish in a single
-instant of time without violating the relationships of precedence and
-amount of available resources. The model proposed by Pristker can be
-stated as follows:
+A binary programming formulation was proposed by Pritsker et al. [PWW69]_.
+In this formulation, decision variables :math:`x_{jt} = 1` if job
+:math:`j` is assigned a completion time at the end of time :math:`t`;
+otherwise, :math:`x_{jt} = 0`. All jobs must finish in a single instant of
+time without violating the relationships of precedence and amount of
+available resources. The model proposed by Pristker can be stated as
+follows:
 
 .. math::
 
@@ -376,16 +376,17 @@ The decision variables are defined by:
     variable for the makespan
 
 
-Follows a MIP formulation :cite:`Mann60` for the JSSP. The objective function
-is computed in the auxiliary variable :math:`C`. The first set of constraints
-are the precedence constraints, that ensure that a job on a machine only starts
-after the processing of the previous machine concluded. The second and third
-set of disjunctive constraints ensure that only one job is processing at a
-given time in a given machine. The :math:`M` constant must be large enough to
-ensure the correctness of these constraints. A valid (but weak) estimate for
-this value can be the summation of all processing times. The fourth set of
-constrains ensure that the makespan value is computed correctly and the last
-constraints indicate variable domains.
+Follows a MIP formulation [Mann60]_ for the JSSP. The objective function
+is computed in the auxiliary variable :math:`C`. The first set of
+constraints are the precedence constraints, that ensure that a job on
+a machine only starts after the processing of the previous machine
+concluded. The second and third set of disjunctive constraints ensure that
+only one job is processing at a given time in a given machine. The
+:math:`M` constant must be large enough to ensure the correctness of these
+constraints. A valid (but weak) estimate for this value can be the
+summation of all processing times. The fourth set of constrains ensure
+that the makespan value is computed correctly and the last constraints
+indicate variable domains.
 
 .. math::
 
@@ -414,11 +415,11 @@ Cutting Stock / One-dimensional Bin Packing Problem
 
 The One-dimensional Cutting Stock Problem (also often referred to as
 One-dimensional Bin Packing Problem) is an NP-hard problem first studied
-by Kantorovich in 1939 :cite:`Kan60`. The problem consists of deciding how
-to cut a set of pieces out of a set of stock materials (paper rolls,
-metals, etc.) in a way that minimizes the number of stock materials used.
+by Kantorovich in 1939 [Kan60]_. The problem consists of deciding how to
+cut a set of pieces out of a set of stock materials (paper rolls, metals,
+etc.) in a way that minimizes the number of stock materials used.
 
-:cite:`Kan60` proposed an integer programming formulation for the problem,
+[Kan60]_ proposed an integer programming formulation for the problem,
 given below:
 
 
@@ -438,7 +439,7 @@ This formulation can be improved by including symmetry reducing constraints, suc
 
 
 The following Python-MIP code creates the formulation proposed by
-:cite:`Kan60`, optimizes it and prints the optimal solution found.
+[Kan60]_, optimizes it and prints the optimal solution found.
 
 .. literalinclude:: ../examples/cuttingstock_kantorovich.py
     :caption: Formulation for the One-dimensional Cutting Stock Problem (examples/cuttingstock_kantorovich.py)

docs/intro.rst

@@ -5,16 +5,16 @@ Introduction
 
 The Python-MIP package provides tools for modeling and solving
 `Mixed-Integer Linear Programming Problems
-<https://en.wikipedia.org/wiki/Integer_programming>`_ (MIPs)
-:cite:`Wols98` in Python. The default installation includes the `COIN-OR
-Linear Programming Solver - CLP <http://github.com/coin-or/Clp>`_, which
-is currently the `fastest <http://plato.asu.edu/ftp/lpsimp.html>`_  open
-source linear programming solver and the `COIN-OR Branch-and-Cut solver
-- CBC <https://github.com/coin-or/Cbc>`_, a highly configurable MIP
-solver. It also works with the state-of-the-art `Gurobi
-<http://www.gurobi.com/>`_ MIP solver. Python-MIP was written in modern,
-`typed Python <https://docs.python.org/3/library/typing.html>`_ and works
-with the fast just-in-time Python compiler `Pypy <https://pypy.org/>`_. 
+<https://en.wikipedia.org/wiki/Integer_programming>`_ (MIPs) [Wols98]_ in
+Python. The default installation includes the `COIN-OR Linear Programming
+Solver - CLP <http://github.com/coin-or/Clp>`_, which is currently the
+`fastest <http://plato.asu.edu/ftp/lpsimp.html>`_  open source linear
+programming solver and the `COIN-OR Branch-and-Cut solver - CBC
+<https://github.com/coin-or/Cbc>`_, a highly configurable MIP solver. It
+also works with the state-of-the-art `Gurobi <http://www.gurobi.com/>`_
+MIP solver. Python-MIP was written in modern, `typed Python
+<https://docs.python.org/3/library/typing.html>`_ and works with the fast
+just-in-time Python compiler `Pypy <https://pypy.org/>`_. 
 
 In the modeling layer, models can be written very concisely, as in high-level
 mathematical programming languages such as `MathProg