/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* This file is part of the program and library */ /* SCIP --- Solving Constraint Integer Programs */ /* */ /* Copyright 2002-2022 Zuse Institute Berlin */ /* */ /* Licensed under the Apache License, Version 2.0 (the "License"); */ /* you may not use this file except in compliance with the License. */ /* You may obtain a copy of the License at */ /* */ /* http://www.apache.org/licenses/LICENSE-2.0 */ /* */ /* Unless required by applicable law or agreed to in writing, software */ /* distributed under the License is distributed on an "AS IS" BASIS, */ /* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */ /* See the License for the specific language governing permissions and */ /* limitations under the License. */ /* */ /* You should have received a copy of the Apache-2.0 license */ /* along with SCIP; see the file LICENSE. If not visit scipopt.org. */ /* */ /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /**@file lpi.h * @ingroup LPIS * @brief interface methods for specific LP solvers * @author Tobias Achterberg * @author Marc Pfetsch * */ /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ #ifndef __SCIP_LPI_H__ #define __SCIP_LPI_H__ #include "blockmemshell/memory.h" #include "lpi/type_lpi.h" #include "scip/def.h" #include "scip/type_message.h" #include "scip/type_retcode.h" #ifdef __cplusplus extern "C" { #endif /**@addtogroup LPIS * * This file specifies a generic LP solver interface used by SCIP to create, modify, and solve linear programs of the * form * * min/max obj * x * lhs <= A * x <= rhs * lb <= x <= ub * * and query information about the solution. Although it includes a few SCIP header files, e.g., because it uses SCIP's * return codes, it can be used independently of any SCIP instance. * * The basis status for (column) variables are as follows: * - If x_j = lb, then j is at its lower bound (SCIP_BASESTAT_LOWER). * - If x_j = ub, then j is at its lower bound (SCIP_BASESTAT_UPPER). * - If x_j is in the basis, it has SCIP_BASESTAT_BASIC status. * - If x_j is free and non-basic, it has SCIP_BASESTAT_ZERO status. * * The basis status for (row) slack variables are: * - If (A * x)_i = lhs, then i is at its lower bound (SCIP_BASESTAT_LOWER). * - If (A * x)_i = rhs, then i is at its upper bound (SCIP_BASESTAT_UPPER). * - If the slack variable for row i is basic, it has SCIP_BASESTAT_BASIC status. * * If the solvers use their status differently, those status codes have to be corrected. * * In the methods accessing information about the (inverse of the) basis matrix, the interface assumes the following * column-oriented format: slack variables of rows have coefficient +1 and the basis matrix is a regular m times m * submatrix of (A,I), where m is the number of rows and I is the identity matrix. This means that if, internally, the * LP solver uses coefficients -1 for some of the slack variables, then every row associated with a slack variable whose * coefficient is -1 should be negated in order to return the result in terms of the LP interface definition. * * The creation of a new LP should always be done in the following ways: Either one can use SCIPlpiLoadColLP() or one * first adds empty columns or rows. Then the matrix entries can be added by adding columns and rows, respectively. * Adding matrix entries for a row or column that have not been added before will result in an error. * * The handling of the objective limit is as follows, if supported by the LP-solver: If the objective is larger than the * objective limit for minimization problems or smaller than the objective limit for maximization problems, the solution * process can be stopped. This naturally occurs in a branch-and-bound process, where the objective limit is set to the * value of the best solution found so far. If the problem is a minimization problem and we use the dual simplex, the * dual feasible solutions are maximized. If their value are larger than the objective limit, the process can be * stopped. In this case, no feasible integer solution can be found in the corresponding branch. * * Some LP-solvers also support the opposite setting, but this can easily be checked after the solution process (i.e., * for a minimization problem a check whether the optimal value is smaller than the limit). Note that this check can * only be determined at the end of the optimization. Thus, we do not support this. * * @{ */ /* * Miscellaneous Methods */ /**@name Miscellaneous Methods */ /**@{ */ /** gets name and version of LP solver */ SCIP_EXPORT const char* SCIPlpiGetSolverName( void ); /** gets description of LP solver (developer, webpage, ...) */ SCIP_EXPORT const char* SCIPlpiGetSolverDesc( void ); /** gets pointer for LP solver - use only with great care * * The behavior of this function depends on the solver and its use is * therefore only recommended if you really know what you are * doing. In general, it returns a pointer to the LP solver object. */ SCIP_EXPORT void* SCIPlpiGetSolverPointer( SCIP_LPI* lpi /**< pointer to an LP interface structure */ ); /** pass integrality information about variables to the solver */ SCIP_EXPORT SCIP_RETCODE SCIPlpiSetIntegralityInformation( SCIP_LPI* lpi, /**< pointer to an LP interface structure */ int ncols, /**< length of integrality array */ int* intInfo /**< integrality array (0: continuous, 1: integer). May be NULL iff ncols is 0. */ ); /** informs about availability of a primal simplex solving method */ SCIP_EXPORT SCIP_Bool SCIPlpiHasPrimalSolve( void ); /** informs about availability of a dual simplex solving method */ SCIP_EXPORT SCIP_Bool SCIPlpiHasDualSolve( void ); /** informs about availability of a barrier solving method */ SCIP_EXPORT SCIP_Bool SCIPlpiHasBarrierSolve( void ); /**@} */ /* * LPI Creation and Destruction Methods */ /**@name LPI Creation and Destruction Methods */ /**@{ */ /** creates an LP problem object */ SCIP_EXPORT SCIP_RETCODE SCIPlpiCreate( SCIP_LPI** lpi, /**< pointer to an LP interface structure */ SCIP_MESSAGEHDLR* messagehdlr, /**< message handler to use for printing messages, or NULL */ const char* name, /**< problem name */ SCIP_OBJSEN objsen /**< objective sense */ ); /** deletes an LP problem object */ SCIP_EXPORT SCIP_RETCODE SCIPlpiFree( SCIP_LPI** lpi /**< pointer to an LP interface structure */ ); /**@} */ /* * Modification Methods */ /**@name Modification Methods */ /**@{ */ /** copies LP data with column matrix into LP solver */ SCIP_EXPORT SCIP_RETCODE SCIPlpiLoadColLP( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_OBJSEN objsen, /**< objective sense */ int ncols, /**< number of columns */ const SCIP_Real* obj, /**< objective function values of columns */ const SCIP_Real* lb, /**< lower bounds of columns */ const SCIP_Real* ub, /**< upper bounds of columns */ char** colnames, /**< column names, or NULL */ int nrows, /**< number of rows */ const SCIP_Real* lhs, /**< left hand sides of rows */ const SCIP_Real* rhs, /**< right hand sides of rows */ char** rownames, /**< row names, or NULL */ int nnonz, /**< number of nonzero elements in the constraint matrix */ const int* beg, /**< start index of each column in ind- and val-array */ const int* ind, /**< row indices of constraint matrix entries */ const SCIP_Real* val /**< values of constraint matrix entries */ ); /** adds columns to the LP * * @note ind array is not checked for duplicates, problems may appear if indices are added more than once */ SCIP_EXPORT SCIP_RETCODE SCIPlpiAddCols( SCIP_LPI* lpi, /**< LP interface structure */ int ncols, /**< number of columns to be added */ const SCIP_Real* obj, /**< objective function values of new columns */ const SCIP_Real* lb, /**< lower bounds of new columns */ const SCIP_Real* ub, /**< upper bounds of new columns */ char** colnames, /**< column names, or NULL */ int nnonz, /**< number of nonzero elements to be added to the constraint matrix */ const int* beg, /**< start index of each column in ind- and val-array, or NULL if nnonz == 0 */ const int* ind, /**< row indices of constraint matrix entries, or NULL if nnonz == 0 */ const SCIP_Real* val /**< values of constraint matrix entries, or NULL if nnonz == 0 */ ); /** deletes all columns in the given range from LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiDelCols( SCIP_LPI* lpi, /**< LP interface structure */ int firstcol, /**< first column to be deleted */ int lastcol /**< last column to be deleted */ ); /** deletes columns from SCIP_LPI; the new position of a column must not be greater that its old position */ SCIP_EXPORT SCIP_RETCODE SCIPlpiDelColset( SCIP_LPI* lpi, /**< LP interface structure */ int* dstat /**< deletion status of columns * input: 1 if column should be deleted, 0 if not * output: new position of column, -1 if column was deleted */ ); /** adds rows to the LP * * @note ind array is not checked for duplicates, problems may appear if indices are added more than once */ SCIP_EXPORT SCIP_RETCODE SCIPlpiAddRows( SCIP_LPI* lpi, /**< LP interface structure */ int nrows, /**< number of rows to be added */ const SCIP_Real* lhs, /**< left hand sides of new rows */ const SCIP_Real* rhs, /**< right hand sides of new rows */ char** rownames, /**< row names, or NULL */ int nnonz, /**< number of nonzero elements to be added to the constraint matrix */ const int* beg, /**< start index of each row in ind- and val-array, or NULL if nnonz == 0 */ const int* ind, /**< column indices of constraint matrix entries, or NULL if nnonz == 0 */ const SCIP_Real* val /**< values of constraint matrix entries, or NULL if nnonz == 0 */ ); /** deletes all rows in the given range from LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiDelRows( SCIP_LPI* lpi, /**< LP interface structure */ int firstrow, /**< first row to be deleted */ int lastrow /**< last row to be deleted */ ); /** deletes rows from SCIP_LPI; the new position of a row must not be greater that its old position */ SCIP_EXPORT SCIP_RETCODE SCIPlpiDelRowset( SCIP_LPI* lpi, /**< LP interface structure */ int* dstat /**< deletion status of rows * input: 1 if row should be deleted, 0 if not * output: new position of row, -1 if row was deleted */ ); /** clears the whole LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiClear( SCIP_LPI* lpi /**< LP interface structure */ ); /** changes lower and upper bounds of columns */ SCIP_EXPORT SCIP_RETCODE SCIPlpiChgBounds( SCIP_LPI* lpi, /**< LP interface structure */ int ncols, /**< number of columns to change bounds for */ const int* ind, /**< column indices or NULL if ncols is zero */ const SCIP_Real* lb, /**< values for the new lower bounds or NULL if ncols is zero */ const SCIP_Real* ub /**< values for the new upper bounds or NULL if ncols is zero */ ); /** changes left and right hand sides of rows */ SCIP_EXPORT SCIP_RETCODE SCIPlpiChgSides( SCIP_LPI* lpi, /**< LP interface structure */ int nrows, /**< number of rows to change sides for */ const int* ind, /**< row indices */ const SCIP_Real* lhs, /**< new values for left hand sides */ const SCIP_Real* rhs /**< new values for right hand sides */ ); /** changes a single coefficient */ SCIP_EXPORT SCIP_RETCODE SCIPlpiChgCoef( SCIP_LPI* lpi, /**< LP interface structure */ int row, /**< row number of coefficient to change */ int col, /**< column number of coefficient to change */ SCIP_Real newval /**< new value of coefficient */ ); /** changes the objective sense */ SCIP_EXPORT SCIP_RETCODE SCIPlpiChgObjsen( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_OBJSEN objsen /**< new objective sense */ ); /** changes objective values of columns in the LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiChgObj( SCIP_LPI* lpi, /**< LP interface structure */ int ncols, /**< number of columns to change objective value for */ const int* ind, /**< column indices to change objective value for */ const SCIP_Real* obj /**< new objective values for columns */ ); /** multiplies a row with a non-zero scalar; for negative scalars, the row's sense is switched accordingly */ SCIP_EXPORT SCIP_RETCODE SCIPlpiScaleRow( SCIP_LPI* lpi, /**< LP interface structure */ int row, /**< row number to scale */ SCIP_Real scaleval /**< scaling multiplier */ ); /** multiplies a column with a non-zero scalar; the objective value is multiplied with the scalar, and the bounds * are divided by the scalar; for negative scalars, the column's bounds are switched */ SCIP_EXPORT SCIP_RETCODE SCIPlpiScaleCol( SCIP_LPI* lpi, /**< LP interface structure */ int col, /**< column number to scale */ SCIP_Real scaleval /**< scaling multiplier */ ); /**@} */ /* * Data Accessing Methods */ /**@name Data Accessing Methods */ /**@{ */ /** gets the number of rows in the LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetNRows( SCIP_LPI* lpi, /**< LP interface structure */ int* nrows /**< pointer to store the number of rows */ ); /** gets the number of columns in the LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetNCols( SCIP_LPI* lpi, /**< LP interface structure */ int* ncols /**< pointer to store the number of cols */ ); /** gets the objective sense of the LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetObjsen( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_OBJSEN* objsen /**< pointer to store objective sense */ ); /** gets the number of nonzero elements in the LP constraint matrix */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetNNonz( SCIP_LPI* lpi, /**< LP interface structure */ int* nnonz /**< pointer to store the number of nonzeros */ ); /** gets columns from LP problem object; the arrays have to be large enough to store all values; * Either both, lb and ub, have to be NULL, or both have to be non-NULL, * either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL. */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetCols( SCIP_LPI* lpi, /**< LP interface structure */ int firstcol, /**< first column to get from LP */ int lastcol, /**< last column to get from LP */ SCIP_Real* lb, /**< buffer to store the lower bound vector, or NULL */ SCIP_Real* ub, /**< buffer to store the upper bound vector, or NULL */ int* nnonz, /**< pointer to store the number of nonzero elements returned, or NULL */ int* beg, /**< buffer to store start index of each column in ind- and val-array, or NULL */ int* ind, /**< buffer to store row indices of constraint matrix entries, or NULL */ SCIP_Real* val /**< buffer to store values of constraint matrix entries, or NULL */ ); /** gets rows from LP problem object; the arrays have to be large enough to store all values. * Either both, lhs and rhs, have to be NULL, or both have to be non-NULL, * either nnonz, beg, ind, and val have to be NULL, or all of them have to be non-NULL. */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetRows( SCIP_LPI* lpi, /**< LP interface structure */ int firstrow, /**< first row to get from LP */ int lastrow, /**< last row to get from LP */ SCIP_Real* lhs, /**< buffer to store left hand side vector, or NULL */ SCIP_Real* rhs, /**< buffer to store right hand side vector, or NULL */ int* nnonz, /**< pointer to store the number of nonzero elements returned, or NULL */ int* beg, /**< buffer to store start index of each row in ind- and val-array, or NULL */ int* ind, /**< buffer to store column indices of constraint matrix entries, or NULL */ SCIP_Real* val /**< buffer to store values of constraint matrix entries, or NULL */ ); /** gets column names */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetColNames( SCIP_LPI* lpi, /**< LP interface structure */ int firstcol, /**< first column to get name from LP */ int lastcol, /**< last column to get name from LP */ char** colnames, /**< pointers to column names (of size at least lastcol-firstcol+1) or NULL if namestoragesize is zero */ char* namestorage, /**< storage for col names or NULL if namestoragesize is zero */ int namestoragesize, /**< size of namestorage (if 0, -storageleft returns the storage needed) */ int* storageleft /**< amount of storage left (if < 0 the namestorage was not big enough) or NULL if namestoragesize is zero */ ); /** gets row names */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetRowNames( SCIP_LPI* lpi, /**< LP interface structure */ int firstrow, /**< first row to get name from LP */ int lastrow, /**< last row to get name from LP */ char** rownames, /**< pointers to row names (of size at least lastrow-firstrow+1) or NULL if namestoragesize is zero */ char* namestorage, /**< storage for row names or NULL if namestoragesize is zero */ int namestoragesize, /**< size of namestorage (if 0, -storageleft returns the storage needed) */ int* storageleft /**< amount of storage left (if < 0 the namestorage was not big enough) or NULL if namestoragesize is zero */ ); /** gets objective coefficients from LP problem object */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetObj( SCIP_LPI* lpi, /**< LP interface structure */ int firstcol, /**< first column to get objective coefficient for */ int lastcol, /**< last column to get objective coefficient for */ SCIP_Real* vals /**< array to store objective coefficients */ ); /** gets current bounds from LP problem object */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetBounds( SCIP_LPI* lpi, /**< LP interface structure */ int firstcol, /**< first column to get bounds for */ int lastcol, /**< last column to get bounds for */ SCIP_Real* lbs, /**< array to store lower bound values, or NULL */ SCIP_Real* ubs /**< array to store upper bound values, or NULL */ ); /** gets current row sides from LP problem object */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetSides( SCIP_LPI* lpi, /**< LP interface structure */ int firstrow, /**< first row to get sides for */ int lastrow, /**< last row to get sides for */ SCIP_Real* lhss, /**< array to store left hand side values, or NULL */ SCIP_Real* rhss /**< array to store right hand side values, or NULL */ ); /** gets a single coefficient */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetCoef( SCIP_LPI* lpi, /**< LP interface structure */ int row, /**< row number of coefficient */ int col, /**< column number of coefficient */ SCIP_Real* val /**< pointer to store the value of the coefficient */ ); /**@} */ /* * Solving Methods */ /**@name Solving Methods */ /**@{ */ /** calls primal simplex to solve the LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiSolvePrimal( SCIP_LPI* lpi /**< LP interface structure */ ); /** calls dual simplex to solve the LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiSolveDual( SCIP_LPI* lpi /**< LP interface structure */ ); /** calls barrier or interior point algorithm to solve the LP with crossover to simplex basis */ SCIP_EXPORT SCIP_RETCODE SCIPlpiSolveBarrier( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_Bool crossover /**< perform crossover */ ); /** start strong branching - call before any strong branching */ SCIP_EXPORT SCIP_RETCODE SCIPlpiStartStrongbranch( SCIP_LPI* lpi /**< LP interface structure */ ); /** end strong branching - call after any strong branching */ SCIP_EXPORT SCIP_RETCODE SCIPlpiEndStrongbranch( SCIP_LPI* lpi /**< LP interface structure */ ); /** performs strong branching iterations on one @b fractional candidate */ SCIP_EXPORT SCIP_RETCODE SCIPlpiStrongbranchFrac( SCIP_LPI* lpi, /**< LP interface structure */ int col, /**< column to apply strong branching on */ SCIP_Real psol, /**< fractional current primal solution value of column */ int itlim, /**< iteration limit for strong branchings */ SCIP_Real* down, /**< stores dual bound after branching column down */ SCIP_Real* up, /**< stores dual bound after branching column up */ SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound; * otherwise, it can only be used as an estimate value */ SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound; * otherwise, it can only be used as an estimate value */ int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */ ); /** performs strong branching iterations on given @b fractional candidates */ SCIP_EXPORT SCIP_RETCODE SCIPlpiStrongbranchesFrac( SCIP_LPI* lpi, /**< LP interface structure */ int* cols, /**< columns to apply strong branching on */ int ncols, /**< number of columns */ SCIP_Real* psols, /**< fractional current primal solution values of columns */ int itlim, /**< iteration limit for strong branchings */ SCIP_Real* down, /**< stores dual bounds after branching columns down */ SCIP_Real* up, /**< stores dual bounds after branching columns up */ SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds; * otherwise, they can only be used as an estimate values */ SCIP_Bool* upvalid, /**< stores whether the returned up values are a valid dual bounds; * otherwise, they can only be used as an estimate values */ int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */ ); /** performs strong branching iterations on one candidate with @b integral value */ SCIP_EXPORT SCIP_RETCODE SCIPlpiStrongbranchInt( SCIP_LPI* lpi, /**< LP interface structure */ int col, /**< column to apply strong branching on */ SCIP_Real psol, /**< current integral primal solution value of column */ int itlim, /**< iteration limit for strong branchings */ SCIP_Real* down, /**< stores dual bound after branching column down */ SCIP_Real* up, /**< stores dual bound after branching column up */ SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound; * otherwise, it can only be used as an estimate value */ SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound; * otherwise, it can only be used as an estimate value */ int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */ ); /** performs strong branching iterations on given candidates with @b integral values */ SCIP_EXPORT SCIP_RETCODE SCIPlpiStrongbranchesInt( SCIP_LPI* lpi, /**< LP interface structure */ int* cols, /**< columns to apply strong branching on */ int ncols, /**< number of columns */ SCIP_Real* psols, /**< current integral primal solution values of columns */ int itlim, /**< iteration limit for strong branchings */ SCIP_Real* down, /**< stores dual bounds after branching columns down */ SCIP_Real* up, /**< stores dual bounds after branching columns up */ SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds; * otherwise, they can only be used as an estimate values */ SCIP_Bool* upvalid, /**< stores whether the returned up values are a valid dual bounds; * otherwise, they can only be used as an estimate values */ int* iter /**< stores total number of strong branching iterations, or -1; may be NULL */ ); /**@} */ /* * Solution Information Methods */ /**@name Solution Information Methods */ /**@{ */ /** returns whether a solve method was called after the last modification of the LP */ SCIP_EXPORT SCIP_Bool SCIPlpiWasSolved( SCIP_LPI* lpi /**< LP interface structure */ ); /** gets information about primal and dual feasibility of the current LP solution * * The feasibility information is with respect to the last solving call and it is only relevant if SCIPlpiWasSolved() * returns true. If the LP is changed, this information might be invalidated. * * Note that @p primalfeasible and @p dualfeasible should only return true if the solver has proved the respective LP to * be feasible. Thus, the return values should be equal to the values of SCIPlpiIsPrimalFeasible() and * SCIPlpiIsDualFeasible(), respectively. Note that if feasibility cannot be proved, they should return false (even if * the problem might actually be feasible). */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetSolFeasibility( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_Bool* primalfeasible, /**< pointer to store primal feasibility status */ SCIP_Bool* dualfeasible /**< pointer to store dual feasibility status */ ); /** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point); * this does not necessarily mean, that the solver knows and can return the primal ray */ SCIP_EXPORT SCIP_Bool SCIPlpiExistsPrimalRay( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff LP is proven to have a primal unbounded ray (but not necessary a primal feasible point), * and the solver knows and can return the primal ray */ SCIP_EXPORT SCIP_Bool SCIPlpiHasPrimalRay( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff LP is proven to be primal unbounded */ SCIP_EXPORT SCIP_Bool SCIPlpiIsPrimalUnbounded( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff LP is proven to be primal infeasible */ SCIP_EXPORT SCIP_Bool SCIPlpiIsPrimalInfeasible( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff LP is proven to be primal feasible */ SCIP_EXPORT SCIP_Bool SCIPlpiIsPrimalFeasible( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point); * this does not necessarily mean, that the solver knows and can return the dual ray */ SCIP_EXPORT SCIP_Bool SCIPlpiExistsDualRay( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff LP is proven to have a dual unbounded ray (but not necessary a dual feasible point), * and the solver knows and can return the dual ray */ SCIP_EXPORT SCIP_Bool SCIPlpiHasDualRay( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff LP is proven to be dual unbounded */ SCIP_EXPORT SCIP_Bool SCIPlpiIsDualUnbounded( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff LP is proven to be dual infeasible */ SCIP_EXPORT SCIP_Bool SCIPlpiIsDualInfeasible( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff LP is proven to be dual feasible */ SCIP_EXPORT SCIP_Bool SCIPlpiIsDualFeasible( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff LP was solved to optimality */ SCIP_EXPORT SCIP_Bool SCIPlpiIsOptimal( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff current LP solution is stable * * This function should return true if the solution is reliable, i.e., feasible and optimal (or proven * infeasible/unbounded) with respect to the original problem. The optimality status might be with respect to a scaled * version of the problem, but the solution might not be feasible to the unscaled original problem; in this case, * SCIPlpiIsStable() should return false. */ SCIP_EXPORT SCIP_Bool SCIPlpiIsStable( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff the objective limit was reached */ SCIP_EXPORT SCIP_Bool SCIPlpiIsObjlimExc( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff the iteration limit was reached */ SCIP_EXPORT SCIP_Bool SCIPlpiIsIterlimExc( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns TRUE iff the time limit was reached */ SCIP_EXPORT SCIP_Bool SCIPlpiIsTimelimExc( SCIP_LPI* lpi /**< LP interface structure */ ); /** returns the internal solution status of the solver */ SCIP_EXPORT int SCIPlpiGetInternalStatus( SCIP_LPI* lpi /**< LP interface structure */ ); /** tries to reset the internal status of the LP solver in order to ignore an instability of the last solving call */ SCIP_EXPORT SCIP_RETCODE SCIPlpiIgnoreInstability( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_Bool* success /**< pointer to store, whether the instability could be ignored */ ); /** gets objective value of solution */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetObjval( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_Real* objval /**< stores the objective value */ ); /** gets primal and dual solution vectors for feasible LPs * * Before calling this function, the caller must ensure that the LP has been solved to optimality, i.e., that * SCIPlpiIsOptimal() returns true. */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetSol( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_Real* objval, /**< stores the objective value, may be NULL if not needed */ SCIP_Real* primsol, /**< primal solution vector, may be NULL if not needed */ SCIP_Real* dualsol, /**< dual solution vector, may be NULL if not needed */ SCIP_Real* activity, /**< row activity vector, may be NULL if not needed */ SCIP_Real* redcost /**< reduced cost vector, may be NULL if not needed */ ); /** gets primal ray for unbounded LPs */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetPrimalRay( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_Real* ray /**< primal ray */ ); /** gets dual Farkas proof for infeasibility */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetDualfarkas( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_Real* dualfarkas /**< dual Farkas row multipliers */ ); /** gets the number of LP iterations of the last solve call */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetIterations( SCIP_LPI* lpi, /**< LP interface structure */ int* iterations /**< pointer to store the number of iterations of the last solve call */ ); /** gets information about the quality of an LP solution * * Such information is usually only available, if also a (maybe not optimal) solution is available. * The LPI should return SCIP_INVALID for @p quality, if the requested quantity is not available. */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetRealSolQuality( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_LPSOLQUALITY qualityindicator, /**< indicates which quality should be returned */ SCIP_Real* quality /**< pointer to store quality number */ ); /**@} */ /* * LP Basis Methods */ /**@name LP Basis Methods */ /**@{ */ /** gets current basis status for columns and rows; arrays must be large enough to store the basis status */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetBase( SCIP_LPI* lpi, /**< LP interface structure */ int* cstat, /**< array to store column basis status, or NULL */ int* rstat /**< array to store row basis status, or NULL */ ); /** sets current basis status for columns and rows */ SCIP_EXPORT SCIP_RETCODE SCIPlpiSetBase( SCIP_LPI* lpi, /**< LP interface structure */ const int* cstat, /**< array with column basis status */ const int* rstat /**< array with row basis status */ ); /** returns the indices of the basic columns and rows; basic column n gives value n, basic row m gives value -1-m */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetBasisInd( SCIP_LPI* lpi, /**< LP interface structure */ int* bind /**< pointer to store basis indices ready to keep number of rows entries */ ); /** get row of inverse basis matrix B^-1 * * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated; * see also the explanation in lpi.h. */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetBInvRow( SCIP_LPI* lpi, /**< LP interface structure */ int r, /**< row number */ SCIP_Real* coef, /**< pointer to store the coefficients of the row */ int* inds, /**< array to store the non-zero indices, or NULL */ int* ninds /**< pointer to store the number of non-zero indices, or NULL * (-1: if we do not store sparsity information) */ ); /** get column of inverse basis matrix B^-1 * * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated; * see also the explanation in lpi.h. */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetBInvCol( SCIP_LPI* lpi, /**< LP interface structure */ int c, /**< column number of B^-1; this is NOT the number of the column in the LP; * you have to call SCIPlpiGetBasisInd() to get the array which links the * B^-1 column numbers to the row and column numbers of the LP! * c must be between 0 and nrows-1, since the basis has the size * nrows * nrows */ SCIP_Real* coef, /**< pointer to store the coefficients of the column */ int* inds, /**< array to store the non-zero indices, or NULL */ int* ninds /**< pointer to store the number of non-zero indices, or NULL * (-1: if we do not store sparsity information) */ ); /** get row of inverse basis matrix times constraint matrix B^-1 * A * * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated; * see also the explanation in lpi.h. */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetBInvARow( SCIP_LPI* lpi, /**< LP interface structure */ int r, /**< row number */ const SCIP_Real* binvrow, /**< row in (A_B)^-1 from prior call to SCIPlpiGetBInvRow(), or NULL */ SCIP_Real* coef, /**< vector to return coefficients of the row */ int* inds, /**< array to store the non-zero indices, or NULL */ int* ninds /**< pointer to store the number of non-zero indices, or NULL * (-1: if we do not store sparsity information) */ ); /** get column of inverse basis matrix times constraint matrix B^-1 * A * * @note The LP interface defines slack variables to have coefficient +1. This means that if, internally, the LP solver * uses a -1 coefficient, then rows associated with slacks variables whose coefficient is -1, should be negated; * see also the explanation in lpi.h. */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetBInvACol( SCIP_LPI* lpi, /**< LP interface structure */ int c, /**< column number */ SCIP_Real* coef, /**< vector to return coefficients of the column */ int* inds, /**< array to store the non-zero indices, or NULL */ int* ninds /**< pointer to store the number of non-zero indices, or NULL * (-1: if we do not store sparsity information) */ ); /**@} */ /* * LPi State Methods */ /**@name LPi State Methods */ /**@{ */ /** stores LPi state (like basis information) into lpistate object */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetState( SCIP_LPI* lpi, /**< LP interface structure */ BMS_BLKMEM* blkmem, /**< block memory */ SCIP_LPISTATE** lpistate /**< pointer to LPi state information (like basis information) */ ); /** loads LPi state (like basis information) into solver; note that the LP might have been extended with additional * columns and rows since the state was stored with SCIPlpiGetState() */ SCIP_EXPORT SCIP_RETCODE SCIPlpiSetState( SCIP_LPI* lpi, /**< LP interface structure */ BMS_BLKMEM* blkmem, /**< block memory */ const SCIP_LPISTATE* lpistate /**< LPi state information (like basis information), or NULL */ ); /** clears current LPi state (like basis information) of the solver */ SCIP_EXPORT SCIP_RETCODE SCIPlpiClearState( SCIP_LPI* lpi /**< LP interface structure */ ); /** frees LPi state information */ SCIP_EXPORT SCIP_RETCODE SCIPlpiFreeState( SCIP_LPI* lpi, /**< LP interface structure */ BMS_BLKMEM* blkmem, /**< block memory */ SCIP_LPISTATE** lpistate /**< pointer to LPi state information (like basis information) */ ); /** checks, whether the given LPi state contains simplex basis information */ SCIP_EXPORT SCIP_Bool SCIPlpiHasStateBasis( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_LPISTATE* lpistate /**< LPi state information (like basis information) */ ); /** reads LPi state (like basis information from a file */ SCIP_EXPORT SCIP_RETCODE SCIPlpiReadState( SCIP_LPI* lpi, /**< LP interface structure */ const char* fname /**< file name */ ); /** writes LPi state (i.e. basis information) to a file */ SCIP_EXPORT SCIP_RETCODE SCIPlpiWriteState( SCIP_LPI* lpi, /**< LP interface structure */ const char* fname /**< file name */ ); /**@} */ /* * LPi Pricing Norms Methods */ /**@name LPi Pricing Norms Methods */ /**@{ */ /** stores LPi pricing norms into lpinorms object */ SCIP_RETCODE SCIPlpiGetNorms( SCIP_LPI* lpi, /**< LP interface structure */ BMS_BLKMEM* blkmem, /**< block memory */ SCIP_LPINORMS** lpinorms /**< pointer to LPi pricing norms information */ ); /** loads LPi pricing norms into solver; note that the LP might have been extended with additional * columns and rows since the norms were stored with SCIPlpiGetNorms() */ SCIP_RETCODE SCIPlpiSetNorms( SCIP_LPI* lpi, /**< LP interface structure */ BMS_BLKMEM* blkmem, /**< block memory */ const SCIP_LPINORMS* lpinorms /**< LPi pricing norms information, or NULL */ ); /** frees LPi pricing norms information */ SCIP_RETCODE SCIPlpiFreeNorms( SCIP_LPI* lpi, /**< LP interface structure */ BMS_BLKMEM* blkmem, /**< block memory */ SCIP_LPINORMS** lpinorms /**< pointer to LPi pricing norms information, or NULL */ ); /**@} */ /* * Parameter Methods */ /**@name Parameter Methods */ /**@{ */ /** gets integer parameter of LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetIntpar( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_LPPARAM type, /**< parameter number */ int* ival /**< buffer to store the parameter value */ ); /** sets integer parameter of LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiSetIntpar( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_LPPARAM type, /**< parameter number */ int ival /**< parameter value */ ); /** gets floating point parameter of LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiGetRealpar( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_LPPARAM type, /**< parameter number */ SCIP_Real* dval /**< buffer to store the parameter value */ ); /** sets floating point parameter of LP */ SCIP_EXPORT SCIP_RETCODE SCIPlpiSetRealpar( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_LPPARAM type, /**< parameter number */ SCIP_Real dval /**< parameter value */ ); /** interrupts the currently ongoing lp solve or disables the interrupt */ SCIP_EXPORT SCIP_RETCODE SCIPlpiInterrupt( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_Bool interrupt /**< TRUE if interrupt should be set, FALSE if it should be disabled */ ); /**@} */ /* * Numerical Methods */ /**@name Numerical Methods */ /**@{ */ /** returns value treated as infinity in the LP solver */ SCIP_EXPORT SCIP_Real SCIPlpiInfinity( SCIP_LPI* lpi /**< LP interface structure */ ); /** checks if given value is treated as infinity in the LP solver */ SCIP_EXPORT SCIP_Bool SCIPlpiIsInfinity( SCIP_LPI* lpi, /**< LP interface structure */ SCIP_Real val /**< value to be checked for infinity */ ); /**@} */ /* * File Interface Methods */ /**@name File Interface Methods */ /**@{ */ /** reads LP from a file */ SCIP_EXPORT SCIP_RETCODE SCIPlpiReadLP( SCIP_LPI* lpi, /**< LP interface structure */ const char* fname /**< file name */ ); /** writes LP to a file */ SCIP_EXPORT SCIP_RETCODE SCIPlpiWriteLP( SCIP_LPI* lpi, /**< LP interface structure */ const char* fname /**< file name */ ); /**@} */ /**@} */ #ifdef __cplusplus } #endif #endif