straindesign.solver_interface
=============================

.. py:module:: straindesign.solver_interface

.. autoapi-nested-parse::

   Unified solver interface for LPs and MILPs (MILP_LP)





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

.. py:class:: MILP_LP(**kwargs)

   Bases: :py:obj:`object`


   Unified MILP and LP interface

   This class is a wrapper for several solver interfaces to offer unique and
   consistent bindings for the construction and manipulation of MILPs and LPs
   in an vector-matrix-based manner and their solution.

   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

   milp = MILP_LP(c, A_ineq, b_ineq, A_eq, b_eq, lb, ub, vtype, indic_constr)

   :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
                        (see reference manual or docstring).
   :type indic_constr: IndicatorConstraints
   :param M: (Default: None)
             A large value that is used in the translation of indicator constraints to
             bigM-constraints for solvers that do not natively support them. If no value
             is provided, 1000 is used.
   :type M: int
   :param solver: (Default: taken from avail_solvers)
                  Solver backend that should be used: 'cplex', 'gurobi', 'glpk' or 'scip'
   :type solver: str
   :param skip_checks: (Default: False)
                       Upon MILP construction, the dimensions of all provided vectors and matrices
                       are checked to verify their consistency. If skip_checks=True is set, these
                       checks are skipped.
   :type skip_checks: bool
   :param tlim: Solution time limit in seconds.
   :type tlim: float
   :param Returns: (MILP_LP):

                   A MILP/LP solver interface class.


   .. 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:: clear_objective()

      Clear objective

      Set all coefficients in the objective vector to 0.



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

      Generate a solution pool for MILPs

      .. rubric:: Example

      sols_x, optim, status = cplex.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 = cplex.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 = milp.solve()

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

                solution_vector, optimal_value, optimization_status