straindesign.glpk_interface
===========================

.. py:module:: straindesign.glpk_interface

.. autoapi-nested-parse::

   GLPK solver interface for LP and MILP





Module Contents
---------------

.. py:class:: GLPK_MILP_LP(c=None, A_ineq=None, b_ineq=None, A_eq=None, b_eq=None, lb=None, ub=None, vtype=None, indic_constr=None, M=None)

   GLPK interface for MILP and LP

   This class is a wrapper for the GLPK-Python API to offer bindings and namings
   for functions for the construction and manipulation of MILPs and LPs in an
   vector-matrix-based manner that are consistent with those of the other solver
   interfaces in the StrainDesign package. The purpose is to unify the instructions
   for operating with MILPs and LPs throughout StrainDesign.

   The GLPK interface does not natively support indicator constraints. They are
   hence translated to bigM-constraints when passed to the GLPK constructor
   (see docstring of IndicatorConstraints). The GLPK interface does not natively
   support the populate function. A high level implementation emulates the behavior
   of populate.

   Accepts a (mixed integer) linear problem in the form:
       minimize(c),
       subject to:
       A_ineq * x <= b_ineq,
       A_eq * x  = b_eq,
       lb <= x <= ub,
       forall(i) type(x_i) = vtype(i) (continous, binary, integer),
       indicator constraints:
       x(j) = [0|1] -> a_indic * x [<=|=|>=] b_indic

   Please ensure that the number of variables and (in)equalities is consistent

   .. rubric:: Example

   glpk = GLPK_MILP_LP(c, A_ineq, b_ineq, A_eq, b_eq, lb, ub, vtype, indic_constr, M)

   :param c: (Default: None)
             The objective vector (Objective sense: minimization).
   :type c: list of float
   :param A_ineq: (Default: None)
                  A coefficient matrix of the static inequalities.
   :type A_ineq: sparse.csr_matrix
   :param b_ineq: (Default: None)
                  The right hand side of the static inequalities.
   :type b_ineq: list of float
   :param A_eq: (Default: None)
                A coefficient matrix of the static equalities.
   :type A_eq: sparse.csr_matrix
   :param b_eq: (Default: None)
                The right hand side of the static equalities.
   :type b_eq: list of float
   :param lb: (Default: None)
              The lower variable bounds.
   :type lb: list of float
   :param ub: (Default: None)
              The upper variable bounds.
   :type ub: list of float
   :param vtype: (Default: None)
                 A character string that specifies the type of each variable:
                 'c'ontinous, 'b'inary or 'i'nteger
   :type vtype: str
   :param indic_constr: (Default: None)
                        A set of indicator constraints stored in an object of IndicatorConstraints.
                        To make GLPK compatible with indicator constraints, they are translated into
                        bigM-constraints (see reference manual or docstring of IndicatorConstraints).
   :type indic_constr: IndicatorConstraints
   :param M: (Default: None)
             A large value that is used in the translation of indicator constraints to
             bigM-constraints. If no value is provided, 1000 is used.
   :type M: int
   :param Returns: (GLPK_MILP_LP):

                   A GLPK MILP/LP interface class.


   .. py:method:: addExclusionConstraintsIneq(x)

      Function to add exclusion constraint (GLPK compatibility function)



   .. py:method:: add_eq_constraints(A_eq, b_eq)

      Add equality constraints to the model

      Additional equality constraints have the form A_eq * x = b_eq.
      The number of columns in A_eq must match with the number of variables x
      in the problem.

      :param A_eq: The coefficient matrix
      :type A_eq: sparse.csr_matrix
      :param b_eq: The right hand side vector
      :type b_eq: list of float



   .. py:method:: add_ineq_constraints(A_ineq, b_ineq)

      Add inequality constraints to the model

      Additional inequality constraints have the form A_ineq * x <= b_ineq.
      The number of columns in A_ineq must match with the number of variables x
      in the problem.

      :param A_ineq: The coefficient matrix
      :type A_ineq: sparse.csr_matrix
      :param b_ineq: The right hand side vector
      :type b_ineq: list of float



   .. py:method:: getSolution(status) -> list

      Retrieve solution from GLPK backend



   .. py:method:: populate(pool_limit) -> Tuple[List, float, float]

      Generate a solution pool for MILPs

      This is only a high-level implementation of the populate function.
      There is no native support in GLPK.

      .. rubric:: Example

      sols_x, optim, status = glpk.populate()

      :returns: (Tuple[List of lists, float, float])

                solution_vectors, optimal_value, optimization_status



   .. py:method:: set_ineq_constraint(idx, a_ineq, b_ineq)

      Replace a specific inequality constraint

      Replace the constraint with the index idx with the constraint a_ineq*x ~ b_ineq

      :param idx: Index of the constraint
      :type idx: int
      :param a_ineq: The coefficient vector
      :type a_ineq: list of float
      :param b_ineq: The right hand side value
      :type b_ineq: float



   .. py:method:: set_objective(c)

      Set the objective function with a vector



   .. py:method:: set_objective_idx(C)

      Set the objective function with index-value pairs

      e.g.: C=[[1, 1.0], [4,-0.2]]



   .. py:method:: set_time_limit(t)

      Set the computation time limit (in seconds)



   .. py:method:: set_ub(ub)

      Set the upper bounds to a given vector



   .. py:method:: slim_solve() -> float

      Solve the MILP or LP, but return only the optimal value

      .. rubric:: Example

      optim = glpk.slim_solve()

      :returns: (float)

                Optimum value of the objective function.



   .. py:method:: solve() -> Tuple[List, float, float]

      Solve the MILP or LP

      .. rubric:: Example

      sol_x, optim, status = glpk.solve()

      :returns: (Tuple[List, float, float])

                solution_vector, optimal_value, optimization_status



   .. py:method:: solve_MILP_LP() -> Tuple[float, int, bool]

      Trigger GLPK solution through backend