/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* 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 scip_lp.h * @ingroup PUBLICCOREAPI * @brief public methods for the LP relaxation, rows and columns * @author Tobias Achterberg * @author Timo Berthold * @author Thorsten Koch * @author Alexander Martin * @author Marc Pfetsch * @author Kati Wolter * @author Gregor Hendel * @author Leona Gottwald */ /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ #ifndef __SCIP_SCIP_LP_H__ #define __SCIP_SCIP_LP_H__ #include "lpi/type_lpi.h" #include "scip/def.h" #include "scip/type_cons.h" #include "scip/type_lp.h" #include "scip/type_misc.h" #include "scip/type_retcode.h" #include "scip/type_scip.h" #include "scip/type_sepa.h" #include "scip/type_sol.h" #include "scip/type_var.h" #ifdef __cplusplus extern "C" { #endif /**@addtogroup PublicLPMethods * * @{ */ /** returns, whether the LP was or is to be solved in the current node * * @return whether the LP was or is to be solved in the current node. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Bool SCIPhasCurrentNodeLP( SCIP* scip /**< SCIP data structure */ ); /** returns, whether the LP of the current node is already constructed * * @return whether the LP of the current node is already constructed. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Bool SCIPisLPConstructed( SCIP* scip /**< SCIP data structure */ ); /** makes sure that the LP of the current node is loaded and may be accessed through the LP information methods * * @warning Contructing the LP might change the amount of variables known in the transformed problem and therefore also * the variables array of SCIP (returned by SCIPgetVars() and SCIPgetVarsData()), so it might be necessary to * call one of the later method after this one * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPconstructLP( SCIP* scip, /**< SCIP data structure */ SCIP_Bool* cutoff /**< pointer to store whether the node can be cut off */ ); /** makes sure that the LP of the current node is flushed * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPflushLP( SCIP* scip /**< SCIP data structure */ ); /** gets solution status of current LP * * @return the solution status of current LP. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_LPSOLSTAT SCIPgetLPSolstat( SCIP* scip /**< SCIP data structure */ ); /** returns whether the current LP solution passed the primal feasibility check * * @returns whether the current LP solution passed the primal feasibility check. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Bool SCIPisLPPrimalReliable( SCIP* scip /**< SCIP data structure */ ); /** returns whether the current LP solution passed the dual feasibility check * * @returns whether the current LP solution passed the dual feasibility check. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Bool SCIPisLPDualReliable( SCIP* scip /**< SCIP data structure */ ); /** returns whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound * * @return whether the current lp is a relaxation of the current problem and its optimal objective value is a local lower bound. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Bool SCIPisLPRelax( SCIP* scip /**< SCIP data structure */ ); /** gets objective value of current LP (which is the sum of column and loose objective value) * * @return the objective value of current LP (which is the sum of column and loose objective value). * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * @note This method returns the objective value of the current LP solution, which might be primal or dual infeasible * if a limit was hit during solving. It must not be used as a dual bound if the LP solution status returned by * SCIPgetLPSolstat() is SCIP_LPSOLSTAT_ITERLIMIT or SCIP_LPSOLSTAT_TIMELIMIT. * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetLPObjval( SCIP* scip /**< SCIP data structure */ ); /** gets part of objective value of current LP that results from COLUMN variables only * * @return the part of objective value of current LP that results from COLUMN variables only. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetLPColumnObjval( SCIP* scip /**< SCIP data structure */ ); /** gets part of objective value of current LP that results from LOOSE variables only * * @return part of objective value of current LP that results from LOOSE variables only. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetLPLooseObjval( SCIP* scip /**< SCIP data structure */ ); /** gets the global pseudo objective value; that is all variables set to their best (w.r.t. the objective * function) global bound * * @return the global pseudo objective value; that is all variables set to their best (w.r.t. the objective * function) global bound. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetGlobalPseudoObjval( SCIP* scip /**< SCIP data structure */ ); /** gets the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the * objective function) local bound * * @return the pseudo objective value for the current search node; that is all variables set to their best (w.r.t. the * objective function) local bound. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetPseudoObjval( SCIP* scip /**< SCIP data structure */ ); /** returns whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound * * @return whether the root lp is a relaxation of the problem and its optimal objective value is a global lower bound. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Bool SCIPisRootLPRelax( SCIP* scip /**< SCIP data structure */ ); /** gets the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved * * @return the objective value of the root node LP or SCIP_INVALID if the root node LP was not (yet) solved. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetLPRootObjval( SCIP* scip /**< SCIP data structure */ ); /** gets part of the objective value of the root node LP that results from COLUMN variables only; * returns SCIP_INVALID if the root node LP was not (yet) solved * * @return the part of the objective value of the root node LP that results from COLUMN variables only; * or SCIP_INVALID if the root node LP was not (yet) solved. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetLPRootColumnObjval( SCIP* scip /**< SCIP data structure */ ); /** gets part of the objective value of the root node LP that results from LOOSE variables only; * returns SCIP_INVALID if the root node LP was not (yet) solved * * @return the part of the objective value of the root node LP that results from LOOSE variables only; * or SCIP_INVALID if the root node LP was not (yet) solved. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetLPRootLooseObjval( SCIP* scip /**< SCIP data structure */ ); /** gets current primal feasibility tolerance of LP */ SCIP_EXPORT SCIP_Real SCIPgetLPFeastol( SCIP* scip /**< SCIP data structure */ ); /** sets primal feasibility tolerance of LP */ SCIP_EXPORT void SCIPsetLPFeastol( SCIP* scip, /**< SCIP data structure */ SCIP_Real newfeastol /**< new primal feasibility tolerance for LP */ ); /** resets primal feasibility tolerance of LP * * Sets primal feasibility tolerance to min of numerics/lpfeastolfactor * numerics/feastol and relaxfeastol. */ SCIP_EXPORT void SCIPresetLPFeastol( SCIP* scip /**< SCIP data structure */ ); /** gets current LP columns along with the current number of LP columns * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPgetLPColsData( SCIP* scip, /**< SCIP data structure */ SCIP_COL*** cols, /**< pointer to store the array of LP columns, or NULL */ int* ncols /**< pointer to store the number of LP columns, or NULL */ ); /** gets current LP columns * * @return the current LP columns. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_COL** SCIPgetLPCols( SCIP* scip /**< SCIP data structure */ ); /** gets current number of LP columns * * @return the current number of LP columns. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT int SCIPgetNLPCols( SCIP* scip /**< SCIP data structure */ ); /** gets current number of unfixed LP columns * * @return the current number of unfixed LP columns. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT int SCIPgetNUnfixedLPCols( SCIP* scip /**< SCIP data structure */ ); /** gets current LP rows along with the current number of LP rows * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPgetLPRowsData( SCIP* scip, /**< SCIP data structure */ SCIP_ROW*** rows, /**< pointer to store the array of LP rows, or NULL */ int* nrows /**< pointer to store the number of LP rows, or NULL */ ); /** gets current LP rows * * @return the current LP rows. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_ROW** SCIPgetLPRows( SCIP* scip /**< SCIP data structure */ ); /** gets current number of LP rows * * @return the current number of LP rows. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT int SCIPgetNLPRows( SCIP* scip /**< SCIP data structure */ ); /** returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing * * @return TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present * in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Bool SCIPallColsInLP( SCIP* scip /**< SCIP data structure */ ); /** returns whether the current LP solution is basic, i.e. is defined by a valid simplex basis * * @return whether the current LP solution is basic, i.e. is defined by a valid simplex basis. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Bool SCIPisLPSolBasic( SCIP* scip /**< SCIP data structure */ ); /** gets all indices of basic columns and rows: index i >= 0 corresponds to column i, index i < 0 to row -i-1 * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPgetLPBasisInd( SCIP* scip, /**< SCIP data structure */ int* basisind /**< pointer to store basis indices ready to keep number of rows entries */ ); /** gets a row from the inverse basis matrix B^-1 * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvRow( SCIP* scip, /**< SCIP data structure */ int r, /**< row number */ SCIP_Real* coefs, /**< array 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 informations) */ ); /** gets a column from the inverse basis matrix B^-1 * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvCol( SCIP* scip, /**< SCIP data structure */ int c, /**< column number of B^-1; this is NOT the number of the column in the LP * returned by SCIPcolGetLPPos(); you have to call SCIPgetBasisInd() * 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* coefs, /**< array 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 informations) */ ); /** gets a row from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A) * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvARow( SCIP* scip, /**< SCIP data structure */ int r, /**< row number */ SCIP_Real* binvrow, /**< row in B^-1 from prior call to SCIPgetLPBInvRow(), or NULL */ SCIP_Real* coefs, /**< array 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 informations) */ ); /** gets a column from the product of inverse basis matrix B^-1 and coefficient matrix A (i.e. from B^-1 * A), * i.e., it computes B^-1 * A_c with A_c being the c'th column of A * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPgetLPBInvACol( SCIP* scip, /**< SCIP data structure */ int c, /**< column number which can be accessed by SCIPcolGetLPPos() */ SCIP_Real* coefs, /**< array 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 informations) */ ); /** calculates a weighted sum of all LP rows; for negative weights, the left and right hand side of the corresponding * LP row are swapped in the summation * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPsumLPRows( SCIP* scip, /**< SCIP data structure */ SCIP_Real* weights, /**< row weights in row summation */ SCIP_REALARRAY* sumcoef, /**< array to store sum coefficients indexed by variables' probindex */ SCIP_Real* sumlhs, /**< pointer to store the left hand side of the row summation */ SCIP_Real* sumrhs /**< pointer to store the right hand side of the row summation */ ); /** interrupts or disables the interrupt of the currently ongoing lp solve; if the lp is not currently constructed just returns with no effect * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPinterruptLP( SCIP* scip, /**< SCIP data structure */ SCIP_Bool interrupt /**< TRUE if interrupt should be set, FALSE if it should be disabled */ ); /** writes current LP to a file * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPwriteLP( SCIP* scip, /**< SCIP data structure */ const char* filename /**< file name */ ); /** writes MIP relaxation of the current branch-and-bound node to a file * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPwriteMIP( SCIP* scip, /**< SCIP data structure */ const char* filename, /**< file name */ SCIP_Bool genericnames, /**< should generic names like x_i and row_j be used in order to avoid * troubles with reserved symbols? */ SCIP_Bool origobj, /**< should the original objective function be used? */ SCIP_Bool lazyconss /**< output removable rows as lazy constraints? */ ); /** gets the LP interface of SCIP; * with the LPI you can use all of the methods defined in lpi/lpi.h; * * @warning You have to make sure, that the full internal state of the LPI does not change or is recovered completely * after the end of the method that uses the LPI. In particular, if you manipulate the LP or its solution * (e.g. by calling one of the SCIPlpiAdd...() or one of the SCIPlpiSolve...() methods), you have to check in * advance with SCIPlpiWasSolved() whether the LP is currently solved. If this is the case, you have to make * sure, the internal solution status is recovered completely at the end of your method. This can be achieved * by getting the LPI state before applying any LPI manipulations with SCIPlpiGetState() and restoring it * afterwards with SCIPlpiSetState() and SCIPlpiFreeState(). Additionally you have to resolve the LP with the * appropriate SCIPlpiSolve...() call in order to reinstall the internal solution status. * * @warning Make also sure, that all parameter values that you have changed are set back to their original values. * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_SOLVED * - \ref SCIP_STAGE_EXITSOLVE * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPgetLPI( SCIP* scip, /**< SCIP data structure */ SCIP_LPI** lpi /**< pointer to store the LP interface */ ); /** Displays quality information about the current LP solution. An LP solution need to be available. Information printed * is subject to what the LP solver supports * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_INIT * - \ref SCIP_STAGE_PROBLEM * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_SOLVED * - \ref SCIP_STAGE_FREE * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. * * @note The printing process is done via the message handler system. */ SCIP_EXPORT SCIP_RETCODE SCIPprintLPSolutionQuality( SCIP* scip, /**< SCIP data structure */ FILE* file /**< output file (or NULL for standard output) */ ); /** compute relative interior point to current LP * @see SCIPlpComputeRelIntPoint * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_SOLVED * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPcomputeLPRelIntPoint( SCIP* scip, /**< SCIP data structure */ SCIP_Bool relaxrows, /**< should the rows be relaxed */ SCIP_Bool inclobjcutoff, /**< should a row for the objective cutoff be included */ SCIP_Real timelimit, /**< time limit for LP solver */ int iterlimit, /**< iteration limit for LP solver */ SCIP_SOL** point /**< relative interior point on exit */ ); /**@} */ /**@addtogroup PublicColumnMethods * * @{ */ /** returns the reduced costs of a column in the last (feasible) LP * * @return the reduced costs of a column in the last (feasible) LP * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_SOLVED * * @note calling this method in SCIP_STAGE_SOLVED is only recommended to experienced users and should only be called * for pure LP instances (without presolving) * * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled. */ SCIP_EXPORT SCIP_Real SCIPgetColRedcost( SCIP* scip, /**< SCIP data structure */ SCIP_COL* col /**< LP column */ ); /** returns the Farkas coefficient of a column in the last (infeasible) LP * * @return the Farkas coefficient of a column in the last (infeasible) LP * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetColFarkasCoef( SCIP* scip, /**< SCIP data structure */ SCIP_COL* col /**< LP column */ ); /** marks a column to be not removable from the LP in the current node * * @pre this method can be called in the following stage of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT void SCIPmarkColNotRemovableLocal( SCIP* scip, /**< SCIP data structure */ SCIP_COL* col /**< LP column */ ); /**@} */ /**@addtogroup PublicRowMethods * * @{ */ /** creates and captures an LP row from a constraint handler * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcreateRowConshdlr( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row, /**< pointer to row */ SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */ const char* name, /**< name of row */ int len, /**< number of nonzeros in the row */ SCIP_COL** cols, /**< array with columns of row entries */ SCIP_Real* vals, /**< array with coefficients of row entries */ SCIP_Real lhs, /**< left hand side of row */ SCIP_Real rhs, /**< right hand side of row */ SCIP_Bool local, /**< is row only valid locally? */ SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ ); /** creates and captures an LP row from a constraint * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcreateRowCons( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row, /**< pointer to row */ SCIP_CONS* cons, /**< constraint that creates the row */ const char* name, /**< name of row */ int len, /**< number of nonzeros in the row */ SCIP_COL** cols, /**< array with columns of row entries */ SCIP_Real* vals, /**< array with coefficients of row entries */ SCIP_Real lhs, /**< left hand side of row */ SCIP_Real rhs, /**< right hand side of row */ SCIP_Bool local, /**< is row only valid locally? */ SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ ); /** creates and captures an LP row from a separator * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcreateRowSepa( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row, /**< pointer to row */ SCIP_SEPA* sepa, /**< separator that creates the row */ const char* name, /**< name of row */ int len, /**< number of nonzeros in the row */ SCIP_COL** cols, /**< array with columns of row entries */ SCIP_Real* vals, /**< array with coefficients of row entries */ SCIP_Real lhs, /**< left hand side of row */ SCIP_Real rhs, /**< right hand side of row */ SCIP_Bool local, /**< is row only valid locally? */ SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ ); /** creates and captures an LP row from an unspecified source * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcreateRowUnspec( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row, /**< pointer to row */ const char* name, /**< name of row */ int len, /**< number of nonzeros in the row */ SCIP_COL** cols, /**< array with columns of row entries */ SCIP_Real* vals, /**< array with coefficients of row entries */ SCIP_Real lhs, /**< left hand side of row */ SCIP_Real rhs, /**< right hand side of row */ SCIP_Bool local, /**< is row only valid locally? */ SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ ); /** creates and captures an LP row * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * * @deprecated Please use SCIPcreateRowConshdlr() or SCIPcreateRowSepa() when calling from a constraint handler or separator in order * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateRowUnspec(). */ SCIP_EXPORT SCIP_DEPRECATED SCIP_RETCODE SCIPcreateRow( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row, /**< pointer to row */ const char* name, /**< name of row */ int len, /**< number of nonzeros in the row */ SCIP_COL** cols, /**< array with columns of row entries */ SCIP_Real* vals, /**< array with coefficients of row entries */ SCIP_Real lhs, /**< left hand side of row */ SCIP_Real rhs, /**< right hand side of row */ SCIP_Bool local, /**< is row only valid locally? */ SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ ); /** creates and captures an LP row without any coefficients from a constraint handler * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcreateEmptyRowConshdlr( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row, /**< pointer to row */ SCIP_CONSHDLR* conshdlr, /**< constraint handler that creates the row */ const char* name, /**< name of row */ SCIP_Real lhs, /**< left hand side of row */ SCIP_Real rhs, /**< right hand side of row */ SCIP_Bool local, /**< is row only valid locally? */ SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ ); /** creates and captures an LP row without any coefficients from a constraint * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcreateEmptyRowCons( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row, /**< pointer to row */ SCIP_CONS* cons, /**< constraint that creates the row */ const char* name, /**< name of row */ SCIP_Real lhs, /**< left hand side of row */ SCIP_Real rhs, /**< right hand side of row */ SCIP_Bool local, /**< is row only valid locally? */ SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ ); /** creates and captures an LP row without any coefficients from a separator * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcreateEmptyRowSepa( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row, /**< pointer to row */ SCIP_SEPA* sepa, /**< separator that creates the row */ const char* name, /**< name of row */ SCIP_Real lhs, /**< left hand side of row */ SCIP_Real rhs, /**< right hand side of row */ SCIP_Bool local, /**< is row only valid locally? */ SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ ); /** creates and captures an LP row without any coefficients from an unspecified source * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcreateEmptyRowUnspec( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row, /**< pointer to row */ const char* name, /**< name of row */ SCIP_Real lhs, /**< left hand side of row */ SCIP_Real rhs, /**< right hand side of row */ SCIP_Bool local, /**< is row only valid locally? */ SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ ); /** creates and captures an LP row without any coefficients * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * * @deprecated Please use SCIPcreateEmptyRowConshdlr() or SCIPcreateEmptyRowSepa() when calling from a constraint handler or separator in order * to facilitate correct statistics. If the call is from neither a constraint handler or separator, use SCIPcreateEmptyRowUnspec(). */ SCIP_EXPORT SCIP_DEPRECATED SCIP_RETCODE SCIPcreateEmptyRow( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row, /**< pointer to row */ const char* name, /**< name of row */ SCIP_Real lhs, /**< left hand side of row */ SCIP_Real rhs, /**< right hand side of row */ SCIP_Bool local, /**< is row only valid locally? */ SCIP_Bool modifiable, /**< is row modifiable during node processing (subject to column generation)? */ SCIP_Bool removable /**< should the row be removed from the LP due to aging or cleanup? */ ); /** increases usage counter of LP row * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcaptureRow( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< row to capture */ ); /** decreases usage counter of LP row, and frees memory if necessary * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_EXITSOLVE */ SCIP_EXPORT SCIP_RETCODE SCIPreleaseRow( SCIP* scip, /**< SCIP data structure */ SCIP_ROW** row /**< pointer to LP row */ ); /** changes left hand side of LP row * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPchgRowLhs( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< LP row */ SCIP_Real lhs /**< new left hand side */ ); /** changes right hand side of LP row * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPchgRowRhs( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< LP row */ SCIP_Real rhs /**< new right hand side */ ); /** informs row, that all subsequent additions of variables to the row should be cached and not directly applied; * after all additions were applied, SCIPflushRowExtensions() must be called; * while the caching of row extensions is activated, information methods of the row give invalid results; * caching should be used, if a row is build with SCIPaddVarToRow() calls variable by variable to increase * the performance * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcacheRowExtensions( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** flushes all cached row extensions after a call of SCIPcacheRowExtensions() and merges coefficients with * equal columns into a single coefficient * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPflushRowExtensions( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** resolves variable to columns and adds them with the coefficient to the row * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variable will not added. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * * @note In case calling this method in the enforcement process of an lp solution, it might be that some variables, * that were not yet in the LP (e.g. dynamic columns) will change their lp solution value returned by SCIP. * For example, a variable, which has a negative objective value, that has no column in the lp yet, is in the lp solution * on its upper bound (variables with status SCIP_VARSTATUS_LOOSE are in an lp solution on it's best bound), but * creating the column, changes the solution value (variable than has status SCIP_VARSTATUS_COLUMN, and the * initialization sets the lp solution value) to 0.0. (This leads to the conclusion that, if a constraint was * violated, the linear relaxation might not be violated anymore.) */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarToRow( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< LP row */ SCIP_VAR* var, /**< problem variable */ SCIP_Real val /**< value of coefficient */ ); /** resolves variables to columns and adds them with the coefficients to the row; * this method caches the row extensions and flushes them afterwards to gain better performance * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @attention If a coefficients absolute value is below the SCIP epsilon tolerance, the variable with its value is not added. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarsToRow( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< LP row */ int nvars, /**< number of variables to add to the row */ SCIP_VAR** vars, /**< problem variables to add */ SCIP_Real* vals /**< values of coefficients */ ); /** resolves variables to columns and adds them with the same single coefficient to the row; * this method caches the row extensions and flushes them afterwards to gain better performance * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @attention If the absolute value of val is below the SCIP epsilon tolerance, the variables will not added. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarsToRowSameCoef( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< LP row */ int nvars, /**< number of variables to add to the row */ SCIP_VAR** vars, /**< problem variables to add */ SCIP_Real val /**< unique value of all coefficients */ ); /** tries to find a value, such that all row coefficients, if scaled with this value become integral * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcalcRowIntegralScalar( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< LP row */ SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */ SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */ SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */ SCIP_Real maxscale, /**< maximal allowed scalar */ SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */ SCIP_Real* intscalar, /**< pointer to store scalar that would make the coefficients integral, or NULL */ SCIP_Bool* success /**< stores whether returned value is valid */ ); /** tries to scale row, s.t. all coefficients (of integer variables) become integral * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPmakeRowIntegral( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< LP row */ SCIP_Real mindelta, /**< minimal relative allowed difference of scaled coefficient s*c and integral i */ SCIP_Real maxdelta, /**< maximal relative allowed difference of scaled coefficient s*c and integral i */ SCIP_Longint maxdnom, /**< maximal denominator allowed in rational numbers */ SCIP_Real maxscale, /**< maximal value to scale row with */ SCIP_Bool usecontvars, /**< should the coefficients of the continuous variables also be made integral? */ SCIP_Bool* success /**< stores whether row could be made rational */ ); /** marks a row to be not removable from the LP in the current node * * @pre this method can be called in the following stage of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT void SCIPmarkRowNotRemovableLocal( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns number of integral columns in the row * * @return number of integral columns in the row * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT int SCIPgetRowNumIntCols( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns minimal absolute value of row vector's non-zero coefficients * * @return minimal absolute value of row vector's non-zero coefficients * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowMinCoef( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns maximal absolute value of row vector's non-zero coefficients * * @return maximal absolute value of row vector's non-zero coefficients * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowMaxCoef( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns the minimal activity of a row w.r.t. the column's bounds * * @return the minimal activity of a row w.r.t. the column's bounds * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowMinActivity( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns the maximal activity of a row w.r.t. the column's bounds * * @return the maximal activity of a row w.r.t. the column's bounds * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowMaxActivity( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** recalculates the activity of a row in the last LP solution * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPrecalcRowLPActivity( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns the activity of a row in the last LP solution * * @return activity of a row in the last LP solution * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowLPActivity( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns the feasibility of a row in the last LP solution * * @return the feasibility of a row in the last LP solution: negative value means infeasibility * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowLPFeasibility( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** recalculates the activity of a row for the current pseudo solution * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPrecalcRowPseudoActivity( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns the activity of a row for the current pseudo solution * * @return the activity of a row for the current pseudo solution * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowPseudoActivity( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns the feasibility of a row for the current pseudo solution: negative value means infeasibility * * @return the feasibility of a row for the current pseudo solution: negative value means infeasibility * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowPseudoFeasibility( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** recalculates the activity of a row in the last LP or pseudo solution * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPrecalcRowActivity( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns the activity of a row in the last LP or pseudo solution * * @return the activity of a row in the last LP or pseudo solution * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowActivity( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns the feasibility of a row in the last LP or pseudo solution * * @return the feasibility of a row in the last LP or pseudo solution * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowFeasibility( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** returns the activity of a row for the given primal solution * * @return the activitiy of a row for the given primal solution * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowSolActivity( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< LP row */ SCIP_SOL* sol /**< primal CIP solution */ ); /** returns the feasibility of a row for the given primal solution * * @return the feasibility of a row for the given primal solution * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowSolFeasibility( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< LP row */ SCIP_SOL* sol /**< primal CIP solution */ ); /** returns the parallelism of row with objective function * * @return 1 is returned if the row is parallel to the objective function and 0 if it is orthogonal * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRowObjParallelism( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< LP row */ ); /** output row to file stream via the message handler system * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre this method can be called in one of the following stages of the SCIP solving process: * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_SOLVED * - \ref SCIP_STAGE_EXITSOLVE */ SCIP_EXPORT SCIP_RETCODE SCIPprintRow( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< LP row */ FILE* file /**< output file (or NULL for standard output) */ ); /**@} */ /**@addtogroup PublicLPDivingMethods * * @{ */ /** initiates LP diving, making methods SCIPchgVarObjDive(), SCIPchgVarLbDive(), and SCIPchgVarUbDive() available * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. * * @note diving is allowed even if the current LP is not flushed, not solved, or not solved to optimality; be aware * that solving the (first) diving LP may take longer than expect and that the latter two cases could stem from * numerical troubles during the last LP solve; because of this, most users will want to call this method only if * SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL */ SCIP_EXPORT SCIP_RETCODE SCIPstartDive( SCIP* scip /**< SCIP data structure */ ); /** quits LP diving and resets bounds and objective values of columns to the current node's values * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPendDive( SCIP* scip /**< SCIP data structure */ ); /** changes cutoffbound in current dive * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPchgCutoffboundDive( SCIP* scip, /**< SCIP data structure */ SCIP_Real newcutoffbound /**< new cutoffbound */ ); /** changes variable's objective value in current dive * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarObjDive( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the objective value for */ SCIP_Real newobj /**< new objective value */ ); /** changes variable's lower bound in current dive * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarLbDive( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound /**< new value for bound */ ); /** changes variable's upper bound in current dive * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarUbDive( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound /**< new value for bound */ ); /** adds a row to the LP in current dive * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPaddRowDive( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row /**< row to be added */ ); /** changes row lhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowLhs() * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPchgRowLhsDive( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< row to change the lhs for */ SCIP_Real newlhs /**< new value for lhs */ ); /** changes row rhs in current dive, change will be undone after diving ends, for permanent changes use SCIPchgRowRhs() * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_RETCODE SCIPchgRowRhsDive( SCIP* scip, /**< SCIP data structure */ SCIP_ROW* row, /**< row to change the lhs for */ SCIP_Real newrhs /**< new value for rhs */ ); /** gets variable's objective value in current dive * * @return the variable's objective value in current dive. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetVarObjDive( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to get the bound for */ ); /** gets variable's lower bound in current dive * * @return the variable's lower bound in current dive. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetVarLbDive( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to get the bound for */ ); /** gets variable's upper bound in current dive * * @return the variable's upper bound in current dive. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Real SCIPgetVarUbDive( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to get the bound for */ ); /** solves the LP of the current dive; no separation or pricing is applied * * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. * * @note be aware that the LP solve may take longer than expected if SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL, * compare the explanation of SCIPstartDive() */ SCIP_EXPORT SCIP_RETCODE SCIPsolveDiveLP( SCIP* scip, /**< SCIP data structure */ int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */ SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */ SCIP_Bool* cutoff /**< pointer to store whether the diving LP was infeasible or the objective * limit was reached (or NULL, if not needed) */ ); /** returns the number of the node in the current branch and bound run, where the last LP was solved in diving * or probing mode * * @return the number of the node in the current branch and bound run, where the last LP was solved in diving * or probing mode. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_SOLVED * - \ref SCIP_STAGE_EXITSOLVE * - \ref SCIP_STAGE_FREETRANS * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Longint SCIPgetLastDivenode( SCIP* scip /**< SCIP data structure */ ); /** returns whether we are in diving mode * * @return whether we are in diving mode. * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_SOLVED * - \ref SCIP_STAGE_EXITSOLVE * - \ref SCIP_STAGE_FREETRANS * * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. */ SCIP_EXPORT SCIP_Bool SCIPinDive( SCIP* scip /**< SCIP data structure */ ); /** computes two measures for dual degeneracy (dual degeneracy rate and variable-constraint ratio) * based on the changes applied when reducing the problem to the optimal face * * returns the dual degeneracy rate, i.e., the share of nonbasic variables with reduced cost 0 * and the variable-constraint ratio, i.e., the number of unfixed variables in relation to the basis size */ SCIP_EXPORT SCIP_RETCODE SCIPgetLPDualDegeneracy( SCIP* scip, /**< SCIP data structure */ SCIP_Real* degeneracy, /**< pointer to store the dual degeneracy rate */ SCIP_Real* varconsratio /**< pointer to store the variable constraint ratio */ ); /**@} */ #ifdef __cplusplus } #endif #endif