# C++ Reference: class MPSolver

This documentation is automatically generated.

This mathematical programming (MP) solver class is the main class though which users build and solve problems.

Method | |
---|---|

`ClampSolutionWithinBounds` | Return type: Resets values of out of bound variables to the corresponding bound and returns an error if any of the variables have NaN value. |

`Clear` | Return type: Clears the objective (including the optimization direction), all variables and constraints. All the other properties of the MPSolver (like the time limit) are kept untouched. |

`ComputeConstraintActivities` | Return type: Advanced usage: compute the "activities" of all constraints, which are the sums of their linear terms. The activities are returned in the same order as constraints(), which is the order in which constraints were added; but you can also use MPConstraint::index() to get a constraint's index. |

`ComputeExactConditionNumber` | Return type: Advanced usage: computes the exact condition number of the current scaled basis: L1norm(B) * L1norm(inverse(B)), where B is the scaled basis. This method requires that a basis exists: it should be called after Solve. It is only available for continuous problems. It is implemented for GLPK but not CLP because CLP does not provide the API for doing it. The condition number measures how well the constraint matrix is conditioned and can be used to predict whether numerical issues will arise during the solve: the model is declared infeasible whereas it is feasible (or vice-versa), the solution obtained is not optimal or violates some constraints, the resolution is slow because of repeated singularities. The rule of thumb to interpret the condition number kappa is: - o kappa <= 1e7: virtually no chance of numerical issues - o 1e7 < kappa <= 1e10: small chance of numerical issues - o 1e10 < kappa <= 1e13: medium chance of numerical issues - o kappa > 1e13: high chance of numerical issues The computation of the condition number depends on the quality of the LU decomposition, so it is not very accurate when the matrix is ill conditioned. |

`constraints` | Return type: Returns the array of constraints handled by the MPSolver. They are listed in the order in which they were created. |

`CreateSolver` | Return type: Arguments: Recommended factory method to create a MPSolver instance, especially in non C++ languages. It returns a newly created solver instance if successful, or a nullptr otherwise. This can occur if the relevant interface is not linked in, or if a needed license is not accessible for commercial solvers. Ownership of the solver is passed on to the caller of this method. It will accept both string names of the OptimizationProblemType enum, as well as a short version (i.e. "SCIP_MIXED_INTEGER_PROGRAMMING" or "SCIP"). solver_id is case insensitive, and the following names are supported: - CLP_LINEAR_PROGRAMMING or CLP - CBC_MIXED_INTEGER_PROGRAMMING or CBC - GLOP_LINEAR_PROGRAMMING or GLOP - BOP_INTEGER_PROGRAMMING or BOP - SAT_INTEGER_PROGRAMMING or SAT or CP_SAT - SCIP_MIXED_INTEGER_PROGRAMMING or SCIP - GUROBI_LINEAR_PROGRAMMING or GUROBI_LP - GUROBI_MIXED_INTEGER_PROGRAMMING or GUROBI or GUROBI_MIP - CPLEX_LINEAR_PROGRAMMING or CPLEX_LP - CPLEX_MIXED_INTEGER_PROGRAMMING or CPLEX or CPLEX_MIP - XPRESS_LINEAR_PROGRAMMING or XPRESS_LP - XPRESS_MIXED_INTEGER_PROGRAMMING or XPRESS or XPRESS_MIP - GLPK_LINEAR_PROGRAMMING or GLPK_LP - GLPK_MIXED_INTEGER_PROGRAMMING or GLPK or GLPK_MIP |

`DurationSinceConstruction` | Return type: |

`EnableOutput` | Return type: Enables solver logging. |

`ExportModelAsLpFormat` | Return type: Arguments: Shortcuts to the homonymous MPModelProtoExporter methods, via exporting to a MPModelProto with ExportModelToProto() (see above). Produces empty std::string on portable platforms (e.g. android, ios). |

`ExportModelAsMpsFormat` | Return type: Arguments: |

`ExportModelToProto` | Return type: Arguments: Exports model to protocol buffer. |

`FillSolutionResponseProto` | Return type: Arguments: Encodes the current solution in a solution response protocol buffer. |

`GetNumThreads` | Return type: Returns the number of threads to be used during solve. |

`GetSolverSpecificParametersAsString` | Return type: |

`infinity` | Return type: Infinity. You can use -MPSolver::infinity() for negative infinity. |

`InterruptSolve` | Return type: Interrupts the Solve() execution to terminate processing if possible. If the underlying interface supports interruption; it does that and returns true regardless of whether there's an ongoing Solve() or not. The Solve() call may still linger for a while depending on the conditions. If interruption is not supported; returns false and does nothing. |

`IsMIP` | Return type: |

`iterations` | Return type: Returns the number of simplex iterations. |

`LoadGurobiSharedLibrary` | Return type: Supports search and loading Gurobi shared library. |

`LoadModelFromProto` | Return type: Arguments: Loads model from protocol buffer. Returns MPSOLVER_MODEL_IS_VALID if the model is valid, and another status otherwise (currently only MPSOLVER_MODEL_INVALID and MPSOLVER_INFEASIBLE). If the model isn't valid, populates "error_message". |

`LoadModelFromProtoWithUniqueNamesOrDie` | Return type: Arguments: Loads model from protocol buffer. The same as above, except that the loading keeps original variable and constraint names. Caller should make sure that all variable names and constraint names are unique, respectively. |

`LoadSolutionFromProto` | Return type: Arguments: Load a solution encoded in a protocol buffer onto this solver for easy access via the MPSolver interface. IMPORTANT: This may only be used in conjunction with ExportModel(), following this example: MPSolver my_solver; ... add variables and constraints ... MPModelProto model_proto; my_solver.ExportModelToProto(&model_proto); MPSolutionResponse solver_response; MPSolver::SolveWithProto(model_proto, &solver_response); if (solver_response.result_status() == MPSolutionResponse::OPTIMAL) { CHECK_OK(my_solver.LoadSolutionFromProto(solver_response)); ... inspect the solution using the usual API: solution_value(), etc... } The response must be in OPTIMAL or FEASIBLE status. Returns a non-OK status if a problem arised (typically, if it wasn't used like it should be): - loading a solution whose variables don't correspond to the solver's current variables - loading a solution with a status other than OPTIMAL / FEASIBLE. Note: the objective value isn't checked. You can use VerifySolution() for that. |

`LookupConstraintOrNull` | Return type: Arguments: Looks up a constraint by name, and returns nullptr if it does not exist. The first call has a O(n) complexity, as the constraint name index is lazily created upon first use. Will crash if constraint names are not unique. |

`LookupVariableOrNull` | Return type: Arguments: Looks up a variable by name, and returns nullptr if it does not exist. The first call has a O(n) complexity, as the variable name index is lazily created upon first use. Will crash if variable names are not unique. |

`MakeBoolVar` | Return type: Arguments: Creates a boolean variable. |

`MakeBoolVarArray` | Return type: Arguments: Creates an array of boolean variables. |

`MakeIntVar` | Return type: Arguments: Creates an integer variable. |

`MakeIntVarArray` | Return type: Arguments: Creates an array of integer variables. |

`MakeNumVar` | Return type: Arguments: Creates a continuous variable. |

`MakeNumVarArray` | Return type: Arguments: Creates an array of continuous variables. |

`MakeRowConstraint` | Return type: Arguments: Creates a linear constraint with given bounds. Bounds can be finite or +/- MPSolver::infinity(). The MPSolver class assumes ownership of the constraint. @return a pointer to the newly created constraint. |

`MakeRowConstraint` | Return type: Creates a constraint with -infinity and +infinity bounds. |

`MakeRowConstraint` | Return type: Arguments: Creates a named constraint with given bounds. |

`MakeRowConstraint` | Return type: Arguments: Creates a named constraint with -infinity and +infinity bounds. |

`MakeRowConstraint` | Return type: Arguments: Creates a constraint owned by MPSolver enforcing: range.lower_bound() <= range.linear_expr() <= range.upper_bound() |

`MakeRowConstraint` | Return type: Arguments: As above, but also names the constraint. |

`MakeVar` | Return type: Arguments: Creates a variable with the given bounds, integrality requirement and name. Bounds can be finite or +/- MPSolver::infinity(). The MPSolver owns the variable (i.e. the returned pointer is borrowed). Variable names are optional. If you give an empty name, name() will auto-generate one for you upon request. |

`MakeVarArray` | Return type: Arguments: Creates an array of variables. All variables created have the same bounds and integrality requirement. If nb <= 0, no variables are created, the function crashes in non-opt mode. @param nb the number of variables to create. @param lb the lower bound of created variables @param ub the upper bound of created variables @param integer controls whether the created variables are continuous or integral. @param name_prefix the prefix of the variable names. Variables are named name_prefix0, name_prefix1, ... @param[out] vars the vector of variables to fill with variables. |

`MPSolver` | Arguments: Create a solver with the given name and underlying solver backend. |

`~MPSolver` | Return type: |

`MutableObjective` | Return type: Returns the mutable objective object. |

`Name` | Return type: Returns the name of the model set at construction. |

`NextSolution` | Return type: Some solvers (MIP only, not LP) can produce multiple solutions to the problem. Returns true when another solution is available, and updates the MPVariable* objects to make the new solution queryable. Call only after calling solve. The optimality properties of the additional solutions found, and whether or not the solver computes them ahead of time or when NextSolution() is called is solver specific. As of 2020-02-10, only Gurobi and SCIP support NextSolution(), see linear_solver_interfaces_test for an example of how to configure these solvers for multiple solutions. Other solvers return false unconditionally. |

`nodes` | Return type: Returns the number of branch-and-bound nodes evaluated during the solve. Only available for discrete problems. |

`NumConstraints` | Return type: Returns the number of constraints. |

`NumVariables` | Return type: Returns the number of variables. |

`Objective` | Return type: Returns the objective object. Note that the objective is owned by the solver, and is initialized to its default value (see the MPObjective class below) at construction. |

`OutputIsEnabled` | Return type: Controls (or queries) the amount of output produced by the underlying solver. The output can surface to LOGs, or to stdout or stderr, depending on the implementation. The amount of output will greatly vary with each implementation and each problem. Output is suppressed by default. |

`OwnsVariable` | Return type: Arguments: Debugging: verify that the given MPVariable* belongs to this solver. |

`ParseSolverType` | Return type: Arguments: Parses the name of the solver. Returns true if the solver type is successfully parsed as one of the OptimizationProblemType. See the documentation of CreateSolver() for the list of supported names. |

`ParseSolverTypeOrDie` | Return type: Arguments: Parses the name of the solver and returns the correct optimization type or dies. |

`ProblemType` | Return type: Returns the optimization problem type set at construction. |

`Reset` | Return type: Advanced usage: resets extracted model to solve from scratch. This won't reset the parameters that were set with SetSolverSpecificParametersAsString() or set_time_limit() or even clear the linear program. It will just make sure that next Solve() will be as if everything was reconstructed from scratch. |

`set_time_limit` | Return type: Arguments: |

`SetCallback` | Return type: Arguments: Does not take ownership of "mp_callback". As of 2019-10-22, only SCIP and Gurobi support Callbacks. SCIP does not support suggesting a heuristic solution in the callback. See go/mpsolver-callbacks for additional documentation. |

`SetGurobiLibraryPath` | Return type: Arguments: |

`SetHint` | Return type: Arguments: Sets a hint for solution. If a feasible or almost-feasible solution to the problem is already known, it may be helpful to pass it to the solver so that it can be used. A solver that supports this feature will try to use this information to create its initial feasible solution. Note: It may not always be faster to give a hint like this to the solver. There is also no guarantee that the solver will use this hint or try to return a solution "close" to this assignment in case of multiple optimal solutions. |

`SetNumThreads` | Return type: Arguments: Sets the number of threads to use by the underlying solver. Returns OkStatus if the operation was successful. num_threads must be equal to or greater than 1. Note that the behaviour of this call depends on the underlying solver. E.g., it may set the exact number of threads or the max number of threads (check the solver's interface implementation for details). Also, some solvers may not (yet) support this function, but still enable multi-threading via SetSolverSpecificParametersAsString(). |

`SetSolverSpecificParametersAsString` | Return type: Arguments: Advanced usage: pass solver specific parameters in text format. The format is solver-specific and is the same as the corresponding solver configuration file format. Returns true if the operation was successful. |

`SetStartingLpBasis` | Return type: Arguments: Advanced usage: Incrementality. This function takes a starting basis to be used in the next LP Solve() call. The statuses of a current solution can be retrieved via the basis_status() function of a MPVariable or a MPConstraint. WARNING: With Glop, you should disable presolve when using this because this information will not be modified in sync with the presolve and will likely not mean much on the presolved problem. |

`SetTimeLimit` | Return type: Arguments: |

`Solve` | Return type: Solves the problem using the default parameter values. |

`Solve` | Return type: Arguments: Solves the problem using the specified parameter values. |

`SolverVersion` | Return type: Returns a string describing the underlying solver and its version. |

`SolveWithProto` | Return type: Arguments: Solves the model encoded by a MPModelRequest protocol buffer and fills the solution encoded as a MPSolutionResponse. Note(user): This creates a temporary MPSolver and destroys it at the end. If you want to keep the MPSolver alive (for debugging, or for incremental solving), you should write another version of this function that creates the MPSolver object on the heap and returns it. Note(user): This attempts to first use `DirectlySolveProto()` (if implemented). Consequently, this most likely does *not* override any of the default parameters of the underlying solver. This behavior *differs* from `MPSolver::Solve()` which by default sets the feasibility tolerance and the gap limit (as of 2020/02/11, to 1e-7 and 0.0001, respectively). |

`SupportsCallbacks` | Return type: |

`SupportsProblemType` | Return type: Arguments: Whether the given problem type is supported (this will depend on the targets that you linked). |

`SuppressOutput` | Return type: Suppresses solver logging. |

`time_limit` | Return type: DEPRECATED: Use TimeLimit() and SetTimeLimit(absl::Duration) instead. NOTE: These deprecated functions used the convention time_limit = 0 to mean "no limit", which now corresponds to time_limit_ = InfiniteDuration(). |

`time_limit_in_secs` | Return type: |

`TimeLimit` | Return type: |

`underlying_solver` | Return type: Advanced usage: returns the underlying solver. Returns the underlying solver so that the user can use solver-specific features or features that are not exposed in the simple API of MPSolver. This method is for advanced users, use at your own risk! In particular, if you modify the model or the solution by accessing the underlying solver directly, then the underlying solver will be out of sync with the information kept in the wrapper (MPSolver, MPVariable, MPConstraint, MPObjective). You need to cast the void* returned back to its original type that depends on the interface (CBC: OsiClpSolverInterface*, CLP: ClpSimplex*, GLPK: glp_prob*, SCIP: SCIP*). |

`variables` | Return type: Returns the array of variables handled by the MPSolver. (They are listed in the order in which they were created.) |

`VerifySolution` | Return type: Arguments: Advanced usage: Verifies the *correctness* of the solution. It verifies that all variables must be within their domains, all constraints must be satisfied, and the reported objective value must be accurate. Usage: - This can only be called after Solve() was called. - "tolerance" is interpreted as an absolute error threshold. - For the objective value only, if the absolute error is too large, the tolerance is interpreted as a relative error threshold instead. - If "log_errors" is true, every single violation will be logged. - If "tolerance" is negative, it will be set to infinity(). Most users should just set the --verify_solution flag and not bother using this method directly. |

`wall_time` | Return type: DEPRECATED: Use DurationSinceConstruction() instead. |

`Write` | Return type: Arguments: Writes the model using the solver internal write function. Currently only available for Gurobi. |