Scippy

    SCIP

    Solving Constraint Integer Programs

    scip_var.h
    Go to the documentation of this file.
    1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    2/* */
    3/* This file is part of the program and library */
    4/* SCIP --- Solving Constraint Integer Programs */
    5/* */
    6/* Copyright (c) 2002-2026 Zuse Institute Berlin (ZIB) */
    7/* */
    8/* Licensed under the Apache License, Version 2.0 (the "License"); */
    9/* you may not use this file except in compliance with the License. */
    10/* You may obtain a copy of the License at */
    11/* */
    12/* http://www.apache.org/licenses/LICENSE-2.0 */
    13/* */
    14/* Unless required by applicable law or agreed to in writing, software */
    15/* distributed under the License is distributed on an "AS IS" BASIS, */
    16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
    17/* See the License for the specific language governing permissions and */
    18/* limitations under the License. */
    19/* */
    20/* You should have received a copy of the Apache-2.0 license */
    21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
    22/* */
    23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
    24
    25/**@file scip_var.h
    26 * @ingroup PUBLICCOREAPI
    27 * @brief public methods for SCIP variables
    28 * @author Tobias Achterberg
    29 * @author Timo Berthold
    30 * @author Thorsten Koch
    31 * @author Alexander Martin
    32 * @author Marc Pfetsch
    33 * @author Kati Wolter
    34 * @author Gregor Hendel
    35 * @author Leona Gottwald
    36 */
    37
    38/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
    39
    40#ifndef __SCIP_SCIP_VAR_H__
    41#define __SCIP_SCIP_VAR_H__
    42
    43
    44#include "scip/def.h"
    45#include "scip/type_cons.h"
    46#include "scip/type_history.h"
    47#include "scip/type_implics.h"
    48#include "scip/type_lp.h"
    49#include "scip/type_misc.h"
    50#include "scip/type_prop.h"
    51#include "scip/type_relax.h"
    52#include "scip/type_result.h"
    53#include "scip/type_retcode.h"
    54#include "scip/type_scip.h"
    55#include "scip/type_sol.h"
    56#include "scip/type_tree.h"
    57#include "scip/type_var.h"
    58
    59/* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
    60 * this structure except the interface methods in scip.c.
    61 * In optimized mode, the structure is included in scip.h, because some of the methods
    62 * are implemented as defines for performance reasons (e.g. the numerical comparisons).
    63 * Additionally, the internal "set.h" is included, such that the defines in set.h are
    64 * available in optimized mode.
    65 */
    66#ifdef NDEBUG
    67#include "scip/pub_var.h"
    68#endif
    69
    70#ifdef __cplusplus
    71extern "C" {
    72#endif
    73
    74/**@addtogroup PublicVariableMethods
    75 *
    76 *@{
    77 */
    78
    79/** creates and captures problem variable
    80 *
    81 * If variable is of integral type, fractional bounds are automatically rounded.
    82 * An integer variable with bounds zero and one is automatically converted into a binary variable.
    83 *
    84 * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
    85 * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
    86 * original objective function value of variables created during the solving process has to be multiplied by
    87 * -1, too.
    88 *
    89 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    90 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    91 *
    92 * @pre This method can be called if @p scip is in one of the following stages:
    93 * - \ref SCIP_STAGE_PROBLEM
    94 * - \ref SCIP_STAGE_TRANSFORMING
    95 * - \ref SCIP_STAGE_INITPRESOLVE
    96 * - \ref SCIP_STAGE_PRESOLVING
    97 * - \ref SCIP_STAGE_EXITPRESOLVE
    98 * - \ref SCIP_STAGE_PRESOLVED
    99 * - \ref SCIP_STAGE_SOLVING
    100 *
    101 * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
    102 */
    103SCIP_EXPORT
    104SCIP_RETCODE SCIPcreateVar(
    105 SCIP* scip, /**< SCIP data structure */
    106 SCIP_VAR** var, /**< pointer to variable object */
    107 const char* name, /**< name of variable, or NULL for automatic name creation */
    108 SCIP_Real lb, /**< lower bound of variable */
    109 SCIP_Real ub, /**< upper bound of variable */
    110 SCIP_Real obj, /**< objective function value */
    111 SCIP_VARTYPE vartype, /**< type of variable */
    112 SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
    113 SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
    114 SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
    115 SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
    116 SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
    117 SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
    118 SCIP_VARDATA* vardata /**< user data for this specific variable, or NULL */
    119 );
    120
    121/** creates and captures problem variable without setting optional callbacks and variable data.
    122 *
    123 * Callbacks and variable data can be set in the following using SCIPvarSetDelorigData(), SCIPvarSetTransData(),
    124 * SCIPvarSetDeltransData(), SCIPvarSetCopy(), and SCIPvarSetData().
    125 *
    126 * Variable flags are set as initial = TRUE and removable = FALSE, and can be adjusted by using SCIPvarSetInitial() and SCIPvarSetRemovable(), resp.
    127 *
    128 * If variable is of integral type, fractional bounds are automatically rounded.
    129 * An integer variable with bounds zero and one is automatically converted into a binary variable.
    130 *
    131 * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
    132 * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
    133 * original objective function value of variables created during the solving process has to be multiplied by
    134 * -1, too.
    135 *
    136 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    137 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    138 *
    139 * @pre This method can be called if @p scip is in one of the following stages:
    140 * - \ref SCIP_STAGE_PROBLEM
    141 * - \ref SCIP_STAGE_TRANSFORMING
    142 * - \ref SCIP_STAGE_INITPRESOLVE
    143 * - \ref SCIP_STAGE_PRESOLVING
    144 * - \ref SCIP_STAGE_EXITPRESOLVE
    145 * - \ref SCIP_STAGE_PRESOLVED
    146 * - \ref SCIP_STAGE_SOLVING
    147 *
    148 * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
    149 */
    150SCIP_EXPORT
    151SCIP_RETCODE SCIPcreateVarBasic(
    152 SCIP* scip, /**< SCIP data structure */
    153 SCIP_VAR** var, /**< pointer to variable object */
    154 const char* name, /**< name of variable, or NULL for automatic name creation */
    155 SCIP_Real lb, /**< lower bound of variable */
    156 SCIP_Real ub, /**< upper bound of variable */
    157 SCIP_Real obj, /**< objective function value */
    158 SCIP_VARTYPE vartype /**< type of variable */
    159 );
    160
    161/** creates and captures problem variable that may be implied integral
    162 *
    163 * If variable is of integral type, fractional bounds are automatically rounded.
    164 * An integer variable with bounds zero and one is automatically converted into a binary variable.
    165 *
    166 * @warning When doing column generation and the original problem is a maximization problem, notice that SCIP will
    167 * transform the problem into a minimization problem by multiplying the objective function by -1. Thus, the
    168 * original objective function value of variables created during the solving process has to be multiplied by
    169 * -1, too.
    170 *
    171 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    172 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    173 *
    174 * @pre This method can be called if @p scip is in one of the following stages:
    175 * - \ref SCIP_STAGE_PROBLEM
    176 * - \ref SCIP_STAGE_TRANSFORMING
    177 * - \ref SCIP_STAGE_INITPRESOLVE
    178 * - \ref SCIP_STAGE_PRESOLVING
    179 * - \ref SCIP_STAGE_EXITPRESOLVE
    180 * - \ref SCIP_STAGE_PRESOLVED
    181 * - \ref SCIP_STAGE_SOLVING
    182 *
    183 * @note the variable gets captured, hence at one point you have to release it using the method SCIPreleaseVar()
    184 */
    185SCIP_EXPORT
    186SCIP_RETCODE SCIPcreateVarImpl(
    187 SCIP* scip, /**< SCIP data structure */
    188 SCIP_VAR** var, /**< pointer to variable object */
    189 const char* name, /**< name of variable, or NULL for automatic name creation */
    190 SCIP_Real lb, /**< lower bound of variable */
    191 SCIP_Real ub, /**< upper bound of variable */
    192 SCIP_Real obj, /**< objective function value */
    193 SCIP_VARTYPE vartype, /**< type of variable */
    194 SCIP_IMPLINTTYPE impltype, /**< implied integral type of the variable (none, weak or strong) */
    195 SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
    196 SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
    197 SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable, or NULL */
    198 SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data, or NULL */
    199 SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable, or NULL */
    200 SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
    201 SCIP_VARDATA* vardata /**< user data for this specific variable, or NULL */
    202);
    203
    204/** adds exact data to variable
    205 *
    206 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    207 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    208 *
    209 * @pre This method can be called if @p scip is in one of the following stages:
    210 * - \ref SCIP_STAGE_PROBLEM
    211 * - \ref SCIP_STAGE_TRANSFORMING
    212 * - \ref SCIP_STAGE_INITPRESOLVE
    213 * - \ref SCIP_STAGE_PRESOLVING
    214 * - \ref SCIP_STAGE_EXITPRESOLVE
    215 * - \ref SCIP_STAGE_PRESOLVED
    216 * - \ref SCIP_STAGE_SOLVING
    217 */
    218SCIP_EXPORT
    219SCIP_RETCODE SCIPaddVarExactData(
    220 SCIP* scip, /**< SCIP data structure */
    221 SCIP_VAR* var, /**< pointer to variable */
    222 SCIP_RATIONAL* lb, /**< lower bounf of variable */
    223 SCIP_RATIONAL* ub, /**< upper bound of variable */
    224 SCIP_RATIONAL* obj /** < objective function value */
    225 );
    226
    227/** outputs the variable name to the file stream
    228 *
    229 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    230 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    231 *
    232 * @pre This method can be called if @p scip is in one of the following stages:
    233 * - \ref SCIP_STAGE_PROBLEM
    234 * - \ref SCIP_STAGE_TRANSFORMING
    235 * - \ref SCIP_STAGE_TRANSFORMED
    236 * - \ref SCIP_STAGE_INITPRESOLVE
    237 * - \ref SCIP_STAGE_PRESOLVING
    238 * - \ref SCIP_STAGE_EXITPRESOLVE
    239 * - \ref SCIP_STAGE_PRESOLVED
    240 * - \ref SCIP_STAGE_INITSOLVE
    241 * - \ref SCIP_STAGE_SOLVING
    242 * - \ref SCIP_STAGE_SOLVED
    243 * - \ref SCIP_STAGE_EXITSOLVE
    244 * - \ref SCIP_STAGE_FREETRANS
    245 */
    246SCIP_EXPORT
    247SCIP_RETCODE SCIPwriteVarName(
    248 SCIP* scip, /**< SCIP data structure */
    249 FILE* file, /**< output file, or NULL for stdout */
    250 SCIP_VAR* var, /**< variable to output */
    251 SCIP_Bool type /**< should the variable type be also posted */
    252 );
    253
    254/** print the given list of variables to output stream separated by the given delimiter character;
    255 *
    256 * i. e. the variables x1, x2, ..., xn with given delimiter ',' are written as: <x1>, <x2>, ..., <xn>;
    257 *
    258 * the method SCIPparseVarsList() can parse such a string
    259 *
    260 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    261 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    262 *
    263 * @pre This method can be called if @p scip is in one of the following stages:
    264 * - \ref SCIP_STAGE_PROBLEM
    265 * - \ref SCIP_STAGE_TRANSFORMING
    266 * - \ref SCIP_STAGE_TRANSFORMED
    267 * - \ref SCIP_STAGE_INITPRESOLVE
    268 * - \ref SCIP_STAGE_PRESOLVING
    269 * - \ref SCIP_STAGE_EXITPRESOLVE
    270 * - \ref SCIP_STAGE_PRESOLVED
    271 * - \ref SCIP_STAGE_INITSOLVE
    272 * - \ref SCIP_STAGE_SOLVING
    273 * - \ref SCIP_STAGE_SOLVED
    274 * - \ref SCIP_STAGE_EXITSOLVE
    275 * - \ref SCIP_STAGE_FREETRANS
    276 *
    277 * @note The printing process is done via the message handler system.
    278 */
    279SCIP_EXPORT
    280SCIP_RETCODE SCIPwriteVarsList(
    281 SCIP* scip, /**< SCIP data structure */
    282 FILE* file, /**< output file, or NULL for stdout */
    283 SCIP_VAR** vars, /**< variable array to output */
    284 int nvars, /**< number of variables */
    285 SCIP_Bool type, /**< should the variable type be also posted */
    286 char delimiter /**< character which is used for delimitation */
    287 );
    288
    289/** print the given variables and coefficients as linear sum in the following form
    290 * c1 <x1> + c2 <x2> ... + cn <xn>
    291 *
    292 * This string can be parsed by the method SCIPparseVarsLinearsum().
    293 *
    294 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    295 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    296 *
    297 * @pre This method can be called if @p scip is in one of the following stages:
    298 * - \ref SCIP_STAGE_PROBLEM
    299 * - \ref SCIP_STAGE_TRANSFORMING
    300 * - \ref SCIP_STAGE_TRANSFORMED
    301 * - \ref SCIP_STAGE_INITPRESOLVE
    302 * - \ref SCIP_STAGE_PRESOLVING
    303 * - \ref SCIP_STAGE_EXITPRESOLVE
    304 * - \ref SCIP_STAGE_PRESOLVED
    305 * - \ref SCIP_STAGE_INITSOLVE
    306 * - \ref SCIP_STAGE_SOLVING
    307 * - \ref SCIP_STAGE_SOLVED
    308 * - \ref SCIP_STAGE_EXITSOLVE
    309 * - \ref SCIP_STAGE_FREETRANS
    310 *
    311 * @note The printing process is done via the message handler system.
    312 */
    313SCIP_EXPORT
    314SCIP_RETCODE SCIPwriteVarsLinearsum(
    315 SCIP* scip, /**< SCIP data structure */
    316 FILE* file, /**< output file, or NULL for stdout */
    317 SCIP_VAR** vars, /**< variable array to output */
    318 SCIP_Real* vals, /**< array of coefficients or NULL if all coefficients are 1.0 */
    319 int nvars, /**< number of variables */
    320 SCIP_Bool type /**< should the variable type be also posted */
    321 );
    322
    323
    324/** print the given monomials as polynomial in the following form
    325 * c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...
    326 *
    327 * This string can be parsed by the method SCIPparseVarsPolynomial().
    328 *
    329 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    330 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    331 *
    332 * @pre This method can be called if @p scip is in one of the following stages:
    333 * - \ref SCIP_STAGE_PROBLEM
    334 * - \ref SCIP_STAGE_TRANSFORMING
    335 * - \ref SCIP_STAGE_TRANSFORMED
    336 * - \ref SCIP_STAGE_INITPRESOLVE
    337 * - \ref SCIP_STAGE_PRESOLVING
    338 * - \ref SCIP_STAGE_EXITPRESOLVE
    339 * - \ref SCIP_STAGE_PRESOLVED
    340 * - \ref SCIP_STAGE_INITSOLVE
    341 * - \ref SCIP_STAGE_SOLVING
    342 * - \ref SCIP_STAGE_SOLVED
    343 * - \ref SCIP_STAGE_EXITSOLVE
    344 * - \ref SCIP_STAGE_FREETRANS
    345 *
    346 * @note The printing process is done via the message handler system.
    347 */
    348SCIP_EXPORT
    349SCIP_RETCODE SCIPwriteVarsPolynomial(
    350 SCIP* scip, /**< SCIP data structure */
    351 FILE* file, /**< output file, or NULL for stdout */
    352 SCIP_VAR*** monomialvars, /**< arrays with variables for each monomial */
    353 SCIP_Real** monomialexps, /**< arrays with variable exponents, or NULL if always 1.0 */
    354 SCIP_Real* monomialcoefs, /**< array with monomial coefficients */
    355 int* monomialnvars, /**< array with number of variables for each monomial */
    356 int nmonomials, /**< number of monomials */
    357 SCIP_Bool type /**< should the variable type be also posted */
    358 );
    359
    360/** parses variable information (in cip format) out of a string; if the parsing process was successful a variable is
    361 * created and captured; if variable is of integral type, fractional bounds are automatically rounded; an integer
    362 * variable with bounds zero and one is automatically converted into a binary variable
    363 *
    364 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    365 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    366 *
    367 * @pre This method can be called if @p scip is in one of the following stages:
    368 * - \ref SCIP_STAGE_PROBLEM
    369 * - \ref SCIP_STAGE_TRANSFORMING
    370 * - \ref SCIP_STAGE_INITPRESOLVE
    371 * - \ref SCIP_STAGE_PRESOLVING
    372 * - \ref SCIP_STAGE_EXITPRESOLVE
    373 * - \ref SCIP_STAGE_PRESOLVED
    374 * - \ref SCIP_STAGE_SOLVING
    375 */
    376SCIP_EXPORT
    377SCIP_RETCODE SCIPparseVar(
    378 SCIP* scip, /**< SCIP data structure */
    379 SCIP_VAR** var, /**< pointer to store the problem variable */
    380 const char* str, /**< string to parse */
    381 SCIP_Bool initial, /**< should var's column be present in the initial root LP? */
    382 SCIP_Bool removable, /**< is var's column removable from the LP (due to aging or cleanup)? */
    383 SCIP_DECL_VARCOPY ((*varcopy)), /**< copies variable data if wanted to subscip, or NULL */
    384 SCIP_DECL_VARDELORIG ((*vardelorig)), /**< frees user data of original variable */
    385 SCIP_DECL_VARTRANS ((*vartrans)), /**< creates transformed user data by transforming original user data */
    386 SCIP_DECL_VARDELTRANS ((*vardeltrans)), /**< frees user data of transformed variable */
    387 SCIP_VARDATA* vardata, /**< user data for this specific variable */
    388 char** endptr, /**< pointer to store the final string position if successful */
    389 SCIP_Bool* success /**< pointer store if the paring process was successful */
    390 );
    391
    392/** parses the given string for a variable name and stores the variable in the corresponding pointer if such a variable
    393 * exits and returns the position where the parsing stopped
    394 *
    395 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    396 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    397 *
    398 * @pre This method can be called if @p scip is in one of the following stages:
    399 * - \ref SCIP_STAGE_PROBLEM
    400 * - \ref SCIP_STAGE_TRANSFORMING
    401 * - \ref SCIP_STAGE_INITPRESOLVE
    402 * - \ref SCIP_STAGE_PRESOLVING
    403 * - \ref SCIP_STAGE_EXITPRESOLVE
    404 * - \ref SCIP_STAGE_PRESOLVED
    405 * - \ref SCIP_STAGE_SOLVING
    406 */
    407SCIP_EXPORT
    408SCIP_RETCODE SCIPparseVarName(
    409 SCIP* scip, /**< SCIP data structure */
    410 const char* str, /**< string to parse */
    411 SCIP_VAR** var, /**< pointer to store the problem variable, or NULL if it does not exit */
    412 char** endptr /**< pointer to store the final string position if successful */
    413 );
    414
    415/** parse the given string as variable list (here ',' is the delimiter)) (<x1>, <x2>, ..., <xn>) (see
    416 * SCIPwriteVarsList() ); if it was successful, the pointer success is set to TRUE
    417 *
    418 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    419 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    420 *
    421 * @pre This method can be called if @p scip is in one of the following stages:
    422 * - \ref SCIP_STAGE_PROBLEM
    423 * - \ref SCIP_STAGE_TRANSFORMING
    424 * - \ref SCIP_STAGE_INITPRESOLVE
    425 * - \ref SCIP_STAGE_PRESOLVING
    426 * - \ref SCIP_STAGE_EXITPRESOLVE
    427 * - \ref SCIP_STAGE_PRESOLVED
    428 * - \ref SCIP_STAGE_SOLVING
    429 *
    430 * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
    431 *
    432 * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
    433 * except that the required size is stored in the corresponding integer; the reason for this approach is that we
    434 * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
    435 * memory functions).
    436 */
    437SCIP_EXPORT
    438SCIP_RETCODE SCIPparseVarsList(
    439 SCIP* scip, /**< SCIP data structure */
    440 const char* str, /**< string to parse */
    441 SCIP_VAR** vars, /**< array to store the parsed variable */
    442 int* nvars, /**< pointer to store number of parsed variables */
    443 int varssize, /**< size of the variable array */
    444 int* requiredsize, /**< pointer to store the required array size for the active variables */
    445 char** endptr, /**< pointer to store the final string position if successful */
    446 char delimiter, /**< character which is used for delimitation */
    447 SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
    448 );
    449
    450/** parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>)
    451 * (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE
    452 *
    453 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    454 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    455 *
    456 * @pre This method can be called if @p scip is in one of the following stages:
    457 * - \ref SCIP_STAGE_PROBLEM
    458 * - \ref SCIP_STAGE_TRANSFORMING
    459 * - \ref SCIP_STAGE_INITPRESOLVE
    460 * - \ref SCIP_STAGE_PRESOLVING
    461 * - \ref SCIP_STAGE_EXITPRESOLVE
    462 * - \ref SCIP_STAGE_PRESOLVED
    463 * - \ref SCIP_STAGE_SOLVING
    464 *
    465 * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
    466 *
    467 * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
    468 * except that the required size is stored in the corresponding integer; the reason for this approach is that we
    469 * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
    470 * memory functions).
    471 */
    472SCIP_EXPORT
    473SCIP_RETCODE SCIPparseVarsLinearsum(
    474 SCIP* scip, /**< SCIP data structure */
    475 const char* str, /**< string to parse */
    476 SCIP_VAR** vars, /**< array to store the parsed variables */
    477 SCIP_Real* vals, /**< array to store the parsed coefficients */
    478 int* nvars, /**< pointer to store number of parsed variables */
    479 int varssize, /**< size of the variable array */
    480 int* requiredsize, /**< pointer to store the required array size for the active variables */
    481 char** endptr, /**< pointer to store the final string position if successful */
    482 SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
    483 );
    484
    485/** parse the given string as linear sum of variables and coefficients (c1 <x1> + c2 <x2> + ... + cn <xn>)
    486 * (see SCIPwriteVarsLinearsum() ); if it was successful, the pointer success is set to TRUE
    487 *
    488 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    489 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    490 *
    491 * @pre This method can be called if @p scip is in one of the following stages:
    492 * - \ref SCIP_STAGE_PROBLEM
    493 * - \ref SCIP_STAGE_TRANSFORMING
    494 * - \ref SCIP_STAGE_INITPRESOLVE
    495 * - \ref SCIP_STAGE_PRESOLVING
    496 * - \ref SCIP_STAGE_EXITPRESOLVE
    497 * - \ref SCIP_STAGE_PRESOLVED
    498 * - \ref SCIP_STAGE_SOLVING
    499 *
    500 * @note The pointer success in only set to FALSE in the case that a variable with a parsed variable name does not exist.
    501 *
    502 * @note If the number of (parsed) variables is greater than the available slots in the variable array, nothing happens
    503 * except that the required size is stored in the corresponding integer; the reason for this approach is that we
    504 * cannot reallocate memory, since we do not know how the memory has been allocated (e.g., by a C++ 'new' or SCIP
    505 * memory functions).
    506 */
    507SCIP_EXPORT
    508SCIP_RETCODE SCIPparseVarsLinearsumExact(
    509 SCIP* scip, /**< SCIP data structure */
    510 char* str, /**< string to parse */
    511 SCIP_VAR** vars, /**< array to store the parsed variables */
    512 SCIP_RATIONAL** vals, /**< array to store the parsed coefficients */
    513 int* nvars, /**< pointer to store number of parsed variables */
    514 int varssize, /**< size of the variable array */
    515 int* requiredsize, /**< pointer to store the required array size for the active variables */
    516 char** endptr, /**< pointer to store the final string position if successful */
    517 SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
    518 );
    519
    520/** parse the given string as signomial of variables and coefficients
    521 * (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...)
    522 * (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE
    523 *
    524 * The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps,
    525 * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the
    526 * allocated memory again. Do not keep the arrays created by SCIPparseVarsPolynomial around, since
    527 * they use buffer memory that is intended for short term use only.
    528 *
    529 * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials
    530 * are recognized.
    531 *
    532 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    533 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    534 *
    535 * @pre This method can be called if @p scip is in one of the following stages:
    536 * - \ref SCIP_STAGE_PROBLEM
    537 * - \ref SCIP_STAGE_TRANSFORMING
    538 * - \ref SCIP_STAGE_INITPRESOLVE
    539 * - \ref SCIP_STAGE_PRESOLVING
    540 * - \ref SCIP_STAGE_EXITPRESOLVE
    541 * - \ref SCIP_STAGE_PRESOLVED
    542 * - \ref SCIP_STAGE_SOLVING
    543 */
    544SCIP_EXPORT
    545SCIP_RETCODE SCIPparseVarsPolynomial(
    546 SCIP* scip, /**< SCIP data structure */
    547 const char* str, /**< string to parse */
    548 SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
    549 SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
    550 SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
    551 int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
    552 int* nmonomials, /**< pointer to store number of parsed monomials */
    553 char** endptr, /**< pointer to store the final string position if successful */
    554 SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
    555 );
    556
    557/** frees memory allocated when parsing a signomial from a string
    558 *
    559 * @pre This method can be called if @p scip is in one of the following stages:
    560 * - \ref SCIP_STAGE_PROBLEM
    561 * - \ref SCIP_STAGE_TRANSFORMING
    562 * - \ref SCIP_STAGE_INITPRESOLVE
    563 * - \ref SCIP_STAGE_PRESOLVING
    564 * - \ref SCIP_STAGE_EXITPRESOLVE
    565 * - \ref SCIP_STAGE_PRESOLVED
    566 * - \ref SCIP_STAGE_SOLVING
    567 */
    568SCIP_EXPORT
    569void SCIPfreeParseVarsPolynomialDataExact(
    570 SCIP* scip, /**< SCIP data structure */
    571 SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
    572 SCIP_RATIONAL*** monomialcoefs, /**< pointer to store array with monomial coefficients */
    573 int nmonomials /**< pointer to store number of parsed monomials */
    574 );
    575
    576/** parse the given string as signomial of variables and coefficients
    577 * (c1 <x11>^e11 <x12>^e12 ... <x1n>^e1n + c2 <x21>^e21 <x22>^e22 ... + ... + cn <xn1>^en1 ...)
    578 * (see SCIPwriteVarsPolynomial()); if it was successful, the pointer success is set to TRUE
    579 *
    580 * The user has to call SCIPfreeParseVarsPolynomialData(scip, monomialvars, monomialexps,
    581 * monomialcoefs, monomialnvars, *nmonomials) short after SCIPparseVarsPolynomial to free all the
    582 * allocated memory again.
    583 *
    584 * Parsing is stopped at the end of string (indicated by the \\0-character) or when no more monomials
    585 * are recognized.
    586 *
    587 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    588 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    589 *
    590 * @pre This method can be called if @p scip is in one of the following stages:
    591 * - \ref SCIP_STAGE_PROBLEM
    592 * - \ref SCIP_STAGE_TRANSFORMING
    593 * - \ref SCIP_STAGE_INITPRESOLVE
    594 * - \ref SCIP_STAGE_PRESOLVING
    595 * - \ref SCIP_STAGE_EXITPRESOLVE
    596 * - \ref SCIP_STAGE_PRESOLVED
    597 * - \ref SCIP_STAGE_SOLVING
    598 */
    599SCIP_EXPORT
    600SCIP_RETCODE SCIPparseVarsPolynomialExact(
    601 SCIP* scip, /**< SCIP data structure */
    602 char* str, /**< string to parse */
    603 SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
    604 SCIP_RATIONAL*** monomialcoefs, /**< pointer to store array with monomial coefficients */
    605 int* nmonomials, /**< pointer to store number of parsed monomials */
    606 char** endptr, /**< pointer to store the final string position if successful */
    607 SCIP_Bool* success /**< pointer to store the whether the parsing was successful or not */
    608 );
    609
    610/** frees memory allocated when parsing a signomial from a string
    611 *
    612 * @pre This method can be called if @p scip is in one of the following stages:
    613 * - \ref SCIP_STAGE_PROBLEM
    614 * - \ref SCIP_STAGE_TRANSFORMING
    615 * - \ref SCIP_STAGE_INITPRESOLVE
    616 * - \ref SCIP_STAGE_PRESOLVING
    617 * - \ref SCIP_STAGE_EXITPRESOLVE
    618 * - \ref SCIP_STAGE_PRESOLVED
    619 * - \ref SCIP_STAGE_SOLVING
    620 */
    621SCIP_EXPORT
    622void SCIPfreeParseVarsPolynomialData(
    623 SCIP* scip, /**< SCIP data structure */
    624 SCIP_VAR**** monomialvars, /**< pointer to store arrays with variables for each monomial */
    625 SCIP_Real*** monomialexps, /**< pointer to store arrays with variable exponents */
    626 SCIP_Real** monomialcoefs, /**< pointer to store array with monomial coefficients */
    627 int** monomialnvars, /**< pointer to store array with number of variables for each monomial */
    628 int nmonomials /**< pointer to store number of parsed monomials */
    629 );
    630
    631/** increases usage counter of variable
    632 *
    633 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    634 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    635 *
    636 * @pre This method can be called if @p scip is in one of the following stages:
    637 * - \ref SCIP_STAGE_PROBLEM
    638 * - \ref SCIP_STAGE_TRANSFORMING
    639 * - \ref SCIP_STAGE_TRANSFORMED
    640 * - \ref SCIP_STAGE_INITPRESOLVE
    641 * - \ref SCIP_STAGE_PRESOLVING
    642 * - \ref SCIP_STAGE_EXITPRESOLVE
    643 * - \ref SCIP_STAGE_PRESOLVED
    644 * - \ref SCIP_STAGE_INITSOLVE
    645 * - \ref SCIP_STAGE_SOLVING
    646 * - \ref SCIP_STAGE_SOLVED
    647 * - \ref SCIP_STAGE_EXITSOLVE
    648 */
    649SCIP_EXPORT
    650SCIP_RETCODE SCIPcaptureVar(
    651 SCIP* scip, /**< SCIP data structure */
    652 SCIP_VAR* var /**< variable to capture */
    653 );
    654
    655/** decreases usage counter of variable, if the usage pointer reaches zero the variable gets freed
    656 *
    657 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    658 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    659 *
    660 * @pre This method can be called if @p scip is in one of the following stages:
    661 * - \ref SCIP_STAGE_PROBLEM
    662 * - \ref SCIP_STAGE_TRANSFORMING
    663 * - \ref SCIP_STAGE_TRANSFORMED
    664 * - \ref SCIP_STAGE_INITPRESOLVE
    665 * - \ref SCIP_STAGE_PRESOLVING
    666 * - \ref SCIP_STAGE_EXITPRESOLVE
    667 * - \ref SCIP_STAGE_PRESOLVED
    668 * - \ref SCIP_STAGE_INITSOLVE
    669 * - \ref SCIP_STAGE_SOLVING
    670 * - \ref SCIP_STAGE_SOLVED
    671 * - \ref SCIP_STAGE_EXITSOLVE
    672 * - \ref SCIP_STAGE_FREETRANS
    673 *
    674 * @note the pointer of the variable will be NULLed
    675 */
    676SCIP_EXPORT
    677SCIP_RETCODE SCIPreleaseVar(
    678 SCIP* scip, /**< SCIP data structure */
    679 SCIP_VAR** var /**< pointer to variable */
    680 );
    681
    682/** changes the name of a variable
    683 *
    684 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    685 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    686 *
    687 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PROBLEM
    688 *
    689 * @note to get the current name of a variable, use SCIPvarGetName() from pub_var.h
    690 */
    691SCIP_EXPORT
    692SCIP_RETCODE SCIPchgVarName(
    693 SCIP* scip, /**< SCIP data structure */
    694 SCIP_VAR* var, /**< variable */
    695 const char* name /**< new name of constraint */
    696 );
    697
    698/** gets and captures transformed variable of a given variable; if the variable is not yet transformed,
    699 * a new transformed variable for this variable is created
    700 *
    701 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    702 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    703 *
    704 * @pre This method can be called if @p scip is in one of the following stages:
    705 * - \ref SCIP_STAGE_TRANSFORMING
    706 * - \ref SCIP_STAGE_TRANSFORMED
    707 * - \ref SCIP_STAGE_INITPRESOLVE
    708 * - \ref SCIP_STAGE_PRESOLVING
    709 * - \ref SCIP_STAGE_EXITPRESOLVE
    710 * - \ref SCIP_STAGE_PRESOLVED
    711 * - \ref SCIP_STAGE_INITSOLVE
    712 * - \ref SCIP_STAGE_SOLVING
    713 */
    714SCIP_EXPORT
    715SCIP_RETCODE SCIPtransformVar(
    716 SCIP* scip, /**< SCIP data structure */
    717 SCIP_VAR* var, /**< variable to get/create transformed variable for */
    718 SCIP_VAR** transvar /**< pointer to store the transformed variable */
    719 );
    720
    721/** gets and captures transformed variables for an array of variables;
    722 * if a variable of the array is not yet transformed, a new transformed variable for this variable is created;
    723 * it is possible to call this method with vars == transvars
    724 *
    725 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    726 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    727 *
    728 * @pre This method can be called if @p scip is in one of the following stages:
    729 * - \ref SCIP_STAGE_TRANSFORMING
    730 * - \ref SCIP_STAGE_TRANSFORMED
    731 * - \ref SCIP_STAGE_INITPRESOLVE
    732 * - \ref SCIP_STAGE_PRESOLVING
    733 * - \ref SCIP_STAGE_EXITPRESOLVE
    734 * - \ref SCIP_STAGE_PRESOLVED
    735 * - \ref SCIP_STAGE_INITSOLVE
    736 * - \ref SCIP_STAGE_SOLVING
    737 */
    738SCIP_EXPORT
    739SCIP_RETCODE SCIPtransformVars(
    740 SCIP* scip, /**< SCIP data structure */
    741 int nvars, /**< number of variables to get/create transformed variables for */
    742 SCIP_VAR** vars, /**< array with variables to get/create transformed variables for */
    743 SCIP_VAR** transvars /**< array to store the transformed variables */
    744 );
    745
    746/** gets corresponding transformed variable of a given variable;
    747 * returns NULL as transvar, if transformed variable is not yet existing
    748 *
    749 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    750 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    751 *
    752 * @pre This method can be called if @p scip is in one of the following stages:
    753 * - \ref SCIP_STAGE_TRANSFORMING
    754 * - \ref SCIP_STAGE_TRANSFORMED
    755 * - \ref SCIP_STAGE_INITPRESOLVE
    756 * - \ref SCIP_STAGE_PRESOLVING
    757 * - \ref SCIP_STAGE_EXITPRESOLVE
    758 * - \ref SCIP_STAGE_PRESOLVED
    759 * - \ref SCIP_STAGE_INITSOLVE
    760 * - \ref SCIP_STAGE_SOLVING
    761 * - \ref SCIP_STAGE_SOLVED
    762 * - \ref SCIP_STAGE_EXITSOLVE
    763 * - \ref SCIP_STAGE_FREETRANS
    764 */
    765SCIP_EXPORT
    766SCIP_RETCODE SCIPgetTransformedVar(
    767 SCIP* scip, /**< SCIP data structure */
    768 SCIP_VAR* var, /**< variable to get transformed variable for */
    769 SCIP_VAR** transvar /**< pointer to store the transformed variable */
    770 );
    771
    772/** gets corresponding transformed variables for an array of variables;
    773 * stores NULL in a transvars slot, if the transformed variable is not yet existing;
    774 * it is possible to call this method with vars == transvars, but remember that variables that are not
    775 * yet transformed will be replaced with NULL
    776 *
    777 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    778 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    779 *
    780 * @pre This method can be called if @p scip is in one of the following stages:
    781 * - \ref SCIP_STAGE_TRANSFORMING
    782 * - \ref SCIP_STAGE_TRANSFORMED
    783 * - \ref SCIP_STAGE_INITPRESOLVE
    784 * - \ref SCIP_STAGE_PRESOLVING
    785 * - \ref SCIP_STAGE_EXITPRESOLVE
    786 * - \ref SCIP_STAGE_PRESOLVED
    787 * - \ref SCIP_STAGE_INITSOLVE
    788 * - \ref SCIP_STAGE_SOLVING
    789 * - \ref SCIP_STAGE_SOLVED
    790 * - \ref SCIP_STAGE_EXITSOLVE
    791 * - \ref SCIP_STAGE_FREETRANS
    792 */
    793SCIP_EXPORT
    794SCIP_RETCODE SCIPgetTransformedVars(
    795 SCIP* scip, /**< SCIP data structure */
    796 int nvars, /**< number of variables to get transformed variables for */
    797 SCIP_VAR** vars, /**< array with variables to get transformed variables for */
    798 SCIP_VAR** transvars /**< array to store the transformed variables */
    799 );
    800
    801/** gets negated variable x' = lb + ub - x of variable x; negated variable is created, if not yet existing
    802 *
    803 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    804 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    805 *
    806 * @pre This method can be called if @p scip is in one of the following stages:
    807 * - \ref SCIP_STAGE_PROBLEM
    808 * - \ref SCIP_STAGE_TRANSFORMING
    809 * - \ref SCIP_STAGE_TRANSFORMED
    810 * - \ref SCIP_STAGE_INITPRESOLVE
    811 * - \ref SCIP_STAGE_PRESOLVING
    812 * - \ref SCIP_STAGE_EXITPRESOLVE
    813 * - \ref SCIP_STAGE_PRESOLVED
    814 * - \ref SCIP_STAGE_INITSOLVE
    815 * - \ref SCIP_STAGE_SOLVING
    816 * - \ref SCIP_STAGE_SOLVED
    817 * - \ref SCIP_STAGE_EXITSOLVE
    818 * - \ref SCIP_STAGE_FREETRANS
    819 */
    820SCIP_EXPORT
    821SCIP_RETCODE SCIPgetNegatedVar(
    822 SCIP* scip, /**< SCIP data structure */
    823 SCIP_VAR* var, /**< variable to get negated variable for */
    824 SCIP_VAR** negvar /**< pointer to store the negated variable */
    825 );
    826
    827/** gets negated variables x' = lb + ub - x of variables x; negated variables are created, if not yet existing;
    828 * in difference to \ref SCIPcreateVar, the negated variable must not be released (unless captured explicitly)
    829 *
    830 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    831 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    832 *
    833 * @pre This method can be called if @p scip is in one of the following stages:
    834 * - \ref SCIP_STAGE_PROBLEM
    835 * - \ref SCIP_STAGE_TRANSFORMING
    836 * - \ref SCIP_STAGE_TRANSFORMED
    837 * - \ref SCIP_STAGE_INITPRESOLVE
    838 * - \ref SCIP_STAGE_PRESOLVING
    839 * - \ref SCIP_STAGE_EXITPRESOLVE
    840 * - \ref SCIP_STAGE_PRESOLVED
    841 * - \ref SCIP_STAGE_INITSOLVE
    842 * - \ref SCIP_STAGE_SOLVING
    843 * - \ref SCIP_STAGE_SOLVED
    844 * - \ref SCIP_STAGE_EXITSOLVE
    845 * - \ref SCIP_STAGE_FREETRANS
    846 */
    847SCIP_EXPORT
    848SCIP_RETCODE SCIPgetNegatedVars(
    849 SCIP* scip, /**< SCIP data structure */
    850 int nvars, /**< number of variables to get negated variables for */
    851 SCIP_VAR** vars, /**< array of variables to get negated variables for */
    852 SCIP_VAR** negvars /**< array to store the negated variables */
    853 );
    854
    855/** gets a binary variable that is equal to the given binary variable, and that is either active, fixed, or
    856 * multi-aggregated, or the negated variable of an active, fixed, or multi-aggregated variable
    857 *
    858 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    859 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    860 *
    861 * @pre This method can be called if @p scip is in one of the following stages:
    862 * - \ref SCIP_STAGE_PROBLEM
    863 * - \ref SCIP_STAGE_TRANSFORMED
    864 * - \ref SCIP_STAGE_INITPRESOLVE
    865 * - \ref SCIP_STAGE_PRESOLVING
    866 * - \ref SCIP_STAGE_EXITPRESOLVE
    867 * - \ref SCIP_STAGE_PRESOLVED
    868 * - \ref SCIP_STAGE_INITSOLVE
    869 * - \ref SCIP_STAGE_SOLVING
    870 * - \ref SCIP_STAGE_SOLVED
    871 * - \ref SCIP_STAGE_EXITSOLVE
    872 */
    873SCIP_EXPORT
    874SCIP_RETCODE SCIPgetBinvarRepresentative(
    875 SCIP* scip, /**< SCIP data structure */
    876 SCIP_VAR* var, /**< binary variable to get binary representative for */
    877 SCIP_VAR** repvar, /**< pointer to store the binary representative */
    878 SCIP_Bool* negated /**< pointer to store whether the negation of an active variable was returned */
    879 );
    880
    881/** gets binary variables that are equal to the given binary variables, and which are either active, fixed, or
    882 * multi-aggregated, or the negated variables of active, fixed, or multi-aggregated variables
    883 *
    884 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    885 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    886 *
    887 * @pre This method can be called if @p scip is in one of the following stages:
    888 * - \ref SCIP_STAGE_PROBLEM
    889 * - \ref SCIP_STAGE_TRANSFORMED
    890 * - \ref SCIP_STAGE_INITPRESOLVE
    891 * - \ref SCIP_STAGE_PRESOLVING
    892 * - \ref SCIP_STAGE_EXITPRESOLVE
    893 * - \ref SCIP_STAGE_PRESOLVED
    894 * - \ref SCIP_STAGE_INITSOLVE
    895 * - \ref SCIP_STAGE_SOLVING
    896 * - \ref SCIP_STAGE_SOLVED
    897 * - \ref SCIP_STAGE_EXITSOLVE
    898 */
    899SCIP_EXPORT
    900SCIP_RETCODE SCIPgetBinvarRepresentatives(
    901 SCIP* scip, /**< SCIP data structure */
    902 int nvars, /**< number of binary variables to get representatives for */
    903 SCIP_VAR** vars, /**< binary variables to get binary representatives for */
    904 SCIP_VAR** repvars, /**< array to store the binary representatives */
    905 SCIP_Bool* negated /**< array to store whether the negation of an active variable was returned */
    906 );
    907
    908/** flattens aggregation graph of multi-aggregated variable in order to avoid exponential recursion later on
    909 *
    910 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    911 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    912 *
    913 * @pre This method can be called if @p scip is in one of the following stages:
    914 * - \ref SCIP_STAGE_INITPRESOLVE
    915 * - \ref SCIP_STAGE_PRESOLVING
    916 * - \ref SCIP_STAGE_EXITPRESOLVE
    917 * - \ref SCIP_STAGE_PRESOLVED
    918 * - \ref SCIP_STAGE_INITSOLVE
    919 * - \ref SCIP_STAGE_SOLVING
    920 * - \ref SCIP_STAGE_SOLVED
    921 */
    922SCIP_EXPORT
    923SCIP_RETCODE SCIPflattenVarAggregationGraph(
    924 SCIP* scip, /**< SCIP data structure */
    925 SCIP_VAR* var /**< problem variable */
    926 );
    927
    928/** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
    929 * active variables, that is b_1*y_1 + ... + b_m*y_m + d.
    930 *
    931 * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
    932 * except that an upper bound on the required size is stored in the variable requiredsize; otherwise, the active
    933 * variable representation is stored in the arrays.
    934 *
    935 * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
    936 * allocated (e.g., by a C++ 'new' or SCIP functions). Note that requiredsize is an upper bound due to possible
    937 * cancelations.
    938 *
    939 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    940 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    941 *
    942 * @pre This method can be called if @p scip is in one of the following stages:
    943 * - \ref SCIP_STAGE_TRANSFORMED
    944 * - \ref SCIP_STAGE_INITPRESOLVE
    945 * - \ref SCIP_STAGE_PRESOLVING
    946 * - \ref SCIP_STAGE_EXITPRESOLVE
    947 * - \ref SCIP_STAGE_PRESOLVED
    948 * - \ref SCIP_STAGE_INITSOLVE
    949 * - \ref SCIP_STAGE_SOLVING
    950 * - \ref SCIP_STAGE_SOLVED
    951 * - \ref SCIP_STAGE_EXITSOLVE
    952 * - \ref SCIP_STAGE_FREETRANS
    953 *
    954 * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
    955 * given entries are overwritten.
    956 *
    957 * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
    958 * the method with the linear sum 1.0*x + 0.0.
    959 */
    960SCIP_EXPORT
    961SCIP_RETCODE SCIPgetProbvarLinearSum(
    962 SCIP* scip, /**< SCIP data structure */
    963 SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be
    964 * overwritten by the variable array y_1, ..., y_m in the linear sum
    965 * w.r.t. active variables */
    966 SCIP_Real* scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the
    967 * scalars b_1, ..., b_m in the linear sum of the active variables */
    968 int* nvars, /**< pointer to number of variables in the linear sum which will be
    969 * overwritten by the number of variables in the linear sum corresponding
    970 * to the active variables */
    971 int varssize, /**< available slots in vars and scalars array which is needed to check if
    972 * the array are large enough for the linear sum w.r.t. active
    973 * variables */
    974 SCIP_Real* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which
    975 * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m +
    976 * d w.r.t. the active variables */
    977 int* requiredsize /**< pointer to store an upper bound on the required size for the linear sum
    978 * w.r.t. the active variables */
    979 );
    980
    981/** transforms given variable, scalar and constant to the corresponding active, fixed, or
    982 * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
    983 * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
    984 * with only one active variable (this can happen due to fixings after the multi-aggregation),
    985 * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
    986 *
    987 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    988 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    989 *
    990 * @pre This method can be called if @p scip is in one of the following stages:
    991 * - \ref SCIP_STAGE_TRANSFORMED
    992 * - \ref SCIP_STAGE_INITPRESOLVE
    993 * - \ref SCIP_STAGE_PRESOLVING
    994 * - \ref SCIP_STAGE_EXITPRESOLVE
    995 * - \ref SCIP_STAGE_PRESOLVED
    996 * - \ref SCIP_STAGE_INITSOLVE
    997 * - \ref SCIP_STAGE_SOLVING
    998 * - \ref SCIP_STAGE_SOLVED
    999 * - \ref SCIP_STAGE_EXITSOLVE
    1000 * - \ref SCIP_STAGE_FREETRANS
    1001 */
    1002SCIP_EXPORT
    1003SCIP_RETCODE SCIPgetProbvarSum(
    1004 SCIP* scip, /**< SCIP data structure */
    1005 SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
    1006 SCIP_Real* scalar, /**< pointer to scalar a in sum a*x + c */
    1007 SCIP_Real* constant /**< pointer to constant c in sum a*x + c */
    1008 );
    1009
    1010/** transforms given variable, scalar and constant to the corresponding active, fixed, or
    1011 * multi-aggregated variable, scalar and constant; if the variable resolves to a fixed variable,
    1012 * "scalar" will be 0.0 and the value of the sum will be stored in "constant"; a multi-aggregation
    1013 * with only one active variable (this can happen due to fixings after the multi-aggregation),
    1014 * is treated like an aggregation; if the multi-aggregation constant is infinite, "scalar" will be 0.0
    1015 *
    1016 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1017 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1018 *
    1019 * @pre This method can be called if @p scip is in one of the following stages:
    1020 * - \ref SCIP_STAGE_TRANSFORMED
    1021 * - \ref SCIP_STAGE_INITPRESOLVE
    1022 * - \ref SCIP_STAGE_PRESOLVING
    1023 * - \ref SCIP_STAGE_EXITPRESOLVE
    1024 * - \ref SCIP_STAGE_PRESOLVED
    1025 * - \ref SCIP_STAGE_INITSOLVE
    1026 * - \ref SCIP_STAGE_SOLVING
    1027 * - \ref SCIP_STAGE_SOLVED
    1028 * - \ref SCIP_STAGE_EXITSOLVE
    1029 * - \ref SCIP_STAGE_FREETRANS
    1030 */
    1031SCIP_EXPORT
    1032SCIP_RETCODE SCIPgetProbvarSumExact(
    1033 SCIP* scip, /**< SCIP data structure */
    1034 SCIP_VAR** var, /**< pointer to problem variable x in sum a*x + c */
    1035 SCIP_RATIONAL* scalar, /**< pointer to scalar a in sum a*x + c */
    1036 SCIP_RATIONAL* constant /**< pointer to constant c in sum a*x + c */
    1037 );
    1038
    1039/** return for given variables all their active counterparts; all active variables will be pairwise different
    1040 * @note It does not hold that the first output variable is the active variable for the first input variable.
    1041 *
    1042 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1043 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1044 *
    1045 * @pre This method can be called if @p scip is in one of the following stages:
    1046 * - \ref SCIP_STAGE_TRANSFORMED
    1047 * - \ref SCIP_STAGE_INITPRESOLVE
    1048 * - \ref SCIP_STAGE_PRESOLVING
    1049 * - \ref SCIP_STAGE_EXITPRESOLVE
    1050 * - \ref SCIP_STAGE_PRESOLVED
    1051 * - \ref SCIP_STAGE_INITSOLVE
    1052 * - \ref SCIP_STAGE_SOLVING
    1053 * - \ref SCIP_STAGE_SOLVED
    1054 * - \ref SCIP_STAGE_EXITSOLVE
    1055 * - \ref SCIP_STAGE_FREETRANS
    1056 */
    1057SCIP_EXPORT
    1058SCIP_RETCODE SCIPgetActiveVars(
    1059 SCIP* scip, /**< SCIP data structure */
    1060 SCIP_VAR** vars, /**< variable array with given variables and as output all active
    1061 * variables, if enough slots exist */
    1062 int* nvars, /**< number of given variables, and as output number of active variables,
    1063 * if enough slots exist */
    1064 int varssize, /**< available slots in vars array */
    1065 int* requiredsize /**< pointer to store the required array size for the active variables */
    1066 );
    1067
    1068/** returns the reduced costs of the variable in the current node's LP relaxation;
    1069 * the current node has to have a feasible LP.
    1070 *
    1071 * returns SCIP_INVALID if the variable is active but not in the current LP;
    1072 * returns 0 if the variable has been aggregated out or fixed in presolving.
    1073 *
    1074 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
    1075 *
    1076 * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
    1077 */
    1078SCIP_EXPORT
    1079SCIP_Real SCIPgetVarRedcost(
    1080 SCIP* scip, /**< SCIP data structure */
    1081 SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
    1082 );
    1083
    1084/** returns the implied reduced costs of the variable in the current node's LP relaxation;
    1085 * the current node has to have a feasible LP.
    1086 *
    1087 * returns SCIP_INVALID if the variable is active but not in the current LP;
    1088 * returns 0 if the variable has been aggregated out or fixed in presolving.
    1089 *
    1090 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
    1091 *
    1092 * @note The return value of this method should be used carefully if the dual feasibility check was explictely disabled.
    1093 */
    1094SCIP_EXPORT
    1095SCIP_Real SCIPgetVarImplRedcost(
    1096 SCIP* scip, /**< SCIP data structure */
    1097 SCIP_VAR* var, /**< variable to get reduced costs, should be a column in current node LP */
    1098 SCIP_Bool varfixing /**< FALSE if for x == 0, TRUE for x == 1 */
    1099 );
    1100
    1101/** returns the Farkas coefficient of the variable in the current node's LP relaxation;
    1102 * the current node has to have an infeasible LP.
    1103 *
    1104 * returns SCIP_INVALID if the variable is active but not in the current LP;
    1105 * returns 0 if the variable has been aggregated out or fixed in presolving.
    1106 *
    1107 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
    1108 */
    1109SCIP_EXPORT
    1110SCIP_Real SCIPgetVarFarkasCoef(
    1111 SCIP* scip, /**< SCIP data structure */
    1112 SCIP_VAR* var /**< variable to get reduced costs, should be a column in current node LP */
    1113 );
    1114
    1115/** returns lower bound of variable directly before or after the bound change given by the bound change index
    1116 * was applied
    1117 */
    1118SCIP_EXPORT
    1119SCIP_Real SCIPgetVarLbAtIndex(
    1120 SCIP* scip, /**< SCIP data structure */
    1121 SCIP_VAR* var, /**< problem variable */
    1122 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
    1123 SCIP_Bool after /**< should the bound change with given index be included? */
    1124 );
    1125
    1126/** returns upper bound of variable directly before or after the bound change given by the bound change index
    1127 * was applied
    1128 */
    1129SCIP_EXPORT
    1130SCIP_Real SCIPgetVarUbAtIndex(
    1131 SCIP* scip, /**< SCIP data structure */
    1132 SCIP_VAR* var, /**< problem variable */
    1133 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
    1134 SCIP_Bool after /**< should the bound change with given index be included? */
    1135 );
    1136
    1137/** returns lower or upper bound of variable directly before or after the bound change given by the bound change index
    1138 * was applied
    1139 */
    1140SCIP_EXPORT
    1141SCIP_Real SCIPgetVarBdAtIndex(
    1142 SCIP* scip, /**< SCIP data structure */
    1143 SCIP_VAR* var, /**< problem variable */
    1144 SCIP_BOUNDTYPE boundtype, /**< type of bound: lower or upper bound */
    1145 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
    1146 SCIP_Bool after /**< should the bound change with given index be included? */
    1147 );
    1148
    1149/** returns whether the binary variable was fixed at the time given by the bound change index */
    1150SCIP_EXPORT
    1151SCIP_Bool SCIPgetVarWasFixedAtIndex(
    1152 SCIP* scip, /**< SCIP data structure */
    1153 SCIP_VAR* var, /**< problem variable */
    1154 SCIP_BDCHGIDX* bdchgidx, /**< bound change index representing time on path to current node */
    1155 SCIP_Bool after /**< should the bound change with given index be included? */
    1156 );
    1157
    1158/** gets solution value for variable in current node
    1159 *
    1160 * @return solution value for variable in current node
    1161 *
    1162 * @pre This method can be called if @p scip is in one of the following stages:
    1163 * - \ref SCIP_STAGE_PRESOLVED
    1164 * - \ref SCIP_STAGE_SOLVING
    1165 */
    1166SCIP_EXPORT
    1167SCIP_Real SCIPgetVarSol(
    1168 SCIP* scip, /**< SCIP data structure */
    1169 SCIP_VAR* var /**< variable to get solution value for */
    1170 );
    1171
    1172/** gets solution values of multiple variables in current node
    1173 *
    1174 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1175 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1176 *
    1177 * @pre This method can be called if @p scip is in one of the following stages:
    1178 * - \ref SCIP_STAGE_PRESOLVED
    1179 * - \ref SCIP_STAGE_SOLVING
    1180 */
    1181SCIP_EXPORT
    1182SCIP_RETCODE SCIPgetVarSols(
    1183 SCIP* scip, /**< SCIP data structure */
    1184 int nvars, /**< number of variables to get solution value for */
    1185 SCIP_VAR** vars, /**< array with variables to get value for */
    1186 SCIP_Real* vals /**< array to store solution values of variables */
    1187 );
    1188
    1189/** sets the solution value of all variables in the global relaxation solution to zero
    1190 *
    1191 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1192 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1193 *
    1194 * @pre This method can be called if @p scip is in one of the following stages:
    1195 * - \ref SCIP_STAGE_PRESOLVED
    1196 * - \ref SCIP_STAGE_SOLVING
    1197 */
    1198SCIP_EXPORT
    1199SCIP_RETCODE SCIPclearRelaxSolVals(
    1200 SCIP* scip, /**< SCIP data structure */
    1201 SCIP_RELAX* relax /**< relaxator data structure */
    1202 );
    1203
    1204/** sets the value of the given variable in the global relaxation solution;
    1205 * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
    1206 * You can use SCIPclearRelaxSolVals() to set all values to zero, initially;
    1207 * after setting all solution values, you have to call SCIPmarkRelaxSolValid()
    1208 * to inform SCIP that the stored solution is valid
    1209 *
    1210 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1211 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1212 *
    1213 * @pre This method can be called if @p scip is in one of the following stages:
    1214 * - \ref SCIP_STAGE_PRESOLVED
    1215 * - \ref SCIP_STAGE_SOLVING
    1216 *
    1217 * @note This method incrementally updates the objective value of the relaxation solution. If the whole solution
    1218 * should be updated, using SCIPsetRelaxSolVals() instead or calling SCIPclearRelaxSolVals() before setting
    1219 * the first value to reset the solution and the objective value to 0 may help the numerics.
    1220 */
    1221SCIP_EXPORT
    1222SCIP_RETCODE SCIPsetRelaxSolVal(
    1223 SCIP* scip, /**< SCIP data structure */
    1224 SCIP_RELAX* relax, /**< relaxator data structure */
    1225 SCIP_VAR* var, /**< variable to set value for */
    1226 SCIP_Real val /**< solution value of variable */
    1227 );
    1228
    1229/** sets the values of the given variables in the global relaxation solution and informs SCIP about the validity
    1230 * and whether the solution can be enforced via linear cuts;
    1231 * this solution can be filled by the relaxation handlers and can be used by heuristics and for separation;
    1232 * the solution is automatically cleared, s.t. all other variables get value 0.0
    1233 *
    1234 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1235 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1236 *
    1237 * @pre This method can be called if @p scip is in one of the following stages:
    1238 * - \ref SCIP_STAGE_PRESOLVED
    1239 * - \ref SCIP_STAGE_SOLVING
    1240 */
    1241SCIP_EXPORT
    1242SCIP_RETCODE SCIPsetRelaxSolVals(
    1243 SCIP* scip, /**< SCIP data structure */
    1244 SCIP_RELAX* relax, /**< relaxator data structure */
    1245 int nvars, /**< number of variables to set relaxation solution value for */
    1246 SCIP_VAR** vars, /**< array with variables to set value for */
    1247 SCIP_Real* vals, /**< array with solution values of variables */
    1248 SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
    1249 );
    1250
    1251/** sets the values of the variables in the global relaxation solution to the values in the given primal solution
    1252 * and informs SCIP about the validity and whether the solution can be enforced via linear cuts;
    1253 * the relaxation solution can be filled by the relaxation handlers and might be used by heuristics and for separation
    1254 *
    1255 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1256 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1257 *
    1258 * @pre This method can be called if @p scip is in one of the following stages:
    1259 * - \ref SCIP_STAGE_PRESOLVED
    1260 * - \ref SCIP_STAGE_SOLVING
    1261 */
    1262SCIP_EXPORT
    1263SCIP_RETCODE SCIPsetRelaxSolValsSol(
    1264 SCIP* scip, /**< SCIP data structure */
    1265 SCIP_RELAX* relax, /**< relaxator data structure */
    1266 SCIP_SOL* sol, /**< primal relaxation solution */
    1267 SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
    1268 );
    1269
    1270/** returns whether the relaxation solution is valid
    1271 *
    1272 * @return TRUE, if the relaxation solution is valid; FALSE, otherwise
    1273 *
    1274 * @pre This method can be called if @p scip is in one of the following stages:
    1275 * - \ref SCIP_STAGE_PRESOLVED
    1276 * - \ref SCIP_STAGE_SOLVING
    1277 */
    1278SCIP_EXPORT
    1279SCIP_Bool SCIPisRelaxSolValid(
    1280 SCIP* scip /**< SCIP data structure */
    1281 );
    1282
    1283/** informs SCIP that the relaxation solution is valid and whether the relaxation can be enforced through linear cuts
    1284 *
    1285 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1286 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1287 *
    1288 * @pre This method can be called if @p scip is in one of the following stages:
    1289 * - \ref SCIP_STAGE_PRESOLVED
    1290 * - \ref SCIP_STAGE_SOLVING
    1291 */
    1292SCIP_EXPORT
    1293SCIP_RETCODE SCIPmarkRelaxSolValid(
    1294 SCIP* scip, /**< SCIP data structure */
    1295 SCIP_RELAX* relax, /**< relaxator data structure that set the current relaxation solution */
    1296 SCIP_Bool includeslp /**< does the relaxator contain all cuts in the LP? */
    1297 );
    1298
    1299/** informs SCIP, that the relaxation solution is invalid
    1300 *
    1301 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1302 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1303 *
    1304 * @pre This method can be called if @p scip is in one of the following stages:
    1305 * - \ref SCIP_STAGE_PRESOLVED
    1306 * - \ref SCIP_STAGE_SOLVING
    1307 */
    1308SCIP_EXPORT
    1309SCIP_RETCODE SCIPmarkRelaxSolInvalid(
    1310 SCIP* scip /**< SCIP data structure */
    1311 );
    1312
    1313/** gets the relaxation solution value of the given variable
    1314 *
    1315 * @return the relaxation solution value of the given variable
    1316 *
    1317 * @pre This method can be called if @p scip is in one of the following stages:
    1318 * - \ref SCIP_STAGE_PRESOLVED
    1319 * - \ref SCIP_STAGE_SOLVING
    1320 */
    1321SCIP_EXPORT
    1322SCIP_Real SCIPgetRelaxSolVal(
    1323 SCIP* scip, /**< SCIP data structure */
    1324 SCIP_VAR* var /**< variable to get value for */
    1325 );
    1326
    1327/** gets the relaxation solution objective value
    1328 *
    1329 * @return the objective value of the relaxation solution
    1330 *
    1331 * @pre This method can be called if @p scip is in one of the following stages:
    1332 * - \ref SCIP_STAGE_PRESOLVED
    1333 * - \ref SCIP_STAGE_SOLVING
    1334 */
    1335SCIP_EXPORT
    1336SCIP_Real SCIPgetRelaxSolObj(
    1337 SCIP* scip /**< SCIP data structure */
    1338 );
    1339
    1340/** determine which branching direction should be evaluated first by strong branching
    1341 *
    1342 * @return TRUE iff strong branching should first evaluate the down child
    1343 *
    1344 */
    1345SCIP_EXPORT
    1346SCIP_Bool SCIPisStrongbranchDownFirst(
    1347 SCIP* scip, /**< SCIP data structure */
    1348 SCIP_VAR* var /**< variable to determine the branching direction on */
    1349 );
    1350
    1351/** start strong branching - call before any strong branching
    1352 *
    1353 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1354 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1355 *
    1356 * @pre This method can be called if @p scip is in one of the following stages:
    1357 * - \ref SCIP_STAGE_PRESOLVED
    1358 * - \ref SCIP_STAGE_SOLVING
    1359 *
    1360 * @note if propagation is enabled, strong branching is not done directly on the LP, but probing nodes are created
    1361 * which allow to perform propagation but also creates some overhead
    1362 */
    1363SCIP_EXPORT
    1364SCIP_RETCODE SCIPstartStrongbranch(
    1365 SCIP* scip, /**< SCIP data structure */
    1366 SCIP_Bool enablepropagation /**< should propagation be done before solving the strong branching LP? */
    1367 );
    1368
    1369/** end strong branching - call after any strong branching
    1370 *
    1371 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1372 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1373 *
    1374 * @pre This method can be called if @p scip is in one of the following stages:
    1375 * - \ref SCIP_STAGE_PRESOLVED
    1376 * - \ref SCIP_STAGE_SOLVING
    1377 */
    1378SCIP_EXPORT
    1379SCIP_RETCODE SCIPendStrongbranch(
    1380 SCIP* scip /**< SCIP data structure */
    1381 );
    1382
    1383/** gets strong branching information on column variable with fractional value
    1384 *
    1385 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1386 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1387 *
    1388 * @pre This method can be called if @p scip is in one of the following stages:
    1389 * - \ref SCIP_STAGE_PRESOLVED
    1390 * - \ref SCIP_STAGE_SOLVING
    1391 */
    1392SCIP_EXPORT
    1393SCIP_RETCODE SCIPgetVarStrongbranchFrac(
    1394 SCIP* scip, /**< SCIP data structure */
    1395 SCIP_VAR* var, /**< variable to get strong branching values for */
    1396 int itlim, /**< iteration limit for strong branchings */
    1397 SCIP_Bool idempotent, /**< should scip's state remain the same after the call (statistics, column states...), or should it be updated ? */
    1398 SCIP_Real* down, /**< stores dual bound after branching column down */
    1399 SCIP_Real* up, /**< stores dual bound after branching column up */
    1400 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
    1401 * otherwise, it can only be used as an estimate value */
    1402 SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
    1403 * otherwise, it can only be used as an estimate value */
    1404 SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
    1405 SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
    1406 SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
    1407 * infeasible downwards branch, or NULL */
    1408 SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
    1409 * infeasible upwards branch, or NULL */
    1410 SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
    1411 * solving process should be stopped (e.g., due to a time limit) */
    1412 );
    1413
    1414/** gets strong branching information with previous domain propagation on column variable
    1415 *
    1416 * Before calling this method, the strong branching mode must have been activated by calling SCIPstartStrongbranch();
    1417 * after strong branching was done for all candidate variables, the strong branching mode must be ended by
    1418 * SCIPendStrongbranch(). Since this method applies domain propagation before strongbranching, propagation has to be be
    1419 * enabled in the SCIPstartStrongbranch() call.
    1420 *
    1421 * Before solving the strong branching LP, domain propagation can be performed. The number of propagation rounds
    1422 * can be specified by the parameter @p maxproprounds.
    1423 *
    1424 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1425 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1426 *
    1427 * @pre This method can be called if @p scip is in one of the following stages:
    1428 * - \ref SCIP_STAGE_PRESOLVED
    1429 * - \ref SCIP_STAGE_SOLVING
    1430 *
    1431 * @warning When using this method, LP banching candidates and solution values must be copied beforehand, because
    1432 * they are updated w.r.t. the strong branching LP solution.
    1433 */
    1434SCIP_EXPORT
    1435SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation(
    1436 SCIP* scip, /**< SCIP data structure */
    1437 SCIP_VAR* var, /**< variable to get strong branching values for */
    1438 SCIP_Real solval, /**< value of the variable in the current LP solution */
    1439 SCIP_Real lpobjval, /**< LP objective value of the current LP solution */
    1440 int itlim, /**< iteration limit for strong branchings */
    1441 int maxproprounds, /**< maximum number of propagation rounds (-1: no limit, -2: parameter
    1442 * settings) */
    1443 SCIP_Real* down, /**< stores dual bound after branching column down */
    1444 SCIP_Real* up, /**< stores dual bound after branching column up */
    1445 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
    1446 * otherwise, it can only be used as an estimate value */
    1447 SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
    1448 * otherwise, it can only be used as an estimate value */
    1449 SCIP_Longint* ndomredsdown, /**< pointer to store the number of domain reductions down, or NULL */
    1450 SCIP_Longint* ndomredsup, /**< pointer to store the number of domain reductions up, or NULL */
    1451 SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
    1452 SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
    1453 SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
    1454 * infeasible downwards branch, or NULL */
    1455 SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
    1456 * infeasible upwards branch, or NULL */
    1457 SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred or the
    1458 * solving process should be stopped (e.g., due to a time limit) */
    1459 SCIP_Real* newlbs, /**< array to store valid lower bounds for all active variables, or NULL */
    1460 SCIP_Real* newubs /**< array to store valid upper bounds for all active variables, or NULL */
    1461 );
    1462
    1463/** gets strong branching information on column variable x with integral LP solution value (val); that is, the down branch
    1464 * is (val -1.0) and the up brach ins (val +1.0)
    1465 *
    1466 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1467 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1468 *
    1469 * @pre This method can be called if @p scip is in one of the following stages:
    1470 * - \ref SCIP_STAGE_PRESOLVED
    1471 * - \ref SCIP_STAGE_SOLVING
    1472 *
    1473 * @note If the integral LP solution value is the lower or upper bound of the variable, the corresponding branch will be
    1474 * marked as infeasible. That is, the valid pointer and the infeasible pointer are set to TRUE.
    1475 */
    1476SCIP_EXPORT
    1477SCIP_RETCODE SCIPgetVarStrongbranchInt(
    1478 SCIP* scip, /**< SCIP data structure */
    1479 SCIP_VAR* var, /**< variable to get strong branching values for */
    1480 int itlim, /**< iteration limit for strong branchings */
    1481 SCIP_Bool idempotent, /**< should scip's state remain the same after the call (statistics, column states...), or should it be updated ? */
    1482 SCIP_Real* down, /**< stores dual bound after branching column down */
    1483 SCIP_Real* up, /**< stores dual bound after branching column up */
    1484 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
    1485 * otherwise, it can only be used as an estimate value */
    1486 SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
    1487 * otherwise, it can only be used as an estimate value */
    1488 SCIP_Bool* downinf, /**< pointer to store whether the downwards branch is infeasible, or NULL */
    1489 SCIP_Bool* upinf, /**< pointer to store whether the upwards branch is infeasible, or NULL */
    1490 SCIP_Bool* downconflict, /**< pointer to store whether a conflict constraint was created for an
    1491 * infeasible downwards branch, or NULL */
    1492 SCIP_Bool* upconflict, /**< pointer to store whether a conflict constraint was created for an
    1493 * infeasible upwards branch, or NULL */
    1494 SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
    1495 * solving process should be stopped (e.g., due to a time limit) */
    1496 );
    1497
    1498/** gets strong branching information on column variables with fractional values
    1499 *
    1500 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1501 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1502 *
    1503 * @pre This method can be called if @p scip is in one of the following stages:
    1504 * - \ref SCIP_STAGE_PRESOLVED
    1505 * - \ref SCIP_STAGE_SOLVING
    1506 */
    1507SCIP_EXPORT
    1508SCIP_RETCODE SCIPgetVarsStrongbranchesFrac(
    1509 SCIP* scip, /**< SCIP data structure */
    1510 SCIP_VAR** vars, /**< variables to get strong branching values for */
    1511 int nvars, /**< number of variables */
    1512 int itlim, /**< iteration limit for strong branchings */
    1513 SCIP_Real* down, /**< stores dual bounds after branching variables down */
    1514 SCIP_Real* up, /**< stores dual bounds after branching variables up */
    1515 SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
    1516 * otherwise, they can only be used as an estimate value */
    1517 SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
    1518 * otherwise, they can only be used as an estimate value */
    1519 SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
    1520 SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
    1521 SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
    1522 * infeasible downward branches, or NULL */
    1523 SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
    1524 * infeasible upward branches, or NULL */
    1525 SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
    1526 * solving process should be stopped (e.g., due to a time limit) */
    1527 );
    1528
    1529/** gets strong branching information on column variables with integral values
    1530 *
    1531 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1532 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1533 *
    1534 * @pre This method can be called if @p scip is in one of the following stages:
    1535 * - \ref SCIP_STAGE_PRESOLVED
    1536 * - \ref SCIP_STAGE_SOLVING
    1537 */
    1538SCIP_EXPORT
    1539SCIP_RETCODE SCIPgetVarsStrongbranchesInt(
    1540 SCIP* scip, /**< SCIP data structure */
    1541 SCIP_VAR** vars, /**< variables to get strong branching values for */
    1542 int nvars, /**< number of variables */
    1543 int itlim, /**< iteration limit for strong branchings */
    1544 SCIP_Real* down, /**< stores dual bounds after branching variables down */
    1545 SCIP_Real* up, /**< stores dual bounds after branching variables up */
    1546 SCIP_Bool* downvalid, /**< stores whether the returned down values are valid dual bounds, or NULL;
    1547 * otherwise, they can only be used as an estimate value */
    1548 SCIP_Bool* upvalid, /**< stores whether the returned up values are valid dual bounds, or NULL;
    1549 * otherwise, they can only be used as an estimate value */
    1550 SCIP_Bool* downinf, /**< array to store whether the downward branches are infeasible, or NULL */
    1551 SCIP_Bool* upinf, /**< array to store whether the upward branches are infeasible, or NULL */
    1552 SCIP_Bool* downconflict, /**< array to store whether conflict constraints were created for
    1553 * infeasible downward branches, or NULL */
    1554 SCIP_Bool* upconflict, /**< array to store whether conflict constraints were created for
    1555 * infeasible upward branches, or NULL */
    1556 SCIP_Bool* lperror /**< pointer to store whether an unresolved LP error occurred or the
    1557 * solving process should be stopped (e.g., due to a time limit) */
    1558 );
    1559
    1560/** get LP solution status of last strong branching call (currently only works for strong branching with propagation) */
    1561SCIP_EXPORT
    1562SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(
    1563 SCIP* scip, /**< SCIP data structure */
    1564 SCIP_BRANCHDIR branchdir /**< branching direction for which LP solution status is requested */
    1565 );
    1566
    1567/** gets strong branching information on COLUMN variable of the last SCIPgetVarStrongbranch() call;
    1568 * returns values of SCIP_INVALID, if strong branching was not yet called on the given variable;
    1569 * keep in mind, that the returned old values may have nothing to do with the current LP solution
    1570 *
    1571 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1572 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1573 *
    1574 * @pre This method can be called if @p scip is in one of the following stages:
    1575 * - \ref SCIP_STAGE_SOLVING
    1576 * - \ref SCIP_STAGE_SOLVED
    1577 */
    1578SCIP_EXPORT
    1579SCIP_RETCODE SCIPgetVarStrongbranchLast(
    1580 SCIP* scip, /**< SCIP data structure */
    1581 SCIP_VAR* var, /**< variable to get last strong branching values for */
    1582 SCIP_Real* down, /**< stores dual bound after branching column down, or NULL */
    1583 SCIP_Real* up, /**< stores dual bound after branching column up, or NULL */
    1584 SCIP_Bool* downvalid, /**< stores whether the returned down value is a valid dual bound, or NULL;
    1585 * otherwise, it can only be used as an estimate value */
    1586 SCIP_Bool* upvalid, /**< stores whether the returned up value is a valid dual bound, or NULL;
    1587 * otherwise, it can only be used as an estimate value */
    1588 SCIP_Real* solval, /**< stores LP solution value of variable at last strong branching call, or NULL */
    1589 SCIP_Real* lpobjval /**< stores LP objective value at last strong branching call, or NULL */
    1590 );
    1591
    1592/** sets strong branching information for a column variable
    1593 *
    1594 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1595 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1596 *
    1597 * @pre This method can be called if @p scip is in one of the following stages:
    1598 * - \ref SCIP_STAGE_SOLVING
    1599 */
    1600SCIP_EXPORT
    1601SCIP_RETCODE SCIPsetVarStrongbranchData(
    1602 SCIP* scip, /**< SCIP data structure */
    1603 SCIP_VAR* var, /**< variable to set last strong branching values for */
    1604 SCIP_Real lpobjval, /**< objective value of the current LP */
    1605 SCIP_Real primsol, /**< primal solution value of the column in the current LP */
    1606 SCIP_Real down, /**< dual bound after branching column down */
    1607 SCIP_Real up, /**< dual bound after branching column up */
    1608 SCIP_Bool downvalid, /**< is the returned down value a valid dual bound? */
    1609 SCIP_Bool upvalid, /**< is the returned up value a valid dual bound? */
    1610 SCIP_Longint iter, /**< total number of strong branching iterations */
    1611 int itlim /**< iteration limit applied to the strong branching call */
    1612 );
    1613
    1614/** rounds the current solution and tries it afterwards; if feasible, adds it to storage
    1615 *
    1616 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1617 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1618 *
    1619 * @pre This method can be called if @p scip is in one of the following stages:
    1620 * - \ref SCIP_STAGE_SOLVING
    1621 */
    1622SCIP_EXPORT
    1623SCIP_RETCODE SCIPtryStrongbranchLPSol(
    1624 SCIP* scip, /**< SCIP data structure */
    1625 SCIP_Bool* foundsol, /**< stores whether solution was feasible and good enough to keep */
    1626 SCIP_Bool* cutoff /**< stores whether solution was cutoff due to exceeding the cutoffbound */
    1627 );
    1628
    1629/** gets node number of the last node in current branch and bound run, where strong branching was used on the
    1630 * given variable, or -1 if strong branching was never applied to the variable in current run
    1631 *
    1632 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1633 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1634 *
    1635 * @pre This method can be called if @p scip is in one of the following stages:
    1636 * - \ref SCIP_STAGE_TRANSFORMING
    1637 * - \ref SCIP_STAGE_TRANSFORMED
    1638 * - \ref SCIP_STAGE_INITPRESOLVE
    1639 * - \ref SCIP_STAGE_PRESOLVING
    1640 * - \ref SCIP_STAGE_EXITPRESOLVE
    1641 * - \ref SCIP_STAGE_PRESOLVED
    1642 * - \ref SCIP_STAGE_INITSOLVE
    1643 * - \ref SCIP_STAGE_SOLVING
    1644 * - \ref SCIP_STAGE_SOLVED
    1645 * - \ref SCIP_STAGE_EXITSOLVE
    1646 */
    1647SCIP_EXPORT
    1648SCIP_Longint SCIPgetVarStrongbranchNode(
    1649 SCIP* scip, /**< SCIP data structure */
    1650 SCIP_VAR* var /**< variable to get last strong branching node for */
    1651 );
    1652
    1653/** if strong branching was already applied on the variable at the current node, returns the number of LPs solved after
    1654 * the LP where the strong branching on this variable was applied;
    1655 * if strong branching was not yet applied on the variable at the current node, returns INT_MAX
    1656 *
    1657 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1658 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1659 *
    1660 * @pre This method can be called if @p scip is in one of the following stages:
    1661 * - \ref SCIP_STAGE_TRANSFORMING
    1662 * - \ref SCIP_STAGE_TRANSFORMED
    1663 * - \ref SCIP_STAGE_INITPRESOLVE
    1664 * - \ref SCIP_STAGE_PRESOLVING
    1665 * - \ref SCIP_STAGE_EXITPRESOLVE
    1666 * - \ref SCIP_STAGE_PRESOLVED
    1667 * - \ref SCIP_STAGE_INITSOLVE
    1668 * - \ref SCIP_STAGE_SOLVING
    1669 * - \ref SCIP_STAGE_SOLVED
    1670 * - \ref SCIP_STAGE_EXITSOLVE
    1671 */
    1672SCIP_EXPORT
    1673SCIP_Longint SCIPgetVarStrongbranchLPAge(
    1674 SCIP* scip, /**< SCIP data structure */
    1675 SCIP_VAR* var /**< variable to get strong branching LP age for */
    1676 );
    1677
    1678/** gets number of times, strong branching was applied in current run on the given variable
    1679 *
    1680 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1681 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1682 *
    1683 * @pre This method can be called if @p scip is in one of the following stages:
    1684 * - \ref SCIP_STAGE_TRANSFORMING
    1685 * - \ref SCIP_STAGE_TRANSFORMED
    1686 * - \ref SCIP_STAGE_INITPRESOLVE
    1687 * - \ref SCIP_STAGE_PRESOLVING
    1688 * - \ref SCIP_STAGE_EXITPRESOLVE
    1689 * - \ref SCIP_STAGE_PRESOLVED
    1690 * - \ref SCIP_STAGE_INITSOLVE
    1691 * - \ref SCIP_STAGE_SOLVING
    1692 * - \ref SCIP_STAGE_SOLVED
    1693 * - \ref SCIP_STAGE_EXITSOLVE
    1694 */
    1695SCIP_EXPORT
    1696int SCIPgetVarNStrongbranchs(
    1697 SCIP* scip, /**< SCIP data structure */
    1698 SCIP_VAR* var /**< variable to get last strong branching node for */
    1699 );
    1700
    1701/** adds given values to lock numbers of type @p locktype of variable for rounding
    1702 *
    1703 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1704 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1705 *
    1706 * @pre This method can be called if @p scip is in one of the following stages:
    1707 * - \ref SCIP_STAGE_PROBLEM
    1708 * - \ref SCIP_STAGE_TRANSFORMING
    1709 * - \ref SCIP_STAGE_TRANSFORMED
    1710 * - \ref SCIP_STAGE_INITPRESOLVE
    1711 * - \ref SCIP_STAGE_PRESOLVING
    1712 * - \ref SCIP_STAGE_EXITPRESOLVE
    1713 * - \ref SCIP_STAGE_PRESOLVED
    1714 * - \ref SCIP_STAGE_INITSOLVE
    1715 * - \ref SCIP_STAGE_SOLVING
    1716 * - \ref SCIP_STAGE_EXITSOLVE
    1717 * - \ref SCIP_STAGE_FREETRANS
    1718 */
    1719SCIP_EXPORT
    1720SCIP_RETCODE SCIPaddVarLocksType(
    1721 SCIP* scip, /**< SCIP data structure */
    1722 SCIP_VAR* var, /**< problem variable */
    1723 SCIP_LOCKTYPE locktype, /**< type of the variable locks */
    1724 int nlocksdown, /**< modification in number of rounding down locks */
    1725 int nlocksup /**< modification in number of rounding up locks */
    1726 );
    1727
    1728
    1729/** adds given values to lock numbers of variable for rounding
    1730 *
    1731 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1732 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1733 *
    1734 * @pre This method can be called if @p scip is in one of the following stages:
    1735 * - \ref SCIP_STAGE_PROBLEM
    1736 * - \ref SCIP_STAGE_TRANSFORMING
    1737 * - \ref SCIP_STAGE_TRANSFORMED
    1738 * - \ref SCIP_STAGE_INITPRESOLVE
    1739 * - \ref SCIP_STAGE_PRESOLVING
    1740 * - \ref SCIP_STAGE_EXITPRESOLVE
    1741 * - \ref SCIP_STAGE_PRESOLVED
    1742 * - \ref SCIP_STAGE_INITSOLVE
    1743 * - \ref SCIP_STAGE_SOLVING
    1744 * - \ref SCIP_STAGE_EXITSOLVE
    1745 * - \ref SCIP_STAGE_FREETRANS
    1746 *
    1747 * @note This method will always add variable locks of type model
    1748 */
    1749SCIP_EXPORT
    1750SCIP_RETCODE SCIPaddVarLocks(
    1751 SCIP* scip, /**< SCIP data structure */
    1752 SCIP_VAR* var, /**< problem variable */
    1753 int nlocksdown, /**< modification in number of rounding down locks */
    1754 int nlocksup /**< modification in number of rounding up locks */
    1755 );
    1756
    1757
    1758/** add locks of type @p locktype of variable with respect to the lock status of the constraint and its negation;
    1759 * this method should be called whenever the lock status of a variable in a constraint changes, for example if
    1760 * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
    1761 * added or removed
    1762 *
    1763 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1764 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1765 *
    1766 * @pre This method can be called if @p scip is in one of the following stages:
    1767 * - \ref SCIP_STAGE_PROBLEM
    1768 * - \ref SCIP_STAGE_TRANSFORMING
    1769 * - \ref SCIP_STAGE_INITPRESOLVE
    1770 * - \ref SCIP_STAGE_PRESOLVING
    1771 * - \ref SCIP_STAGE_EXITPRESOLVE
    1772 * - \ref SCIP_STAGE_INITSOLVE
    1773 * - \ref SCIP_STAGE_SOLVING
    1774 * - \ref SCIP_STAGE_EXITSOLVE
    1775 * - \ref SCIP_STAGE_FREETRANS
    1776 */
    1777SCIP_EXPORT
    1778SCIP_RETCODE SCIPlockVarCons(
    1779 SCIP* scip, /**< SCIP data structure */
    1780 SCIP_VAR* var, /**< problem variable */
    1781 SCIP_CONS* cons, /**< constraint */
    1782 SCIP_Bool lockdown, /**< should the rounding be locked in downwards direction? */
    1783 SCIP_Bool lockup /**< should the rounding be locked in upwards direction? */
    1784 );
    1785
    1786/** remove locks of type @p locktype of variable with respect to the lock status of the constraint and its negation;
    1787 * this method should be called whenever the lock status of a variable in a constraint changes, for example if
    1788 * the coefficient of the variable changed its sign or if the left or right hand sides of the constraint were
    1789 * added or removed
    1790 *
    1791 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1792 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1793 *
    1794 * @pre This method can be called if @p scip is in one of the following stages:
    1795 * - \ref SCIP_STAGE_PROBLEM
    1796 * - \ref SCIP_STAGE_TRANSFORMING
    1797 * - \ref SCIP_STAGE_INITPRESOLVE
    1798 * - \ref SCIP_STAGE_PRESOLVING
    1799 * - \ref SCIP_STAGE_EXITPRESOLVE
    1800 * - \ref SCIP_STAGE_INITSOLVE
    1801 * - \ref SCIP_STAGE_SOLVING
    1802 * - \ref SCIP_STAGE_EXITSOLVE
    1803 * - \ref SCIP_STAGE_FREETRANS
    1804 */
    1805SCIP_EXPORT
    1806SCIP_RETCODE SCIPunlockVarCons(
    1807 SCIP* scip, /**< SCIP data structure */
    1808 SCIP_VAR* var, /**< problem variable */
    1809 SCIP_CONS* cons, /**< constraint */
    1810 SCIP_Bool lockdown, /**< should the rounding be unlocked in downwards direction? */
    1811 SCIP_Bool lockup /**< should the rounding be unlocked in upwards direction? */
    1812 );
    1813
    1814/** changes variable's objective value
    1815 *
    1816 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1817 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1818 *
    1819 * @pre This method can be called if @p scip is in one of the following stages:
    1820 * - \ref SCIP_STAGE_PROBLEM
    1821 * - \ref SCIP_STAGE_TRANSFORMING
    1822 * - \ref SCIP_STAGE_PRESOLVING
    1823 */
    1824SCIP_EXPORT
    1825SCIP_RETCODE SCIPchgVarObj(
    1826 SCIP* scip, /**< SCIP data structure */
    1827 SCIP_VAR* var, /**< variable to change the objective value for */
    1828 SCIP_Real newobj /**< new objective value */
    1829 );
    1830
    1831/** adds value to variable's objective value
    1832 *
    1833 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1834 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1835 *
    1836 * @pre This method can be called if @p scip is in one of the following stages:
    1837 * - \ref SCIP_STAGE_PROBLEM
    1838 * - \ref SCIP_STAGE_TRANSFORMING
    1839 * - \ref SCIP_STAGE_PRESOLVING
    1840 * - \ref SCIP_STAGE_EXITPRESOLVE
    1841 * - \ref SCIP_STAGE_PRESOLVED
    1842 */
    1843SCIP_EXPORT
    1844SCIP_RETCODE SCIPaddVarObj(
    1845 SCIP* scip, /**< SCIP data structure */
    1846 SCIP_VAR* var, /**< variable to change the objective value for */
    1847 SCIP_Real addobj /**< additional objective value */
    1848 );
    1849
    1850/** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
    1851 * does not change the bounds of the variable
    1852 *
    1853 * @return adjusted lower bound for the given variable; the bound of the variable is not changed
    1854 *
    1855 * @pre This method can be called if @p scip is in one of the following stages:
    1856 * - \ref SCIP_STAGE_PROBLEM
    1857 * - \ref SCIP_STAGE_TRANSFORMING
    1858 * - \ref SCIP_STAGE_TRANSFORMED
    1859 * - \ref SCIP_STAGE_INITPRESOLVE
    1860 * - \ref SCIP_STAGE_PRESOLVING
    1861 * - \ref SCIP_STAGE_EXITPRESOLVE
    1862 * - \ref SCIP_STAGE_PRESOLVED
    1863 * - \ref SCIP_STAGE_INITSOLVE
    1864 * - \ref SCIP_STAGE_SOLVING
    1865 * - \ref SCIP_STAGE_SOLVED
    1866 * - \ref SCIP_STAGE_EXITSOLVE
    1867 * - \ref SCIP_STAGE_FREETRANS
    1868 */
    1869SCIP_EXPORT
    1870SCIP_Real SCIPadjustedVarLb(
    1871 SCIP* scip, /**< SCIP data structure */
    1872 SCIP_VAR* var, /**< variable to adjust the bound for */
    1873 SCIP_Real lb /**< lower bound value to adjust */
    1874 );
    1875
    1876/** returns the adjusted (i.e. rounded, if the given variable is of integral type) lower bound value;
    1877 * does not change the bounds of the variable
    1878 *
    1879 * @return adjusted lower bound for the given variable; the bound of the variable is not changed
    1880 *
    1881 * @pre This method can be called if @p scip is in one of the following stages:
    1882 * - \ref SCIP_STAGE_PROBLEM
    1883 * - \ref SCIP_STAGE_TRANSFORMING
    1884 * - \ref SCIP_STAGE_TRANSFORMED
    1885 * - \ref SCIP_STAGE_INITPRESOLVE
    1886 * - \ref SCIP_STAGE_PRESOLVING
    1887 * - \ref SCIP_STAGE_EXITPRESOLVE
    1888 * - \ref SCIP_STAGE_PRESOLVED
    1889 * - \ref SCIP_STAGE_INITSOLVE
    1890 * - \ref SCIP_STAGE_SOLVING
    1891 * - \ref SCIP_STAGE_SOLVED
    1892 * - \ref SCIP_STAGE_EXITSOLVE
    1893 * - \ref SCIP_STAGE_FREETRANS
    1894 */
    1895SCIP_EXPORT
    1896SCIP_Real SCIPadjustedVarLbExactFloat(
    1897 SCIP* scip, /**< SCIP data structure */
    1898 SCIP_VAR* var, /**< variable to adjust the bound for */
    1899 SCIP_Real lb /**< lower bound value to adjust */
    1900 );
    1901
    1902/** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
    1903 * does not change the bounds of the variable
    1904 *
    1905 * @return adjusted upper bound for the given variable; the bound of the variable is not changed
    1906 *
    1907 * @pre This method can be called if @p scip is in one of the following stages:
    1908 * - \ref SCIP_STAGE_PROBLEM
    1909 * - \ref SCIP_STAGE_TRANSFORMING
    1910 * - \ref SCIP_STAGE_TRANSFORMED
    1911 * - \ref SCIP_STAGE_INITPRESOLVE
    1912 * - \ref SCIP_STAGE_PRESOLVING
    1913 * - \ref SCIP_STAGE_EXITPRESOLVE
    1914 * - \ref SCIP_STAGE_PRESOLVED
    1915 * - \ref SCIP_STAGE_INITSOLVE
    1916 * - \ref SCIP_STAGE_SOLVING
    1917 * - \ref SCIP_STAGE_SOLVED
    1918 * - \ref SCIP_STAGE_EXITSOLVE
    1919 * - \ref SCIP_STAGE_FREETRANS
    1920 */
    1921SCIP_EXPORT
    1922SCIP_Real SCIPadjustedVarUb(
    1923 SCIP* scip, /**< SCIP data structure */
    1924 SCIP_VAR* var, /**< variable to adjust the bound for */
    1925 SCIP_Real ub /**< upper bound value to adjust */
    1926 );
    1927
    1928/** returns the adjusted (i.e. rounded, if the given variable is of integral type) upper bound value;
    1929 * does not change the bounds of the variable
    1930 *
    1931 * @return adjusted upper bound for the given variable; the bound of the variable is not changed
    1932 *
    1933 * @pre This method can be called if @p scip is in one of the following stages:
    1934 * - \ref SCIP_STAGE_PROBLEM
    1935 * - \ref SCIP_STAGE_TRANSFORMING
    1936 * - \ref SCIP_STAGE_TRANSFORMED
    1937 * - \ref SCIP_STAGE_INITPRESOLVE
    1938 * - \ref SCIP_STAGE_PRESOLVING
    1939 * - \ref SCIP_STAGE_EXITPRESOLVE
    1940 * - \ref SCIP_STAGE_PRESOLVED
    1941 * - \ref SCIP_STAGE_INITSOLVE
    1942 * - \ref SCIP_STAGE_SOLVING
    1943 * - \ref SCIP_STAGE_SOLVED
    1944 * - \ref SCIP_STAGE_EXITSOLVE
    1945 * - \ref SCIP_STAGE_FREETRANS
    1946 */
    1947SCIP_EXPORT
    1948SCIP_Real SCIPadjustedVarUbExactFloat(
    1949 SCIP* scip, /**< SCIP data structure */
    1950 SCIP_VAR* var, /**< variable to adjust the bound for */
    1951 SCIP_Real ub /**< upper bound value to adjust */
    1952 );
    1953
    1954/** depending on SCIP's stage, changes lower bound of variable in the problem, in preprocessing, or in current node;
    1955 * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
    1956 * that in conflict analysis, this change is treated like a branching decision
    1957 *
    1958 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    1959 * SCIPgetVars()) gets re-sorted.
    1960 *
    1961 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1962 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1963 *
    1964 * @pre This method can be called if @p scip is in one of the following stages:
    1965 * - \ref SCIP_STAGE_PROBLEM
    1966 * - \ref SCIP_STAGE_TRANSFORMING
    1967 * - \ref SCIP_STAGE_PRESOLVING
    1968 * - \ref SCIP_STAGE_SOLVING
    1969 *
    1970 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    1971 */
    1972SCIP_EXPORT
    1973SCIP_RETCODE SCIPchgVarLb(
    1974 SCIP* scip, /**< SCIP data structure */
    1975 SCIP_VAR* var, /**< variable to change the bound for */
    1976 SCIP_Real newbound /**< new value for bound */
    1977 );
    1978
    1979/** depending on SCIP's stage, changes exact lower bound of variable in the problem, in preprocessing, or in current node;
    1980 * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
    1981 * that in conflict analysis, this change is treated like a branching decision
    1982 *
    1983 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    1984 * SCIPgetVars()) gets resorted.
    1985 *
    1986 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1987 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1988 *
    1989 * @pre This method can be called if @p scip is in one of the following stages:
    1990 * - \ref SCIP_STAGE_PROBLEM
    1991 * - \ref SCIP_STAGE_TRANSFORMING
    1992 * - \ref SCIP_STAGE_PRESOLVING
    1993 * - \ref SCIP_STAGE_SOLVING
    1994 *
    1995 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    1996 */
    1997SCIP_EXPORT
    1998SCIP_RETCODE SCIPchgVarLbExact(
    1999 SCIP* scip, /**< SCIP data structure */
    2000 SCIP_VAR* var, /**< variable to change the bound for */
    2001 SCIP_RATIONAL* newbound /**< new value for bound */
    2002 );
    2003
    2004/** depending on SCIP's stage, changes upper bound of variable in the problem, in preprocessing, or in current node;
    2005 * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
    2006 * that in conflict analysis, this change is treated like a branching decision
    2007 *
    2008 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2009 * SCIPgetVars()) gets re-sorted.
    2010 *
    2011 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2012 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2013 *
    2014 * @pre This method can be called if @p scip is in one of the following stages:
    2015 * - \ref SCIP_STAGE_PROBLEM
    2016 * - \ref SCIP_STAGE_TRANSFORMING
    2017 * - \ref SCIP_STAGE_PRESOLVING
    2018 * - \ref SCIP_STAGE_SOLVING
    2019 *
    2020 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2021 */
    2022SCIP_EXPORT
    2023SCIP_RETCODE SCIPchgVarUb(
    2024 SCIP* scip, /**< SCIP data structure */
    2025 SCIP_VAR* var, /**< variable to change the bound for */
    2026 SCIP_Real newbound /**< new value for bound */
    2027 );
    2028
    2029/** depending on SCIP's stage, changes exact upper bound of variable in the problem, in preprocessing, or in current node;
    2030 * if possible, adjusts bound to integral value; doesn't store any inference information in the bound change, such
    2031 * that in conflict analysis, this change is treated like a branching decision
    2032 *
    2033 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2034 * SCIPgetVars()) gets resorted.
    2035 *
    2036 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2037 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2038 *
    2039 * @pre This method can be called if @p scip is in one of the following stages:
    2040 * - \ref SCIP_STAGE_PROBLEM
    2041 * - \ref SCIP_STAGE_TRANSFORMING
    2042 * - \ref SCIP_STAGE_PRESOLVING
    2043 * - \ref SCIP_STAGE_SOLVING
    2044 *
    2045 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2046 */
    2047SCIP_EXPORT
    2048SCIP_RETCODE SCIPchgVarUbExact(
    2049 SCIP* scip, /**< SCIP data structure */
    2050 SCIP_VAR* var, /**< variable to change the bound for */
    2051 SCIP_RATIONAL* newbound /**< new value for bound */
    2052 );
    2053
    2054/** changes lower bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
    2055 * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
    2056 * decision
    2057 *
    2058 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2059 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2060 *
    2061 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
    2062 */
    2063SCIP_EXPORT
    2064SCIP_RETCODE SCIPchgVarLbNode(
    2065 SCIP* scip, /**< SCIP data structure */
    2066 SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
    2067 SCIP_VAR* var, /**< variable to change the bound for */
    2068 SCIP_Real newbound /**< new value for bound */
    2069 );
    2070
    2071/** changes upper bound of variable in the given node; if possible, adjust bound to integral value; doesn't store any
    2072 * inference information in the bound change, such that in conflict analysis, this change is treated like a branching
    2073 * decision
    2074 *
    2075 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2076 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2077 *
    2078 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
    2079 */
    2080SCIP_EXPORT
    2081SCIP_RETCODE SCIPchgVarUbNode(
    2082 SCIP* scip, /**< SCIP data structure */
    2083 SCIP_NODE* node, /**< node to change bound at, or NULL for current node */
    2084 SCIP_VAR* var, /**< variable to change the bound for */
    2085 SCIP_Real newbound /**< new value for bound */
    2086 );
    2087
    2088/** changes global lower bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
    2089 * if the global bound is better than the local bound
    2090 *
    2091 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2092 * SCIPgetVars()) gets re-sorted.
    2093 *
    2094 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2095 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2096 *
    2097 * @pre This method can be called if @p scip is in one of the following stages:
    2098 * - \ref SCIP_STAGE_PROBLEM
    2099 * - \ref SCIP_STAGE_TRANSFORMING
    2100 * - \ref SCIP_STAGE_TRANSFORMED
    2101 * - \ref SCIP_STAGE_PRESOLVING
    2102 * - \ref SCIP_STAGE_SOLVING
    2103 *
    2104 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2105 */
    2106SCIP_EXPORT
    2107SCIP_RETCODE SCIPchgVarLbGlobal(
    2108 SCIP* scip, /**< SCIP data structure */
    2109 SCIP_VAR* var, /**< variable to change the bound for */
    2110 SCIP_Real newbound /**< new value for bound */
    2111 );
    2112
    2113/** changes global upper bound of variable; if possible, adjust bound to integral value; also tightens the local bound,
    2114 * if the global bound is better than the local bound
    2115 *
    2116 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2117 * SCIPgetVars()) gets re-sorted.
    2118 *
    2119 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2120 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2121 *
    2122 * @pre This method can be called if @p scip is in one of the following stages:
    2123 * - \ref SCIP_STAGE_PROBLEM
    2124 * - \ref SCIP_STAGE_TRANSFORMING
    2125 * - \ref SCIP_STAGE_TRANSFORMED
    2126 * - \ref SCIP_STAGE_PRESOLVING
    2127 * - \ref SCIP_STAGE_SOLVING
    2128 *
    2129 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2130 */
    2131SCIP_EXPORT
    2132SCIP_RETCODE SCIPchgVarUbGlobal(
    2133 SCIP* scip, /**< SCIP data structure */
    2134 SCIP_VAR* var, /**< variable to change the bound for */
    2135 SCIP_Real newbound /**< new value for bound */
    2136 );
    2137
    2138/** changes lazy lower bound of the variable, this is only possible if the variable is not in the LP yet
    2139 *
    2140 * Lazy bounds are bounds that are already enforced by constraints and the objective function.
    2141 * Setting a lazy lower bound has the consequence that for variables which lower bound equals the lazy lower bound,
    2142 * the lower bound does not need to be passed on to the LP solver.
    2143 * This is especially useful in a column generation (branch-and-price) setting.
    2144 *
    2145 * @attention If the variable has a global lower bound below lazylb, then the global lower bound is tightened to
    2146 * lazylb by a call to SCIPchgVarLbGlobal().
    2147 *
    2148 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2149 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2150 *
    2151 * @pre This method can be called if @p scip is in one of the following stages:
    2152 * - \ref SCIP_STAGE_PROBLEM
    2153 * - \ref SCIP_STAGE_TRANSFORMING
    2154 * - \ref SCIP_STAGE_TRANSFORMED
    2155 * - \ref SCIP_STAGE_PRESOLVING
    2156 * - \ref SCIP_STAGE_SOLVING
    2157 */
    2158SCIP_EXPORT
    2159SCIP_RETCODE SCIPchgVarLbLazy(
    2160 SCIP* scip, /**< SCIP data structure */
    2161 SCIP_VAR* var, /**< problem variable */
    2162 SCIP_Real lazylb /**< the lazy lower bound to be set */
    2163 );
    2164
    2165/** changes lazy upper bound of the variable, this is only possible if the variable is not in the LP yet
    2166 *
    2167 * Lazy bounds are bounds that are already enforced by constraints and the objective function.
    2168 * Setting a lazy upper bound has the consequence that for variables which upper bound equals the lazy upper bound,
    2169 * the upper bound does not need to be passed on to the LP solver.
    2170 * This is especially useful in a column generation (branch-and-price) setting.
    2171 *
    2172 * @attention If the variable has a global upper bound above lazyub, then the global upper bound is tightened to
    2173 * lazyub by a call to SCIPchgVarUbGlobal().
    2174 *
    2175 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2176 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2177 *
    2178 * @pre This method can be called if @p scip is in one of the following stages:
    2179 * - \ref SCIP_STAGE_PROBLEM
    2180 * - \ref SCIP_STAGE_TRANSFORMING
    2181 * - \ref SCIP_STAGE_TRANSFORMED
    2182 * - \ref SCIP_STAGE_PRESOLVING
    2183 * - \ref SCIP_STAGE_SOLVING
    2184 */
    2185SCIP_EXPORT
    2186SCIP_RETCODE SCIPchgVarUbLazy(
    2187 SCIP* scip, /**< SCIP data structure */
    2188 SCIP_VAR* var, /**< problem variable */
    2189 SCIP_Real lazyub /**< the lazy lower bound to be set */
    2190 );
    2191
    2192/** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
    2193 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
    2194 * doesn't store any inference information in the bound change, such that in conflict analysis, this change
    2195 * is treated like a branching decision
    2196 *
    2197 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2198 * SCIPgetVars()) gets re-sorted.
    2199 *
    2200 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2201 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2202 *
    2203 * @pre This method can be called if @p scip is in one of the following stages:
    2204 * - \ref SCIP_STAGE_PROBLEM
    2205 * - \ref SCIP_STAGE_PRESOLVING
    2206 * - \ref SCIP_STAGE_SOLVING
    2207 *
    2208 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2209 */
    2210SCIP_EXPORT
    2211SCIP_RETCODE SCIPtightenVarLb(
    2212 SCIP* scip, /**< SCIP data structure */
    2213 SCIP_VAR* var, /**< variable to change the bound for */
    2214 SCIP_Real newbound, /**< new value for bound */
    2215 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2216 SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
    2217 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2218 );
    2219
    2220/** changes exact lower bound of variable in preprocessing or in the current node, if the new bound is tighter
    2221 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
    2222 * doesn't store any inference information in the bound change, such that in conflict analysis, this change
    2223 * is treated like a branching decision
    2224 *
    2225 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2226 * SCIPgetVars()) gets resorted.
    2227 *
    2228 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2229 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2230 *
    2231 * @pre This method can be called if @p scip is in one of the following stages:
    2232 * - \ref SCIP_STAGE_PROBLEM
    2233 * - \ref SCIP_STAGE_PRESOLVING
    2234 * - \ref SCIP_STAGE_SOLVING
    2235 *
    2236 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2237 */
    2238SCIP_EXPORT
    2239SCIP_RETCODE SCIPtightenVarLbExact(
    2240 SCIP* scip, /**< SCIP data structure */
    2241 SCIP_VAR* var, /**< variable to change the bound for */
    2242 SCIP_RATIONAL* newbound, /**< new value for bound */
    2243 SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
    2244 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2245 );
    2246
    2247/** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
    2248 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
    2249 * doesn't store any inference information in the bound change, such that in conflict analysis, this change
    2250 * is treated like a branching decision
    2251 *
    2252 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2253 * SCIPgetVars()) gets re-sorted.
    2254 *
    2255 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2256 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2257 *
    2258 * @pre This method can be called if @p scip is in one of the following stages:
    2259 * - \ref SCIP_STAGE_PROBLEM
    2260 * - \ref SCIP_STAGE_PRESOLVING
    2261 * - \ref SCIP_STAGE_SOLVING
    2262 *
    2263 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2264 */
    2265SCIP_EXPORT
    2266SCIP_RETCODE SCIPtightenVarUb(
    2267 SCIP* scip, /**< SCIP data structure */
    2268 SCIP_VAR* var, /**< variable to change the bound for */
    2269 SCIP_Real newbound, /**< new value for bound */
    2270 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2271 SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
    2272 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2273 );
    2274
    2275/** changes exact upper bound of variable in preprocessing or in the current node, if the new bound is tighter
    2276 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
    2277 * doesn't store any inference information in the bound change, such that in conflict analysis, this change
    2278 * is treated like a branching decision
    2279 *
    2280 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2281 * SCIPgetVars()) gets resorted.
    2282 *
    2283 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2284 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2285 *
    2286 * @pre This method can be called if @p scip is in one of the following stages:
    2287 * - \ref SCIP_STAGE_PROBLEM
    2288 * - \ref SCIP_STAGE_PRESOLVING
    2289 * - \ref SCIP_STAGE_SOLVING
    2290 *
    2291 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2292 */
    2293SCIP_EXPORT
    2294SCIP_RETCODE SCIPtightenVarUbExact(
    2295 SCIP* scip, /**< SCIP data structure */
    2296 SCIP_VAR* var, /**< variable to change the bound for */
    2297 SCIP_RATIONAL* newbound, /**< new value for bound */
    2298 SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
    2299 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2300 );
    2301
    2302/** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
    2303 * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
    2304 * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
    2305 *
    2306 * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
    2307 * changes first the lowerbound by calling SCIPinferVarLbCons and second the upperbound by calling
    2308 * SCIPinferVarUbCons
    2309 *
    2310 * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
    2311 * SCIPgetVars()) gets re-sorted.
    2312 *
    2313 * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
    2314 */
    2315SCIP_EXPORT
    2316SCIP_RETCODE SCIPinferVarFixCons(
    2317 SCIP* scip, /**< SCIP data structure */
    2318 SCIP_VAR* var, /**< variable to change the bound for */
    2319 SCIP_Real fixedval, /**< new value for fixation */
    2320 SCIP_CONS* infercons, /**< constraint that deduced the bound change */
    2321 int inferinfo, /**< user information for inference to help resolving the conflict */
    2322 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2323 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2324 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2325 );
    2326
    2327/** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
    2328 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
    2329 * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
    2330 * for the deduction of the bound change
    2331 *
    2332 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2333 * SCIPgetVars()) gets re-sorted.
    2334 *
    2335 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2336 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2337 *
    2338 * @pre This method can be called if @p scip is in one of the following stages:
    2339 * - \ref SCIP_STAGE_PROBLEM
    2340 * - \ref SCIP_STAGE_PRESOLVING
    2341 * - \ref SCIP_STAGE_SOLVING
    2342 *
    2343 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2344 */
    2345SCIP_EXPORT
    2346SCIP_RETCODE SCIPinferVarLbCons(
    2347 SCIP* scip, /**< SCIP data structure */
    2348 SCIP_VAR* var, /**< variable to change the bound for */
    2349 SCIP_Real newbound, /**< new value for bound */
    2350 SCIP_CONS* infercons, /**< constraint that deduced the bound change, or NULL */
    2351 int inferinfo, /**< user information for inference to help resolving the conflict */
    2352 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2353 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2354 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2355 );
    2356
    2357/** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
    2358 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
    2359 * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
    2360 * for the deduction of the bound change
    2361 *
    2362 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2363 * SCIPgetVars()) gets re-sorted.
    2364 *
    2365 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2366 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2367 *
    2368 * @pre This method can be called if @p scip is in one of the following stages:
    2369 * - \ref SCIP_STAGE_PROBLEM
    2370 * - \ref SCIP_STAGE_PRESOLVING
    2371 * - \ref SCIP_STAGE_SOLVING
    2372 *
    2373 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2374 */
    2375SCIP_EXPORT
    2376SCIP_RETCODE SCIPinferVarUbCons(
    2377 SCIP* scip, /**< SCIP data structure */
    2378 SCIP_VAR* var, /**< variable to change the bound for */
    2379 SCIP_Real newbound, /**< new value for bound */
    2380 SCIP_CONS* infercons, /**< constraint that deduced the bound change */
    2381 int inferinfo, /**< user information for inference to help resolving the conflict */
    2382 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2383 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2384 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2385 );
    2386
    2387/** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
    2388 * the given inference constraint is stored, such that the conflict analysis is able to find out the reason for the
    2389 * deduction of the fixing
    2390 *
    2391 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2392 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2393 *
    2394 * @pre This method can be called if @p scip is in one of the following stages:
    2395 * - \ref SCIP_STAGE_PROBLEM
    2396 * - \ref SCIP_STAGE_PRESOLVING
    2397 * - \ref SCIP_STAGE_SOLVING
    2398 */
    2399SCIP_EXPORT
    2400SCIP_RETCODE SCIPinferBinvarCons(
    2401 SCIP* scip, /**< SCIP data structure */
    2402 SCIP_VAR* var, /**< binary variable to fix */
    2403 SCIP_Bool fixedval, /**< value to fix binary variable to */
    2404 SCIP_CONS* infercons, /**< constraint that deduced the fixing */
    2405 int inferinfo, /**< user information for inference to help resolving the conflict */
    2406 SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
    2407 SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
    2408 );
    2409
    2410/** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
    2411 * than the current bound; if possible, adjusts bound to integral value;
    2412 * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
    2413 * for the deduction of the bound change
    2414 *
    2415 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2416 * SCIPgetVars()) gets resorted.
    2417 *
    2418 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2419 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2420 *
    2421 * @pre This method can be called if @p scip is in one of the following stages:
    2422 * - \ref SCIP_STAGE_PROBLEM
    2423 * - \ref SCIP_STAGE_PRESOLVING
    2424 * - \ref SCIP_STAGE_SOLVING
    2425 *
    2426 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2427 */
    2428SCIP_EXPORT
    2429SCIP_RETCODE SCIPinferVarUbConsExact(
    2430 SCIP* scip, /**< SCIP data structure */
    2431 SCIP_VAR* var, /**< variable to change the bound for */
    2432 SCIP_RATIONAL* newbound, /**< new value for bound */
    2433 SCIP_CONS* infercons, /**< constraint that deduced the bound change */
    2434 int inferinfo, /**< user information for inference to help resolving the conflict */
    2435 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2436 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2437 );
    2438
    2439/** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
    2440 * than the current bound; if possible, adjusts bound to integral value;
    2441 * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
    2442 * for the deduction of the bound change
    2443 *
    2444 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2445 * SCIPgetVars()) gets resorted.
    2446 *
    2447 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2448 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2449 *
    2450 * @pre This method can be called if @p scip is in one of the following stages:
    2451 * - \ref SCIP_STAGE_PROBLEM
    2452 * - \ref SCIP_STAGE_PRESOLVING
    2453 * - \ref SCIP_STAGE_SOLVING
    2454 *
    2455 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2456 */
    2457SCIP_EXPORT
    2458SCIP_RETCODE SCIPinferVarLbConsExact(
    2459 SCIP* scip, /**< SCIP data structure */
    2460 SCIP_VAR* var, /**< variable to change the bound for */
    2461 SCIP_RATIONAL* newbound, /**< new value for bound */
    2462 SCIP_CONS* infercons, /**< constraint that deduced the bound change */
    2463 int inferinfo, /**< user information for inference to help resolving the conflict */
    2464 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2465 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2466 );
    2467
    2468/** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
    2469 * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
    2470 * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
    2471 *
    2472 * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
    2473 * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
    2474 * SCIPinferVarUbProp
    2475 *
    2476 * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
    2477 * SCIPgetVars()) gets re-sorted.
    2478 *
    2479 * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
    2480 */
    2481SCIP_EXPORT
    2482SCIP_RETCODE SCIPinferVarFixProp(
    2483 SCIP* scip, /**< SCIP data structure */
    2484 SCIP_VAR* var, /**< variable to change the bound for */
    2485 SCIP_Real fixedval, /**< new value for fixation */
    2486 SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
    2487 int inferinfo, /**< user information for inference to help resolving the conflict */
    2488 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2489 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2490 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2491 );
    2492
    2493/** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
    2494 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
    2495 * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
    2496 * for the deduction of the bound change
    2497 *
    2498 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2499 * SCIPgetVars()) gets re-sorted.
    2500 *
    2501 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2502 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2503 *
    2504 * @pre This method can be called if @p scip is in one of the following stages:
    2505 * - \ref SCIP_STAGE_PROBLEM
    2506 * - \ref SCIP_STAGE_PRESOLVING
    2507 * - \ref SCIP_STAGE_SOLVING
    2508 *
    2509 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2510 */
    2511SCIP_EXPORT
    2512SCIP_RETCODE SCIPinferVarLbProp(
    2513 SCIP* scip, /**< SCIP data structure */
    2514 SCIP_VAR* var, /**< variable to change the bound for */
    2515 SCIP_Real newbound, /**< new value for bound */
    2516 SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
    2517 int inferinfo, /**< user information for inference to help resolving the conflict */
    2518 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2519 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2520 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2521 );
    2522
    2523/** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
    2524 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
    2525 * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
    2526 * for the deduction of the bound change
    2527 *
    2528 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2529 * SCIPgetVars()) gets re-sorted.
    2530 *
    2531 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2532 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2533 *
    2534 * @pre This method can be called if @p scip is in one of the following stages:
    2535 * - \ref SCIP_STAGE_PROBLEM
    2536 * - \ref SCIP_STAGE_PRESOLVING
    2537 * - \ref SCIP_STAGE_SOLVING
    2538 *
    2539 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2540 */
    2541SCIP_EXPORT
    2542SCIP_RETCODE SCIPinferVarUbProp(
    2543 SCIP* scip, /**< SCIP data structure */
    2544 SCIP_VAR* var, /**< variable to change the bound for */
    2545 SCIP_Real newbound, /**< new value for bound */
    2546 SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
    2547 int inferinfo, /**< user information for inference to help resolving the conflict */
    2548 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2549 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2550 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2551 );
    2552
    2553/** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
    2554 * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
    2555 * deduction of the fixing
    2556 *
    2557 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2558 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2559 *
    2560 * @pre This method can be called if @p scip is in one of the following stages:
    2561 * - \ref SCIP_STAGE_PROBLEM
    2562 * - \ref SCIP_STAGE_PRESOLVING
    2563 * - \ref SCIP_STAGE_PRESOLVED
    2564 * - \ref SCIP_STAGE_SOLVING
    2565 */
    2566SCIP_EXPORT
    2567SCIP_RETCODE SCIPinferBinvarProp(
    2568 SCIP* scip, /**< SCIP data structure */
    2569 SCIP_VAR* var, /**< binary variable to fix */
    2570 SCIP_Bool fixedval, /**< value to fix binary variable to */
    2571 SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
    2572 int inferinfo, /**< user information for inference to help resolving the conflict */
    2573 SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
    2574 SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
    2575 );
    2576
    2577/** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
    2578 * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
    2579 * also tightens the local bound, if the global bound is better than the local bound
    2580 *
    2581 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2582 * SCIPgetVars()) gets re-sorted.
    2583 *
    2584 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2585 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2586 *
    2587 * @pre This method can be called if @p scip is in one of the following stages:
    2588 * - \ref SCIP_STAGE_PROBLEM
    2589 * - \ref SCIP_STAGE_TRANSFORMING
    2590 * - \ref SCIP_STAGE_PRESOLVING
    2591 * - \ref SCIP_STAGE_SOLVING
    2592 *
    2593 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2594 */
    2595SCIP_EXPORT
    2596SCIP_RETCODE SCIPtightenVarLbGlobal(
    2597 SCIP* scip, /**< SCIP data structure */
    2598 SCIP_VAR* var, /**< variable to change the bound for */
    2599 SCIP_Real newbound, /**< new value for bound */
    2600 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2601 SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
    2602 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2603 );
    2604
    2605/** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
    2606 * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
    2607 * also tightens the local bound, if the global bound is better than the local bound
    2608 *
    2609 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2610 * SCIPgetVars()) gets re-sorted.
    2611 *
    2612 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2613 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2614 *
    2615 * @pre This method can be called if @p scip is in one of the following stages:
    2616 * - \ref SCIP_STAGE_PROBLEM
    2617 * - \ref SCIP_STAGE_TRANSFORMING
    2618 * - \ref SCIP_STAGE_PRESOLVING
    2619 * - \ref SCIP_STAGE_SOLVING
    2620 *
    2621 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2622 */
    2623SCIP_EXPORT
    2624SCIP_RETCODE SCIPtightenVarUbGlobal(
    2625 SCIP* scip, /**< SCIP data structure */
    2626 SCIP_VAR* var, /**< variable to change the bound for */
    2627 SCIP_Real newbound, /**< new value for bound */
    2628 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2629 SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
    2630 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2631 );
    2632
    2633/** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
    2634 *
    2635 * 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
    2636 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
    2637 *
    2638 * @return the global lower bound computed by adding the global bounds from all aggregation variables
    2639 */
    2640SCIP_EXPORT
    2641SCIP_Real SCIPcomputeVarLbGlobal(
    2642 SCIP* scip, /**< SCIP data structure */
    2643 SCIP_VAR* var /**< variable to compute the bound for */
    2644 );
    2645
    2646/** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
    2647 *
    2648 * 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
    2649 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal.
    2650 *
    2651 * @return the global upper bound computed by adding the global bounds from all aggregation variables
    2652 */
    2653SCIP_EXPORT
    2654SCIP_Real SCIPcomputeVarUbGlobal(
    2655 SCIP* scip, /**< SCIP data structure */
    2656 SCIP_VAR* var /**< variable to compute the bound for */
    2657 );
    2658
    2659/** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
    2660 *
    2661 * 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
    2662 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
    2663 *
    2664 * @return the local lower bound computed by adding the global bounds from all aggregation variables
    2665 */
    2666SCIP_EXPORT
    2667SCIP_Real SCIPcomputeVarLbLocal(
    2668 SCIP* scip, /**< SCIP data structure */
    2669 SCIP_VAR* var /**< variable to compute the bound for */
    2670 );
    2671
    2672/** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
    2673 *
    2674 * 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
    2675 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
    2676 *
    2677 * @return the local lower bound computed by adding the global bounds from all aggregation variables
    2678 */
    2679SCIP_EXPORT
    2680SCIP_RETCODE SCIPcomputeVarLbLocalExact(
    2681 SCIP* scip, /**< SCIP data structure */
    2682 SCIP_VAR* var, /**< variable to compute the bound for */
    2683 SCIP_RATIONAL* result /**< rational to store the resulting bound */
    2684 );
    2685
    2686/** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
    2687 *
    2688 * 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
    2689 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
    2690 *
    2691 * @return the local upper bound computed by adding the global bounds from all aggregation variables
    2692 */
    2693SCIP_EXPORT
    2694SCIP_Real SCIPcomputeVarUbLocal(
    2695 SCIP* scip, /**< SCIP data structure */
    2696 SCIP_VAR* var /**< variable to compute the bound for */
    2697 );
    2698
    2699/** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
    2700 *
    2701 * 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
    2702 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
    2703 *
    2704 * @return the local upper bound computed by adding the global bounds from all aggregation variables
    2705 */
    2706SCIP_EXPORT
    2707SCIP_RETCODE SCIPcomputeVarUbLocalExact(
    2708 SCIP* scip, /**< SCIP data structure */
    2709 SCIP_VAR* var, /**< variable to compute the bound for */
    2710 SCIP_RATIONAL* result /**< rational to store the resulting bound */
    2711 );
    2712
    2713/** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
    2714 * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
    2715 * not updated if bounds of aggregation variables are changing
    2716 *
    2717 * calling this function for a non-multi-aggregated variable is not allowed
    2718 */
    2719SCIP_EXPORT
    2720SCIP_Real SCIPgetVarMultaggrLbGlobal(
    2721 SCIP* scip, /**< SCIP data structure */
    2722 SCIP_VAR* var /**< variable to compute the bound for */
    2723 );
    2724
    2725/** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
    2726 * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
    2727 * not updated if bounds of aggregation variables are changing
    2728 *
    2729 * calling this function for a non-multi-aggregated variable is not allowed
    2730 */
    2731SCIP_EXPORT
    2732SCIP_Real SCIPgetVarMultaggrUbGlobal(
    2733 SCIP* scip, /**< SCIP data structure */
    2734 SCIP_VAR* var /**< variable to compute the bound for */
    2735 );
    2736
    2737/** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
    2738 * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
    2739 * not updated if bounds of aggregation variables are changing
    2740 *
    2741 * calling this function for a non-multi-aggregated variable is not allowed
    2742 */
    2743SCIP_EXPORT
    2744SCIP_Real SCIPgetVarMultaggrLbLocal(
    2745 SCIP* scip, /**< SCIP data structure */
    2746 SCIP_VAR* var /**< variable to compute the bound for */
    2747 );
    2748
    2749/** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
    2750 * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
    2751 * not updated if bounds of aggregation variables are changing
    2752 *
    2753 * calling this function for a non-multi-aggregated variable is not allowed
    2754 */
    2755SCIP_EXPORT
    2756SCIP_Real SCIPgetVarMultaggrUbLocal(
    2757 SCIP* scip, /**< SCIP data structure */
    2758 SCIP_VAR* var /**< variable to compute the bound for */
    2759 );
    2760
    2761#ifdef NDEBUG
    2762
    2763/* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
    2764 * speed up the algorithms.
    2765 */
    2766
    2767#define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbGlobal(scip, var) : SCIPvarGetLbGlobal(var))
    2768#define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbGlobal(scip, var) : SCIPvarGetUbGlobal(var))
    2769#define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbLocal(scip, var) : SCIPvarGetLbLocal(var))
    2770#define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbLocal(scip, var) : SCIPvarGetUbLocal(var))
    2771
    2772#endif
    2773
    2774/** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
    2775 * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
    2776 * available
    2777 *
    2778 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2779 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2780 *
    2781 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
    2782 */
    2783SCIP_EXPORT
    2784SCIP_RETCODE SCIPgetVarClosestVlb(
    2785 SCIP* scip, /**< SCIP data structure */
    2786 SCIP_VAR* var, /**< active problem variable */
    2787 SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
    2788 SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
    2789 int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
    2790 );
    2791
    2792/** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
    2793 * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
    2794 *
    2795 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2796 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2797 *
    2798 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
    2799 */
    2800SCIP_EXPORT
    2801SCIP_RETCODE SCIPgetVarClosestVub(
    2802 SCIP* scip, /**< SCIP data structure */
    2803 SCIP_VAR* var, /**< active problem variable */
    2804 SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
    2805 SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
    2806 int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
    2807 );
    2808
    2809/** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
    2810 * if z is binary, the corresponding valid implication for z is also added;
    2811 * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
    2812 * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
    2813 * improves the global bounds of the variable and the vlb variable if possible
    2814 *
    2815 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2816 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2817 *
    2818 * @pre This method can be called if @p scip is in one of the following stages:
    2819 * - \ref SCIP_STAGE_PRESOLVING
    2820 * - \ref SCIP_STAGE_PRESOLVED
    2821 * - \ref SCIP_STAGE_SOLVING
    2822 */
    2823SCIP_EXPORT
    2824SCIP_RETCODE SCIPaddVarVlb(
    2825 SCIP* scip, /**< SCIP data structure */
    2826 SCIP_VAR* var, /**< problem variable */
    2827 SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
    2828 SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
    2829 SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
    2830 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
    2831 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
    2832 );
    2833
    2834
    2835/** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
    2836 * if z is binary, the corresponding valid implication for z is also added;
    2837 * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
    2838 * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
    2839 * improves the global bounds of the variable and the vlb variable if possible
    2840 *
    2841 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2842 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2843 *
    2844 * @pre This method can be called if @p scip is in one of the following stages:
    2845 * - \ref SCIP_STAGE_PRESOLVING
    2846 * - \ref SCIP_STAGE_PRESOLVED
    2847 * - \ref SCIP_STAGE_SOLVING
    2848 */
    2849SCIP_EXPORT
    2850SCIP_RETCODE SCIPaddVarVub(
    2851 SCIP* scip, /**< SCIP data structure */
    2852 SCIP_VAR* var, /**< problem variable */
    2853 SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
    2854 SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
    2855 SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
    2856 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
    2857 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
    2858 );
    2859
    2860/** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
    2861 * also adds the corresponding implication or variable bound to the implied variable;
    2862 * if the implication is conflicting, the variable is fixed to the opposite value;
    2863 * if the variable is already fixed to the given value, the implication is performed immediately;
    2864 * if the implication is redundant with respect to the variables' global bounds, it is ignored
    2865 *
    2866 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2867 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2868 *
    2869 * @pre This method can be called if @p scip is in one of the following stages:
    2870 * - \ref SCIP_STAGE_TRANSFORMED
    2871 * - \ref SCIP_STAGE_PRESOLVING
    2872 * - \ref SCIP_STAGE_PRESOLVED
    2873 * - \ref SCIP_STAGE_SOLVING
    2874 */
    2875SCIP_EXPORT
    2876SCIP_RETCODE SCIPaddVarImplication(
    2877 SCIP* scip, /**< SCIP data structure */
    2878 SCIP_VAR* var, /**< problem variable */
    2879 SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
    2880 SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
    2881 SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
    2882 * or y >= b (SCIP_BOUNDTYPE_LOWER) */
    2883 SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
    2884 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
    2885 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
    2886 );
    2887
    2888/** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
    2889 * if a variable appears twice in the same clique, the corresponding implications are performed
    2890 *
    2891 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2892 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2893 *
    2894 * @pre This method can be called if @p scip is in one of the following stages:
    2895 * - \ref SCIP_STAGE_TRANSFORMED
    2896 * - \ref SCIP_STAGE_PRESOLVING
    2897 * - \ref SCIP_STAGE_PRESOLVED
    2898 * - \ref SCIP_STAGE_SOLVING
    2899 */
    2900SCIP_EXPORT
    2901SCIP_RETCODE SCIPaddClique(
    2902 SCIP* scip, /**< SCIP data structure */
    2903 SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
    2904 SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
    2905 int nvars, /**< number of variables in the clique */
    2906 SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
    2907 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
    2908 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
    2909 );
    2910
    2911/** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
    2912 *
    2913 * The algorithm performs the following steps:
    2914 * - recomputes connected components of the clique table, if necessary
    2915 * - computes a clique partition for every connected component greedily.
    2916 * - relabels the resulting clique partition such that it satisfies the description below
    2917 *
    2918 * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
    2919 * were assigned to the same clique;
    2920 * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
    2921 * the preceding variables was assigned to clique i-1;
    2922 * for each clique at most 1 variables can be set to TRUE in a feasible solution;
    2923 *
    2924 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2925 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2926 *
    2927 * @pre This method can be called if @p scip is in one of the following stages:
    2928 * - \ref SCIP_STAGE_INITPRESOLVE
    2929 * - \ref SCIP_STAGE_PRESOLVING
    2930 * - \ref SCIP_STAGE_EXITPRESOLVE
    2931 * - \ref SCIP_STAGE_PRESOLVED
    2932 * - \ref SCIP_STAGE_SOLVING
    2933 */
    2934SCIP_EXPORT
    2935SCIP_RETCODE SCIPcalcCliquePartition(
    2936 SCIP* scip, /**< SCIP data structure */
    2937 SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
    2938 int nvars, /**< number of variables in the clique */
    2939 int** probtoidxmap, /**< cleared memory array with default values -1 */
    2940 int* probtoidxmapsize, /**< returns size of probtoidxmap */
    2941 int* cliquepartition, /**< array of length nvars to store the clique partition */
    2942 int* ncliques /**< pointer to store the number of cliques actually contained in the partition */
    2943 );
    2944
    2945/** calculates a partition of the given set of binary variables into negated cliques;
    2946 * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
    2947 * were assigned to the same negated clique;
    2948 * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
    2949 * the preceding variables was assigned to clique i-1;
    2950 * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
    2951 *
    2952 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2953 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2954 *
    2955 * @pre This method can be called if @p scip is in one of the following stages:
    2956 * - \ref SCIP_STAGE_INITPRESOLVE
    2957 * - \ref SCIP_STAGE_PRESOLVING
    2958 * - \ref SCIP_STAGE_EXITPRESOLVE
    2959 * - \ref SCIP_STAGE_PRESOLVED
    2960 * - \ref SCIP_STAGE_SOLVING
    2961 */
    2962SCIP_EXPORT
    2963SCIP_RETCODE SCIPcalcNegatedCliquePartition(
    2964 SCIP* scip, /**< SCIP data structure */
    2965 SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
    2966 int nvars, /**< number of variables in the clique */
    2967 int** probtoidxmap, /**< cleared memory array with default values -1 */
    2968 int* probtoidxmapsize, /**< returns size of probtoidxmap */
    2969 int* cliquepartition, /**< array of length nvars to store the clique partition */
    2970 int* ncliques /**< pointer to store the number of cliques actually contained in the partition */
    2971 );
    2972
    2973/** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
    2974 * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
    2975 *
    2976 * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
    2977 *
    2978 * @pre This method can be called if @p scip is in one of the following stages:
    2979 * - \ref SCIP_STAGE_TRANSFORMED
    2980 * - \ref SCIP_STAGE_INITPRESOLVE
    2981 * - \ref SCIP_STAGE_PRESOLVING
    2982 * - \ref SCIP_STAGE_EXITPRESOLVE
    2983 * - \ref SCIP_STAGE_PRESOLVED
    2984 * - \ref SCIP_STAGE_INITSOLVE
    2985 * - \ref SCIP_STAGE_SOLVING
    2986 * - \ref SCIP_STAGE_SOLVED
    2987 * - \ref SCIP_STAGE_EXITSOLVE
    2988 */
    2989SCIP_EXPORT
    2990SCIP_RETCODE SCIPcleanupCliques(
    2991 SCIP* scip, /**< SCIP data structure */
    2992 SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */
    2993 );
    2994
    2995/** gets the number of cliques in the clique table
    2996 *
    2997 * @return number of cliques in the clique table
    2998 *
    2999 * @pre This method can be called if @p scip is in one of the following stages:
    3000 * - \ref SCIP_STAGE_TRANSFORMED
    3001 * - \ref SCIP_STAGE_INITPRESOLVE
    3002 * - \ref SCIP_STAGE_PRESOLVING
    3003 * - \ref SCIP_STAGE_EXITPRESOLVE
    3004 * - \ref SCIP_STAGE_PRESOLVED
    3005 * - \ref SCIP_STAGE_INITSOLVE
    3006 * - \ref SCIP_STAGE_SOLVING
    3007 * - \ref SCIP_STAGE_SOLVED
    3008 * - \ref SCIP_STAGE_EXITSOLVE
    3009 */
    3010SCIP_EXPORT
    3011int SCIPgetNCliques(
    3012 SCIP* scip /**< SCIP data structure */
    3013 );
    3014
    3015/** gets the number of cliques created so far by the cliquetable
    3016 *
    3017 * @return number of cliques created so far by the cliquetable
    3018 *
    3019 * @pre This method can be called if @p scip is in one of the following stages:
    3020 * - \ref SCIP_STAGE_TRANSFORMED
    3021 * - \ref SCIP_STAGE_INITPRESOLVE
    3022 * - \ref SCIP_STAGE_PRESOLVING
    3023 * - \ref SCIP_STAGE_EXITPRESOLVE
    3024 * - \ref SCIP_STAGE_PRESOLVED
    3025 * - \ref SCIP_STAGE_INITSOLVE
    3026 * - \ref SCIP_STAGE_SOLVING
    3027 * - \ref SCIP_STAGE_SOLVED
    3028 * - \ref SCIP_STAGE_EXITSOLVE
    3029 */
    3030SCIP_EXPORT
    3031int SCIPgetNCliquesCreated(
    3032 SCIP* scip /**< SCIP data structure */
    3033 );
    3034
    3035/** gets the array of cliques in the clique table
    3036 *
    3037 * @return array of cliques in the clique table
    3038 *
    3039 * @pre This method can be called if @p scip is in one of the following stages:
    3040 * - \ref SCIP_STAGE_TRANSFORMED
    3041 * - \ref SCIP_STAGE_INITPRESOLVE
    3042 * - \ref SCIP_STAGE_PRESOLVING
    3043 * - \ref SCIP_STAGE_EXITPRESOLVE
    3044 * - \ref SCIP_STAGE_PRESOLVED
    3045 * - \ref SCIP_STAGE_INITSOLVE
    3046 * - \ref SCIP_STAGE_SOLVING
    3047 * - \ref SCIP_STAGE_SOLVED
    3048 * - \ref SCIP_STAGE_EXITSOLVE
    3049 */
    3050SCIP_EXPORT
    3051SCIP_CLIQUE** SCIPgetCliques(
    3052 SCIP* scip /**< SCIP data structure */
    3053 );
    3054
    3055/** returns whether there is a clique that contains both given variable/value pairs;
    3056 * the variables must be active binary variables;
    3057 * if regardimplics is FALSE, only the cliques in the clique table are looked at;
    3058 * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
    3059 *
    3060 * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
    3061 *
    3062 * @pre This method can be called if @p scip is in one of the following stages:
    3063 * - \ref SCIP_STAGE_TRANSFORMED
    3064 * - \ref SCIP_STAGE_INITPRESOLVE
    3065 * - \ref SCIP_STAGE_PRESOLVING
    3066 * - \ref SCIP_STAGE_EXITPRESOLVE
    3067 * - \ref SCIP_STAGE_PRESOLVED
    3068 * - \ref SCIP_STAGE_INITSOLVE
    3069 * - \ref SCIP_STAGE_SOLVING
    3070 * - \ref SCIP_STAGE_SOLVED
    3071 * - \ref SCIP_STAGE_EXITSOLVE
    3072 *
    3073 * @note a variable with it's negated variable are NOT! in a clique
    3074 * @note a variable with itself are in a clique
    3075 */
    3076SCIP_EXPORT
    3077SCIP_Bool SCIPhaveVarsCommonClique(
    3078 SCIP* scip, /**< SCIP data structure */
    3079 SCIP_VAR* var1, /**< first variable */
    3080 SCIP_Bool value1, /**< value of first variable */
    3081 SCIP_VAR* var2, /**< second variable */
    3082 SCIP_Bool value2, /**< value of second variable */
    3083 SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
    3084 );
    3085
    3086/** writes the clique graph to a gml file
    3087 *
    3088 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3089 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3090 *
    3091 * @pre This method can be called if @p scip is in one of the following stages:
    3092 * - \ref SCIP_STAGE_TRANSFORMED
    3093 * - \ref SCIP_STAGE_INITPRESOLVE
    3094 * - \ref SCIP_STAGE_PRESOLVING
    3095 * - \ref SCIP_STAGE_EXITPRESOLVE
    3096 * - \ref SCIP_STAGE_PRESOLVED
    3097 * - \ref SCIP_STAGE_INITSOLVE
    3098 * - \ref SCIP_STAGE_SOLVING
    3099 * - \ref SCIP_STAGE_SOLVED
    3100 * - \ref SCIP_STAGE_EXITSOLVE
    3101 *
    3102 * @note there can be duplicated arcs in the output file
    3103 *
    3104 * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
    3105 * between such nodes are written.
    3106 */
    3107SCIP_EXPORT
    3108SCIP_RETCODE SCIPwriteCliqueGraph(
    3109 SCIP* scip, /**< SCIP data structure */
    3110 const char* fname, /**< name of file */
    3111 SCIP_Bool writenodeweights /**< should we write weights of nodes? */
    3112 );
    3113
    3114/** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
    3115 * This is an advanced method which should be used with care.
    3116 *
    3117 * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
    3118 *
    3119 * @pre This method can be called if @p scip is in one of the following stages:
    3120 * - \ref SCIP_STAGE_TRANSFORMED
    3121 * - \ref SCIP_STAGE_INITPRESOLVE
    3122 * - \ref SCIP_STAGE_PRESOLVING
    3123 * - \ref SCIP_STAGE_EXITPRESOLVE
    3124 * - \ref SCIP_STAGE_PRESOLVED
    3125 * - \ref SCIP_STAGE_INITSOLVE
    3126 * - \ref SCIP_STAGE_SOLVING
    3127 * - \ref SCIP_STAGE_SOLVED
    3128 * - \ref SCIP_STAGE_EXITSOLVE
    3129 */
    3130SCIP_EXPORT
    3131SCIP_RETCODE SCIPremoveVarFromGlobalStructures(
    3132 SCIP* scip, /**< SCIP data structure */
    3133 SCIP_VAR* var /**< variable to remove from global structures */
    3134 );
    3135
    3136/** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
    3137 * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
    3138 *
    3139 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3140 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3141 *
    3142 * @pre This method can be called if @p scip is in one of the following stages:
    3143 * - \ref SCIP_STAGE_PROBLEM
    3144 * - \ref SCIP_STAGE_TRANSFORMING
    3145 * - \ref SCIP_STAGE_TRANSFORMED
    3146 * - \ref SCIP_STAGE_INITPRESOLVE
    3147 * - \ref SCIP_STAGE_PRESOLVING
    3148 * - \ref SCIP_STAGE_EXITPRESOLVE
    3149 * - \ref SCIP_STAGE_PRESOLVED
    3150 * - \ref SCIP_STAGE_SOLVING
    3151 */
    3152SCIP_EXPORT
    3153SCIP_RETCODE SCIPchgVarBranchFactor(
    3154 SCIP* scip, /**< SCIP data structure */
    3155 SCIP_VAR* var, /**< problem variable */
    3156 SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
    3157 );
    3158
    3159/** scales the branch factor of the variable with the given value
    3160 *
    3161 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3162 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3163 *
    3164 * @pre This method can be called if @p scip is in one of the following stages:
    3165 * - \ref SCIP_STAGE_PROBLEM
    3166 * - \ref SCIP_STAGE_TRANSFORMING
    3167 * - \ref SCIP_STAGE_TRANSFORMED
    3168 * - \ref SCIP_STAGE_INITPRESOLVE
    3169 * - \ref SCIP_STAGE_PRESOLVING
    3170 * - \ref SCIP_STAGE_EXITPRESOLVE
    3171 * - \ref SCIP_STAGE_PRESOLVED
    3172 * - \ref SCIP_STAGE_SOLVING
    3173 */
    3174SCIP_EXPORT
    3175SCIP_RETCODE SCIPscaleVarBranchFactor(
    3176 SCIP* scip, /**< SCIP data structure */
    3177 SCIP_VAR* var, /**< problem variable */
    3178 SCIP_Real scale /**< factor to scale variable's branching factor with */
    3179 );
    3180
    3181/** adds the given value to the branch factor of the variable
    3182 *
    3183 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3184 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3185 *
    3186 * @pre This method can be called if @p scip is in one of the following stages:
    3187 * - \ref SCIP_STAGE_PROBLEM
    3188 * - \ref SCIP_STAGE_TRANSFORMING
    3189 * - \ref SCIP_STAGE_TRANSFORMED
    3190 * - \ref SCIP_STAGE_INITPRESOLVE
    3191 * - \ref SCIP_STAGE_PRESOLVING
    3192 * - \ref SCIP_STAGE_EXITPRESOLVE
    3193 * - \ref SCIP_STAGE_PRESOLVED
    3194 * - \ref SCIP_STAGE_SOLVING
    3195 */
    3196SCIP_EXPORT
    3197SCIP_RETCODE SCIPaddVarBranchFactor(
    3198 SCIP* scip, /**< SCIP data structure */
    3199 SCIP_VAR* var, /**< problem variable */
    3200 SCIP_Real addfactor /**< value to add to the branch factor of the variable */
    3201 );
    3202
    3203/** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
    3204 * with lower priority in selection of branching variable
    3205 *
    3206 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3207 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3208 *
    3209 * @pre This method can be called if @p scip is in one of the following stages:
    3210 * - \ref SCIP_STAGE_PROBLEM
    3211 * - \ref SCIP_STAGE_TRANSFORMING
    3212 * - \ref SCIP_STAGE_TRANSFORMED
    3213 * - \ref SCIP_STAGE_INITPRESOLVE
    3214 * - \ref SCIP_STAGE_PRESOLVING
    3215 * - \ref SCIP_STAGE_EXITPRESOLVE
    3216 * - \ref SCIP_STAGE_PRESOLVED
    3217 * - \ref SCIP_STAGE_SOLVING
    3218 *
    3219 * @note the default branching priority is 0
    3220 */
    3221SCIP_EXPORT
    3222SCIP_RETCODE SCIPchgVarBranchPriority(
    3223 SCIP* scip, /**< SCIP data structure */
    3224 SCIP_VAR* var, /**< problem variable */
    3225 int branchpriority /**< branch priority of the variable */
    3226 );
    3227
    3228/** changes the branch priority of the variable to the given value, if it is larger than the current priority
    3229 *
    3230 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3231 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3232 *
    3233 * @pre This method can be called if @p scip is in one of the following stages:
    3234 * - \ref SCIP_STAGE_PROBLEM
    3235 * - \ref SCIP_STAGE_TRANSFORMING
    3236 * - \ref SCIP_STAGE_TRANSFORMED
    3237 * - \ref SCIP_STAGE_INITPRESOLVE
    3238 * - \ref SCIP_STAGE_PRESOLVING
    3239 * - \ref SCIP_STAGE_EXITPRESOLVE
    3240 * - \ref SCIP_STAGE_PRESOLVED
    3241 * - \ref SCIP_STAGE_SOLVING
    3242 */
    3243SCIP_EXPORT
    3244SCIP_RETCODE SCIPupdateVarBranchPriority(
    3245 SCIP* scip, /**< SCIP data structure */
    3246 SCIP_VAR* var, /**< problem variable */
    3247 int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
    3248 );
    3249
    3250/** adds the given value to the branch priority of the variable
    3251 *
    3252 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3253 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3254 *
    3255 * @pre This method can be called if @p scip is in one of the following stages:
    3256 * - \ref SCIP_STAGE_PROBLEM
    3257 * - \ref SCIP_STAGE_TRANSFORMING
    3258 * - \ref SCIP_STAGE_TRANSFORMED
    3259 * - \ref SCIP_STAGE_INITPRESOLVE
    3260 * - \ref SCIP_STAGE_PRESOLVING
    3261 * - \ref SCIP_STAGE_EXITPRESOLVE
    3262 * - \ref SCIP_STAGE_PRESOLVED
    3263 * - \ref SCIP_STAGE_SOLVING
    3264 */
    3265SCIP_EXPORT
    3266SCIP_RETCODE SCIPaddVarBranchPriority(
    3267 SCIP* scip, /**< SCIP data structure */
    3268 SCIP_VAR* var, /**< problem variable */
    3269 int addpriority /**< value to add to the branch priority of the variable */
    3270 );
    3271
    3272/** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
    3273 * branch)
    3274 *
    3275 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3276 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3277 *
    3278 * @pre This method can be called if @p scip is in one of the following stages:
    3279 * - \ref SCIP_STAGE_PROBLEM
    3280 * - \ref SCIP_STAGE_TRANSFORMING
    3281 * - \ref SCIP_STAGE_TRANSFORMED
    3282 * - \ref SCIP_STAGE_INITPRESOLVE
    3283 * - \ref SCIP_STAGE_PRESOLVING
    3284 * - \ref SCIP_STAGE_EXITPRESOLVE
    3285 * - \ref SCIP_STAGE_PRESOLVED
    3286 * - \ref SCIP_STAGE_SOLVING
    3287 */
    3288SCIP_EXPORT
    3289SCIP_RETCODE SCIPchgVarBranchDirection(
    3290 SCIP* scip, /**< SCIP data structure */
    3291 SCIP_VAR* var, /**< problem variable */
    3292 SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
    3293 );
    3294
    3295/** changes type of variable in the problem;
    3296 *
    3297 * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
    3298 *
    3299 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3300 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3301 *
    3302 * @pre This method can be called if @p scip is in one of the following stages:
    3303 * - \ref SCIP_STAGE_PROBLEM
    3304 * - \ref SCIP_STAGE_TRANSFORMING
    3305 * - \ref SCIP_STAGE_PRESOLVING
    3306 *
    3307 * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
    3308 * corresponding transformed variable is changed; the type of the original variable does not change
    3309 *
    3310 * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
    3311 * adjusted w.r.t. to integrality information
    3312 */
    3313SCIP_EXPORT
    3314SCIP_RETCODE SCIPchgVarType(
    3315 SCIP* scip, /**< SCIP data structure */
    3316 SCIP_VAR* var, /**< variable to change the type for */
    3317 SCIP_VARTYPE vartype, /**< new type of variable */
    3318 SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
    3319 * integrality condition of the new variable type) */
    3320 );
    3321
    3322/** changes implied integral type of variable in the problem
    3323 *
    3324 * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
    3325 *
    3326 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3327 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3328 *
    3329 * @pre This method can be called if @p scip is in one of the following stages:
    3330 * - \ref SCIP_STAGE_PROBLEM
    3331 * - \ref SCIP_STAGE_TRANSFORMING
    3332 * - \ref SCIP_STAGE_PRESOLVING
    3333 *
    3334 * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the implied integral type of the
    3335 * corresponding transformed variable is changed; the type of the original variable does not change
    3336 *
    3337 * @note If the implied integral type is adjusted to weak or strong for a continuous variable, the bounds of the variable get
    3338 * adjusted w.r.t. to integrality information
    3339 */
    3340SCIP_EXPORT
    3341SCIP_RETCODE SCIPchgVarImplType(
    3342 SCIP* scip, /**< SCIP data structure */
    3343 SCIP_VAR* var, /**< variable to change the type for */
    3344 SCIP_IMPLINTTYPE impltype, /**< New implied integral type of the variable */
    3345 SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (due to
    3346 * integrality condition for the new variable type) */
    3347 );
    3348
    3349/** in problem creation and solving stage, both bounds of the variable are set to the given value;
    3350 * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
    3351 * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
    3352 * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
    3353 *
    3354 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3355 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3356 *
    3357 * @pre This method can be called if @p scip is in one of the following stages:
    3358 * - \ref SCIP_STAGE_PROBLEM
    3359 * - \ref SCIP_STAGE_PRESOLVING
    3360 * - \ref SCIP_STAGE_SOLVING
    3361 */
    3362SCIP_EXPORT
    3363SCIP_RETCODE SCIPfixVar(
    3364 SCIP* scip, /**< SCIP data structure */
    3365 SCIP_VAR* var, /**< variable to fix */
    3366 SCIP_Real fixedval, /**< value to fix variable to */
    3367 SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
    3368 SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
    3369 );
    3370
    3371/** in problem creation and solving stage, both bounds of the variable are set to the given value;
    3372 * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
    3373 * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
    3374 * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
    3375 *
    3376 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3377 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3378 *
    3379 * @pre This method can be called if @p scip is in one of the following stages:
    3380 * - \ref SCIP_STAGE_PROBLEM
    3381 * - \ref SCIP_STAGE_PRESOLVING
    3382 * - \ref SCIP_STAGE_SOLVING
    3383 */
    3384SCIP_EXPORT
    3385SCIP_RETCODE SCIPfixVarExact(
    3386 SCIP* scip, /**< SCIP data structure */
    3387 SCIP_VAR* var, /**< variable to fix */
    3388 SCIP_RATIONAL* fixedval, /**< value to fix variable to */
    3389 SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
    3390 SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
    3391 );
    3392
    3393/** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
    3394 * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
    3395 * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
    3396 * In the first step, the equality is transformed into an equality with active problem variables
    3397 * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
    3398 * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
    3399 * infeasibility) otherwise.
    3400 * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
    3401 * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
    3402 * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
    3403 * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
    3404 * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
    3405 * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
    3406 *
    3407 * The output flags have the following meaning:
    3408 * - infeasible: the problem is infeasible
    3409 * - redundant: the equality can be deleted from the constraint set
    3410 * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
    3411 *
    3412 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3413 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3414 *
    3415 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
    3416 */
    3417SCIP_EXPORT
    3418SCIP_RETCODE SCIPaggregateVars(
    3419 SCIP* scip, /**< SCIP data structure */
    3420 SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
    3421 SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
    3422 SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
    3423 SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
    3424 SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
    3425 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
    3426 SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
    3427 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
    3428 );
    3429
    3430/** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
    3431 * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
    3432 * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
    3433 * In the first step, the equality is transformed into an equality with active problem variables
    3434 * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
    3435 * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
    3436 * infeasibility) otherwise.
    3437 * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
    3438 * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
    3439 * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
    3440 * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
    3441 * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
    3442 * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
    3443 *
    3444 * The output flags have the following meaning:
    3445 * - infeasible: the problem is infeasible
    3446 * - redundant: the equality can be deleted from the constraint set
    3447 * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
    3448 *
    3449 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3450 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3451 *
    3452 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
    3453 */
    3454SCIP_EXPORT
    3455SCIP_RETCODE SCIPaggregateVarsExact(
    3456 SCIP* scip, /**< SCIP data structure */
    3457 SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
    3458 SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
    3459 SCIP_RATIONAL* scalarx, /**< multiplier a in equality a*x + b*y == c */
    3460 SCIP_RATIONAL* scalary, /**< multiplier b in equality a*x + b*y == c */
    3461 SCIP_RATIONAL* rhs, /**< right hand side c in equality a*x + b*y == c */
    3462 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
    3463 SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
    3464 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
    3465 );
    3466
    3467/** converts variable into multi-aggregated variable; this changes the variable array returned from
    3468 * SCIPgetVars() and SCIPgetVarsData();
    3469 *
    3470 * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
    3471 * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
    3472 * implies integrality on the aggregated variable.
    3473 *
    3474 * The output flags have the following meaning:
    3475 * - infeasible: the problem is infeasible
    3476 * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
    3477 *
    3478 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3479 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3480 *
    3481 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
    3482 */
    3483SCIP_EXPORT
    3484SCIP_RETCODE SCIPmultiaggregateVar(
    3485 SCIP* scip, /**< SCIP data structure */
    3486 SCIP_VAR* var, /**< variable x to aggregate */
    3487 int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3488 SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3489 SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3490 SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3491 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
    3492 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
    3493 );
    3494
    3495/** converts variable into exact multi-aggregated variable; this changes the variable array returned from
    3496 * SCIPgetVars() and SCIPgetVarsData();
    3497 *
    3498 * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
    3499 * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
    3500 * implies integrality on the aggregated variable.
    3501 *
    3502 * The output flags have the following meaning:
    3503 * - infeasible: the problem is infeasible
    3504 * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
    3505 *
    3506 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3507 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3508 *
    3509 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
    3510 */
    3511SCIP_EXPORT
    3512SCIP_RETCODE SCIPmultiaggregateVarExact(
    3513 SCIP* scip, /**< SCIP data structure */
    3514 SCIP_VAR* var, /**< variable x to aggregate */
    3515 int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3516 SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3517 SCIP_RATIONAL** scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3518 SCIP_RATIONAL* constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3519 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
    3520 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
    3521 );
    3522
    3523/** returns whether aggregation of variables is not allowed */
    3524SCIP_EXPORT
    3525SCIP_Bool SCIPdoNotAggr(
    3526 SCIP* scip /**< SCIP data structure */
    3527 );
    3528
    3529/** returns whether multi-aggregation is disabled */
    3530SCIP_EXPORT
    3531SCIP_Bool SCIPdoNotMultaggr(
    3532 SCIP* scip /**< SCIP data structure */
    3533 );
    3534
    3535/** returns whether variable is not allowed to be aggregated */
    3536SCIP_EXPORT
    3537SCIP_Bool SCIPdoNotAggrVar(
    3538 SCIP* scip, /**< SCIP data structure */
    3539 SCIP_VAR* var /**< variable x to aggregate */
    3540 );
    3541
    3542/** returns whether variable is not allowed to be multi-aggregated */
    3543SCIP_EXPORT
    3544SCIP_Bool SCIPdoNotMultaggrVar(
    3545 SCIP* scip, /**< SCIP data structure */
    3546 SCIP_VAR* var /**< variable x to aggregate */
    3547 );
    3548
    3549/** checks whether a loose variable can be used in a new aggregation with given coefficient
    3550 *
    3551 * Checks whether multiplying the bounds on the coefficient with which the variable appears in aggregations
    3552 * (SCIPvarGetMinAggrCoef(), SCIPvarGetMaxAggrCoef()) by the given scalar would exceed acceptable values
    3553 * (numerics/sumepsilon and 1.0 / numerics/sumepsilon).
    3554 *
    3555 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
    3556 */
    3557SCIP_EXPORT
    3558SCIP_Bool SCIPisVarAggrCoefAcceptable(
    3559 SCIP* scip, /**< SCIP data structure */
    3560 SCIP_VAR* var, /**< problem variable */
    3561 SCIP_Real scalar /**< aggregation scalar */
    3562 );
    3563
    3564/** returns whether strong dual reductions are allowed during propagation and presolving
    3565 *
    3566 * @note A reduction is called strong dual, if it may discard feasible/optimal solutions, but leaves at least one
    3567 * optimal solution intact. Often such reductions are based on analyzing the objective function and variable
    3568 * locks.
    3569 */
    3570SCIP_EXPORT
    3571SCIP_Bool SCIPallowStrongDualReds(
    3572 SCIP* scip /**< SCIP data structure */
    3573 );
    3574
    3575/** returns whether weak dual reductions are allowed during propagation and presolving
    3576 *
    3577 * @note A reduction is called weak dual, if it may discard feasible solutions, but leaves at all optimal solutions
    3578 * intact. Often such reductions are based on analyzing the objective function, reduced costs, and/or dual LPs.
    3579 */
    3580SCIP_EXPORT
    3581SCIP_Bool SCIPallowWeakDualReds(
    3582 SCIP* scip /**< SCIP data structure */
    3583 );
    3584
    3585/** marks the variable that it must not be aggregated
    3586 *
    3587 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3588 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3589 *
    3590 * @pre This method can be called if @p scip is in one of the following stages:
    3591 * - \ref SCIP_STAGE_INIT
    3592 * - \ref SCIP_STAGE_PROBLEM
    3593 * - \ref SCIP_STAGE_TRANSFORMING
    3594 * - \ref SCIP_STAGE_TRANSFORMED
    3595 * - \ref SCIP_STAGE_INITPRESOLVE
    3596 * - \ref SCIP_STAGE_PRESOLVING
    3597 * - \ref SCIP_STAGE_EXITPRESOLVE
    3598 *
    3599 * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
    3600 * aggregated that this is will be the case.
    3601 */
    3602SCIP_EXPORT
    3603SCIP_RETCODE SCIPmarkDoNotAggrVar(
    3604 SCIP* scip, /**< SCIP data structure */
    3605 SCIP_VAR* var /**< variable to delete */
    3606 );
    3607
    3608/** marks the variable that it must not be multi-aggregated
    3609 *
    3610 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3611 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3612 *
    3613 * @pre This method can be called if @p scip is in one of the following stages:
    3614 * - \ref SCIP_STAGE_INIT
    3615 * - \ref SCIP_STAGE_PROBLEM
    3616 * - \ref SCIP_STAGE_TRANSFORMING
    3617 * - \ref SCIP_STAGE_TRANSFORMED
    3618 * - \ref SCIP_STAGE_INITPRESOLVE
    3619 * - \ref SCIP_STAGE_PRESOLVING
    3620 * - \ref SCIP_STAGE_EXITPRESOLVE
    3621 *
    3622 * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
    3623 * multi-aggregated that this is will be the case.
    3624 */
    3625SCIP_EXPORT
    3626SCIP_RETCODE SCIPmarkDoNotMultaggrVar(
    3627 SCIP* scip, /**< SCIP data structure */
    3628 SCIP_VAR* var /**< variable to delete */
    3629 );
    3630
    3631/** enables the collection of statistics for a variable
    3632 *
    3633 * @pre This method can be called if @p scip is in one of the following stages:
    3634 * - \ref SCIP_STAGE_PROBLEM
    3635 * - \ref SCIP_STAGE_INITPRESOLVE
    3636 * - \ref SCIP_STAGE_PRESOLVING
    3637 * - \ref SCIP_STAGE_EXITPRESOLVE
    3638 * - \ref SCIP_STAGE_SOLVING
    3639 * - \ref SCIP_STAGE_SOLVED
    3640 */
    3641SCIP_EXPORT
    3642void SCIPenableVarHistory(
    3643 SCIP* scip /**< SCIP data structure */
    3644 );
    3645
    3646/** disables the collection of any statistic for a variable
    3647 *
    3648 * @pre This method can be called if @p scip is in one of the following stages:
    3649 * - \ref SCIP_STAGE_PROBLEM
    3650 * - \ref SCIP_STAGE_INITPRESOLVE
    3651 * - \ref SCIP_STAGE_PRESOLVING
    3652 * - \ref SCIP_STAGE_EXITPRESOLVE
    3653 * - \ref SCIP_STAGE_SOLVING
    3654 * - \ref SCIP_STAGE_SOLVED
    3655 */
    3656SCIP_EXPORT
    3657void SCIPdisableVarHistory(
    3658 SCIP* scip /**< SCIP data structure */
    3659 );
    3660
    3661/** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
    3662 * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
    3663 * the update is ignored, if the objective value difference is infinite
    3664 *
    3665 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3666 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3667 *
    3668 * @pre This method can be called if @p scip is in one of the following stages:
    3669 * - \ref SCIP_STAGE_SOLVING
    3670 * - \ref SCIP_STAGE_SOLVED
    3671 */
    3672SCIP_EXPORT
    3673SCIP_RETCODE SCIPupdateVarPseudocost(
    3674 SCIP* scip, /**< SCIP data structure */
    3675 SCIP_VAR* var, /**< problem variable */
    3676 SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
    3677 SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
    3678 SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
    3679 );
    3680
    3681/** updates the ancestor pseudo costs of the given variable and the global ancestor pseudo costs after a change of "solvaldelta" in the
    3682 * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
    3683 * the update is ignored, if the objective value difference is infinite
    3684 *
    3685 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3686 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3687 *
    3688 * @pre This method can be called if @p scip is in one of the following stages:
    3689 * - \ref SCIP_STAGE_SOLVING
    3690 * - \ref SCIP_STAGE_SOLVED
    3691 */
    3692SCIP_EXPORT
    3693SCIP_RETCODE SCIPupdateVarAncPseudocost(
    3694 SCIP* scip, /**< SCIP data structure */
    3695 SCIP_VAR* var, /**< problem variable */
    3696 SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
    3697 SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
    3698 SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
    3699 );
    3700
    3701/** gets the variable's pseudo cost value for the given change of the variable's LP value
    3702 *
    3703 * @return the variable's pseudo cost value for the given change of the variable's LP value
    3704 *
    3705 * @pre This method can be called if @p scip is in one of the following stages:
    3706 * - \ref SCIP_STAGE_INITPRESOLVE
    3707 * - \ref SCIP_STAGE_PRESOLVING
    3708 * - \ref SCIP_STAGE_EXITPRESOLVE
    3709 * - \ref SCIP_STAGE_PRESOLVED
    3710 * - \ref SCIP_STAGE_INITSOLVE
    3711 * - \ref SCIP_STAGE_SOLVING
    3712 * - \ref SCIP_STAGE_SOLVED
    3713 */
    3714SCIP_EXPORT
    3715SCIP_Real SCIPgetVarPseudocostVal(
    3716 SCIP* scip, /**< SCIP data structure */
    3717 SCIP_VAR* var, /**< problem variable */
    3718 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
    3719 );
    3720
    3721/** gets the variable's ancestral pseudo cost value for the given change of the variable's LP value
    3722 *
    3723 * @return the variable's ancestral pseudo cost value for the given change of the variable's LP value
    3724 *
    3725 * @pre This method can be called if @p scip is in one of the following stages:
    3726 * - \ref SCIP_STAGE_INITPRESOLVE
    3727 * - \ref SCIP_STAGE_PRESOLVING
    3728 * - \ref SCIP_STAGE_EXITPRESOLVE
    3729 * - \ref SCIP_STAGE_PRESOLVED
    3730 * - \ref SCIP_STAGE_INITSOLVE
    3731 * - \ref SCIP_STAGE_SOLVING
    3732 * - \ref SCIP_STAGE_SOLVED
    3733 */
    3734SCIP_EXPORT
    3735SCIP_Real SCIPgetVarAncPseudocostVal(
    3736 SCIP* scip, /**< SCIP data structure */
    3737 SCIP_VAR* var, /**< problem variable */
    3738 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
    3739 );
    3740
    3741/** gets the variable's pseudo cost value for the given change of the variable's LP value,
    3742 * only using the pseudo cost information of the current run
    3743 *
    3744 * @return the variable's pseudo cost value for the given change of the variable's LP value,
    3745 * only using the pseudo cost information of the current run
    3746 *
    3747 * @pre This method can be called if @p scip is in one of the following stages:
    3748 * - \ref SCIP_STAGE_INITPRESOLVE
    3749 * - \ref SCIP_STAGE_PRESOLVING
    3750 * - \ref SCIP_STAGE_EXITPRESOLVE
    3751 * - \ref SCIP_STAGE_PRESOLVED
    3752 * - \ref SCIP_STAGE_INITSOLVE
    3753 * - \ref SCIP_STAGE_SOLVING
    3754 * - \ref SCIP_STAGE_SOLVED
    3755 */
    3756SCIP_EXPORT
    3757SCIP_Real SCIPgetVarPseudocostValCurrentRun(
    3758 SCIP* scip, /**< SCIP data structure */
    3759 SCIP_VAR* var, /**< problem variable */
    3760 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
    3761 );
    3762
    3763/** gets the variable's pseudo cost value for the given direction
    3764 *
    3765 * @return the variable's pseudo cost value for the given direction
    3766 *
    3767 * @pre This method can be called if @p scip is in one of the following stages:
    3768 * - \ref SCIP_STAGE_INITPRESOLVE
    3769 * - \ref SCIP_STAGE_PRESOLVING
    3770 * - \ref SCIP_STAGE_EXITPRESOLVE
    3771 * - \ref SCIP_STAGE_PRESOLVED
    3772 * - \ref SCIP_STAGE_INITSOLVE
    3773 * - \ref SCIP_STAGE_SOLVING
    3774 * - \ref SCIP_STAGE_SOLVED
    3775 */
    3776SCIP_EXPORT
    3777SCIP_Real SCIPgetVarPseudocost(
    3778 SCIP* scip, /**< SCIP data structure */
    3779 SCIP_VAR* var, /**< problem variable */
    3780 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    3781 );
    3782
    3783/** gets the variable's pseudo cost value for the given direction,
    3784 * only using the pseudo cost information of the current run
    3785 *
    3786 * @return the variable's pseudo cost value for the given direction,
    3787 * only using the pseudo cost information of the current run
    3788 *
    3789 * @pre This method can be called if @p scip is in one of the following stages:
    3790 * - \ref SCIP_STAGE_INITPRESOLVE
    3791 * - \ref SCIP_STAGE_PRESOLVING
    3792 * - \ref SCIP_STAGE_EXITPRESOLVE
    3793 * - \ref SCIP_STAGE_PRESOLVED
    3794 * - \ref SCIP_STAGE_INITSOLVE
    3795 * - \ref SCIP_STAGE_SOLVING
    3796 * - \ref SCIP_STAGE_SOLVED
    3797 */
    3798SCIP_EXPORT
    3799SCIP_Real SCIPgetVarPseudocostCurrentRun(
    3800 SCIP* scip, /**< SCIP data structure */
    3801 SCIP_VAR* var, /**< problem variable */
    3802 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    3803 );
    3804
    3805/** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
    3806 *
    3807 * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
    3808 *
    3809 * @pre This method can be called if @p scip is in one of the following stages:
    3810 * - \ref SCIP_STAGE_INITPRESOLVE
    3811 * - \ref SCIP_STAGE_PRESOLVING
    3812 * - \ref SCIP_STAGE_EXITPRESOLVE
    3813 * - \ref SCIP_STAGE_PRESOLVED
    3814 * - \ref SCIP_STAGE_INITSOLVE
    3815 * - \ref SCIP_STAGE_SOLVING
    3816 * - \ref SCIP_STAGE_SOLVED
    3817 */
    3818SCIP_EXPORT
    3819SCIP_Real SCIPgetVarPseudocostCount(
    3820 SCIP* scip, /**< SCIP data structure */
    3821 SCIP_VAR* var, /**< problem variable */
    3822 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    3823 );
    3824
    3825/** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
    3826 * only using the pseudo cost information of the current run
    3827 *
    3828 * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
    3829 * only using the pseudo cost information of the current run
    3830 *
    3831 * @pre This method can be called if @p scip is in one of the following stages:
    3832 * - \ref SCIP_STAGE_INITPRESOLVE
    3833 * - \ref SCIP_STAGE_PRESOLVING
    3834 * - \ref SCIP_STAGE_EXITPRESOLVE
    3835 * - \ref SCIP_STAGE_PRESOLVED
    3836 * - \ref SCIP_STAGE_INITSOLVE
    3837 * - \ref SCIP_STAGE_SOLVING
    3838 * - \ref SCIP_STAGE_SOLVED
    3839 */
    3840SCIP_EXPORT
    3841SCIP_Real SCIPgetVarPseudocostCountCurrentRun(
    3842 SCIP* scip, /**< SCIP data structure */
    3843 SCIP_VAR* var, /**< problem variable */
    3844 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    3845 );
    3846
    3847/** gets the variable's (possible fractional) number of ancestor pseudo cost updates for the given direction,
    3848 * only using the pseudo cost information of the current run
    3849 *
    3850 * @return the variable's (possible fractional) number of ancestor pseudo cost updates for the given direction,
    3851 * only using the pseudo cost information of the current run
    3852 *
    3853 * @pre This method can be called if @p scip is in one of the following stages:
    3854 * - \ref SCIP_STAGE_INITPRESOLVE
    3855 * - \ref SCIP_STAGE_PRESOLVING
    3856 * - \ref SCIP_STAGE_EXITPRESOLVE
    3857 * - \ref SCIP_STAGE_PRESOLVED
    3858 * - \ref SCIP_STAGE_INITSOLVE
    3859 * - \ref SCIP_STAGE_SOLVING
    3860 * - \ref SCIP_STAGE_SOLVED
    3861 */
    3862SCIP_EXPORT
    3863SCIP_Real SCIPgetVarAncPseudocostCountCurrentRun(
    3864 SCIP* scip, /**< SCIP data structure */
    3865 SCIP_VAR* var, /**< problem variable */
    3866 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    3867 );
    3868
    3869/** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
    3870 *
    3871 * @return returns the (corrected) variance of pseudo code information collected so far.
    3872 *
    3873 * @pre This method can be called if @p scip is in one of the following stages:
    3874 * - \ref SCIP_STAGE_INITPRESOLVE
    3875 * - \ref SCIP_STAGE_PRESOLVING
    3876 * - \ref SCIP_STAGE_EXITPRESOLVE
    3877 * - \ref SCIP_STAGE_PRESOLVED
    3878 * - \ref SCIP_STAGE_INITSOLVE
    3879 * - \ref SCIP_STAGE_SOLVING
    3880 * - \ref SCIP_STAGE_SOLVED
    3881 */
    3882SCIP_EXPORT
    3883SCIP_Real SCIPgetVarPseudocostVariance(
    3884 SCIP* scip, /**< SCIP data structure */
    3885 SCIP_VAR* var, /**< problem variable */
    3886 SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
    3887 SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */
    3888 );
    3889
    3890/** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
    3891 *
    3892 * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
    3893 * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
    3894 * of 2 * clevel - 1.
    3895 *
    3896 * @return value of confidence bound for this variable
    3897 */
    3898SCIP_EXPORT
    3899SCIP_Real SCIPcalculatePscostConfidenceBound(
    3900 SCIP* scip, /**< SCIP data structure */
    3901 SCIP_VAR* var, /**< variable in question */
    3902 SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
    3903 SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
    3904 SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
    3905 );
    3906
    3907/** check if variable pseudo-costs have a significant difference in location. The significance depends on
    3908 * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
    3909 * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
    3910 * unknown location means of the underlying pseudo-cost distributions of x and y.
    3911 *
    3912 * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
    3913 * better than x (despite the current information), meaning that y can be expected to yield branching
    3914 * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
    3915 * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
    3916 * than y.
    3917 *
    3918 * @note The order of x and y matters for the one-sided hypothesis
    3919 *
    3920 * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
    3921 * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
    3922 *
    3923 * @return TRUE if the hypothesis can be safely rejected at the given confidence level
    3924 */
    3925SCIP_EXPORT
    3926SCIP_Bool SCIPsignificantVarPscostDifference(
    3927 SCIP* scip, /**< SCIP data structure */
    3928 SCIP_VAR* varx, /**< variable x */
    3929 SCIP_Real fracx, /**< the fractionality of variable x */
    3930 SCIP_VAR* vary, /**< variable y */
    3931 SCIP_Real fracy, /**< the fractionality of variable y */
    3932 SCIP_BRANCHDIR dir, /**< branching direction */
    3933 SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
    3934 SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
    3935 );
    3936
    3937/** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
    3938 * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
    3939 * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
    3940 * of at least \p threshold.
    3941 *
    3942 * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
    3943 * the estimated probability to exceed \p threshold is less than 25 %.
    3944 *
    3945 * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
    3946 * of confidence.
    3947 *
    3948 * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
    3949 * at the given confidence level \p clevel.
    3950 */
    3951SCIP_EXPORT
    3952SCIP_Bool SCIPpscostThresholdProbabilityTest(
    3953 SCIP* scip, /**< SCIP data structure */
    3954 SCIP_VAR* var, /**< variable x */
    3955 SCIP_Real frac, /**< the fractionality of variable x */
    3956 SCIP_Real threshold, /**< the threshold to test against */
    3957 SCIP_BRANCHDIR dir, /**< branching direction */
    3958 SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
    3959 );
    3960
    3961/** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
    3962 * Error is calculated at a specific confidence level
    3963 *
    3964 * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold
    3965 */
    3966SCIP_EXPORT
    3967SCIP_Bool SCIPisVarPscostRelerrorReliable(
    3968 SCIP* scip, /**< SCIP data structure */
    3969 SCIP_VAR* var, /**< variable in question */
    3970 SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
    3971 SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
    3972 );
    3973
    3974/** gets the variable's pseudo cost score value for the given LP solution value
    3975 *
    3976 * @return the variable's pseudo cost score value for the given LP solution value
    3977 *
    3978 * @pre This method can be called if @p scip is in one of the following stages:
    3979 * - \ref SCIP_STAGE_INITPRESOLVE
    3980 * - \ref SCIP_STAGE_PRESOLVING
    3981 * - \ref SCIP_STAGE_EXITPRESOLVE
    3982 * - \ref SCIP_STAGE_PRESOLVED
    3983 * - \ref SCIP_STAGE_INITSOLVE
    3984 * - \ref SCIP_STAGE_SOLVING
    3985 * - \ref SCIP_STAGE_SOLVED
    3986 */
    3987SCIP_EXPORT
    3988SCIP_Real SCIPgetVarPseudocostScore(
    3989 SCIP* scip, /**< SCIP data structure */
    3990 SCIP_VAR* var, /**< problem variable */
    3991 SCIP_Real solval /**< variable's LP solution value */
    3992 );
    3993
    3994/** gets the variable's discounted pseudo cost score value for the given LP solution value.
    3995 *
    3996 * This combines both pscost and ancpscost fields.
    3997 *
    3998 * @return the variable's discounted pseudo cost score value for the given LP solution value,
    3999 * combining both pscost and ancpscost fields.
    4000 *
    4001 * @pre This method can be called if @p scip is in one of the following stages:
    4002 * - \ref SCIP_STAGE_INITPRESOLVE
    4003 * - \ref SCIP_STAGE_PRESOLVING
    4004 * - \ref SCIP_STAGE_EXITPRESOLVE
    4005 * - \ref SCIP_STAGE_PRESOLVED
    4006 * - \ref SCIP_STAGE_INITSOLVE
    4007 * - \ref SCIP_STAGE_SOLVING
    4008 * - \ref SCIP_STAGE_SOLVED
    4009 */
    4010SCIP_EXPORT
    4011SCIP_Real SCIPgetVarDPseudocostScore(
    4012 SCIP* scip, /**< SCIP data structure */
    4013 SCIP_VAR* var, /**< problem variable */
    4014 SCIP_Real solval, /**< variable's LP solution value */
    4015 SCIP_Real discountfac /**< discount factor for discounted pseudocost */
    4016 );
    4017
    4018/** gets the variable's pseudo cost score value for the given LP solution value,
    4019 * only using the pseudo cost information of the current run
    4020 *
    4021 * @return the variable's pseudo cost score value for the given LP solution value,
    4022 * only using the pseudo cost information of the current run
    4023 *
    4024 * @pre This method can be called if @p scip is in one of the following stages:
    4025 * - \ref SCIP_STAGE_INITPRESOLVE
    4026 * - \ref SCIP_STAGE_PRESOLVING
    4027 * - \ref SCIP_STAGE_EXITPRESOLVE
    4028 * - \ref SCIP_STAGE_PRESOLVED
    4029 * - \ref SCIP_STAGE_INITSOLVE
    4030 * - \ref SCIP_STAGE_SOLVING
    4031 * - \ref SCIP_STAGE_SOLVED
    4032 */
    4033SCIP_EXPORT
    4034SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(
    4035 SCIP* scip, /**< SCIP data structure */
    4036 SCIP_VAR* var, /**< problem variable */
    4037 SCIP_Real solval /**< variable's LP solution value */
    4038 );
    4039
    4040/** returns the variable's VSIDS value
    4041 *
    4042 * @return the variable's VSIDS value
    4043 *
    4044 * @pre This method can be called if @p scip is in one of the following stages:
    4045 * - \ref SCIP_STAGE_INITPRESOLVE
    4046 * - \ref SCIP_STAGE_PRESOLVING
    4047 * - \ref SCIP_STAGE_EXITPRESOLVE
    4048 * - \ref SCIP_STAGE_PRESOLVED
    4049 * - \ref SCIP_STAGE_INITSOLVE
    4050 * - \ref SCIP_STAGE_SOLVING
    4051 * - \ref SCIP_STAGE_SOLVED
    4052 */
    4053SCIP_EXPORT
    4054SCIP_Real SCIPgetVarVSIDS(
    4055 SCIP* scip, /**< SCIP data structure */
    4056 SCIP_VAR* var, /**< problem variable */
    4057 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4058 );
    4059
    4060/** returns the variable's VSIDS value only using conflicts of the current run
    4061 *
    4062 * @return the variable's VSIDS value only using conflicts of the current run
    4063 *
    4064 * @pre This method can be called if @p scip is in one of the following stages:
    4065 * - \ref SCIP_STAGE_INITPRESOLVE
    4066 * - \ref SCIP_STAGE_PRESOLVING
    4067 * - \ref SCIP_STAGE_EXITPRESOLVE
    4068 * - \ref SCIP_STAGE_PRESOLVED
    4069 * - \ref SCIP_STAGE_INITSOLVE
    4070 * - \ref SCIP_STAGE_SOLVING
    4071 * - \ref SCIP_STAGE_SOLVED
    4072 */
    4073SCIP_EXPORT
    4074SCIP_Real SCIPgetVarVSIDSCurrentRun(
    4075 SCIP* scip, /**< SCIP data structure */
    4076 SCIP_VAR* var, /**< problem variable */
    4077 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4078 );
    4079
    4080/** returns the variable's conflict score value
    4081 *
    4082 * @return the variable's conflict score value
    4083 *
    4084 * @pre This method can be called if @p scip is in one of the following stages:
    4085 * - \ref SCIP_STAGE_INITPRESOLVE
    4086 * - \ref SCIP_STAGE_PRESOLVING
    4087 * - \ref SCIP_STAGE_EXITPRESOLVE
    4088 * - \ref SCIP_STAGE_PRESOLVED
    4089 * - \ref SCIP_STAGE_INITSOLVE
    4090 * - \ref SCIP_STAGE_SOLVING
    4091 * - \ref SCIP_STAGE_SOLVED
    4092 */
    4093SCIP_EXPORT
    4094SCIP_Real SCIPgetVarConflictScore(
    4095 SCIP* scip, /**< SCIP data structure */
    4096 SCIP_VAR* var /**< problem variable */
    4097 );
    4098
    4099/** returns the variable's conflict score value only using conflicts of the current run
    4100 *
    4101 * @return the variable's conflict score value only using conflicts of the current run
    4102 *
    4103 * @pre This method can be called if @p scip is in one of the following stages:
    4104 * - \ref SCIP_STAGE_INITPRESOLVE
    4105 * - \ref SCIP_STAGE_PRESOLVING
    4106 * - \ref SCIP_STAGE_EXITPRESOLVE
    4107 * - \ref SCIP_STAGE_PRESOLVED
    4108 * - \ref SCIP_STAGE_INITSOLVE
    4109 * - \ref SCIP_STAGE_SOLVING
    4110 * - \ref SCIP_STAGE_SOLVED
    4111 */
    4112SCIP_EXPORT
    4113SCIP_Real SCIPgetVarConflictScoreCurrentRun(
    4114 SCIP* scip, /**< SCIP data structure */
    4115 SCIP_VAR* var /**< problem variable */
    4116 );
    4117
    4118/** returns the variable's conflict length score
    4119 *
    4120 * @return the variable's conflict length score
    4121 *
    4122 * @pre This method can be called if @p scip is in one of the following stages:
    4123 * - \ref SCIP_STAGE_INITPRESOLVE
    4124 * - \ref SCIP_STAGE_PRESOLVING
    4125 * - \ref SCIP_STAGE_EXITPRESOLVE
    4126 * - \ref SCIP_STAGE_PRESOLVED
    4127 * - \ref SCIP_STAGE_INITSOLVE
    4128 * - \ref SCIP_STAGE_SOLVING
    4129 * - \ref SCIP_STAGE_SOLVED
    4130 */
    4131SCIP_EXPORT
    4132SCIP_Real SCIPgetVarConflictlengthScore(
    4133 SCIP* scip, /**< SCIP data structure */
    4134 SCIP_VAR* var /**< problem variable */
    4135 );
    4136
    4137/** returns the variable's conflict length score only using conflicts of the current run
    4138 *
    4139 * @return the variable's conflict length score only using conflicts of the current run
    4140 *
    4141 * @pre This method can be called if @p scip is in one of the following stages:
    4142 * - \ref SCIP_STAGE_INITPRESOLVE
    4143 * - \ref SCIP_STAGE_PRESOLVING
    4144 * - \ref SCIP_STAGE_EXITPRESOLVE
    4145 * - \ref SCIP_STAGE_PRESOLVED
    4146 * - \ref SCIP_STAGE_INITSOLVE
    4147 * - \ref SCIP_STAGE_SOLVING
    4148 * - \ref SCIP_STAGE_SOLVED
    4149 */
    4150SCIP_EXPORT
    4151SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(
    4152 SCIP* scip, /**< SCIP data structure */
    4153 SCIP_VAR* var /**< problem variable */
    4154 );
    4155
    4156/** returns the variable's average conflict length
    4157 *
    4158 * @return the variable's average conflict length
    4159 *
    4160 * @pre This method can be called if @p scip is in one of the following stages:
    4161 * - \ref SCIP_STAGE_INITPRESOLVE
    4162 * - \ref SCIP_STAGE_PRESOLVING
    4163 * - \ref SCIP_STAGE_EXITPRESOLVE
    4164 * - \ref SCIP_STAGE_PRESOLVED
    4165 * - \ref SCIP_STAGE_INITSOLVE
    4166 * - \ref SCIP_STAGE_SOLVING
    4167 * - \ref SCIP_STAGE_SOLVED
    4168 */
    4169SCIP_EXPORT
    4170SCIP_Real SCIPgetVarAvgConflictlength(
    4171 SCIP* scip, /**< SCIP data structure */
    4172 SCIP_VAR* var, /**< problem variable */
    4173 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4174 );
    4175
    4176/** returns the variable's average conflict length only using conflicts of the current run
    4177 *
    4178 * @return the variable's average conflict length only using conflicts of the current run
    4179 *
    4180 * @pre This method can be called if @p scip is in one of the following stages:
    4181 * - \ref SCIP_STAGE_INITPRESOLVE
    4182 * - \ref SCIP_STAGE_PRESOLVING
    4183 * - \ref SCIP_STAGE_EXITPRESOLVE
    4184 * - \ref SCIP_STAGE_PRESOLVED
    4185 * - \ref SCIP_STAGE_INITSOLVE
    4186 * - \ref SCIP_STAGE_SOLVING
    4187 * - \ref SCIP_STAGE_SOLVED
    4188 */
    4189SCIP_EXPORT
    4190SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(
    4191 SCIP* scip, /**< SCIP data structure */
    4192 SCIP_VAR* var, /**< problem variable */
    4193 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4194 );
    4195
    4196/** returns the average number of inferences found after branching on the variable in given direction;
    4197 * if branching on the variable in the given direction was yet evaluated, the average number of inferences
    4198 * over all variables for branching in the given direction is returned
    4199 *
    4200 * @return the average number of inferences found after branching on the variable in given direction
    4201 *
    4202 * @pre This method can be called if @p scip is in one of the following stages:
    4203 * - \ref SCIP_STAGE_INITPRESOLVE
    4204 * - \ref SCIP_STAGE_PRESOLVING
    4205 * - \ref SCIP_STAGE_EXITPRESOLVE
    4206 * - \ref SCIP_STAGE_PRESOLVED
    4207 * - \ref SCIP_STAGE_INITSOLVE
    4208 * - \ref SCIP_STAGE_SOLVING
    4209 * - \ref SCIP_STAGE_SOLVED
    4210 */
    4211SCIP_EXPORT
    4212SCIP_Real SCIPgetVarAvgInferences(
    4213 SCIP* scip, /**< SCIP data structure */
    4214 SCIP_VAR* var, /**< problem variable */
    4215 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4216 );
    4217
    4218/** returns the average number of inferences found after branching on the variable in given direction in the current run;
    4219 * if branching on the variable in the given direction was yet evaluated, the average number of inferences
    4220 * over all variables for branching in the given direction is returned
    4221 *
    4222 * @return the average number of inferences found after branching on the variable in given direction in the current run
    4223 *
    4224 * @pre This method can be called if @p scip is in one of the following stages:
    4225 * - \ref SCIP_STAGE_INITPRESOLVE
    4226 * - \ref SCIP_STAGE_PRESOLVING
    4227 * - \ref SCIP_STAGE_EXITPRESOLVE
    4228 * - \ref SCIP_STAGE_PRESOLVED
    4229 * - \ref SCIP_STAGE_INITSOLVE
    4230 * - \ref SCIP_STAGE_SOLVING
    4231 * - \ref SCIP_STAGE_SOLVED
    4232 */
    4233SCIP_EXPORT
    4234SCIP_Real SCIPgetVarAvgInferencesCurrentRun(
    4235 SCIP* scip, /**< SCIP data structure */
    4236 SCIP_VAR* var, /**< problem variable */
    4237 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4238 );
    4239
    4240/** returns the variable's average inference score value
    4241 *
    4242 * @return the variable's average inference score value
    4243 *
    4244 * @pre This method can be called if @p scip is in one of the following stages:
    4245 * - \ref SCIP_STAGE_INITPRESOLVE
    4246 * - \ref SCIP_STAGE_PRESOLVING
    4247 * - \ref SCIP_STAGE_EXITPRESOLVE
    4248 * - \ref SCIP_STAGE_PRESOLVED
    4249 * - \ref SCIP_STAGE_INITSOLVE
    4250 * - \ref SCIP_STAGE_SOLVING
    4251 * - \ref SCIP_STAGE_SOLVED
    4252 */
    4253SCIP_EXPORT
    4254SCIP_Real SCIPgetVarAvgInferenceScore(
    4255 SCIP* scip, /**< SCIP data structure */
    4256 SCIP_VAR* var /**< problem variable */
    4257 );
    4258
    4259/** returns the variable's average inference score value only using inferences of the current run
    4260 *
    4261 * @return the variable's average inference score value only using inferences of the current run
    4262 *
    4263 * @pre This method can be called if @p scip is in one of the following stages:
    4264 * - \ref SCIP_STAGE_INITPRESOLVE
    4265 * - \ref SCIP_STAGE_PRESOLVING
    4266 * - \ref SCIP_STAGE_EXITPRESOLVE
    4267 * - \ref SCIP_STAGE_PRESOLVED
    4268 * - \ref SCIP_STAGE_INITSOLVE
    4269 * - \ref SCIP_STAGE_SOLVING
    4270 * - \ref SCIP_STAGE_SOLVED
    4271 */
    4272SCIP_EXPORT
    4273SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(
    4274 SCIP* scip, /**< SCIP data structure */
    4275 SCIP_VAR* var /**< problem variable */
    4276 );
    4277
    4278/** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
    4279 * of a variable to the given values
    4280 *
    4281 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4282 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4283 *
    4284 * @pre This method can be called if @p scip is in one of the following stages:
    4285 * - \ref SCIP_STAGE_TRANSFORMED
    4286 * - \ref SCIP_STAGE_INITPRESOLVE
    4287 * - \ref SCIP_STAGE_PRESOLVING
    4288 * - \ref SCIP_STAGE_EXITPRESOLVE
    4289 * - \ref SCIP_STAGE_PRESOLVED
    4290 * - \ref SCIP_STAGE_INITSOLVE
    4291 * - \ref SCIP_STAGE_SOLVING
    4292 */
    4293SCIP_EXPORT
    4294SCIP_RETCODE SCIPinitVarBranchStats(
    4295 SCIP* scip, /**< SCIP data structure */
    4296 SCIP_VAR* var, /**< variable which should be initialized */
    4297 SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
    4298 SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
    4299 SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
    4300 SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
    4301 SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
    4302 SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
    4303 SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
    4304 SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
    4305 SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
    4306 SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
    4307 );
    4308
    4309/** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
    4310 * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
    4311 *
    4312 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4313 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4314 *
    4315 * @pre This method can be called if @p scip is in one of the following stages:
    4316 * - \ref SCIP_STAGE_TRANSFORMED
    4317 * - \ref SCIP_STAGE_INITPRESOLVE
    4318 * - \ref SCIP_STAGE_PRESOLVING
    4319 * - \ref SCIP_STAGE_EXITPRESOLVE
    4320 * - \ref SCIP_STAGE_PRESOLVED
    4321 * - \ref SCIP_STAGE_INITSOLVE
    4322 * - \ref SCIP_STAGE_SOLVING
    4323 */
    4324SCIP_EXPORT
    4325SCIP_RETCODE SCIPinitVarValueBranchStats(
    4326 SCIP* scip, /**< SCIP data structure */
    4327 SCIP_VAR* var, /**< variable which should be initialized */
    4328 SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
    4329 SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
    4330 SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
    4331 SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
    4332 SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
    4333 SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
    4334 SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
    4335 SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
    4336 SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
    4337 );
    4338
    4339/** returns the average number of cutoffs found after branching on the variable in given direction;
    4340 * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
    4341 * over all variables for branching in the given direction is returned
    4342 *
    4343 * @return the average number of cutoffs found after branching on the variable in given direction
    4344 *
    4345 * @pre This method can be called if @p scip is in one of the following stages:
    4346 * - \ref SCIP_STAGE_INITPRESOLVE
    4347 * - \ref SCIP_STAGE_PRESOLVING
    4348 * - \ref SCIP_STAGE_EXITPRESOLVE
    4349 * - \ref SCIP_STAGE_PRESOLVED
    4350 * - \ref SCIP_STAGE_INITSOLVE
    4351 * - \ref SCIP_STAGE_SOLVING
    4352 * - \ref SCIP_STAGE_SOLVED
    4353 */
    4354SCIP_EXPORT
    4355SCIP_Real SCIPgetVarAvgCutoffs(
    4356 SCIP* scip, /**< SCIP data structure */
    4357 SCIP_VAR* var, /**< problem variable */
    4358 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4359 );
    4360
    4361/** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
    4362 * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
    4363 * over all variables for branching in the given direction is returned
    4364 *
    4365 * @return the average number of cutoffs found after branching on the variable in given direction in the current run
    4366 *
    4367 * @pre This method can be called if @p scip is in one of the following stages:
    4368 * - \ref SCIP_STAGE_INITPRESOLVE
    4369 * - \ref SCIP_STAGE_PRESOLVING
    4370 * - \ref SCIP_STAGE_EXITPRESOLVE
    4371 * - \ref SCIP_STAGE_PRESOLVED
    4372 * - \ref SCIP_STAGE_INITSOLVE
    4373 * - \ref SCIP_STAGE_SOLVING
    4374 * - \ref SCIP_STAGE_SOLVED
    4375 */
    4376SCIP_EXPORT
    4377SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(
    4378 SCIP* scip, /**< SCIP data structure */
    4379 SCIP_VAR* var, /**< problem variable */
    4380 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4381 );
    4382
    4383/** returns the variable's average cutoff score value
    4384 *
    4385 * @return the variable's average cutoff score value
    4386 *
    4387 * @pre This method can be called if @p scip is in one of the following stages:
    4388 * - \ref SCIP_STAGE_INITPRESOLVE
    4389 * - \ref SCIP_STAGE_PRESOLVING
    4390 * - \ref SCIP_STAGE_EXITPRESOLVE
    4391 * - \ref SCIP_STAGE_PRESOLVED
    4392 * - \ref SCIP_STAGE_INITSOLVE
    4393 * - \ref SCIP_STAGE_SOLVING
    4394 * - \ref SCIP_STAGE_SOLVED
    4395 */
    4396SCIP_EXPORT
    4397SCIP_Real SCIPgetVarAvgCutoffScore(
    4398 SCIP* scip, /**< SCIP data structure */
    4399 SCIP_VAR* var /**< problem variable */
    4400 );
    4401
    4402/** returns the variable's average cutoff score value, only using cutoffs of the current run
    4403 *
    4404 * @return the variable's average cutoff score value, only using cutoffs of the current run
    4405 *
    4406 * @pre This method can be called if @p scip is in one of the following stages:
    4407 * - \ref SCIP_STAGE_INITPRESOLVE
    4408 * - \ref SCIP_STAGE_PRESOLVING
    4409 * - \ref SCIP_STAGE_EXITPRESOLVE
    4410 * - \ref SCIP_STAGE_PRESOLVED
    4411 * - \ref SCIP_STAGE_INITSOLVE
    4412 * - \ref SCIP_STAGE_SOLVING
    4413 * - \ref SCIP_STAGE_SOLVED
    4414 */
    4415SCIP_EXPORT
    4416SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(
    4417 SCIP* scip, /**< SCIP data structure */
    4418 SCIP_VAR* var /**< problem variable */
    4419 );
    4420
    4421/** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
    4422 * factor
    4423 *
    4424 * @return the variable's average inference/cutoff score value
    4425 *
    4426 * @pre This method can be called if @p scip is in one of the following stages:
    4427 * - \ref SCIP_STAGE_INITPRESOLVE
    4428 * - \ref SCIP_STAGE_PRESOLVING
    4429 * - \ref SCIP_STAGE_EXITPRESOLVE
    4430 * - \ref SCIP_STAGE_PRESOLVED
    4431 * - \ref SCIP_STAGE_INITSOLVE
    4432 * - \ref SCIP_STAGE_SOLVING
    4433 * - \ref SCIP_STAGE_SOLVED
    4434 */
    4435SCIP_EXPORT
    4436SCIP_Real SCIPgetVarAvgInferenceCutoffScore(
    4437 SCIP* scip, /**< SCIP data structure */
    4438 SCIP_VAR* var, /**< problem variable */
    4439 SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
    4440 );
    4441
    4442/** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
    4443 * factor, only using inferences and cutoffs of the current run
    4444 *
    4445 * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
    4446 *
    4447 * @pre This method can be called if @p scip is in one of the following stages:
    4448 * - \ref SCIP_STAGE_INITPRESOLVE
    4449 * - \ref SCIP_STAGE_PRESOLVING
    4450 * - \ref SCIP_STAGE_EXITPRESOLVE
    4451 * - \ref SCIP_STAGE_PRESOLVED
    4452 * - \ref SCIP_STAGE_INITSOLVE
    4453 * - \ref SCIP_STAGE_SOLVING
    4454 * - \ref SCIP_STAGE_SOLVED
    4455 */
    4456SCIP_EXPORT
    4457SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(
    4458 SCIP* scip, /**< SCIP data structure */
    4459 SCIP_VAR* var, /**< problem variable */
    4460 SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
    4461 );
    4462
    4463/** returns the variable's average GMI efficacy score value
    4464 *
    4465 * @return the variable's average GMI efficacy score value (for when it was fractional and basic in the LP)
    4466 *
    4467 * @pre This method can be called if @p scip is in one of the following stages:
    4468 * - \ref SCIP_STAGE_INITPRESOLVE
    4469 * - \ref SCIP_STAGE_PRESOLVING
    4470 * - \ref SCIP_STAGE_EXITPRESOLVE
    4471 * - \ref SCIP_STAGE_PRESOLVED
    4472 * - \ref SCIP_STAGE_INITSOLVE
    4473 * - \ref SCIP_STAGE_SOLVING
    4474 * - \ref SCIP_STAGE_SOLVED
    4475 */
    4476SCIP_EXPORT
    4477SCIP_Real SCIPgetVarAvgGMIScore(
    4478 SCIP* scip, /**< SCIP data structure */
    4479 SCIP_VAR* var /**< problem variable */
    4480 );
    4481
    4482/** sets the variable's avg GMI efficacy score value
    4483 *
    4484 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4485 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4486 *
    4487 * @pre This method can be called if @p scip is in one of the following stages:
    4488 * - \ref SCIP_STAGE_INITPRESOLVE
    4489 * - \ref SCIP_STAGE_PRESOLVING
    4490 * - \ref SCIP_STAGE_EXITPRESOLVE
    4491 * - \ref SCIP_STAGE_PRESOLVED
    4492 * - \ref SCIP_STAGE_INITSOLVE
    4493 * - \ref SCIP_STAGE_SOLVING
    4494 * - \ref SCIP_STAGE_SOLVED
    4495 */
    4496SCIP_EXPORT
    4497SCIP_RETCODE SCIPincVarGMISumScore(
    4498 SCIP* scip, /**< SCIP data structure */
    4499 SCIP_VAR* var, /**< problem variable */
    4500 SCIP_Real gmieff /**< Efficacy of last GMI cut generated from when var was basic /frac */
    4501 );
    4502
    4503/** returns the variable's last GMI efficacy score value
    4504 *
    4505 * @return the variable's last GMI efficacy score value (for when it was fractional and basic in the LP)
    4506 *
    4507 * @pre This method can be called if @p scip is in one of the following stages:
    4508 * - \ref SCIP_STAGE_INITPRESOLVE
    4509 * - \ref SCIP_STAGE_PRESOLVING
    4510 * - \ref SCIP_STAGE_EXITPRESOLVE
    4511 * - \ref SCIP_STAGE_PRESOLVED
    4512 * - \ref SCIP_STAGE_INITSOLVE
    4513 * - \ref SCIP_STAGE_SOLVING
    4514 * - \ref SCIP_STAGE_SOLVED
    4515 */
    4516SCIP_EXPORT
    4517SCIP_Real SCIPgetVarLastGMIScore(
    4518 SCIP* scip, /**< SCIP data structure */
    4519 SCIP_VAR* var /**< problem variable */
    4520 );
    4521
    4522/** sets the variable's last GMI efficacy score value
    4523 *
    4524 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4525 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4526 *
    4527 * @pre This method can be called if @p scip is in one of the following stages:
    4528 * - \ref SCIP_STAGE_INITPRESOLVE
    4529 * - \ref SCIP_STAGE_PRESOLVING
    4530 * - \ref SCIP_STAGE_EXITPRESOLVE
    4531 * - \ref SCIP_STAGE_PRESOLVED
    4532 * - \ref SCIP_STAGE_INITSOLVE
    4533 * - \ref SCIP_STAGE_SOLVING
    4534 * - \ref SCIP_STAGE_SOLVED
    4535 */
    4536SCIP_EXPORT
    4537SCIP_RETCODE SCIPsetVarLastGMIScore(
    4538 SCIP* scip, /**< SCIP data structure */
    4539 SCIP_VAR* var, /**< problem variable */
    4540 SCIP_Real gmieff /**< Efficacy of last GMI cut generated from when var was basic /frac */
    4541 );
    4542
    4543/** outputs variable information to file stream via the message system
    4544 *
    4545 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4546 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4547 *
    4548 * @pre This method can be called if @p scip is in one of the following stages:
    4549 * - \ref SCIP_STAGE_PROBLEM
    4550 * - \ref SCIP_STAGE_TRANSFORMING
    4551 * - \ref SCIP_STAGE_TRANSFORMED
    4552 * - \ref SCIP_STAGE_INITPRESOLVE
    4553 * - \ref SCIP_STAGE_PRESOLVING
    4554 * - \ref SCIP_STAGE_EXITPRESOLVE
    4555 * - \ref SCIP_STAGE_PRESOLVED
    4556 * - \ref SCIP_STAGE_INITSOLVE
    4557 * - \ref SCIP_STAGE_SOLVING
    4558 * - \ref SCIP_STAGE_SOLVED
    4559 * - \ref SCIP_STAGE_EXITSOLVE
    4560 * - \ref SCIP_STAGE_FREETRANS
    4561 *
    4562 * @note If the message handler is set to a NULL pointer nothing will be printed
    4563 */
    4564SCIP_EXPORT
    4565SCIP_RETCODE SCIPprintVar(
    4566 SCIP* scip, /**< SCIP data structure */
    4567 SCIP_VAR* var, /**< problem variable */
    4568 FILE* file /**< output file (or NULL for standard output) */
    4569 );
    4570
    4571/** changes variable's exact objective value
    4572 *
    4573 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4574 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4575 *
    4576 * @pre This method can be called if @p scip is in one of the following stages:
    4577 * - \ref SCIP_STAGE_PROBLEM
    4578 * - \ref SCIP_STAGE_TRANSFORMING
    4579 * - \ref SCIP_STAGE_PRESOLVING
    4580 * - \ref SCIP_STAGE_PRESOLVED
    4581 */
    4582SCIP_EXPORT
    4583SCIP_RETCODE SCIPchgVarObjExact(
    4584 SCIP* scip, /**< SCIP data structure */
    4585 SCIP_VAR* var, /**< variable to change the objective value for */
    4586 SCIP_RATIONAL* newobj /**< new objective value */
    4587 );
    4588
    4589/** changes exact global upper bound of variable;
    4590 *
    4591 *
    4592 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4593 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4594 *
    4595 * @pre This method can be called if @p scip is in one of the following stages:
    4596 * - \ref SCIP_STAGE_PROBLEM
    4597 *
    4598 */
    4599SCIP_EXPORT
    4600SCIP_RETCODE SCIPchgVarUbGlobalExact(
    4601 SCIP* scip, /**< SCIP data structure */
    4602 SCIP_VAR* var, /**< variable to change the bound for */
    4603 SCIP_RATIONAL* newbound /**< new value for bound */
    4604 );
    4605
    4606/** changes exact global lower bound of variable;
    4607 *
    4608 *
    4609 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4610 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4611 *
    4612 * @pre This method can be called if @p scip is in one of the following stages:
    4613 * - \ref SCIP_STAGE_PROBLEM
    4614 *
    4615 */
    4616SCIP_EXPORT
    4617SCIP_RETCODE SCIPchgVarLbGlobalExact(
    4618 SCIP* scip, /**< SCIP data structure */
    4619 SCIP_VAR* var, /**< variable to change the bound for */
    4620 SCIP_RATIONAL* newbound /**< new value for bound */
    4621 );
    4622
    4623/** print the given variables and rational coefficients as linear sum in the following form
    4624 * c1 <x1> + c2 <x2> ... + cn <xn>
    4625 *
    4626 * This string can be parsed by the method SCIPparseVarsLinearsum().
    4627 *
    4628 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4629 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4630 *
    4631 * @pre This method can be called if @p scip is in one of the following stages:
    4632 * - \ref SCIP_STAGE_PROBLEM
    4633 * - \ref SCIP_STAGE_TRANSFORMING
    4634 * - \ref SCIP_STAGE_TRANSFORMED
    4635 * - \ref SCIP_STAGE_INITPRESOLVE
    4636 * - \ref SCIP_STAGE_PRESOLVING
    4637 * - \ref SCIP_STAGE_EXITPRESOLVE
    4638 * - \ref SCIP_STAGE_PRESOLVED
    4639 * - \ref SCIP_STAGE_INITSOLVE
    4640 * - \ref SCIP_STAGE_SOLVING
    4641 * - \ref SCIP_STAGE_SOLVED
    4642 * - \ref SCIP_STAGE_EXITSOLVE
    4643 * - \ref SCIP_STAGE_FREETRANS
    4644 *
    4645 * @note The printing process is done via the message handler system.
    4646 */
    4647SCIP_EXPORT
    4648SCIP_RETCODE SCIPwriteVarsLinearsumExact(
    4649 SCIP* scip, /**< SCIP data structure */
    4650 FILE* file, /**< output file, or NULL for stdout */
    4651 SCIP_VAR** vars, /**< variable array to output */
    4652 SCIP_RATIONAL** vals, /**< array of coefficients or NULL if all coefficients are 1.0 */
    4653 int nvars, /**< number of variables */
    4654 SCIP_Bool type /**< should the variable type be also posted */
    4655 );
    4656
    4657/** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
    4658 * active variables, that is b_1*y_1 + ... + b_m*y_m + d.
    4659 *
    4660 * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
    4661 * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable
    4662 * representation is stored in the variable array, scalar array and constant.
    4663 *
    4664 * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
    4665 * allocated (e.g., by a C++ 'new' or SCIP functions).
    4666 *
    4667 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4668 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4669 *
    4670 * @pre This method can be called if @p scip is in one of the following stages:
    4671 * - \ref SCIP_STAGE_TRANSFORMED
    4672 * - \ref SCIP_STAGE_INITPRESOLVE
    4673 * - \ref SCIP_STAGE_PRESOLVING
    4674 * - \ref SCIP_STAGE_EXITPRESOLVE
    4675 * - \ref SCIP_STAGE_PRESOLVED
    4676 * - \ref SCIP_STAGE_INITSOLVE
    4677 * - \ref SCIP_STAGE_SOLVING
    4678 * - \ref SCIP_STAGE_SOLVED
    4679 * - \ref SCIP_STAGE_EXITSOLVE
    4680 * - \ref SCIP_STAGE_FREETRANS
    4681 *
    4682 * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
    4683 * given entries are overwritten.
    4684 *
    4685 * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
    4686 * the method with the linear sum 1.0*x + 0.0.
    4687 */
    4688SCIP_EXPORT
    4689SCIP_RETCODE SCIPgetProbvarLinearSumExact(
    4690 SCIP* scip, /**< SCIP data structure */
    4691 SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be
    4692 * overwritten by the variable array y_1, ..., y_m in the linear sum
    4693 * w.r.t. active variables */
    4694 SCIP_RATIONAL** scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the
    4695 * scalars b_1, ..., b_m in the linear sum of the active variables */
    4696 int* nvars, /**< pointer to number of variables in the linear sum which will be
    4697 * overwritten by the number of variables in the linear sum corresponding
    4698 * to the active variables */
    4699 int varssize, /**< available slots in vars and scalars array which is needed to check if
    4700 * the array are large enough for the linear sum w.r.t. active
    4701 * variables */
    4702 SCIP_RATIONAL* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which
    4703 * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m +
    4704 * d w.r.t. the active variables */
    4705 int* requiredsize, /**< pointer to store the required array size for the linear sum w.r.t. the
    4706 * active variables */
    4707 SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
    4708 );
    4709
    4710/**@} */
    4711
    4712#ifdef __cplusplus
    4713}
    4714#endif
    4715
    4716#endif
    def.h
    common defines and data types used in all packages of SCIP
    SCIP_Longint
    #define SCIP_Longint
    Definition: def.h:148
    SCIP_Bool
    #define SCIP_Bool
    Definition: def.h:98
    SCIP_Real
    #define SCIP_Real
    Definition: def.h:163
    SCIPgetVarStrongbranchFrac
    SCIP_RETCODE SCIPgetVarStrongbranchFrac(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Bool idempotent, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
    Definition: scip_var.c:3664
    SCIPgetRelaxSolObj
    SCIP_Real SCIPgetRelaxSolObj(SCIP *scip)
    Definition: scip_var.c:3376
    SCIPinitVarBranchStats
    SCIP_RETCODE SCIPinitVarBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real downpscost, SCIP_Real uppscost, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
    Definition: scip_var.c:12009
    SCIPgetVarAncPseudocostCountCurrentRun
    SCIP_Real SCIPgetVarAncPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11378
    SCIPtightenVarLb
    SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:6401
    SCIPgetVarBdAtIndex
    SCIP_Real SCIPgetVarBdAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
    Definition: scip_var.c:3008
    SCIPinitVarValueBranchStats
    SCIP_RETCODE SCIPinitVarValueBranchStats(SCIP *scip, SCIP_VAR *var, SCIP_Real value, SCIP_Real downvsids, SCIP_Real upvsids, SCIP_Real downconflen, SCIP_Real upconflen, SCIP_Real downinfer, SCIP_Real upinfer, SCIP_Real downcutoff, SCIP_Real upcutoff)
    Definition: scip_var.c:12080
    SCIPaddVarLocks
    SCIP_RETCODE SCIPaddVarLocks(SCIP *scip, SCIP_VAR *var, int nlocksdown, int nlocksup)
    Definition: scip_var.c:5176
    SCIPgetVarMultaggrLbGlobal
    SCIP_Real SCIPgetVarMultaggrLbGlobal(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:8506
    SCIPpscostThresholdProbabilityTest
    SCIP_Bool SCIPpscostThresholdProbabilityTest(SCIP *scip, SCIP_VAR *var, SCIP_Real frac, SCIP_Real threshold, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel)
    Definition: scip_var.c:11487
    SCIPlockVarCons
    SCIP_RETCODE SCIPlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
    Definition: scip_var.c:5210
    SCIPremoveVarFromGlobalStructures
    SCIP_RETCODE SCIPremoveVarFromGlobalStructures(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:9796
    SCIPtightenVarUbExact
    SCIP_RETCODE SCIPtightenVarUbExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newbound, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:6768
    SCIPdoNotAggrVar
    SCIP_Bool SCIPdoNotAggrVar(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:10929
    SCIPdisableVarHistory
    void SCIPdisableVarHistory(SCIP *scip)
    Definition: scip_var.c:11102
    SCIPgetVarWasFixedAtIndex
    SCIP_Bool SCIPgetVarWasFixedAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
    Definition: scip_var.c:3026
    SCIPincVarGMISumScore
    SCIP_RETCODE SCIPincVarGMISumScore(SCIP *scip, SCIP_VAR *var, SCIP_Real gmieff)
    Definition: scip_var.c:12375
    SCIPinferVarFixProp
    SCIP_RETCODE SCIPinferVarFixProp(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:7515
    SCIPchgVarUbExact
    SCIP_RETCODE SCIPchgVarUbExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newbound)
    Definition: scip_var.c:5964
    SCIPgetVarMultaggrLbLocal
    SCIP_Real SCIPgetVarMultaggrLbLocal(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:8536
    SCIPinferVarUbProp
    SCIP_RETCODE SCIPinferVarUbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:7699
    SCIPaddClique
    SCIP_RETCODE SCIPaddClique(SCIP *scip, SCIP_VAR **vars, SCIP_Bool *values, int nvars, SCIP_Bool isequation, SCIP_Bool *infeasible, int *nbdchgs)
    Definition: scip_var.c:8882
    SCIPsetRelaxSolVal
    SCIP_RETCODE SCIPsetRelaxSolVal(SCIP *scip, SCIP_RELAX *relax, SCIP_VAR *var, SCIP_Real val)
    Definition: scip_var.c:3158
    SCIPtightenVarUbGlobal
    SCIP_RETCODE SCIPtightenVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:8257
    SCIPgetVarAvgInferenceScoreCurrentRun
    SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:11976
    SCIPgetVarStrongbranchInt
    SCIP_RETCODE SCIPgetVarStrongbranchInt(SCIP *scip, SCIP_VAR *var, int itlim, SCIP_Bool idempotent, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
    Definition: scip_var.c:4478
    SCIPgetVarPseudocostCountCurrentRun
    SCIP_Real SCIPgetVarPseudocostCountCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11350
    SCIPgetVarAvgInferenceScore
    SCIP_Real SCIPgetVarAvgInferenceScore(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:11945
    SCIPscaleVarBranchFactor
    SCIP_RETCODE SCIPscaleVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real scale)
    Definition: scip_var.c:9858
    SCIPendStrongbranch
    SCIP_RETCODE SCIPendStrongbranch(SCIP *scip)
    Definition: scip_var.c:3488
    SCIPchgVarLb
    SCIP_RETCODE SCIPchgVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
    Definition: scip_var.c:5697
    SCIPgetVarMultaggrUbGlobal
    SCIP_Real SCIPgetVarMultaggrUbGlobal(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:8521
    SCIPgetTransformedVars
    SCIP_RETCODE SCIPgetTransformedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
    Definition: scip_var.c:2119
    SCIPgetVarPseudocostCount
    SCIP_Real SCIPgetVarPseudocostCount(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11322
    SCIPadjustedVarLbExactFloat
    SCIP_Real SCIPadjustedVarLbExactFloat(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
    Definition: scip_var.c:5602
    SCIPgetVarPseudocostCurrentRun
    SCIP_Real SCIPgetVarPseudocostCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11296
    SCIPwriteCliqueGraph
    SCIP_RETCODE SCIPwriteCliqueGraph(SCIP *scip, const char *fname, SCIP_Bool writenodeweights)
    Definition: scip_var.c:9647
    SCIPchgVarName
    SCIP_RETCODE SCIPchgVarName(SCIP *scip, SCIP_VAR *var, const char *name)
    Definition: scip_var.c:1938
    SCIPcalcNegatedCliquePartition
    SCIP_RETCODE SCIPcalcNegatedCliquePartition(SCIP *scip, SCIP_VAR **vars, int nvars, int **probtoidxmap, int *probtoidxmapsize, int *cliquepartition, int *ncliques)
    Definition: scip_var.c:9410
    SCIPdoNotAggr
    SCIP_Bool SCIPdoNotAggr(SCIP *scip)
    Definition: scip_var.c:10909
    SCIPgetVarMultaggrUbLocal
    SCIP_Real SCIPgetVarMultaggrUbLocal(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:8551
    SCIPaggregateVarsExact
    SCIP_RETCODE SCIPaggregateVarsExact(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_RATIONAL *scalarx, SCIP_RATIONAL *scalary, SCIP_RATIONAL *rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
    Definition: scip_var.c:10692
    SCIPupdateVarBranchPriority
    SCIP_RETCODE SCIPupdateVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
    Definition: scip_var.c:9958
    SCIPgetVarAvgConflictlength
    SCIP_Real SCIPgetVarAvgConflictlength(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11837
    SCIPisVarPscostRelerrorReliable
    SCIP_Bool SCIPisVarPscostRelerrorReliable(SCIP *scip, SCIP_VAR *var, SCIP_Real threshold, SCIP_CONFIDENCELEVEL clevel)
    Definition: scip_var.c:11506
    SCIPgetBinvarRepresentatives
    SCIP_RETCODE SCIPgetBinvarRepresentatives(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **repvars, SCIP_Bool *negated)
    Definition: scip_var.c:2283
    SCIPdoNotMultaggrVar
    SCIP_Bool SCIPdoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:10942
    SCIPgetVarPseudocost
    SCIP_Real SCIPgetVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11268
    SCIPparseVarsList
    SCIP_RETCODE SCIPparseVarsList(SCIP *scip, const char *str, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize, char **endptr, char delimiter, SCIP_Bool *success)
    Definition: scip_var.c:805
    SCIPgetVarAvgCutoffScoreCurrentRun
    SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:12230
    SCIPaggregateVars
    SCIP_RETCODE SCIPaggregateVars(SCIP *scip, SCIP_VAR *varx, SCIP_VAR *vary, SCIP_Real scalarx, SCIP_Real scalary, SCIP_Real rhs, SCIP_Bool *infeasible, SCIP_Bool *redundant, SCIP_Bool *aggregated)
    Definition: scip_var.c:10550
    SCIPinferVarUbCons
    SCIP_RETCODE SCIPinferVarUbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:7069
    SCIPparseVarsPolynomialExact
    SCIP_RETCODE SCIPparseVarsPolynomialExact(SCIP *scip, char *str, SCIP_VAR ****monomialvars, SCIP_RATIONAL ***monomialcoefs, int *nmonomials, char **endptr, SCIP_Bool *success)
    Definition: scip_var.c:1453
    SCIPaddVarExactData
    SCIP_RETCODE SCIPaddVarExactData(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *lb, SCIP_RATIONAL *ub, SCIP_RATIONAL *obj)
    Definition: scip_var.c:299
    SCIPchgVarUb
    SCIP_RETCODE SCIPchgVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
    Definition: scip_var.c:5875
    SCIPchgVarUbNode
    SCIP_RETCODE SCIPchgVarUbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
    Definition: scip_var.c:6088
    SCIPgetVarAvgInferencesCurrentRun
    SCIP_Real SCIPgetVarAvgInferencesCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11919
    SCIPchgVarImplType
    SCIP_RETCODE SCIPchgVarImplType(SCIP *scip, SCIP_VAR *var, SCIP_IMPLINTTYPE impltype, SCIP_Bool *infeasible)
    Definition: scip_var.c:10218
    SCIPgetCliques
    SCIP_CLIQUE ** SCIPgetCliques(SCIP *scip)
    Definition: scip_var.c:9566
    SCIPtightenVarUb
    SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:6651
    SCIPparseVarName
    SCIP_RETCODE SCIPparseVarName(SCIP *scip, const char *str, SCIP_VAR **var, char **endptr)
    Definition: scip_var.c:728
    SCIPparseVar
    SCIP_RETCODE SCIPparseVar(SCIP *scip, SCIP_VAR **var, const char *str, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARCOPY((*varcopy)), SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_VARDATA *vardata, char **endptr, SCIP_Bool *success)
    Definition: scip_var.c:669
    SCIPgetProbvarSum
    SCIP_RETCODE SCIPgetProbvarSum(SCIP *scip, SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
    Definition: scip_var.c:2499
    SCIPchgVarBranchDirection
    SCIP_RETCODE SCIPchgVarBranchDirection(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR branchdirection)
    Definition: scip_var.c:10022
    SCIPaddVarVub
    SCIP_RETCODE SCIPaddVarVub(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vubvar, SCIP_Real vubcoef, SCIP_Real vubconstant, SCIP_Bool *infeasible, int *nbdchgs)
    Definition: scip_var.c:8680
    SCIPaddVarLocksType
    SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
    Definition: scip_var.c:5118
    SCIPchgVarLbGlobalExact
    SCIP_RETCODE SCIPchgVarLbGlobalExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newbound)
    Definition: scip_var.c:5492
    SCIPaddVarVlb
    SCIP_RETCODE SCIPaddVarVlb(SCIP *scip, SCIP_VAR *var, SCIP_VAR *vlbvar, SCIP_Real vlbcoef, SCIP_Real vlbconstant, SCIP_Bool *infeasible, int *nbdchgs)
    Definition: scip_var.c:8621
    SCIPchgVarBranchPriority
    SCIP_RETCODE SCIPchgVarBranchPriority(SCIP *scip, SCIP_VAR *var, int branchpriority)
    Definition: scip_var.c:9917
    SCIPunlockVarCons
    SCIP_RETCODE SCIPunlockVarCons(SCIP *scip, SCIP_VAR *var, SCIP_CONS *cons, SCIP_Bool lockdown, SCIP_Bool lockup)
    Definition: scip_var.c:5296
    SCIPchgVarUbGlobalExact
    SCIP_RETCODE SCIPchgVarUbGlobalExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newbound)
    Definition: scip_var.c:5467
    SCIPinferVarLbConsExact
    SCIP_RETCODE SCIPinferVarLbConsExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:7296
    SCIPgetVarFarkasCoef
    SCIP_Real SCIPgetVarFarkasCoef(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:2698
    SCIPgetVarClosestVub
    SCIP_RETCODE SCIPgetVarClosestVub(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvub, int *closestvubidx)
    Definition: scip_var.c:8592
    SCIPgetVarAvgCutoffsCurrentRun
    SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:12173
    SCIPcreateVarImpl
    SCIP_RETCODE SCIPcreateVarImpl(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_IMPLINTTYPE impltype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
    Definition: scip_var.c:225
    SCIPchgVarLbLazy
    SCIP_RETCODE SCIPchgVarLbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazylb)
    Definition: scip_var.c:6321
    SCIPgetVarUbAtIndex
    SCIP_Real SCIPgetVarUbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
    Definition: scip_var.c:2872
    SCIPgetVarStrongbranchNode
    SCIP_Longint SCIPgetVarStrongbranchNode(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:5019
    SCIPtransformVars
    SCIP_RETCODE SCIPtransformVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **transvars)
    Definition: scip_var.c:2028
    SCIPcalcCliquePartition
    SCIP_RETCODE SCIPcalcCliquePartition(SCIP *scip, SCIP_VAR **vars, int nvars, int **probtoidxmap, int *probtoidxmapsize, int *cliquepartition, int *ncliques)
    Definition: scip_var.c:9330
    SCIPgetVarDPseudocostScore
    SCIP_Real SCIPgetVarDPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real discountfac)
    Definition: scip_var.c:11570
    SCIPmultiaggregateVar
    SCIP_RETCODE SCIPmultiaggregateVar(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_Real *scalars, SCIP_Real constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
    Definition: scip_var.c:10834
    SCIPfreeParseVarsPolynomialData
    void SCIPfreeParseVarsPolynomialData(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int nmonomials)
    Definition: scip_var.c:1755
    SCIPgetLastStrongbranchLPSolStat
    SCIP_LPSOLSTAT SCIPgetLastStrongbranchLPSolStat(SCIP *scip, SCIP_BRANCHDIR branchdir)
    Definition: scip_var.c:4847
    SCIPaddVarBranchFactor
    SCIP_RETCODE SCIPaddVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real addfactor)
    Definition: scip_var.c:9886
    SCIPgetNCliquesCreated
    int SCIPgetNCliquesCreated(SCIP *scip)
    Definition: scip_var.c:9539
    SCIPcleanupCliques
    SCIP_RETCODE SCIPcleanupCliques(SCIP *scip, SCIP_Bool *infeasible)
    Definition: scip_var.c:9469
    SCIPreleaseVar
    SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
    Definition: scip_var.c:1887
    SCIPadjustedVarUb
    SCIP_Real SCIPadjustedVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
    Definition: scip_var.c:5634
    SCIPgetVarStrongbranchLPAge
    SCIP_Longint SCIPgetVarStrongbranchLPAge(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:5053
    SCIPchgVarLbGlobal
    SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
    Definition: scip_var.c:6141
    SCIPgetProbvarLinearSumExact
    SCIP_RETCODE SCIPgetProbvarLinearSumExact(SCIP *scip, SCIP_VAR **vars, SCIP_RATIONAL **scalars, int *nvars, int varssize, SCIP_RATIONAL *constant, int *requiredsize, SCIP_Bool mergemultiples)
    Definition: scip_var.c:2443
    SCIPmarkRelaxSolValid
    SCIP_RETCODE SCIPmarkRelaxSolValid(SCIP *scip, SCIP_RELAX *relax, SCIP_Bool includeslp)
    Definition: scip_var.c:3301
    SCIPgetVarsStrongbranchesFrac
    SCIP_RETCODE SCIPgetVarsStrongbranchesFrac(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
    Definition: scip_var.c:4632
    SCIPsetVarStrongbranchData
    SCIP_RETCODE SCIPsetVarStrongbranchData(SCIP *scip, SCIP_VAR *var, SCIP_Real lpobjval, SCIP_Real primsol, SCIP_Real down, SCIP_Real up, SCIP_Bool downvalid, SCIP_Bool upvalid, SCIP_Longint iter, int itlim)
    Definition: scip_var.c:4903
    SCIPdoNotMultaggr
    SCIP_Bool SCIPdoNotMultaggr(SCIP *scip)
    Definition: scip_var.c:10919
    SCIPgetVarPseudocostVal
    SCIP_Real SCIPgetVarPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
    Definition: scip_var.c:11188
    SCIPparseVarsLinearsum
    SCIP_RETCODE SCIPparseVarsLinearsum(SCIP *scip, const char *str, SCIP_VAR **vars, SCIP_Real *vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
    Definition: scip_var.c:899
    SCIPgetVarConflictlengthScore
    SCIP_Real SCIPgetVarConflictlengthScore(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:11775
    SCIPsignificantVarPscostDifference
    SCIP_Bool SCIPsignificantVarPscostDifference(SCIP *scip, SCIP_VAR *varx, SCIP_Real fracx, SCIP_VAR *vary, SCIP_Real fracy, SCIP_BRANCHDIR dir, SCIP_CONFIDENCELEVEL clevel, SCIP_Bool onesided)
    Definition: scip_var.c:11457
    SCIPgetProbvarLinearSum
    SCIP_RETCODE SCIPgetProbvarLinearSum(SCIP *scip, SCIP_VAR **vars, SCIP_Real *scalars, int *nvars, int varssize, SCIP_Real *constant, int *requiredsize)
    Definition: scip_var.c:2378
    SCIPgetRelaxSolVal
    SCIP_Real SCIPgetRelaxSolVal(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:3347
    SCIPgetVarStrongbranchWithPropagation
    SCIP_RETCODE SCIPgetVarStrongbranchWithPropagation(SCIP *scip, SCIP_VAR *var, SCIP_Real solval, SCIP_Real lpobjval, int itlim, int maxproprounds, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Longint *ndomredsdown, SCIP_Longint *ndomredsup, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror, SCIP_Real *newlbs, SCIP_Real *newubs)
    Definition: scip_var.c:4138
    SCIPadjustedVarLb
    SCIP_Real SCIPadjustedVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real lb)
    Definition: scip_var.c:5570
    SCIPgetVarAvgCutoffs
    SCIP_Real SCIPgetVarAvgCutoffs(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:12145
    SCIPgetVarAncPseudocostVal
    SCIP_Real SCIPgetVarAncPseudocostVal(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
    Definition: scip_var.c:11214
    SCIPisRelaxSolValid
    SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)
    Definition: scip_var.c:3281
    SCIPgetVarClosestVlb
    SCIP_RETCODE SCIPgetVarClosestVlb(SCIP *scip, SCIP_VAR *var, SCIP_SOL *sol, SCIP_Real *closestvlb, int *closestvlbidx)
    Definition: scip_var.c:8569
    SCIPparseVarsLinearsumExact
    SCIP_RETCODE SCIPparseVarsLinearsumExact(SCIP *scip, char *str, SCIP_VAR **vars, SCIP_RATIONAL **vals, int *nvars, int varssize, int *requiredsize, char **endptr, SCIP_Bool *success)
    Definition: scip_var.c:1007
    SCIPchgVarType
    SCIP_RETCODE SCIPchgVarType(SCIP *scip, SCIP_VAR *var, SCIP_VARTYPE vartype, SCIP_Bool *infeasible)
    Definition: scip_var.c:10113
    SCIPflattenVarAggregationGraph
    SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:2332
    SCIPcomputeVarLbGlobal
    SCIP_Real SCIPcomputeVarLbGlobal(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:8375
    SCIPgetVarSol
    SCIP_Real SCIPgetVarSol(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:3051
    SCIPgetNegatedVar
    SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
    Definition: scip_var.c:2166
    SCIPgetVarPseudocostScoreCurrentRun
    SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
    Definition: scip_var.c:11613
    SCIPinferVarUbConsExact
    SCIP_RETCODE SCIPinferVarUbConsExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:7174
    SCIPhaveVarsCommonClique
    SCIP_Bool SCIPhaveVarsCommonClique(SCIP *scip, SCIP_VAR *var1, SCIP_Bool value1, SCIP_VAR *var2, SCIP_Bool value2, SCIP_Bool regardimplics)
    Definition: scip_var.c:9596
    SCIPaddVarImplication
    SCIP_RETCODE SCIPaddVarImplication(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing, SCIP_VAR *implvar, SCIP_BOUNDTYPE impltype, SCIP_Real implbound, SCIP_Bool *infeasible, int *nbdchgs)
    Definition: scip_var.c:8740
    SCIPsetRelaxSolVals
    SCIP_RETCODE SCIPsetRelaxSolVals(SCIP *scip, SCIP_RELAX *relax, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Bool includeslp)
    Definition: scip_var.c:3191
    SCIPcalculatePscostConfidenceBound
    SCIP_Real SCIPcalculatePscostConfidenceBound(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun, SCIP_CONFIDENCELEVEL clevel)
    Definition: scip_var.c:11426
    SCIPchgVarUbGlobal
    SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
    Definition: scip_var.c:6230
    SCIPcomputeVarLbLocal
    SCIP_Real SCIPcomputeVarLbLocal(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:8417
    SCIPwriteVarsPolynomial
    SCIP_RETCODE SCIPwriteVarsPolynomial(SCIP *scip, FILE *file, SCIP_VAR ***monomialvars, SCIP_Real **monomialexps, SCIP_Real *monomialcoefs, int *monomialnvars, int nmonomials, SCIP_Bool type)
    Definition: scip_var.c:599
    SCIPgetVarPseudocostValCurrentRun
    SCIP_Real SCIPgetVarPseudocostValCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta)
    Definition: scip_var.c:11242
    SCIPupdateVarPseudocost
    SCIP_RETCODE SCIPupdateVarPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
    Definition: scip_var.c:11122
    SCIPgetNCliques
    int SCIPgetNCliques(SCIP *scip)
    Definition: scip_var.c:9512
    SCIPgetVarAvgGMIScore
    SCIP_Real SCIPgetVarAvgGMIScore(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:12349
    SCIPcreateVar
    SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
    Definition: scip_var.c:120
    SCIPadjustedVarUbExactFloat
    SCIP_Real SCIPadjustedVarUbExactFloat(SCIP *scip, SCIP_VAR *var, SCIP_Real ub)
    Definition: scip_var.c:5666
    SCIPaddVarBranchPriority
    SCIP_RETCODE SCIPaddVarBranchPriority(SCIP *scip, SCIP_VAR *var, int addpriority)
    Definition: scip_var.c:9991
    SCIPtransformVar
    SCIP_RETCODE SCIPtransformVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
    Definition: scip_var.c:1988
    SCIPgetVarRedcost
    SCIP_Real SCIPgetVarRedcost(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:2608
    SCIPmarkDoNotMultaggrVar
    SCIP_RETCODE SCIPmarkDoNotMultaggrVar(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:11057
    SCIPfixVar
    SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
    Definition: scip_var.c:10318
    SCIPmarkRelaxSolInvalid
    SCIP_RETCODE SCIPmarkRelaxSolInvalid(SCIP *scip)
    Definition: scip_var.c:3326
    SCIPgetVarAvgInferenceCutoffScoreCurrentRun
    SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
    Definition: scip_var.c:12306
    SCIPinferVarLbCons
    SCIP_RETCODE SCIPinferVarLbCons(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:6964
    SCIPgetVarsStrongbranchesInt
    SCIP_RETCODE SCIPgetVarsStrongbranchesInt(SCIP *scip, SCIP_VAR **vars, int nvars, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Bool *downinf, SCIP_Bool *upinf, SCIP_Bool *downconflict, SCIP_Bool *upconflict, SCIP_Bool *lperror)
    Definition: scip_var.c:4743
    SCIPgetVarLbAtIndex
    SCIP_Real SCIPgetVarLbAtIndex(SCIP *scip, SCIP_VAR *var, SCIP_BDCHGIDX *bdchgidx, SCIP_Bool after)
    Definition: scip_var.c:2736
    SCIPparseVarsPolynomial
    SCIP_RETCODE SCIPparseVarsPolynomial(SCIP *scip, const char *str, SCIP_VAR ****monomialvars, SCIP_Real ***monomialexps, SCIP_Real **monomialcoefs, int **monomialnvars, int *nmonomials, char **endptr, SCIP_Bool *success)
    Definition: scip_var.c:1100
    SCIPgetVarLastGMIScore
    SCIP_Real SCIPgetVarLastGMIScore(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:12403
    SCIPgetVarConflictScore
    SCIP_Real SCIPgetVarConflictScore(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:11713
    SCIPprintVar
    SCIP_RETCODE SCIPprintVar(SCIP *scip, SCIP_VAR *var, FILE *file)
    Definition: scip_var.c:12465
    SCIPgetVarAvgCutoffScore
    SCIP_Real SCIPgetVarAvgCutoffScore(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:12199
    SCIPchgVarLbNode
    SCIP_RETCODE SCIPchgVarLbNode(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound)
    Definition: scip_var.c:6044
    SCIPcreateVarBasic
    SCIP_RETCODE SCIPcreateVarBasic(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype)
    Definition: scip_var.c:184
    SCIPsetVarLastGMIScore
    SCIP_RETCODE SCIPsetVarLastGMIScore(SCIP *scip, SCIP_VAR *var, SCIP_Real gmieff)
    Definition: scip_var.c:12429
    SCIPchgVarUbLazy
    SCIP_RETCODE SCIPchgVarUbLazy(SCIP *scip, SCIP_VAR *var, SCIP_Real lazyub)
    Definition: scip_var.c:6362
    SCIPinferBinvarCons
    SCIP_RETCODE SCIPinferBinvarCons(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:7412
    SCIPtryStrongbranchLPSol
    SCIP_RETCODE SCIPtryStrongbranchLPSol(SCIP *scip, SCIP_Bool *foundsol, SCIP_Bool *cutoff)
    Definition: scip_var.c:4938
    SCIPchgVarObjExact
    SCIP_RETCODE SCIPchgVarObjExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newobj)
    Definition: scip_var.c:5420
    SCIPwriteVarName
    SCIP_RETCODE SCIPwriteVarName(SCIP *scip, FILE *file, SCIP_VAR *var, SCIP_Bool type)
    Definition: scip_var.c:361
    SCIPgetVarSols
    SCIP_RETCODE SCIPgetVarSols(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
    Definition: scip_var.c:3071
    SCIPchgVarObj
    SCIP_RETCODE SCIPchgVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
    Definition: scip_var.c:5372
    SCIPupdateVarAncPseudocost
    SCIP_RETCODE SCIPupdateVarAncPseudocost(SCIP *scip, SCIP_VAR *var, SCIP_Real solvaldelta, SCIP_Real objdelta, SCIP_Real weight)
    Definition: scip_var.c:11154
    SCIPchgVarLbExact
    SCIP_RETCODE SCIPchgVarLbExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newbound)
    Definition: scip_var.c:5786
    SCIPgetBinvarRepresentative
    SCIP_RETCODE SCIPgetBinvarRepresentative(SCIP *scip, SCIP_VAR *var, SCIP_VAR **repvar, SCIP_Bool *negated)
    Definition: scip_var.c:2236
    SCIPgetVarAvgInferenceCutoffScore
    SCIP_Real SCIPgetVarAvgInferenceCutoffScore(SCIP *scip, SCIP_VAR *var, SCIP_Real cutoffweight)
    Definition: scip_var.c:12262
    SCIPwriteVarsList
    SCIP_RETCODE SCIPwriteVarsList(SCIP *scip, FILE *file, SCIP_VAR **vars, int nvars, SCIP_Bool type, char delimiter)
    Definition: scip_var.c:423
    SCIPcomputeVarUbGlobal
    SCIP_Real SCIPcomputeVarUbGlobal(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:8396
    SCIPcomputeVarUbLocal
    SCIP_Real SCIPcomputeVarUbLocal(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:8462
    SCIPgetActiveVars
    SCIP_RETCODE SCIPgetActiveVars(SCIP *scip, SCIP_VAR **vars, int *nvars, int varssize, int *requiredsize)
    Definition: scip_var.c:2574
    SCIPgetVarNStrongbranchs
    int SCIPgetVarNStrongbranchs(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:5085
    SCIPwriteVarsLinearsum
    SCIP_RETCODE SCIPwriteVarsLinearsum(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_Real *vals, int nvars, SCIP_Bool type)
    Definition: scip_var.c:474
    SCIPgetProbvarSumExact
    SCIP_RETCODE SCIPgetProbvarSumExact(SCIP *scip, SCIP_VAR **var, SCIP_RATIONAL *scalar, SCIP_RATIONAL *constant)
    Definition: scip_var.c:2538
    SCIPgetVarStrongbranchLast
    SCIP_RETCODE SCIPgetVarStrongbranchLast(SCIP *scip, SCIP_VAR *var, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, SCIP_Real *solval, SCIP_Real *lpobjval)
    Definition: scip_var.c:4869
    SCIPgetVarVSIDS
    SCIP_Real SCIPgetVarVSIDS(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11649
    SCIPgetVarConflictlengthScoreCurrentRun
    SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:11806
    SCIPisVarAggrCoefAcceptable
    SCIP_Bool SCIPisVarAggrCoefAcceptable(SCIP *scip, SCIP_VAR *var, SCIP_Real scalar)
    Definition: scip_var.c:10962
    SCIPgetVarVSIDSCurrentRun
    SCIP_Real SCIPgetVarVSIDSCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11681
    SCIPisStrongbranchDownFirst
    SCIP_Bool SCIPisStrongbranchDownFirst(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:3399
    SCIPenableVarHistory
    void SCIPenableVarHistory(SCIP *scip)
    Definition: scip_var.c:11083
    SCIPgetVarImplRedcost
    SCIP_Real SCIPgetVarImplRedcost(SCIP *scip, SCIP_VAR *var, SCIP_Bool varfixing)
    Definition: scip_var.c:2653
    SCIPallowWeakDualReds
    SCIP_Bool SCIPallowWeakDualReds(SCIP *scip)
    Definition: scip_var.c:10998
    SCIPgetVarPseudocostVariance
    SCIP_Real SCIPgetVarPseudocostVariance(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Bool onlycurrentrun)
    Definition: scip_var.c:11404
    SCIPgetNegatedVars
    SCIP_RETCODE SCIPgetNegatedVars(SCIP *scip, int nvars, SCIP_VAR **vars, SCIP_VAR **negvars)
    Definition: scip_var.c:2199
    SCIPgetTransformedVar
    SCIP_RETCODE SCIPgetTransformedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **transvar)
    Definition: scip_var.c:2078
    SCIPmultiaggregateVarExact
    SCIP_RETCODE SCIPmultiaggregateVarExact(SCIP *scip, SCIP_VAR *var, int naggvars, SCIP_VAR **aggvars, SCIP_RATIONAL **scalars, SCIP_RATIONAL *constant, SCIP_Bool *infeasible, SCIP_Bool *aggregated)
    Definition: scip_var.c:10879
    SCIPgetVarConflictScoreCurrentRun
    SCIP_Real SCIPgetVarConflictScoreCurrentRun(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:11744
    SCIPtightenVarLbExact
    SCIP_RETCODE SCIPtightenVarLbExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *newbound, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:6518
    SCIPcaptureVar
    SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:1853
    SCIPgetVarPseudocostScore
    SCIP_Real SCIPgetVarPseudocostScore(SCIP *scip, SCIP_VAR *var, SCIP_Real solval)
    Definition: scip_var.c:11531
    SCIPstartStrongbranch
    SCIP_RETCODE SCIPstartStrongbranch(SCIP *scip, SCIP_Bool enablepropagation)
    Definition: scip_var.c:3430
    SCIPclearRelaxSolVals
    SCIP_RETCODE SCIPclearRelaxSolVals(SCIP *scip, SCIP_RELAX *relax)
    Definition: scip_var.c:3108
    SCIPmarkDoNotAggrVar
    SCIP_RETCODE SCIPmarkDoNotAggrVar(SCIP *scip, SCIP_VAR *var)
    Definition: scip_var.c:11024
    SCIPgetVarAvgInferences
    SCIP_Real SCIPgetVarAvgInferences(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11891
    SCIPallowStrongDualReds
    SCIP_Bool SCIPallowStrongDualReds(SCIP *scip)
    Definition: scip_var.c:10984
    SCIPinferBinvarProp
    SCIP_RETCODE SCIPinferBinvarProp(SCIP *scip, SCIP_VAR *var, SCIP_Bool fixedval, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:7809
    SCIPwriteVarsLinearsumExact
    SCIP_RETCODE SCIPwriteVarsLinearsumExact(SCIP *scip, FILE *file, SCIP_VAR **vars, SCIP_RATIONAL **vals, int nvars, SCIP_Bool type)
    Definition: scip_var.c:533
    SCIPinferVarFixCons
    SCIP_RETCODE SCIPinferVarFixCons(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_CONS *infercons, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:6895
    SCIPgetVarAvgConflictlengthCurrentRun
    SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir)
    Definition: scip_var.c:11863
    SCIPfreeParseVarsPolynomialDataExact
    void SCIPfreeParseVarsPolynomialDataExact(SCIP *scip, SCIP_VAR ****monomialvars, SCIP_RATIONAL ***monomialcoefs, int nmonomials)
    Definition: scip_var.c:1806
    SCIPsetRelaxSolValsSol
    SCIP_RETCODE SCIPsetRelaxSolValsSol(SCIP *scip, SCIP_RELAX *relax, SCIP_SOL *sol, SCIP_Bool includeslp)
    Definition: scip_var.c:3233
    SCIPchgVarBranchFactor
    SCIP_RETCODE SCIPchgVarBranchFactor(SCIP *scip, SCIP_VAR *var, SCIP_Real branchfactor)
    Definition: scip_var.c:9830
    SCIPtightenVarLbGlobal
    SCIP_RETCODE SCIPtightenVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:8026
    SCIPcomputeVarLbLocalExact
    SCIP_RETCODE SCIPcomputeVarLbLocalExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *result)
    Definition: scip_var.c:8438
    SCIPfixVarExact
    SCIP_RETCODE SCIPfixVarExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
    Definition: scip_var.c:10420
    SCIPinferVarLbProp
    SCIP_RETCODE SCIPinferVarLbProp(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_PROP *inferprop, int inferinfo, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
    Definition: scip_var.c:7584
    SCIPaddVarObj
    SCIP_RETCODE SCIPaddVarObj(SCIP *scip, SCIP_VAR *var, SCIP_Real addobj)
    Definition: scip_var.c:5519
    SCIPcomputeVarUbLocalExact
    SCIP_RETCODE SCIPcomputeVarUbLocalExact(SCIP *scip, SCIP_VAR *var, SCIP_RATIONAL *result)
    Definition: scip_var.c:8483
    scalars
    static const SCIP_Real scalars[]
    Definition: lp.c:5959
    pub_var.h
    public methods for problem variables
    SCIP_BdChgIdx
    Definition: struct_var.h:114
    SCIP_Clique
    Definition: struct_implics.h:76
    SCIP_Cons
    Definition: struct_cons.h:47
    SCIP_Node
    Definition: struct_tree.h:142
    SCIP_Prop
    Definition: struct_prop.h:47
    SCIP_Rational
    Definition: struct_rational.h:47
    SCIP_Relax
    Definition: struct_relax.h:47
    SCIP_Sol
    Definition: struct_sol.h:74
    SCIP_Var
    Definition: struct_var.h:262
    type_cons.h
    type definitions for constraints and constraint handlers
    type_history.h
    type definitions for branching and inference history
    SCIP_BRANCHDIR
    enum SCIP_BranchDir SCIP_BRANCHDIR
    Definition: type_history.h:48
    type_implics.h
    type definitions for implications, variable bounds, and cliques
    type_lp.h
    type definitions for LP management
    SCIP_LPSOLSTAT
    enum SCIP_LPSolStat SCIP_LPSOLSTAT
    Definition: type_lp.h:52
    SCIP_BOUNDTYPE
    enum SCIP_BoundType SCIP_BOUNDTYPE
    Definition: type_lp.h:60
    type_misc.h
    type definitions for miscellaneous datastructures
    SCIP_CONFIDENCELEVEL
    enum SCIP_Confidencelevel SCIP_CONFIDENCELEVEL
    Definition: type_misc.h:53
    type_prop.h
    type definitions for propagators
    type_relax.h
    type definitions for relaxators
    type_result.h
    result codes for SCIP callback methods
    type_retcode.h
    type definitions for return codes for SCIP methods
    SCIP_RETCODE
    enum SCIP_Retcode SCIP_RETCODE
    Definition: type_retcode.h:63
    type_scip.h
    type definitions for SCIP's main datastructure
    type_sol.h
    type definitions for storing primal CIP solutions
    type_tree.h
    type definitions for branch and bound tree
    type_var.h
    type definitions for problem variables
    SCIP_VARDATA
    struct SCIP_VarData SCIP_VARDATA
    Definition: type_var.h:167
    SCIP_IMPLINTTYPE
    enum SCIP_ImplintType SCIP_IMPLINTTYPE
    Definition: type_var.h:117
    SCIP_DECL_VARDELORIG
    #define SCIP_DECL_VARDELORIG(x)
    Definition: type_var.h:180
    SCIP_DECL_VARTRANS
    #define SCIP_DECL_VARTRANS(x)
    Definition: type_var.h:200
    SCIP_DECL_VARCOPY
    #define SCIP_DECL_VARCOPY(x)
    Definition: type_var.h:243
    SCIP_DECL_VARDELTRANS
    #define SCIP_DECL_VARDELTRANS(x)
    Definition: type_var.h:213
    SCIP_LOCKTYPE
    enum SCIP_LockType SCIP_LOCKTYPE
    Definition: type_var.h:144
    SCIP_VARTYPE
    enum SCIP_Vartype SCIP_VARTYPE
    Definition: type_var.h:73