/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* */ /* 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_var.h * @ingroup PUBLICCOREAPI * @brief public methods for SCIP variables * @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_VAR_H__ #define __SCIP_SCIP_VAR_H__ #include "scip/def.h" #include "scip/type_cons.h" #include "scip/type_history.h" #include "scip/type_implics.h" #include "scip/type_lp.h" #include "scip/type_misc.h" #include "scip/type_prop.h" #include "scip/type_relax.h" #include "scip/type_result.h" #include "scip/type_retcode.h" #include "scip/type_scip.h" #include "scip/type_sol.h" #include "scip/type_tree.h" #include "scip/type_var.h" /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access * this structure except the interface methods in scip.c. * In optimized mode, the structure is included in scip.h, because some of the methods * are implemented as defines for performance reasons (e.g. the numerical comparisons). * Additionally, the internal "set.h" is included, such that the defines in set.h are * available in optimized mode. */ #ifdef NDEBUG #include "scip/pub_var.h" #endif #ifdef __cplusplus extern "C" { #endif /**@addtogroup PublicVariableMethods * *@{ */ /** creates and captures problem variable; if variable is of integral type, fractional bounds are automatically rounded; * an integer variable with bounds zero and one is automatically converted into a binary variable; * * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the * original objective function value of variables created during the solving process has to be multiplied by * -1, too. * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING * * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar() */ SCIP_EXPORT SCIP_RETCODE SCIPcreateVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR** var, /**< pointer to variable object */ const char* name, /**< name of variable, or NULL for automatic name creation */ SCIP_Real lb, /**< lower bound of variable */ SCIP_Real ub, /**< upper bound of variable */ SCIP_Real obj, /**< objective function value */ SCIP_VARTYPE vartype, /**< type of variable */ SCIP_Bool initial, /**< should var's column be present in the initial root LP? */ SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */ SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */ SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */ SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */ SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */ SCIP_VARDATA* vardata /**< user data for this specific variable, or NULL */ ); /** creates and captures problem variable with optional callbacks and variable data set to NULL, which can be set * afterwards using SCIPvarSetDelorigData(), SCIPvarSetTransData(), * SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData(); sets variable flags initial=TRUE * and removable = FALSE, which can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.; * if variable is of integral type, fractional bounds are automatically rounded; * an integer variable with bounds zero and one is automatically converted into a binary variable; * * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the * original objective function value of variables created during the solving process has to be multiplied by * -1, too. * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING * * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar() */ SCIP_EXPORT SCIP_RETCODE SCIPcreateVarBasic( SCIP* scip, /**< SCIP data structure */ SCIP_VAR** var, /**< pointer to variable object */ const char* name, /**< name of variable, or NULL for automatic name creation */ SCIP_Real lb, /**< lower bound of variable */ SCIP_Real ub, /**< upper bound of variable */ SCIP_Real obj, /**< objective function value */ SCIP_VARTYPE vartype /**< type of variable */ ); /** outputs the variable name to the file stream * * @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_PROBLEM * - \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 */ SCIP_EXPORT SCIP_RETCODE SCIPwriteVarName( SCIP* scip, /**< SCIP data structure */ FILE* file, /**< output file, or NULL for stdout */ SCIP_VAR* var, /**< variable to output */ SCIP_Bool type /**< should the variable type be also posted */ ); /** print the given list of variables to output stream separated by the given delimiter character; * * i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: \, \, ..., \; * * the method SCIPparseVarsList() can parse such a string * * @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_PROBLEM * - \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 * * @note The printing process is done via the message handler system. */ SCIP_EXPORT SCIP_RETCODE SCIPwriteVarsList( SCIP* scip, /**< SCIP data structure */ FILE* file, /**< output file, or NULL for stdout */ SCIP_VAR** vars, /**< variable array to output */ int nvars, /**< number of variables */ SCIP_Bool type, /**< should the variable type be also posted */ char delimiter /**< character which is used for delimitation */ ); /** print the given variables and coefficients as linear sum in the following form * c1 \ + c2 \ ... + cn \ * * This string can be parsed by the method SCIPparseVarsLinearsum(). * * @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_PROBLEM * - \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 * * @note The printing process is done via the message handler system. */ SCIP_EXPORT SCIP_RETCODE SCIPwriteVarsLinearsum( SCIP* scip, /**< SCIP data structure */ FILE* file, /**< output file, or NULL for stdout */ SCIP_VAR** vars, /**< variable array to output */ SCIP_Real* vals, /**< array of coefficients or NULL if all coefficients are 1.0 */ int nvars, /**< number of variables */ SCIP_Bool type /**< should the variable type be also posted */ ); /** print the given terms as signomial in the following form * c1 \^e11 \^e12 ... \^e1n + c2 \^e21 \^e22 ... + ... + cn \^en1 ... * * This string can be parsed by the method SCIPparseVarsPolynomial(). * * @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_PROBLEM * - \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 * * @note The printing process is done via the message handler system. */ SCIP_EXPORT SCIP_RETCODE SCIPwriteVarsPolynomial( SCIP* scip, /**< SCIP data structure */ FILE* file, /**< output file, or NULL for stdout */ SCIP_VAR*** monomialvars, /**< arrays with variables for each monomial */ SCIP_Real** monomialexps, /**< arrays with variable exponents, or NULL if always 1.0 */ SCIP_Real* monomialcoefs, /**< array with monomial coefficients */ int* monomialnvars, /**< array with number of variables for each monomial */ int nmonomials, /**< number of monomials */ SCIP_Bool type /**< should the variable type be also posted */ ); /** parses variable information (in cip format) out of a string; if the parsing process was successful a variable is * created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer * variable with bounds zero and one is automatically converted into a binary variable * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPparseVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR** var, /**< pointer to store the problem variable */ const char* str, /**< string to parse */ SCIP_Bool initial, /**< should var's column be present in the initial root LP? */ SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */ SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */ SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */ SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */ SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */ SCIP_VARDATA* vardata, /**< user data for this specific variable */ char** endptr, /**< pointer to store the final string position if successful */ SCIP_Bool* success /**< pointer store if the paring process was successful */ ); /** parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable * exits and returns the position where the parsing stopped * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPparseVarName( SCIP* scip, /**< SCIP data structure */ const char* str, /**< string to parse */ SCIP_VAR** var, /**< pointer to store the problem variable, or NULL if it does not exit */ char** endptr /**< pointer to store the final string position if successful */ ); /** parse the given string as variable list (here ',' is the delimiter)) (\, \, ..., \) (see * SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING * * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist. * * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens * except that the required size is stored in the corresponding integer; the reason for this approach is that we * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP * memory functions). */ SCIP_EXPORT SCIP_RETCODE SCIPparseVarsList( SCIP* scip, /**< SCIP data structure */ const char* str, /**< string to parse */ SCIP_VAR** vars, /**< array to store the parsed variable */ int* nvars, /**< pointer to store number of parsed variables */ int varssize, /**< size of the variable array */ int* requiredsize, /**< pointer to store the required array size for the active variables */ char** endptr, /**< pointer to store the final string position if successful */ char delimiter, /**< character which is used for delimitation */ SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */ ); /** parse the given string as linear sum of variables and coefficients (c1 \ + c2 \ + ... + cn \) * (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING * * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist. * * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens * except that the required size is stored in the corresponding integer; the reason for this approach is that we * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP * memory functions). */ SCIP_EXPORT SCIP_RETCODE SCIPparseVarsLinearsum( SCIP* scip, /**< SCIP data structure */ const char* str, /**< string to parse */ SCIP_VAR** vars, /**< array to store the parsed variables */ SCIP_Real* vals, /**< array to store the parsed coefficients */ int* nvars, /**< pointer to store number of parsed variables */ int varssize, /**< size of the variable array */ int* requiredsize, /**< pointer to store the required array size for the active variables */ char** endptr, /**< pointer to store the final string position if successful */ SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */ ); /** parse the given string as signomial of variables and coefficients * (c1 \^e11 \^e12 ... \^e1n + c2 \^e21 \^e22 ... + ... + cn \^en1 ...) * (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE * * The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps, * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the * allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since * they use buffer memory that is intended for short term use only. * * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials * are recognized. * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPparseVarsPolynomial( SCIP* scip, /**< SCIP data structure */ const char* str, /**< string to parse */ SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */ SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */ SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */ int** monomialnvars, /**< pointer to store array with number of variables for each monomial */ int* nmonomials, /**< pointer to store number of parsed monomials */ char** endptr, /**< pointer to store the final string position if successful */ SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */ ); /** frees memory allocated when parsing a signomial from a string * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT void SCIPfreeParseVarsPolynomialData( SCIP* scip, /**< SCIP data structure */ SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */ SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */ SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */ int** monomialnvars, /**< pointer to store array with number of variables for each monomial */ int nmonomials /**< pointer to store number of parsed monomials */ ); /** increases usage counter of variable * * @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_PROBLEM * - \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 */ SCIP_EXPORT SCIP_RETCODE SCIPcaptureVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to capture */ ); /** decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed * * @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_PROBLEM * - \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 * * @note the pointer of the variable will be NULLed */ SCIP_EXPORT SCIP_RETCODE SCIPreleaseVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR** var /**< pointer to variable */ ); /** changes the name of a variable * * @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 only be called if @p scip is in stage \ref SCIP_STAGE_PROBLEM * * @note to get the current name of a variable, use SCIPvarGetName() from pub_var.h */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarName( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable */ const char* name /**< new name of constraint */ ); /** gets and captures transformed variable of a given variable; if the variable is not yet transformed, * a new transformed variable for this variable is created * * @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_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 */ SCIP_EXPORT SCIP_RETCODE SCIPtransformVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to get/create transformed variable for */ SCIP_VAR** transvar /**< pointer to store the transformed variable */ ); /** gets and captures transformed variables for an array of variables; * if a variable of the array is not yet transformed, a new transformed variable for this variable is created; * it is possible to call this method with vars == transvars * * @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_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 */ SCIP_EXPORT SCIP_RETCODE SCIPtransformVars( SCIP* scip, /**< SCIP data structure */ int nvars, /**< number of variables to get/create transformed variables for */ SCIP_VAR** vars, /**< array with variables to get/create transformed variables for */ SCIP_VAR** transvars /**< array to store the transformed variables */ ); /** gets corresponding transformed variable of a given variable; * returns NULL as transvar, if transformed variable is not yet existing * * @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_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 */ SCIP_EXPORT SCIP_RETCODE SCIPgetTransformedVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to get transformed variable for */ SCIP_VAR** transvar /**< pointer to store the transformed variable */ ); /** gets corresponding transformed variables for an array of variables; * stores NULL in a transvars slot, if the transformed variable is not yet existing; * it is possible to call this method with vars == transvars, but remember that variables that are not * yet transformed will be replaced with NULL * * @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_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 */ SCIP_EXPORT SCIP_RETCODE SCIPgetTransformedVars( SCIP* scip, /**< SCIP data structure */ int nvars, /**< number of variables to get transformed variables for */ SCIP_VAR** vars, /**< array with variables to get transformed variables for */ SCIP_VAR** transvars /**< array to store the transformed variables */ ); /** gets negated variable x' = lb + ub - x of variable x; negated variable is created, if not yet existing * * @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_PROBLEM * - \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 */ SCIP_EXPORT SCIP_RETCODE SCIPgetNegatedVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to get negated variable for */ SCIP_VAR** negvar /**< pointer to store the negated variable */ ); /** gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing; * in difference to \ref SCIPcreateVar, the negated variable must not be released (unless captured explicitly) * * @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_PROBLEM * - \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 */ SCIP_EXPORT SCIP_RETCODE SCIPgetNegatedVars( SCIP* scip, /**< SCIP data structure */ int nvars, /**< number of variables to get negated variables for */ SCIP_VAR** vars, /**< array of variables to get negated variables for */ SCIP_VAR** negvars /**< array to store the negated variables */ ); /** gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or * multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable * * @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_PROBLEM * - \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 */ SCIP_EXPORT SCIP_RETCODE SCIPgetBinvarRepresentative( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< binary variable to get binary representative for */ SCIP_VAR** repvar, /**< pointer to store the binary representative */ SCIP_Bool* negated /**< pointer to store whether the negation of an active variable was returned */ ); /** gets binary variables that are equal to the given binary variables, and which are either active, fixed, or * multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables * * @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_PROBLEM * - \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 */ SCIP_EXPORT SCIP_RETCODE SCIPgetBinvarRepresentatives( SCIP* scip, /**< SCIP data structure */ int nvars, /**< number of binary variables to get representatives for */ SCIP_VAR** vars, /**< binary variables to get binary representatives for */ SCIP_VAR** repvars, /**< array to store the binary representatives */ SCIP_Bool* negated /**< array to store whether the negation of an active variable was returned */ ); /** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on * * @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_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 */ SCIP_EXPORT SCIP_RETCODE SCIPflattenVarAggregationGraph( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< problem variable */ ); /** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of * active variables, that is b_1*y_1 + ... + b_m*y_m + d. * * If the number of needed active variables is greater than the available slots in the variable array, nothing happens * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable * representation is stored in the variable array, scalar array and constant. * * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been * allocated (e.g., by a C++ 'new' or SCIP functions). * * @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 * - \ref SCIP_STAGE_FREETRANS * * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the * given entries are overwritten. * * @note That method can be used to convert a single variables into variable space of active variables. Therefore call * the method with the linear sum 1.0*x + 0.0. */ SCIP_EXPORT SCIP_RETCODE SCIPgetProbvarLinearSum( SCIP* scip, /**< SCIP data structure */ SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be * overwritten by the variable array y_1, ..., y_m in the linear sum * w.r.t. active variables */ SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the * scalars b_1, ..., b_m in the linear sum of the active variables */ int* nvars, /**< pointer to number of variables in the linear sum which will be * overwritten by the number of variables in the linear sum corresponding * to the active variables */ int varssize, /**< available slots in vars and scalars array which is needed to check if * the array are large enough for the linear sum w.r.t. active * variables */ SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m + * d w.r.t. the active variables */ int* requiredsize, /**< pointer to store the required array size for the linear sum w.r.t. the * active variables */ SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */ ); /** transforms given variable, scalar and constant to the corresponding active, fixed, or * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable, * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation * with only one active variable (this can happen due to fixings after the multi-aggregation), * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0 * * @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 * - \ref SCIP_STAGE_FREETRANS */ SCIP_EXPORT SCIP_RETCODE SCIPgetProbvarSum( SCIP* scip, /**< SCIP data structure */ SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */ SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */ SCIP_Real* constant /**< pointer to constant c in sum a*x + c */ ); /** return for given variables all their active counterparts; all active variables will be pairwise different * @note It does not hold that the first output variable is the active variable for the first input variable. * * @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 * - \ref SCIP_STAGE_FREETRANS */ SCIP_EXPORT SCIP_RETCODE SCIPgetActiveVars( SCIP* scip, /**< SCIP data structure */ SCIP_VAR** vars, /**< variable array with given variables and as output all active * variables, if enough slots exist */ int* nvars, /**< number of given variables, and as output number of active variables, * if enough slots exist */ int varssize, /**< available slots in vars array */ int* requiredsize /**< pointer to store the required array size for the active variables */ ); /** returns the reduced costs of the variable in the current node's LP relaxation; * the current node has to have a feasible LP. * * returns SCIP_INVALID if the variable is active but not in the current LP; * returns 0 if the variable has been aggregated out or fixed in presolving. * * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING * * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled. */ SCIP_EXPORT SCIP_Real SCIPgetVarRedcost( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */ ); /** returns the implied reduced costs of the variable in the current node's LP relaxation; * the current node has to have a feasible LP. * * returns SCIP_INVALID if the variable is active but not in the current LP; * returns 0 if the variable has been aggregated out or fixed in presolving. * * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING * * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled. */ SCIP_EXPORT SCIP_Real SCIPgetVarImplRedcost( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to get reduced costs, should be a column in current node LP */ SCIP_Bool varfixing /**< FALSE if for x == 0, TRUE for x == 1 */ ); /** returns the Farkas coefficient of the variable in the current node's LP relaxation; * the current node has to have an infeasible LP. * * returns SCIP_INVALID if the variable is active but not in the current LP; * returns 0 if the variable has been aggregated out or fixed in presolving. * * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetVarFarkasCoef( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */ ); /** returns lower bound of variable directly before or after the bound change given by the bound change index * was applied */ SCIP_EXPORT SCIP_Real SCIPgetVarLbAtIndex( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */ SCIP_Bool after /**< should the bound change with given index be included? */ ); /** returns upper bound of variable directly before or after the bound change given by the bound change index * was applied */ SCIP_EXPORT SCIP_Real SCIPgetVarUbAtIndex( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */ SCIP_Bool after /**< should the bound change with given index be included? */ ); /** returns lower or upper bound of variable directly before or after the bound change given by the bound change index * was applied */ SCIP_EXPORT SCIP_Real SCIPgetVarBdAtIndex( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */ SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */ SCIP_Bool after /**< should the bound change with given index be included? */ ); /** returns whether the binary variable was fixed at the time given by the bound change index */ SCIP_EXPORT SCIP_Bool SCIPgetVarWasFixedAtIndex( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */ SCIP_Bool after /**< should the bound change with given index be included? */ ); /** gets solution value for variable in current node * * @return solution value for variable in current node * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetVarSol( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to get solution value for */ ); /** gets solution values of multiple variables in current node * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPgetVarSols( SCIP* scip, /**< SCIP data structure */ int nvars, /**< number of variables to get solution value for */ SCIP_VAR** vars, /**< array with variables to get value for */ SCIP_Real* vals /**< array to store solution values of variables */ ); /** sets the solution value of all variables in the global relaxation solution to zero * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPclearRelaxSolVals( SCIP* scip, /**< SCIP data structure */ SCIP_RELAX* relax /**< relaxator data structure */ ); /** sets the value of the given variable in the global relaxation solution; * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation; * You can use SCIPclearRelaxSolVals() to set all values to zero, initially; * after setting all solution values, you have to call SCIPmarkRelaxSolValid() * to inform SCIP that the stored solution is valid * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING * * @note This method incrementally updates the objective value of the relaxation solution. If the whole solution * should be updated, using SCIPsetRelaxSolVals() instead or calling SCIPclearRelaxSolVals() before setting * the first value to reset the solution and the objective value to 0 may help the numerics. */ SCIP_EXPORT SCIP_RETCODE SCIPsetRelaxSolVal( SCIP* scip, /**< SCIP data structure */ SCIP_RELAX* relax, /**< relaxator data structure */ SCIP_VAR* var, /**< variable to set value for */ SCIP_Real val /**< solution value of variable */ ); /** sets the values of the given variables in the global relaxation solution and informs SCIP about the validity * and whether the solution can be enforced via linear cuts; * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation; * the solution is automatically cleared, s.t. all other variables get value 0.0 * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPsetRelaxSolVals( SCIP* scip, /**< SCIP data structure */ SCIP_RELAX* relax, /**< relaxator data structure */ int nvars, /**< number of variables to set relaxation solution value for */ SCIP_VAR** vars, /**< array with variables to set value for */ SCIP_Real* vals, /**< array with solution values of variables */ SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */ ); /** sets the values of the variables in the global relaxation solution to the values in the given primal solution * and informs SCIP about the validity and whether the solution can be enforced via linear cuts; * the relaxation solution can be filled by the relaxation handlers and might be used by heuristics and for separation * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPsetRelaxSolValsSol( SCIP* scip, /**< SCIP data structure */ SCIP_RELAX* relax, /**< relaxator data structure */ SCIP_SOL* sol, /**< primal relaxation solution */ SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */ ); /** returns whether the relaxation solution is valid * * @return TRUE, if the relaxation solution is valid; FALSE, otherwise * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Bool SCIPisRelaxSolValid( SCIP* scip /**< SCIP data structure */ ); /** informs SCIP that the relaxation solution is valid and whether the relaxation can be enforced through linear cuts * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPmarkRelaxSolValid( SCIP* scip, /**< SCIP data structure */ SCIP_RELAX* relax, /**< relaxator data structure that set the current relaxation solution */ SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */ ); /** informs SCIP, that the relaxation solution is invalid * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPmarkRelaxSolInvalid( SCIP* scip /**< SCIP data structure */ ); /** gets the relaxation solution value of the given variable * * @return the relaxation solution value of the given variable * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRelaxSolVal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to get value for */ ); /** gets the relaxation solution objective value * * @return the objective value of the relaxation solution * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_Real SCIPgetRelaxSolObj( SCIP* scip /**< SCIP data structure */ ); /** determine which branching direction should be evaluated first by strong branching * * @return TRUE iff strong branching should first evaluate the down child * */ SCIP_EXPORT SCIP_Bool SCIPisStrongbranchDownFirst( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to determine the branching direction on */ ); /** start strong branching - call before any strong branching * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING * * @note if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created * which allow to perform propagation but also creates some overhead */ SCIP_EXPORT SCIP_RETCODE SCIPstartStrongbranch( SCIP* scip, /**< SCIP data structure */ SCIP_Bool enablepropagation /**< should propagation be done before solving the strong branching LP? */ ); /** end strong branching - call after any strong branching * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPendStrongbranch( SCIP* scip /**< SCIP data structure */ ); /** gets strong branching information on column variable with fractional value * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPgetVarStrongbranchFrac( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to get strong branching values for */ int itlim, /**< iteration limit for strong branchings */ SCIP_Bool idempotent, /**< should scip's state remain the same after the call (statistics, column states...), or should it be updated ? */ 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, or NULL; * otherwise, it can only be used as an estimate value */ SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL; * otherwise, it can only be used as an estimate value */ SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */ SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */ SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an * infeasible downwards branch, or NULL */ SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an * infeasible upwards branch, or NULL */ SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the * solving process should be stopped (e.g., due to a time limit) */ ); /** gets strong branching information with previous domain propagation on column variable * * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch(); * after strong branching was done for all candidate variables, the strong branching mode must be ended by * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be * enabled in the SCIPstartStrongbranch() call. * * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds * can be specified by the parameter @p maxproprounds. * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING * * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because * they are updated w.r.t. the strong branching LP solution. */ SCIP_EXPORT SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to get strong branching values for */ SCIP_Real solval, /**< value of the variable in the current LP solution */ SCIP_Real lpobjval, /**< LP objective value of the current LP solution */ int itlim, /**< iteration limit for strong branchings */ int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter * settings) */ 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, or NULL; * otherwise, it can only be used as an estimate value */ SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL; * otherwise, it can only be used as an estimate value */ SCIP_Longint* ndomredsdown, /**< pointer to store the number of domain reductions down, or NULL */ SCIP_Longint* ndomredsup, /**< pointer to store the number of domain reductions up, or NULL */ SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */ SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */ SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an * infeasible downwards branch, or NULL */ SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an * infeasible upwards branch, or NULL */ SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the * solving process should be stopped (e.g., due to a time limit) */ SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */ SCIP_Real* newubs /**< array to store valid upper bounds for all active variables, or NULL */ ); /** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch * is (val -1.0) and the up brach ins (val +1.0) * * @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_PRESOLVED * - \ref SCIP_STAGE_SOLVING * * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be * marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE. */ SCIP_EXPORT SCIP_RETCODE SCIPgetVarStrongbranchInt( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to get strong branching values for */ int itlim, /**< iteration limit for strong branchings */ SCIP_Bool idempotent, /**< should scip's state remain the same after the call (statistics, column states...), or should it be updated ? */ 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, or NULL; * otherwise, it can only be used as an estimate value */ SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL; * otherwise, it can only be used as an estimate value */ SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */ SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */ SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an * infeasible downwards branch, or NULL */ SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an * infeasible upwards branch, or NULL */ SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the * solving process should be stopped (e.g., due to a time limit) */ ); /** gets strong branching information on column variables with fractional 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_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPgetVarsStrongbranchesFrac( SCIP* scip, /**< SCIP data structure */ SCIP_VAR** vars, /**< variables to get strong branching values for */ int nvars, /**< number of variables */ int itlim, /**< iteration limit for strong branchings */ SCIP_Real* down, /**< stores dual bounds after branching variables down */ SCIP_Real* up, /**< stores dual bounds after branching variables up */ SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL; * otherwise, they can only be used as an estimate value */ SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL; * otherwise, they can only be used as an estimate value */ SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */ SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */ SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for * infeasible downward branches, or NULL */ SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for * infeasible upward branches, or NULL */ SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the * solving process should be stopped (e.g., due to a time limit) */ ); /** gets strong branching information on column variables with integral 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_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPgetVarsStrongbranchesInt( SCIP* scip, /**< SCIP data structure */ SCIP_VAR** vars, /**< variables to get strong branching values for */ int nvars, /**< number of variables */ int itlim, /**< iteration limit for strong branchings */ SCIP_Real* down, /**< stores dual bounds after branching variables down */ SCIP_Real* up, /**< stores dual bounds after branching variables up */ SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL; * otherwise, they can only be used as an estimate value */ SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL; * otherwise, they can only be used as an estimate value */ SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */ SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */ SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for * infeasible downward branches, or NULL */ SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for * infeasible upward branches, or NULL */ SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the * solving process should be stopped (e.g., due to a time limit) */ ); /** get LP solution status of last strong branching call (currently only works for strong branching with propagation) */ SCIP_EXPORT SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat( SCIP* scip, /**< SCIP data structure */ SCIP_BRANCHDIR branchdir /**< branching direction for which LP solution status is requested */ ); /** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call; * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable; * keep in mind, that the returned old values may have nothing to do with the current 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 if @p scip is in one of the following stages: * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_RETCODE SCIPgetVarStrongbranchLast( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to get last strong branching values for */ SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */ SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */ SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL; * otherwise, it can only be used as an estimate value */ SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL; * otherwise, it can only be used as an estimate value */ SCIP_Real* solval, /**< stores LP solution value of variable at last strong branching call, or NULL */ SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */ ); /** sets strong branching information for a column variable * * @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 */ SCIP_EXPORT SCIP_RETCODE SCIPsetVarStrongbranchData( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to set last strong branching values for */ SCIP_Real lpobjval, /**< objective value of the current LP */ SCIP_Real primsol, /**< primal solution value of the column in the current LP */ SCIP_Real down, /**< dual bound after branching column down */ SCIP_Real up, /**< dual bound after branching column up */ SCIP_Bool downvalid, /**< is the returned down value a valid dual bound? */ SCIP_Bool upvalid, /**< is the returned up value a valid dual bound? */ SCIP_Longint iter, /**< total number of strong branching iterations */ int itlim /**< iteration limit applied to the strong branching call */ ); /** rounds the current solution and tries it afterwards; if feasible, adds it to storage * * @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 */ SCIP_EXPORT SCIP_RETCODE SCIPtryStrongbranchLPSol( SCIP* scip, /**< SCIP data structure */ SCIP_Bool* foundsol, /**< stores whether solution was feasible and good enough to keep */ SCIP_Bool* cutoff /**< stores whether solution was cutoff due to exceeding the cutoffbound */ ); /** gets node number of the last node in current branch and bound run, where strong branching was used on the * given variable, or -1 if strong branching was never applied to the variable in current run * * @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_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 */ SCIP_EXPORT SCIP_Longint SCIPgetVarStrongbranchNode( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to get last strong branching node for */ ); /** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after * the LP where the strong branching on this variable was applied; * if strong branching was not yet applied on the variable at the current node, returns INT_MAX * * @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_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 */ SCIP_EXPORT SCIP_Longint SCIPgetVarStrongbranchLPAge( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to get strong branching LP age for */ ); /** gets number of times, strong branching was applied in current run on the given variable * * @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_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 */ SCIP_EXPORT int SCIPgetVarNStrongbranchs( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to get last strong branching node for */ ); /** adds given values to lock numbers of type @p locktype of variable for rounding * * @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_PROBLEM * - \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_EXITSOLVE * - \ref SCIP_STAGE_FREETRANS */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarLocksType( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_LOCKTYPE locktype, /**< type of the variable locks */ int nlocksdown, /**< modification in number of rounding down locks */ int nlocksup /**< modification in number of rounding up locks */ ); /** adds given values to lock numbers of variable for rounding * * @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_PROBLEM * - \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_EXITSOLVE * - \ref SCIP_STAGE_FREETRANS * * @note This method will always add variable locks of type model */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarLocks( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ int nlocksdown, /**< modification in number of rounding down locks */ int nlocksup /**< modification in number of rounding up locks */ ); /** add locks of type @p locktype of variable with respect to the lock status of the constraint and its negation; * this method should be called whenever the lock status of a variable in a constraint changes, for example if * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were * added or removed * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_EXITSOLVE * - \ref SCIP_STAGE_FREETRANS */ SCIP_EXPORT SCIP_RETCODE SCIPlockVarCons( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_CONS* cons, /**< constraint */ SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */ SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */ ); /** remove locks of type @p locktype of variable with respect to the lock status of the constraint and its negation; * this method should be called whenever the lock status of a variable in a constraint changes, for example if * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were * added or removed * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_INITSOLVE * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_EXITSOLVE * - \ref SCIP_STAGE_FREETRANS */ SCIP_EXPORT SCIP_RETCODE SCIPunlockVarCons( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_CONS* cons, /**< constraint */ SCIP_Bool lockdown, /**< should the rounding be unlocked in downwards direction? */ SCIP_Bool lockup /**< should the rounding be unlocked in upwards direction? */ ); /** changes variable's objective value * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_PRESOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarObj( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the objective value for */ SCIP_Real newobj /**< new objective value */ ); /** adds value to variable's objective value * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_PRESOLVED */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarObj( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the objective value for */ SCIP_Real addobj /**< additional objective value */ ); /** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value; * does not change the bounds of the variable * * @return adjusted lower bound for the given variable; the bound of the variable is not changed * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_PROBLEM * - \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 */ SCIP_EXPORT SCIP_Real SCIPadjustedVarLb( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to adjust the bound for */ SCIP_Real lb /**< lower bound value to adjust */ ); /** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value; * does not change the bounds of the variable * * @return adjusted upper bound for the given variable; the bound of the variable is not changed * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_PROBLEM * - \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 */ SCIP_EXPORT SCIP_Real SCIPadjustedVarUb( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to adjust the bound for */ SCIP_Real ub /**< upper bound value to adjust */ ); /** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node; * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such * that in conflict analysis, this change is treated like a branching decision * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarLb( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound /**< new value for bound */ ); /** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node; * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such * that in conflict analysis, this change is treated like a branching decision * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarUb( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound /**< new value for bound */ ); /** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any * inference information in the bound change, such that in conflict analysis, this change is treated like a branching * decision * * @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 only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarLbNode( SCIP* scip, /**< SCIP data structure */ SCIP_NODE* node, /**< node to change bound at, or NULL for current node */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound /**< new value for bound */ ); /** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any * inference information in the bound change, such that in conflict analysis, this change is treated like a branching * decision * * @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 only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarUbNode( SCIP* scip, /**< SCIP data structure */ SCIP_NODE* node, /**< node to change bound at, or NULL for current node */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound /**< new value for bound */ ); /** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound, * if the global bound is better than the local bound * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarLbGlobal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound /**< new value for bound */ ); /** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound, * if the global bound is better than the local bound * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarUbGlobal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound /**< new value for bound */ ); /** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet * * Lazy bounds are bounds that are already enforced by constraints and the objective function. * Setting a lazy lower bound has the consequence that for variables which lower bound equals the lazy lower bound, * the lower bound does not need to be passed on to the LP solver. * This is especially useful in a column generation (branch-and-price) setting. * * @attention If the variable has a global lower bound below lazylb, then the global lower bound is tightened to * lazylb by a call to SCIPchgVarLbGlobal(). * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarLbLazy( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real lazylb /**< the lazy lower bound to be set */ ); /** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet * * Lazy bounds are bounds that are already enforced by constraints and the objective function. * Setting a lazy upper bound has the consequence that for variables which upper bound equals the lazy upper bound, * the upper bound does not need to be passed on to the LP solver. * This is especially useful in a column generation (branch-and-price) setting. * * @attention If the variable has a global upper bound above lazyub, then the global upper bound is tightened to * lazyub by a call to SCIPchgVarUbGlobal(). * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarUbLazy( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real lazyub /**< the lazy lower bound to be set */ ); /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; * doesn't store any inference information in the bound change, such that in conflict analysis, this change * is treated like a branching decision * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPtightenVarLb( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound, /**< new value for bound */ SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */ SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */ SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */ ); /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; * doesn't store any inference information in the bound change, such that in conflict analysis, this change * is treated like a branching decision * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPtightenVarUb( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound, /**< new value for bound */ SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */ SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */ SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */ ); /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change * * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling * SCIPinferVarUbCons * * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via * SCIPgetVars()) gets resorted. * * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPinferVarFixCons( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real fixedval, /**< new value for fixation */ SCIP_CONS* infercons, /**< constraint that deduced the bound change */ int inferinfo, /**< user information for inference to help resolving the conflict */ SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */ SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */ SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */ ); /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; * the given inference constraint is stored, such that the conflict analysis is able to find out the reason * for the deduction of the bound change * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPinferVarLbCons( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound, /**< new value for bound */ SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */ int inferinfo, /**< user information for inference to help resolving the conflict */ SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */ SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */ SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */ ); /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; * the given inference constraint is stored, such that the conflict analysis is able to find out the reason * for the deduction of the bound change * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPinferVarUbCons( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound, /**< new value for bound */ SCIP_CONS* infercons, /**< constraint that deduced the bound change */ int inferinfo, /**< user information for inference to help resolving the conflict */ SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */ SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */ SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */ ); /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node; * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the * deduction of the fixing * * @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_PROBLEM * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPinferBinvarCons( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< binary variable to fix */ SCIP_Bool fixedval, /**< value to fix binary variable to */ SCIP_CONS* infercons, /**< constraint that deduced the fixing */ int inferinfo, /**< user information for inference to help resolving the conflict */ SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */ SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */ ); /** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change * * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling * SCIPinferVarUbProp * * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via * SCIPgetVars()) gets resorted. * * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPinferVarFixProp( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real fixedval, /**< new value for fixation */ SCIP_PROP* inferprop, /**< propagator that deduced the bound change */ int inferinfo, /**< user information for inference to help resolving the conflict */ SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */ SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */ SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */ ); /** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; * the given inference propagator is stored, such that the conflict analysis is able to find out the reason * for the deduction of the bound change * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPinferVarLbProp( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound, /**< new value for bound */ SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */ int inferinfo, /**< user information for inference to help resolving the conflict */ SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */ SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */ SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */ ); /** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value; * the given inference propagator is stored, such that the conflict analysis is able to find out the reason * for the deduction of the bound change * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPinferVarUbProp( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound, /**< new value for bound */ SCIP_PROP* inferprop, /**< propagator that deduced the bound change */ int inferinfo, /**< user information for inference to help resolving the conflict */ SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */ SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */ SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */ ); /** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node; * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the * deduction of the fixing * * @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_PROBLEM * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPinferBinvarProp( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< binary variable to fix */ SCIP_Bool fixedval, /**< value to fix binary variable to */ SCIP_PROP* inferprop, /**< propagator that deduced the fixing */ int inferinfo, /**< user information for inference to help resolving the conflict */ SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */ SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */ ); /** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value; * also tightens the local bound, if the global bound is better than the local bound * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPtightenVarLbGlobal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound, /**< new value for bound */ SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */ SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */ SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */ ); /** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value; * also tightens the local bound, if the global bound is better than the local bound * * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via * SCIPgetVars()) gets resorted. * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING * * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable. */ SCIP_EXPORT SCIP_RETCODE SCIPtightenVarUbGlobal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_Real newbound, /**< new value for bound */ SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */ SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */ SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */ ); /** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables * * This global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is not updated if bounds of aggregation variables are changing * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal. * * @return the global lower bound computed by adding the global bounds from all aggregation variables */ SCIP_EXPORT SCIP_Real SCIPcomputeVarLbGlobal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to compute the bound for */ ); /** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables * * This global bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is not updated if bounds of aggregation variables are changing * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal. * * @return the global upper bound computed by adding the global bounds from all aggregation variables */ SCIP_EXPORT SCIP_Real SCIPcomputeVarUbGlobal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to compute the bound for */ ); /** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables * * This local bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is not updated if bounds of aggregation variables are changing * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal. * * @return the local lower bound computed by adding the global bounds from all aggregation variables */ SCIP_EXPORT SCIP_Real SCIPcomputeVarLbLocal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to compute the bound for */ ); /** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables * * This local bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is not updated if bounds of aggregation variables are changing * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal. * * @return the local upper bound computed by adding the global bounds from all aggregation variables */ SCIP_EXPORT SCIP_Real SCIPcomputeVarUbLocal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to compute the bound for */ ); /** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is * not updated if bounds of aggregation variables are changing * * calling this function for a non-multi-aggregated variable is not allowed */ SCIP_EXPORT SCIP_Real SCIPgetVarMultaggrLbGlobal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to compute the bound for */ ); /** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is * not updated if bounds of aggregation variables are changing * * calling this function for a non-multi-aggregated variable is not allowed */ SCIP_EXPORT SCIP_Real SCIPgetVarMultaggrUbGlobal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to compute the bound for */ ); /** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is * not updated if bounds of aggregation variables are changing * * calling this function for a non-multi-aggregated variable is not allowed */ SCIP_EXPORT SCIP_Real SCIPgetVarMultaggrLbLocal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to compute the bound for */ ); /** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is * not updated if bounds of aggregation variables are changing * * calling this function for a non-multi-aggregated variable is not allowed */ SCIP_EXPORT SCIP_Real SCIPgetVarMultaggrUbLocal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to compute the bound for */ ); #ifdef NDEBUG /* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and * speed up the algorithms. */ #define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbGlobal(scip, var) : SCIPvarGetLbGlobal(var)) #define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbGlobal(scip, var) : SCIPvarGetUbGlobal(var)) #define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbLocal(scip, var) : SCIPvarGetLbLocal(var)) #define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbLocal(scip, var) : SCIPvarGetUbLocal(var)) #endif /** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is * 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 only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPgetVarClosestVlb( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< active problem variable */ SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */ SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */ int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */ ); /** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution; * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is 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 only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPgetVarClosestVub( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< active problem variable */ SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */ SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */ int* closestvubidx /**< pointer to store the index of the closest variable lower bound */ ); /** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z; * if z is binary, the corresponding valid implication for z is also added; * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too; * improves the global bounds of the variable and the vlb variable if possible * * @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_PRESOLVING * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarVlb( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */ SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */ SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */ SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */ int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */ ); /** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z; * if z is binary, the corresponding valid implication for z is also added; * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too; * improves the global bounds of the variable and the vlb variable if possible * * @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_PRESOLVING * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarVub( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */ SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */ SCIP_Real vubconstant, /**< constant d in x <= b*z + d */ SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */ int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */ ); /** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b; * also adds the corresponding implication or variable bound to the implied variable; * if the implication is conflicting, the variable is fixed to the opposite value; * if the variable is already fixed to the given value, the implication is performed immediately; * if the implication is redundant with respect to the variables' global bounds, it is ignored * * @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_PRESOLVING * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarImplication( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */ SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */ SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER) * or y >= b (SCIP_BOUNDTYPE_LOWER) */ SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */ SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */ int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */ ); /** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1; * if a variable appears twice in the same clique, the corresponding implications are performed * * @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_PRESOLVING * - \ref SCIP_STAGE_PRESOLVED * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPaddClique( SCIP* scip, /**< SCIP data structure */ SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */ SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */ int nvars, /**< number of variables in the clique */ SCIP_Bool isequation, /**< is the clique an equation or an inequality? */ SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */ int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */ ); /** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components * * The algorithm performs the following steps: * - recomputes connected components of the clique table, if necessary * - computes a clique partition for every connected component greedily. * - relabels the resulting clique partition such that it satisfies the description below * * afterwards the output array contains one value for each variable, such that two variables got the same value iff they * were assigned to the same clique; * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of * the preceding variables was assigned to clique i-1; * for each clique at most 1 variables can be set to TRUE in a feasible 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 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_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcalcCliquePartition( SCIP*const scip, /**< SCIP data structure */ SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */ int const nvars, /**< number of variables in the clique */ int*const cliquepartition, /**< array of length nvars to store the clique partition */ int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */ ); /** calculates a partition of the given set of binary variables into negated cliques; * afterwards the output array contains one value for each variable, such that two variables got the same value iff they * were assigned to the same negated clique; * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of * the preceding variables was assigned to clique i-1; * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible 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 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_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPcalcNegatedCliquePartition( SCIP*const scip, /**< SCIP data structure */ SCIP_VAR**const vars, /**< binary variables in the clique from which at most one can be set to 1 */ int const nvars, /**< number of variables in the clique */ int*const cliquepartition, /**< array of length nvars to store the clique partition */ int*const ncliques /**< pointer to store the number of cliques actually contained in the partition */ ); /** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques() * * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed * * @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 */ SCIP_EXPORT SCIP_RETCODE SCIPcleanupCliques( SCIP* scip, /**< SCIP data structure */ SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */ ); /** gets the number of cliques in the clique table * * @return number of cliques in the clique table * * @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 */ SCIP_EXPORT int SCIPgetNCliques( SCIP* scip /**< SCIP data structure */ ); /** gets the number of cliques created so far by the cliquetable * * @return number of cliques created so far by the cliquetable * * @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 */ SCIP_EXPORT int SCIPgetNCliquesCreated( SCIP* scip /**< SCIP data structure */ ); /** gets the array of cliques in the clique table * * @return array of cliques in the clique table * * @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 */ SCIP_EXPORT SCIP_CLIQUE** SCIPgetCliques( SCIP* scip /**< SCIP data structure */ ); /** returns whether there is a clique that contains both given variable/value pairs; * the variables must be active binary variables; * if regardimplics is FALSE, only the cliques in the clique table are looked at; * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded * * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise * * @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 * * @note a variable with it's negated variable are NOT! in a clique * @note a variable with itself are in a clique */ SCIP_EXPORT SCIP_Bool SCIPhaveVarsCommonClique( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var1, /**< first variable */ SCIP_Bool value1, /**< value of first variable */ SCIP_VAR* var2, /**< second variable */ SCIP_Bool value2, /**< value of second variable */ SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */ ); /** writes the clique graph to a gml 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_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 * * @note there can be duplicated arcs in the output file * * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges * between such nodes are written. */ SCIP_EXPORT SCIP_RETCODE SCIPwriteCliqueGraph( SCIP* scip, /**< SCIP data structure */ const char* fname, /**< name of file */ SCIP_Bool writenodeweights /**< should we write weights of nodes? */ ); /** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds. * This is an advanced method which should be used with care. * * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed * * @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 */ SCIP_EXPORT SCIP_RETCODE SCIPremoveVarFromGlobalStructures( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to remove from global structures */ ); /** sets the branch factor of the variable; this value can be used in the branching methods to scale the score * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching * * @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_PROBLEM * - \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_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarBranchFactor( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real branchfactor /**< factor to weigh variable's branching score with */ ); /** scales the branch factor of the variable with the given value * * @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_PROBLEM * - \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_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPscaleVarBranchFactor( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real scale /**< factor to scale variable's branching factor with */ ); /** adds the given value to the branch factor of the variable * * @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_PROBLEM * - \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_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarBranchFactor( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real addfactor /**< value to add to the branch factor of the variable */ ); /** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables * with lower priority in selection of branching variable * * @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_PROBLEM * - \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_SOLVING * * @note the default branching priority is 0 */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarBranchPriority( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ int branchpriority /**< branch priority of the variable */ ); /** changes the branch priority of the variable to the given value, if it is larger than the current priority * * @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_PROBLEM * - \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_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPupdateVarBranchPriority( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ int branchpriority /**< new branch priority of the variable, if it is larger than current priority */ ); /** adds the given value to the branch priority of the variable * * @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_PROBLEM * - \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_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPaddVarBranchPriority( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ int addpriority /**< value to add to the branch priority of the variable */ ); /** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards * branch) * * @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_PROBLEM * - \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_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarBranchDirection( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */ ); /** changes type of variable in the problem; * * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData(); * * @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_PROBLEM * - \ref SCIP_STAGE_TRANSFORMING * - \ref SCIP_STAGE_PRESOLVING * * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the * corresponding transformed variable is changed; the type of the original variable does not change * * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get * adjusted w.r.t. to integrality information */ SCIP_EXPORT SCIP_RETCODE SCIPchgVarType( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to change the bound for */ SCIP_VARTYPE vartype, /**< new type of variable */ SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to * integrality condition of the new variable type) */ ); /** in problem creation and solving stage, both bounds of the variable are set to the given value; * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively; * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(), * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid * * @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_PROBLEM * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_SOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPfixVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable to fix */ SCIP_Real fixedval, /**< value to fix variable to */ SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */ SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */ ); /** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(), * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid. * In the first step, the equality is transformed into an equality with active problem variables * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0, * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible * infeasibility) otherwise. * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable. * * The output flags have the following meaning: * - infeasible: the problem is infeasible * - redundant: the equality can be deleted from the constraint set * - aggregated: the aggregation was successfully performed (the variables were not aggregated before) * * @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 only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPaggregateVars( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */ SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */ SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */ SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */ SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */ SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */ SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */ SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */ ); /** converts variable into multi-aggregated variable; this changes the variable array returned from * SCIPgetVars() and SCIPgetVarsData(); * * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables * implies integrality on the aggregated variable. * * The output flags have the following meaning: * - infeasible: the problem is infeasible * - aggregated: the aggregation was successfully performed (the variables were not aggregated before) * * @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 only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING */ SCIP_EXPORT SCIP_RETCODE SCIPmultiaggregateVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable x to aggregate */ int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */ SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */ SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */ SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */ SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */ SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */ ); /** returns whether aggregation of variables is not allowed */ SCIP_EXPORT SCIP_Bool SCIPdoNotAggr( SCIP* scip /**< SCIP data structure */ ); /** returns whether multi-aggregation is disabled */ SCIP_EXPORT SCIP_Bool SCIPdoNotMultaggr( SCIP* scip /**< SCIP data structure */ ); /** returns whether variable is not allowed to be aggregated */ SCIP_EXPORT SCIP_Bool SCIPdoNotAggrVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable x to aggregate */ ); /** returns whether variable is not allowed to be multi-aggregated */ SCIP_EXPORT SCIP_Bool SCIPdoNotMultaggrVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable x to aggregate */ ); /** returns whether dual reductions are allowed during propagation and presolving * * @deprecated Please use SCIPallowStrongDualReds() */ SCIP_EXPORT SCIP_DEPRECATED SCIP_Bool SCIPallowDualReds( SCIP* scip /**< SCIP data structure */ ); /** returns whether strong dual reductions are allowed during propagation and presolving * * @note A reduction is called strong dual, if it may discard feasible/optimal solutions, but leaves at least one * optimal solution intact. Often such reductions are based on analyzing the objective function and variable * locks. */ SCIP_EXPORT SCIP_Bool SCIPallowStrongDualReds( SCIP* scip /**< SCIP data structure */ ); /** returns whether propagation w.r.t. current objective is allowed * * @deprecated Please use SCIPallowWeakDualReds() */ SCIP_EXPORT SCIP_DEPRECATED SCIP_Bool SCIPallowObjProp( SCIP* scip /**< SCIP data structure */ ); /** returns whether weak dual reductions are allowed during propagation and presolving * * @note A reduction is called weak dual, if it may discard feasible solutions, but leaves at all optimal solutions * intact. Often such reductions are based on analyzing the objective function, reduced costs, and/or dual LPs. */ SCIP_EXPORT SCIP_Bool SCIPallowWeakDualReds( SCIP* scip /**< SCIP data structure */ ); /** marks the variable that it must not be aggregated * * @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_TRANSFORMING * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not * aggregated that this is will be the case. */ SCIP_EXPORT SCIP_RETCODE SCIPmarkDoNotAggrVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to delete */ ); /** marks the variable that it must not be multi-aggregated * * @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_TRANSFORMING * - \ref SCIP_STAGE_TRANSFORMED * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not * multi-aggregated that this is will be the case. */ SCIP_EXPORT SCIP_RETCODE SCIPmarkDoNotMultaggrVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< variable to delete */ ); /** enables the collection of statistics for a variable * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_PROBLEM * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT void SCIPenableVarHistory( SCIP* scip /**< SCIP data structure */ ); /** disables the collection of any statistic for a variable * * @pre This method can be called if @p scip is in one of the following stages: * - \ref SCIP_STAGE_PROBLEM * - \ref SCIP_STAGE_INITPRESOLVE * - \ref SCIP_STAGE_PRESOLVING * - \ref SCIP_STAGE_EXITPRESOLVE * - \ref SCIP_STAGE_SOLVING * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT void SCIPdisableVarHistory( SCIP* scip /**< SCIP data structure */ ); /** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the * variable's solution value and resulting change of "objdelta" in the in the LP's objective value; * the update is ignored, if the objective value difference is infinite * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_RETCODE SCIPupdateVarPseudocost( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */ SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */ SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */ ); /** gets the variable's pseudo cost value for the given change of the variable's LP value * * @return the variable's pseudo cost value for the given change of the variable's LP value * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarPseudocostVal( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */ ); /** gets the variable's pseudo cost value for the given change of the variable's LP value, * only using the pseudo cost information of the current run * * @return the variable's pseudo cost value for the given change of the variable's LP value, * only using the pseudo cost information of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarPseudocostValCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */ ); /** gets the variable's pseudo cost value for the given direction * * @return the variable's pseudo cost value for the given direction * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarPseudocost( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** gets the variable's pseudo cost value for the given direction, * only using the pseudo cost information of the current run * * @return the variable's pseudo cost value for the given direction, * only using the pseudo cost information of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarPseudocostCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction * * @return the variable's (possible fractional) number of pseudo cost updates for the given direction * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarPseudocostCount( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** gets the variable's (possible fractional) number of pseudo cost updates for the given direction, * only using the pseudo cost information of the current run * * @return the variable's (possible fractional) number of pseudo cost updates for the given direction, * only using the pseudo cost information of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarPseudocostCountCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run * * @return returns the (corrected) variance of pseudo code information collected so far. * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarPseudocostVariance( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */ SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */ ); /** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs * * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability * of 2 * clevel - 1. * * @return value of confidence bound for this variable */ SCIP_EXPORT SCIP_Real SCIPcalculatePscostConfidenceBound( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable in question */ SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */ SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */ SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */ ); /** check if variable pseudo-costs have a significant difference in location. The significance depends on * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the * unknown location means of the underlying pseudo-cost distributions of x and y. * * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually * better than x (despite the current information), meaning that y can be expected to yield branching * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average) * than y. * * @note The order of x and y matters for the one-sided hypothesis * * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x. * * @return TRUE if the hypothesis can be safely rejected at the given confidence level */ SCIP_EXPORT SCIP_Bool SCIPsignificantVarPscostDifference( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* varx, /**< variable x */ SCIP_Real fracx, /**< the fractionality of variable x */ SCIP_VAR* vary, /**< variable y */ SCIP_Real fracy, /**< the fractionality of variable y */ SCIP_BRANCHDIR dir, /**< branching direction */ SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */ SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */ ); /** tests at a given confidence level whether the variable pseudo-costs only have a small probability to * exceed a \p threshold. This is useful to determine if past observations provide enough evidence * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement * of at least \p threshold. * * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if * the estimated probability to exceed \p threshold is less than 25 %. * * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels * of confidence. * * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold * at the given confidence level \p clevel. */ SCIP_EXPORT SCIP_Bool SCIPpscostThresholdProbabilityTest( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable x */ SCIP_Real frac, /**< the fractionality of variable x */ SCIP_Real threshold, /**< the threshold to test against */ SCIP_BRANCHDIR dir, /**< branching direction */ SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */ ); /** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative * Error is calculated at a specific confidence level * * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold */ SCIP_EXPORT SCIP_Bool SCIPisVarPscostRelerrorReliable( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable in question */ SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */ SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */ ); /** gets the variable's pseudo cost score value for the given LP solution value * * @return the variable's pseudo cost score value for the given LP solution value * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarPseudocostScore( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real solval /**< variable's LP solution value */ ); /** gets the variable's pseudo cost score value for the given LP solution value, * only using the pseudo cost information of the current run * * @return the variable's pseudo cost score value for the given LP solution value, * only using the pseudo cost information of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarPseudocostScoreCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real solval /**< variable's LP solution value */ ); /** returns the variable's VSIDS value * * @return the variable's VSIDS value * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarVSIDS( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** returns the variable's VSIDS value only using conflicts of the current run * * @return the variable's VSIDS value only using conflicts of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarVSIDSCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** returns the variable's conflict score value * * @return the variable's conflict score value * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarConflictScore( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< problem variable */ ); /** returns the variable's conflict score value only using conflicts of the current run * * @return the variable's conflict score value only using conflicts of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarConflictScoreCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< problem variable */ ); /** returns the variable's conflict length score * * @return the variable's conflict length score * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarConflictlengthScore( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< problem variable */ ); /** returns the variable's conflict length score only using conflicts of the current run * * @return the variable's conflict length score only using conflicts of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< problem variable */ ); /** returns the variable's average conflict length * * @return the variable's average conflict length * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgConflictlength( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** returns the variable's average conflict length only using conflicts of the current run * * @return the variable's average conflict length only using conflicts of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** returns the average number of inferences found after branching on the variable in given direction; * if branching on the variable in the given direction was yet evaluated, the average number of inferences * over all variables for branching in the given direction is returned * * @return the average number of inferences found after branching on the variable in given direction * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgInferences( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** returns the average number of inferences found after branching on the variable in given direction in the current run; * if branching on the variable in the given direction was yet evaluated, the average number of inferences * over all variables for branching in the given direction is returned * * @return the average number of inferences found after branching on the variable in given direction in the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgInferencesCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** returns the variable's average inference score value * * @return the variable's average inference score value * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgInferenceScore( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< problem variable */ ); /** returns the variable's average inference score value only using inferences of the current run * * @return the variable's average inference score value only using inferences of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< problem variable */ ); /** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores * of a variable to the given 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 */ SCIP_EXPORT SCIP_RETCODE SCIPinitVarBranchStats( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable which should be initialized */ SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */ SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */ SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */ SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */ SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */ SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */ SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */ SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */ SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */ SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */ ); /** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY) * * @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 */ SCIP_EXPORT SCIP_RETCODE SCIPinitVarValueBranchStats( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< variable which should be initialized */ SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */ SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */ SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */ SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */ SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */ SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */ SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */ SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */ SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */ ); /** returns the average number of cutoffs found after branching on the variable in given direction; * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs * over all variables for branching in the given direction is returned * * @return the average number of cutoffs found after branching on the variable in given direction * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgCutoffs( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** returns the average number of cutoffs found after branching on the variable in given direction in the current run; * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs * over all variables for branching in the given direction is returned * * @return the average number of cutoffs found after branching on the variable in given direction in the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgCutoffsCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */ ); /** returns the variable's average cutoff score value * * @return the variable's average cutoff score value * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgCutoffScore( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< problem variable */ ); /** returns the variable's average cutoff score value, only using cutoffs of the current run * * @return the variable's average cutoff score value, only using cutoffs of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var /**< problem variable */ ); /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given * factor * * @return the variable's average inference/cutoff score value * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgInferenceCutoffScore( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */ ); /** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given * factor, only using inferences and cutoffs of the current run * * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run * * @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 * - \ref SCIP_STAGE_SOLVED */ SCIP_EXPORT SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */ ); /** outputs variable information to file stream via the message 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 if @p scip is in one of the following stages: * - \ref SCIP_STAGE_PROBLEM * - \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 * * @note If the message handler is set to a NULL pointer nothing will be printed */ SCIP_EXPORT SCIP_RETCODE SCIPprintVar( SCIP* scip, /**< SCIP data structure */ SCIP_VAR* var, /**< problem variable */ FILE* file /**< output file (or NULL for standard output) */ ); /**@} */ #ifdef __cplusplus } #endif #endif