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-2025 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_RETCODE SCIPinferVarUbConsExact(
    2429 SCIP* scip, /**< SCIP data structure */
    2430 SCIP_VAR* var, /**< variable to change the bound for */
    2431 SCIP_RATIONAL* newbound, /**< new value for bound */
    2432 SCIP_CONS* infercons, /**< constraint that deduced the bound change */
    2433 int inferinfo, /**< user information for inference to help resolving the conflict */
    2434 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2435 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2436 );
    2437
    2438/** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
    2439 * than the current bound; if possible, adjusts bound to integral value;
    2440 * the given inference constraint is stored, such that the conflict analysis is able to find out the reason
    2441 * for the deduction of the bound change
    2442 *
    2443 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2444 * SCIPgetVars()) gets resorted.
    2445 *
    2446 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2447 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2448 *
    2449 * @pre This method can be called if @p scip is in one of the following stages:
    2450 * - \ref SCIP_STAGE_PROBLEM
    2451 * - \ref SCIP_STAGE_PRESOLVING
    2452 * - \ref SCIP_STAGE_SOLVING
    2453 *
    2454 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2455 */
    2456SCIP_RETCODE SCIPinferVarLbConsExact(
    2457 SCIP* scip, /**< SCIP data structure */
    2458 SCIP_VAR* var, /**< variable to change the bound for */
    2459 SCIP_RATIONAL* newbound, /**< new value for bound */
    2460 SCIP_CONS* infercons, /**< constraint that deduced the bound change */
    2461 int inferinfo, /**< user information for inference to help resolving the conflict */
    2462 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2463 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2464 );
    2465
    2466/** fixes variable in preprocessing or in the current node, if the new bound is tighter (w.r.t. bound strengthening
    2467 * epsilon) than the current bound; if possible, adjusts bound to integral value; the given inference constraint is
    2468 * stored, such that the conflict analysis is able to find out the reason for the deduction of the bound change
    2469 *
    2470 * @note In presolving stage when not in probing mode the variable will be fixed directly, otherwise this method
    2471 * changes first the lowerbound by calling SCIPinferVarLbProp and second the upperbound by calling
    2472 * SCIPinferVarUbProp
    2473 *
    2474 * @note If SCIP is in presolving stage, it can happen that the internal variable array (which get be accessed via
    2475 * SCIPgetVars()) gets re-sorted.
    2476 *
    2477 * @note During presolving, an integer variable which bound changes to {0,1} is upgraded to a binary variable.
    2478 */
    2479SCIP_EXPORT
    2480SCIP_RETCODE SCIPinferVarFixProp(
    2481 SCIP* scip, /**< SCIP data structure */
    2482 SCIP_VAR* var, /**< variable to change the bound for */
    2483 SCIP_Real fixedval, /**< new value for fixation */
    2484 SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
    2485 int inferinfo, /**< user information for inference to help resolving the conflict */
    2486 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2487 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2488 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2489 );
    2490
    2491/** changes lower bound of variable in preprocessing or in the current node, if the new bound is tighter
    2492 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
    2493 * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
    2494 * for the deduction of the bound change
    2495 *
    2496 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2497 * SCIPgetVars()) gets re-sorted.
    2498 *
    2499 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2500 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2501 *
    2502 * @pre This method can be called if @p scip is in one of the following stages:
    2503 * - \ref SCIP_STAGE_PROBLEM
    2504 * - \ref SCIP_STAGE_PRESOLVING
    2505 * - \ref SCIP_STAGE_SOLVING
    2506 *
    2507 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2508 */
    2509SCIP_EXPORT
    2510SCIP_RETCODE SCIPinferVarLbProp(
    2511 SCIP* scip, /**< SCIP data structure */
    2512 SCIP_VAR* var, /**< variable to change the bound for */
    2513 SCIP_Real newbound, /**< new value for bound */
    2514 SCIP_PROP* inferprop, /**< propagator that deduced the bound change, or NULL */
    2515 int inferinfo, /**< user information for inference to help resolving the conflict */
    2516 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2517 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2518 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2519 );
    2520
    2521/** changes upper bound of variable in preprocessing or in the current node, if the new bound is tighter
    2522 * (w.r.t. bound strengthening epsilon) than the current bound; if possible, adjusts bound to integral value;
    2523 * the given inference propagator is stored, such that the conflict analysis is able to find out the reason
    2524 * for the deduction of the bound change
    2525 *
    2526 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2527 * SCIPgetVars()) gets re-sorted.
    2528 *
    2529 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2530 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2531 *
    2532 * @pre This method can be called if @p scip is in one of the following stages:
    2533 * - \ref SCIP_STAGE_PROBLEM
    2534 * - \ref SCIP_STAGE_PRESOLVING
    2535 * - \ref SCIP_STAGE_SOLVING
    2536 *
    2537 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2538 */
    2539SCIP_EXPORT
    2540SCIP_RETCODE SCIPinferVarUbProp(
    2541 SCIP* scip, /**< SCIP data structure */
    2542 SCIP_VAR* var, /**< variable to change the bound for */
    2543 SCIP_Real newbound, /**< new value for bound */
    2544 SCIP_PROP* inferprop, /**< propagator that deduced the bound change */
    2545 int inferinfo, /**< user information for inference to help resolving the conflict */
    2546 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2547 SCIP_Bool* infeasible, /**< pointer to store whether the bound change is infeasible */
    2548 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2549 );
    2550
    2551/** depending on SCIP's stage, fixes binary variable in the problem, in preprocessing, or in current node;
    2552 * the given inference propagator is stored, such that the conflict analysis is able to find out the reason for the
    2553 * deduction of the fixing
    2554 *
    2555 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2556 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2557 *
    2558 * @pre This method can be called if @p scip is in one of the following stages:
    2559 * - \ref SCIP_STAGE_PROBLEM
    2560 * - \ref SCIP_STAGE_PRESOLVING
    2561 * - \ref SCIP_STAGE_PRESOLVED
    2562 * - \ref SCIP_STAGE_SOLVING
    2563 */
    2564SCIP_EXPORT
    2565SCIP_RETCODE SCIPinferBinvarProp(
    2566 SCIP* scip, /**< SCIP data structure */
    2567 SCIP_VAR* var, /**< binary variable to fix */
    2568 SCIP_Bool fixedval, /**< value to fix binary variable to */
    2569 SCIP_PROP* inferprop, /**< propagator that deduced the fixing */
    2570 int inferinfo, /**< user information for inference to help resolving the conflict */
    2571 SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
    2572 SCIP_Bool* tightened /**< pointer to store whether the fixing tightened the local bounds, or NULL */
    2573 );
    2574
    2575/** changes global lower bound of variable in preprocessing or in the current node, if the new bound is tighter
    2576 * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
    2577 * also tightens the local bound, if the global bound is better than the local bound
    2578 *
    2579 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2580 * SCIPgetVars()) gets re-sorted.
    2581 *
    2582 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2583 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2584 *
    2585 * @pre This method can be called if @p scip is in one of the following stages:
    2586 * - \ref SCIP_STAGE_PROBLEM
    2587 * - \ref SCIP_STAGE_TRANSFORMING
    2588 * - \ref SCIP_STAGE_PRESOLVING
    2589 * - \ref SCIP_STAGE_SOLVING
    2590 *
    2591 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2592 */
    2593SCIP_EXPORT
    2594SCIP_RETCODE SCIPtightenVarLbGlobal(
    2595 SCIP* scip, /**< SCIP data structure */
    2596 SCIP_VAR* var, /**< variable to change the bound for */
    2597 SCIP_Real newbound, /**< new value for bound */
    2598 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2599 SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
    2600 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2601 );
    2602
    2603/** changes global upper bound of variable in preprocessing or in the current node, if the new bound is tighter
    2604 * (w.r.t. bound strengthening epsilon) than the current global bound; if possible, adjusts bound to integral value;
    2605 * also tightens the local bound, if the global bound is better than the local bound
    2606 *
    2607 * @warning If SCIP is in presolving stage, it can happen that the internal variable array (which can be accessed via
    2608 * SCIPgetVars()) gets re-sorted.
    2609 *
    2610 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2611 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2612 *
    2613 * @pre This method can be called if @p scip is in one of the following stages:
    2614 * - \ref SCIP_STAGE_PROBLEM
    2615 * - \ref SCIP_STAGE_TRANSFORMING
    2616 * - \ref SCIP_STAGE_PRESOLVING
    2617 * - \ref SCIP_STAGE_SOLVING
    2618 *
    2619 * @note During presolving, an integer variable whose bound changes to {0,1} is upgraded to a binary variable.
    2620 */
    2621SCIP_EXPORT
    2622SCIP_RETCODE SCIPtightenVarUbGlobal(
    2623 SCIP* scip, /**< SCIP data structure */
    2624 SCIP_VAR* var, /**< variable to change the bound for */
    2625 SCIP_Real newbound, /**< new value for bound */
    2626 SCIP_Bool force, /**< force tightening even if below bound strengthening tolerance */
    2627 SCIP_Bool* infeasible, /**< pointer to store whether the new domain is empty */
    2628 SCIP_Bool* tightened /**< pointer to store whether the bound was tightened, or NULL */
    2629 );
    2630
    2631/** for a multi-aggregated variable, returns the global lower bound computed by adding the global bounds from all aggregation variables
    2632 *
    2633 * 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
    2634 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbGlobal.
    2635 *
    2636 * @return the global lower bound computed by adding the global bounds from all aggregation variables
    2637 */
    2638SCIP_EXPORT
    2639SCIP_Real SCIPcomputeVarLbGlobal(
    2640 SCIP* scip, /**< SCIP data structure */
    2641 SCIP_VAR* var /**< variable to compute the bound for */
    2642 );
    2643
    2644/** for a multi-aggregated variable, returns the global upper bound computed by adding the global bounds from all aggregation variables
    2645 *
    2646 * 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
    2647 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbGlobal.
    2648 *
    2649 * @return the global upper bound computed by adding the global bounds from all aggregation variables
    2650 */
    2651SCIP_EXPORT
    2652SCIP_Real SCIPcomputeVarUbGlobal(
    2653 SCIP* scip, /**< SCIP data structure */
    2654 SCIP_VAR* var /**< variable to compute the bound for */
    2655 );
    2656
    2657/** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
    2658 *
    2659 * 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
    2660 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
    2661 *
    2662 * @return the local lower bound computed by adding the global bounds from all aggregation variables
    2663 */
    2664SCIP_EXPORT
    2665SCIP_Real SCIPcomputeVarLbLocal(
    2666 SCIP* scip, /**< SCIP data structure */
    2667 SCIP_VAR* var /**< variable to compute the bound for */
    2668 );
    2669
    2670/** for a multi-aggregated variable, returns the local lower bound computed by adding the local bounds from all aggregation variables
    2671 *
    2672 * 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
    2673 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetLbLocal.
    2674 *
    2675 * @return the local lower bound computed by adding the global bounds from all aggregation variables
    2676 */
    2677SCIP_EXPORT
    2678SCIP_RETCODE SCIPcomputeVarLbLocalExact(
    2679 SCIP* scip, /**< SCIP data structure */
    2680 SCIP_VAR* var, /**< variable to compute the bound for */
    2681 SCIP_RATIONAL* result /**< rational to store the resulting bound */
    2682 );
    2683
    2684/** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
    2685 *
    2686 * 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
    2687 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
    2688 *
    2689 * @return the local upper bound computed by adding the global bounds from all aggregation variables
    2690 */
    2691SCIP_EXPORT
    2692SCIP_Real SCIPcomputeVarUbLocal(
    2693 SCIP* scip, /**< SCIP data structure */
    2694 SCIP_VAR* var /**< variable to compute the bound for */
    2695 );
    2696
    2697/** for a multi-aggregated variable, returns the local upper bound computed by adding the local bounds from all aggregation variables
    2698 *
    2699 * 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
    2700 * calling this function for a non-multi-aggregated variable results in a call to SCIPvarGetUbLocal.
    2701 *
    2702 * @return the local upper bound computed by adding the global bounds from all aggregation variables
    2703 */
    2704SCIP_EXPORT
    2705SCIP_RETCODE SCIPcomputeVarUbLocalExact(
    2706 SCIP* scip, /**< SCIP data structure */
    2707 SCIP_VAR* var, /**< variable to compute the bound for */
    2708 SCIP_RATIONAL* result /**< rational to store the resulting bound */
    2709 );
    2710
    2711/** for a multi-aggregated variable, gives the global lower bound computed by adding the global bounds from all
    2712 * aggregation variables, this global bound may be tighter than the one given by SCIPvarGetLbGlobal, since the latter is
    2713 * not updated if bounds of aggregation variables are changing
    2714 *
    2715 * calling this function for a non-multi-aggregated variable is not allowed
    2716 */
    2717SCIP_EXPORT
    2718SCIP_Real SCIPgetVarMultaggrLbGlobal(
    2719 SCIP* scip, /**< SCIP data structure */
    2720 SCIP_VAR* var /**< variable to compute the bound for */
    2721 );
    2722
    2723/** for a multi-aggregated variable, gives the global upper bound computed by adding the global bounds from all
    2724 * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbGlobal, since the latter is
    2725 * not updated if bounds of aggregation variables are changing
    2726 *
    2727 * calling this function for a non-multi-aggregated variable is not allowed
    2728 */
    2729SCIP_EXPORT
    2730SCIP_Real SCIPgetVarMultaggrUbGlobal(
    2731 SCIP* scip, /**< SCIP data structure */
    2732 SCIP_VAR* var /**< variable to compute the bound for */
    2733 );
    2734
    2735/** for a multi-aggregated variable, gives the local lower bound computed by adding the local bounds from all
    2736 * aggregation variables, this lower bound may be tighter than the one given by SCIPvarGetLbLocal, since the latter is
    2737 * not updated if bounds of aggregation variables are changing
    2738 *
    2739 * calling this function for a non-multi-aggregated variable is not allowed
    2740 */
    2741SCIP_EXPORT
    2742SCIP_Real SCIPgetVarMultaggrLbLocal(
    2743 SCIP* scip, /**< SCIP data structure */
    2744 SCIP_VAR* var /**< variable to compute the bound for */
    2745 );
    2746
    2747/** for a multi-aggregated variable, gives the local upper bound computed by adding the local bounds from all
    2748 * aggregation variables, this upper bound may be tighter than the one given by SCIPvarGetUbLocal, since the latter is
    2749 * not updated if bounds of aggregation variables are changing
    2750 *
    2751 * calling this function for a non-multi-aggregated variable is not allowed
    2752 */
    2753SCIP_EXPORT
    2754SCIP_Real SCIPgetVarMultaggrUbLocal(
    2755 SCIP* scip, /**< SCIP data structure */
    2756 SCIP_VAR* var /**< variable to compute the bound for */
    2757 );
    2758
    2759#ifdef NDEBUG
    2760
    2761/* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
    2762 * speed up the algorithms.
    2763 */
    2764
    2765#define SCIPcomputeVarLbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbGlobal(scip, var) : SCIPvarGetLbGlobal(var))
    2766#define SCIPcomputeVarUbGlobal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbGlobal(scip, var) : SCIPvarGetUbGlobal(var))
    2767#define SCIPcomputeVarLbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrLbLocal(scip, var) : SCIPvarGetLbLocal(var))
    2768#define SCIPcomputeVarUbLocal(scip, var) (SCIPvarGetStatus(var) == SCIP_VARSTATUS_MULTAGGR ? SCIPgetVarMultaggrUbLocal(scip, var) : SCIPvarGetUbLocal(var))
    2769
    2770#endif
    2771
    2772/** returns solution value and index of variable lower bound that is closest to the variable's value in the given primal
    2773 * solution or current LP solution if no primal solution is given; returns an index of -1 if no variable lower bound is
    2774 * available
    2775 *
    2776 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2777 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2778 *
    2779 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
    2780 */
    2781SCIP_EXPORT
    2782SCIP_RETCODE SCIPgetVarClosestVlb(
    2783 SCIP* scip, /**< SCIP data structure */
    2784 SCIP_VAR* var, /**< active problem variable */
    2785 SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
    2786 SCIP_Real* closestvlb, /**< pointer to store the value of the closest variable lower bound */
    2787 int* closestvlbidx /**< pointer to store the index of the closest variable lower bound */
    2788 );
    2789
    2790/** returns solution value and index of variable upper bound that is closest to the variable's value in the given primal solution;
    2791 * or current LP solution if no primal solution is given; returns an index of -1 if no variable upper bound is available
    2792 *
    2793 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2794 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2795 *
    2796 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
    2797 */
    2798SCIP_EXPORT
    2799SCIP_RETCODE SCIPgetVarClosestVub(
    2800 SCIP* scip, /**< SCIP data structure */
    2801 SCIP_VAR* var, /**< active problem variable */
    2802 SCIP_SOL* sol, /**< primal solution, or NULL for LP solution */
    2803 SCIP_Real* closestvub, /**< pointer to store the value of the closest variable lower bound */
    2804 int* closestvubidx /**< pointer to store the index of the closest variable lower bound */
    2805 );
    2806
    2807/** informs variable x about a globally valid variable lower bound x >= b*z + d with integer variable z;
    2808 * if z is binary, the corresponding valid implication for z is also added;
    2809 * if z is non-continuous and 1/b not too small, the corresponding valid upper/lower bound
    2810 * z <= (x-d)/b or z >= (x-d)/b (depending on the sign of of b) is added, too;
    2811 * improves the global bounds of the variable and the vlb variable if possible
    2812 *
    2813 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2814 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2815 *
    2816 * @pre This method can be called if @p scip is in one of the following stages:
    2817 * - \ref SCIP_STAGE_PRESOLVING
    2818 * - \ref SCIP_STAGE_PRESOLVED
    2819 * - \ref SCIP_STAGE_SOLVING
    2820 */
    2821SCIP_EXPORT
    2822SCIP_RETCODE SCIPaddVarVlb(
    2823 SCIP* scip, /**< SCIP data structure */
    2824 SCIP_VAR* var, /**< problem variable */
    2825 SCIP_VAR* vlbvar, /**< variable z in x >= b*z + d */
    2826 SCIP_Real vlbcoef, /**< coefficient b in x >= b*z + d */
    2827 SCIP_Real vlbconstant, /**< constant d in x >= b*z + d */
    2828 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
    2829 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
    2830 );
    2831
    2832
    2833/** informs variable x about a globally valid variable upper bound x <= b*z + d with integer variable z;
    2834 * if z is binary, the corresponding valid implication for z is also added;
    2835 * if z is non-continuous and 1/b not too small, the corresponding valid lower/upper bound
    2836 * z >= (x-d)/b or z <= (x-d)/b (depending on the sign of of b) is added, too;
    2837 * improves the global bounds of the variable and the vlb variable if possible
    2838 *
    2839 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2840 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2841 *
    2842 * @pre This method can be called if @p scip is in one of the following stages:
    2843 * - \ref SCIP_STAGE_PRESOLVING
    2844 * - \ref SCIP_STAGE_PRESOLVED
    2845 * - \ref SCIP_STAGE_SOLVING
    2846 */
    2847SCIP_EXPORT
    2848SCIP_RETCODE SCIPaddVarVub(
    2849 SCIP* scip, /**< SCIP data structure */
    2850 SCIP_VAR* var, /**< problem variable */
    2851 SCIP_VAR* vubvar, /**< variable z in x <= b*z + d */
    2852 SCIP_Real vubcoef, /**< coefficient b in x <= b*z + d */
    2853 SCIP_Real vubconstant, /**< constant d in x <= b*z + d */
    2854 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
    2855 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
    2856 );
    2857
    2858/** informs binary variable x about a globally valid implication: x == 0 or x == 1 ==> y <= b or y >= b;
    2859 * also adds the corresponding implication or variable bound to the implied variable;
    2860 * if the implication is conflicting, the variable is fixed to the opposite value;
    2861 * if the variable is already fixed to the given value, the implication is performed immediately;
    2862 * if the implication is redundant with respect to the variables' global bounds, it is ignored
    2863 *
    2864 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2865 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2866 *
    2867 * @pre This method can be called if @p scip is in one of the following stages:
    2868 * - \ref SCIP_STAGE_TRANSFORMED
    2869 * - \ref SCIP_STAGE_PRESOLVING
    2870 * - \ref SCIP_STAGE_PRESOLVED
    2871 * - \ref SCIP_STAGE_SOLVING
    2872 */
    2873SCIP_EXPORT
    2874SCIP_RETCODE SCIPaddVarImplication(
    2875 SCIP* scip, /**< SCIP data structure */
    2876 SCIP_VAR* var, /**< problem variable */
    2877 SCIP_Bool varfixing, /**< FALSE if y should be added in implications for x == 0, TRUE for x == 1 */
    2878 SCIP_VAR* implvar, /**< variable y in implication y <= b or y >= b */
    2879 SCIP_BOUNDTYPE impltype, /**< type of implication y <= b (SCIP_BOUNDTYPE_UPPER)
    2880 * or y >= b (SCIP_BOUNDTYPE_LOWER) */
    2881 SCIP_Real implbound, /**< bound b in implication y <= b or y >= b */
    2882 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
    2883 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
    2884 );
    2885
    2886/** adds a clique information to SCIP, stating that at most one of the given binary variables can be set to 1;
    2887 * if a variable appears twice in the same clique, the corresponding implications are performed
    2888 *
    2889 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2890 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2891 *
    2892 * @pre This method can be called if @p scip is in one of the following stages:
    2893 * - \ref SCIP_STAGE_TRANSFORMED
    2894 * - \ref SCIP_STAGE_PRESOLVING
    2895 * - \ref SCIP_STAGE_PRESOLVED
    2896 * - \ref SCIP_STAGE_SOLVING
    2897 */
    2898SCIP_EXPORT
    2899SCIP_RETCODE SCIPaddClique(
    2900 SCIP* scip, /**< SCIP data structure */
    2901 SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
    2902 SCIP_Bool* values, /**< values of the variables in the clique; NULL to use TRUE for all vars */
    2903 int nvars, /**< number of variables in the clique */
    2904 SCIP_Bool isequation, /**< is the clique an equation or an inequality? */
    2905 SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
    2906 int* nbdchgs /**< pointer to store the number of performed bound changes, or NULL */
    2907 );
    2908
    2909/** calculates a partition of the given set of binary variables into cliques; takes into account independent clique components
    2910 *
    2911 * The algorithm performs the following steps:
    2912 * - recomputes connected components of the clique table, if necessary
    2913 * - computes a clique partition for every connected component greedily.
    2914 * - relabels the resulting clique partition such that it satisfies the description below
    2915 *
    2916 * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
    2917 * were assigned to the same clique;
    2918 * the first variable is always assigned to clique 0, and a variable can only be assigned to clique i if at least one of
    2919 * the preceding variables was assigned to clique i-1;
    2920 * for each clique at most 1 variables can be set to TRUE in a feasible solution;
    2921 *
    2922 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2923 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2924 *
    2925 * @pre This method can be called if @p scip is in one of the following stages:
    2926 * - \ref SCIP_STAGE_INITPRESOLVE
    2927 * - \ref SCIP_STAGE_PRESOLVING
    2928 * - \ref SCIP_STAGE_EXITPRESOLVE
    2929 * - \ref SCIP_STAGE_PRESOLVED
    2930 * - \ref SCIP_STAGE_SOLVING
    2931 */
    2932SCIP_EXPORT
    2933SCIP_RETCODE SCIPcalcCliquePartition(
    2934 SCIP* scip, /**< SCIP data structure */
    2935 SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
    2936 int nvars, /**< number of variables in the clique */
    2937 int** probtoidxmap, /**< cleared memory array with default values -1 */
    2938 int* probtoidxmapsize, /**< returns size of probtoidxmap */
    2939 int* cliquepartition, /**< array of length nvars to store the clique partition */
    2940 int* ncliques /**< pointer to store the number of cliques actually contained in the partition */
    2941 );
    2942
    2943/** calculates a partition of the given set of binary variables into negated cliques;
    2944 * afterwards the output array contains one value for each variable, such that two variables got the same value iff they
    2945 * were assigned to the same negated clique;
    2946 * the first variable is always assigned to clique 0 and a variable can only be assigned to clique i if at least one of
    2947 * the preceding variables was assigned to clique i-1;
    2948 * for each clique with n_c variables at least n_c-1 variables can be set to TRUE in a feasible solution;
    2949 *
    2950 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2951 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2952 *
    2953 * @pre This method can be called if @p scip is in one of the following stages:
    2954 * - \ref SCIP_STAGE_INITPRESOLVE
    2955 * - \ref SCIP_STAGE_PRESOLVING
    2956 * - \ref SCIP_STAGE_EXITPRESOLVE
    2957 * - \ref SCIP_STAGE_PRESOLVED
    2958 * - \ref SCIP_STAGE_SOLVING
    2959 */
    2960SCIP_EXPORT
    2961SCIP_RETCODE SCIPcalcNegatedCliquePartition(
    2962 SCIP* scip, /**< SCIP data structure */
    2963 SCIP_VAR** vars, /**< binary variables in the clique from which at most one can be set to 1 */
    2964 int nvars, /**< number of variables in the clique */
    2965 int** probtoidxmap, /**< cleared memory array with default values -1 */
    2966 int* probtoidxmapsize, /**< returns size of probtoidxmap */
    2967 int* cliquepartition, /**< array of length nvars to store the clique partition */
    2968 int* ncliques /**< pointer to store the number of cliques actually contained in the partition */
    2969 );
    2970
    2971/** force SCIP to clean up all cliques; cliques do not get automatically cleaned up after presolving. Use
    2972 * this method to prevent inactive variables in cliques when retrieved via SCIPgetCliques()
    2973 *
    2974 * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
    2975 *
    2976 * @pre This method can be called if @p scip is in one of the following stages:
    2977 * - \ref SCIP_STAGE_TRANSFORMED
    2978 * - \ref SCIP_STAGE_INITPRESOLVE
    2979 * - \ref SCIP_STAGE_PRESOLVING
    2980 * - \ref SCIP_STAGE_EXITPRESOLVE
    2981 * - \ref SCIP_STAGE_PRESOLVED
    2982 * - \ref SCIP_STAGE_INITSOLVE
    2983 * - \ref SCIP_STAGE_SOLVING
    2984 * - \ref SCIP_STAGE_SOLVED
    2985 * - \ref SCIP_STAGE_EXITSOLVE
    2986 */
    2987SCIP_EXPORT
    2988SCIP_RETCODE SCIPcleanupCliques(
    2989 SCIP* scip, /**< SCIP data structure */
    2990 SCIP_Bool* infeasible /**< pointer to store if cleanup detected infeasibility */
    2991 );
    2992
    2993/** gets the number of cliques in the clique table
    2994 *
    2995 * @return number of cliques in the clique table
    2996 *
    2997 * @pre This method can be called if @p scip is in one of the following stages:
    2998 * - \ref SCIP_STAGE_TRANSFORMED
    2999 * - \ref SCIP_STAGE_INITPRESOLVE
    3000 * - \ref SCIP_STAGE_PRESOLVING
    3001 * - \ref SCIP_STAGE_EXITPRESOLVE
    3002 * - \ref SCIP_STAGE_PRESOLVED
    3003 * - \ref SCIP_STAGE_INITSOLVE
    3004 * - \ref SCIP_STAGE_SOLVING
    3005 * - \ref SCIP_STAGE_SOLVED
    3006 * - \ref SCIP_STAGE_EXITSOLVE
    3007 */
    3008SCIP_EXPORT
    3009int SCIPgetNCliques(
    3010 SCIP* scip /**< SCIP data structure */
    3011 );
    3012
    3013/** gets the number of cliques created so far by the cliquetable
    3014 *
    3015 * @return number of cliques created so far by the cliquetable
    3016 *
    3017 * @pre This method can be called if @p scip is in one of the following stages:
    3018 * - \ref SCIP_STAGE_TRANSFORMED
    3019 * - \ref SCIP_STAGE_INITPRESOLVE
    3020 * - \ref SCIP_STAGE_PRESOLVING
    3021 * - \ref SCIP_STAGE_EXITPRESOLVE
    3022 * - \ref SCIP_STAGE_PRESOLVED
    3023 * - \ref SCIP_STAGE_INITSOLVE
    3024 * - \ref SCIP_STAGE_SOLVING
    3025 * - \ref SCIP_STAGE_SOLVED
    3026 * - \ref SCIP_STAGE_EXITSOLVE
    3027 */
    3028SCIP_EXPORT
    3029int SCIPgetNCliquesCreated(
    3030 SCIP* scip /**< SCIP data structure */
    3031 );
    3032
    3033/** gets the array of cliques in the clique table
    3034 *
    3035 * @return array of cliques in the clique table
    3036 *
    3037 * @pre This method can be called if @p scip is in one of the following stages:
    3038 * - \ref SCIP_STAGE_TRANSFORMED
    3039 * - \ref SCIP_STAGE_INITPRESOLVE
    3040 * - \ref SCIP_STAGE_PRESOLVING
    3041 * - \ref SCIP_STAGE_EXITPRESOLVE
    3042 * - \ref SCIP_STAGE_PRESOLVED
    3043 * - \ref SCIP_STAGE_INITSOLVE
    3044 * - \ref SCIP_STAGE_SOLVING
    3045 * - \ref SCIP_STAGE_SOLVED
    3046 * - \ref SCIP_STAGE_EXITSOLVE
    3047 */
    3048SCIP_EXPORT
    3049SCIP_CLIQUE** SCIPgetCliques(
    3050 SCIP* scip /**< SCIP data structure */
    3051 );
    3052
    3053/** returns whether there is a clique that contains both given variable/value pairs;
    3054 * the variables must be active binary variables;
    3055 * if regardimplics is FALSE, only the cliques in the clique table are looked at;
    3056 * if regardimplics is TRUE, both the cliques and the implications of the implication graph are regarded
    3057 *
    3058 * @return TRUE, if there is a clique that contains both variable/clique pairs; FALSE, otherwise
    3059 *
    3060 * @pre This method can be called if @p scip is in one of the following stages:
    3061 * - \ref SCIP_STAGE_TRANSFORMED
    3062 * - \ref SCIP_STAGE_INITPRESOLVE
    3063 * - \ref SCIP_STAGE_PRESOLVING
    3064 * - \ref SCIP_STAGE_EXITPRESOLVE
    3065 * - \ref SCIP_STAGE_PRESOLVED
    3066 * - \ref SCIP_STAGE_INITSOLVE
    3067 * - \ref SCIP_STAGE_SOLVING
    3068 * - \ref SCIP_STAGE_SOLVED
    3069 * - \ref SCIP_STAGE_EXITSOLVE
    3070 *
    3071 * @note a variable with it's negated variable are NOT! in a clique
    3072 * @note a variable with itself are in a clique
    3073 */
    3074SCIP_EXPORT
    3075SCIP_Bool SCIPhaveVarsCommonClique(
    3076 SCIP* scip, /**< SCIP data structure */
    3077 SCIP_VAR* var1, /**< first variable */
    3078 SCIP_Bool value1, /**< value of first variable */
    3079 SCIP_VAR* var2, /**< second variable */
    3080 SCIP_Bool value2, /**< value of second variable */
    3081 SCIP_Bool regardimplics /**< should the implication graph also be searched for a clique? */
    3082 );
    3083
    3084/** writes the clique graph to a gml file
    3085 *
    3086 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3087 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3088 *
    3089 * @pre This method can be called if @p scip is in one of the following stages:
    3090 * - \ref SCIP_STAGE_TRANSFORMED
    3091 * - \ref SCIP_STAGE_INITPRESOLVE
    3092 * - \ref SCIP_STAGE_PRESOLVING
    3093 * - \ref SCIP_STAGE_EXITPRESOLVE
    3094 * - \ref SCIP_STAGE_PRESOLVED
    3095 * - \ref SCIP_STAGE_INITSOLVE
    3096 * - \ref SCIP_STAGE_SOLVING
    3097 * - \ref SCIP_STAGE_SOLVED
    3098 * - \ref SCIP_STAGE_EXITSOLVE
    3099 *
    3100 * @note there can be duplicated arcs in the output file
    3101 *
    3102 * If @p writenodeweights is true, only nodes corresponding to variables that have a fractional value and only edges
    3103 * between such nodes are written.
    3104 */
    3105SCIP_EXPORT
    3106SCIP_RETCODE SCIPwriteCliqueGraph(
    3107 SCIP* scip, /**< SCIP data structure */
    3108 const char* fname, /**< name of file */
    3109 SCIP_Bool writenodeweights /**< should we write weights of nodes? */
    3110 );
    3111
    3112/** Removes (irrelevant) variable from all its global structures, i.e. cliques, implications and variable bounds.
    3113 * This is an advanced method which should be used with care.
    3114 *
    3115 * @return SCIP_OKAY if everything worked, otherwise a suitable error code is passed
    3116 *
    3117 * @pre This method can be called if @p scip is in one of the following stages:
    3118 * - \ref SCIP_STAGE_TRANSFORMED
    3119 * - \ref SCIP_STAGE_INITPRESOLVE
    3120 * - \ref SCIP_STAGE_PRESOLVING
    3121 * - \ref SCIP_STAGE_EXITPRESOLVE
    3122 * - \ref SCIP_STAGE_PRESOLVED
    3123 * - \ref SCIP_STAGE_INITSOLVE
    3124 * - \ref SCIP_STAGE_SOLVING
    3125 * - \ref SCIP_STAGE_SOLVED
    3126 * - \ref SCIP_STAGE_EXITSOLVE
    3127 */
    3128SCIP_EXPORT
    3129SCIP_RETCODE SCIPremoveVarFromGlobalStructures(
    3130 SCIP* scip, /**< SCIP data structure */
    3131 SCIP_VAR* var /**< variable to remove from global structures */
    3132 );
    3133
    3134/** sets the branch factor of the variable; this value can be used in the branching methods to scale the score
    3135 * values of the variables; higher factor leads to a higher probability that this variable is chosen for branching
    3136 *
    3137 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3138 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3139 *
    3140 * @pre This method can be called if @p scip is in one of the following stages:
    3141 * - \ref SCIP_STAGE_PROBLEM
    3142 * - \ref SCIP_STAGE_TRANSFORMING
    3143 * - \ref SCIP_STAGE_TRANSFORMED
    3144 * - \ref SCIP_STAGE_INITPRESOLVE
    3145 * - \ref SCIP_STAGE_PRESOLVING
    3146 * - \ref SCIP_STAGE_EXITPRESOLVE
    3147 * - \ref SCIP_STAGE_PRESOLVED
    3148 * - \ref SCIP_STAGE_SOLVING
    3149 */
    3150SCIP_EXPORT
    3151SCIP_RETCODE SCIPchgVarBranchFactor(
    3152 SCIP* scip, /**< SCIP data structure */
    3153 SCIP_VAR* var, /**< problem variable */
    3154 SCIP_Real branchfactor /**< factor to weigh variable's branching score with */
    3155 );
    3156
    3157/** scales the branch factor of the variable with the given value
    3158 *
    3159 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3160 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3161 *
    3162 * @pre This method can be called if @p scip is in one of the following stages:
    3163 * - \ref SCIP_STAGE_PROBLEM
    3164 * - \ref SCIP_STAGE_TRANSFORMING
    3165 * - \ref SCIP_STAGE_TRANSFORMED
    3166 * - \ref SCIP_STAGE_INITPRESOLVE
    3167 * - \ref SCIP_STAGE_PRESOLVING
    3168 * - \ref SCIP_STAGE_EXITPRESOLVE
    3169 * - \ref SCIP_STAGE_PRESOLVED
    3170 * - \ref SCIP_STAGE_SOLVING
    3171 */
    3172SCIP_EXPORT
    3173SCIP_RETCODE SCIPscaleVarBranchFactor(
    3174 SCIP* scip, /**< SCIP data structure */
    3175 SCIP_VAR* var, /**< problem variable */
    3176 SCIP_Real scale /**< factor to scale variable's branching factor with */
    3177 );
    3178
    3179/** adds the given value to the branch factor of the variable
    3180 *
    3181 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3182 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3183 *
    3184 * @pre This method can be called if @p scip is in one of the following stages:
    3185 * - \ref SCIP_STAGE_PROBLEM
    3186 * - \ref SCIP_STAGE_TRANSFORMING
    3187 * - \ref SCIP_STAGE_TRANSFORMED
    3188 * - \ref SCIP_STAGE_INITPRESOLVE
    3189 * - \ref SCIP_STAGE_PRESOLVING
    3190 * - \ref SCIP_STAGE_EXITPRESOLVE
    3191 * - \ref SCIP_STAGE_PRESOLVED
    3192 * - \ref SCIP_STAGE_SOLVING
    3193 */
    3194SCIP_EXPORT
    3195SCIP_RETCODE SCIPaddVarBranchFactor(
    3196 SCIP* scip, /**< SCIP data structure */
    3197 SCIP_VAR* var, /**< problem variable */
    3198 SCIP_Real addfactor /**< value to add to the branch factor of the variable */
    3199 );
    3200
    3201/** sets the branch priority of the variable; variables with higher branch priority are always preferred to variables
    3202 * with lower priority in selection of branching variable
    3203 *
    3204 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3205 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3206 *
    3207 * @pre This method can be called if @p scip is in one of the following stages:
    3208 * - \ref SCIP_STAGE_PROBLEM
    3209 * - \ref SCIP_STAGE_TRANSFORMING
    3210 * - \ref SCIP_STAGE_TRANSFORMED
    3211 * - \ref SCIP_STAGE_INITPRESOLVE
    3212 * - \ref SCIP_STAGE_PRESOLVING
    3213 * - \ref SCIP_STAGE_EXITPRESOLVE
    3214 * - \ref SCIP_STAGE_PRESOLVED
    3215 * - \ref SCIP_STAGE_SOLVING
    3216 *
    3217 * @note the default branching priority is 0
    3218 */
    3219SCIP_EXPORT
    3220SCIP_RETCODE SCIPchgVarBranchPriority(
    3221 SCIP* scip, /**< SCIP data structure */
    3222 SCIP_VAR* var, /**< problem variable */
    3223 int branchpriority /**< branch priority of the variable */
    3224 );
    3225
    3226/** changes the branch priority of the variable to the given value, if it is larger than the current priority
    3227 *
    3228 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3229 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3230 *
    3231 * @pre This method can be called if @p scip is in one of the following stages:
    3232 * - \ref SCIP_STAGE_PROBLEM
    3233 * - \ref SCIP_STAGE_TRANSFORMING
    3234 * - \ref SCIP_STAGE_TRANSFORMED
    3235 * - \ref SCIP_STAGE_INITPRESOLVE
    3236 * - \ref SCIP_STAGE_PRESOLVING
    3237 * - \ref SCIP_STAGE_EXITPRESOLVE
    3238 * - \ref SCIP_STAGE_PRESOLVED
    3239 * - \ref SCIP_STAGE_SOLVING
    3240 */
    3241SCIP_EXPORT
    3242SCIP_RETCODE SCIPupdateVarBranchPriority(
    3243 SCIP* scip, /**< SCIP data structure */
    3244 SCIP_VAR* var, /**< problem variable */
    3245 int branchpriority /**< new branch priority of the variable, if it is larger than current priority */
    3246 );
    3247
    3248/** adds the given value to the branch priority of the variable
    3249 *
    3250 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3251 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3252 *
    3253 * @pre This method can be called if @p scip is in one of the following stages:
    3254 * - \ref SCIP_STAGE_PROBLEM
    3255 * - \ref SCIP_STAGE_TRANSFORMING
    3256 * - \ref SCIP_STAGE_TRANSFORMED
    3257 * - \ref SCIP_STAGE_INITPRESOLVE
    3258 * - \ref SCIP_STAGE_PRESOLVING
    3259 * - \ref SCIP_STAGE_EXITPRESOLVE
    3260 * - \ref SCIP_STAGE_PRESOLVED
    3261 * - \ref SCIP_STAGE_SOLVING
    3262 */
    3263SCIP_EXPORT
    3264SCIP_RETCODE SCIPaddVarBranchPriority(
    3265 SCIP* scip, /**< SCIP data structure */
    3266 SCIP_VAR* var, /**< problem variable */
    3267 int addpriority /**< value to add to the branch priority of the variable */
    3268 );
    3269
    3270/** sets the branch direction of the variable (-1: prefer downwards branch, 0: automatic selection, +1: prefer upwards
    3271 * branch)
    3272 *
    3273 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3274 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3275 *
    3276 * @pre This method can be called if @p scip is in one of the following stages:
    3277 * - \ref SCIP_STAGE_PROBLEM
    3278 * - \ref SCIP_STAGE_TRANSFORMING
    3279 * - \ref SCIP_STAGE_TRANSFORMED
    3280 * - \ref SCIP_STAGE_INITPRESOLVE
    3281 * - \ref SCIP_STAGE_PRESOLVING
    3282 * - \ref SCIP_STAGE_EXITPRESOLVE
    3283 * - \ref SCIP_STAGE_PRESOLVED
    3284 * - \ref SCIP_STAGE_SOLVING
    3285 */
    3286SCIP_EXPORT
    3287SCIP_RETCODE SCIPchgVarBranchDirection(
    3288 SCIP* scip, /**< SCIP data structure */
    3289 SCIP_VAR* var, /**< problem variable */
    3290 SCIP_BRANCHDIR branchdirection /**< preferred branch direction of the variable (downwards, upwards, auto) */
    3291 );
    3292
    3293/** changes type of variable in the problem;
    3294 *
    3295 * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
    3296 *
    3297 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3298 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3299 *
    3300 * @pre This method can be called if @p scip is in one of the following stages:
    3301 * - \ref SCIP_STAGE_PROBLEM
    3302 * - \ref SCIP_STAGE_TRANSFORMING
    3303 * - \ref SCIP_STAGE_PRESOLVING
    3304 *
    3305 * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the variable type of the
    3306 * corresponding transformed variable is changed; the type of the original variable does not change
    3307 *
    3308 * @note If the type changes from a continuous variable to a non-continuous variable the bounds of the variable get
    3309 * adjusted w.r.t. to integrality information
    3310 */
    3311SCIP_EXPORT
    3312SCIP_RETCODE SCIPchgVarType(
    3313 SCIP* scip, /**< SCIP data structure */
    3314 SCIP_VAR* var, /**< variable to change the type for */
    3315 SCIP_VARTYPE vartype, /**< new type of variable */
    3316 SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (, due to
    3317 * integrality condition of the new variable type) */
    3318 );
    3319
    3320/** changes implied integral type of variable in the problem
    3321 *
    3322 * @warning This type change might change the variable array returned from SCIPgetVars() and SCIPgetVarsData();
    3323 *
    3324 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3325 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3326 *
    3327 * @pre This method can be called if @p scip is in one of the following stages:
    3328 * - \ref SCIP_STAGE_PROBLEM
    3329 * - \ref SCIP_STAGE_TRANSFORMING
    3330 * - \ref SCIP_STAGE_PRESOLVING
    3331 *
    3332 * @note If SCIP is already beyond the SCIP_STAGE_PROBLEM and a original variable is passed, the implied integral type of the
    3333 * corresponding transformed variable is changed; the type of the original variable does not change
    3334 *
    3335 * @note If the implied integral type is adjusted to weak or strong for a continuous variable, the bounds of the variable get
    3336 * adjusted w.r.t. to integrality information
    3337 */
    3338SCIP_EXPORT
    3339SCIP_RETCODE SCIPchgVarImplType(
    3340 SCIP* scip, /**< SCIP data structure */
    3341 SCIP_VAR* var, /**< variable to change the type for */
    3342 SCIP_IMPLINTTYPE impltype, /**< New implied integral type of the variable */
    3343 SCIP_Bool* infeasible /**< pointer to store whether an infeasibility was detected (due to
    3344 * integrality condition for the new variable type) */
    3345 );
    3346
    3347/** in problem creation and solving stage, both bounds of the variable are set to the given value;
    3348 * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
    3349 * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
    3350 * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
    3351 *
    3352 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3353 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3354 *
    3355 * @pre This method can be called if @p scip is in one of the following stages:
    3356 * - \ref SCIP_STAGE_PROBLEM
    3357 * - \ref SCIP_STAGE_PRESOLVING
    3358 * - \ref SCIP_STAGE_SOLVING
    3359 */
    3360SCIP_EXPORT
    3361SCIP_RETCODE SCIPfixVar(
    3362 SCIP* scip, /**< SCIP data structure */
    3363 SCIP_VAR* var, /**< variable to fix */
    3364 SCIP_Real fixedval, /**< value to fix variable to */
    3365 SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
    3366 SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
    3367 );
    3368
    3369/** in problem creation and solving stage, both bounds of the variable are set to the given value;
    3370 * in presolving stage, the variable is converted into a fixed variable, and bounds are changed respectively;
    3371 * conversion into a fixed variable changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
    3372 * and also renders arrays returned from the SCIPvarGetImpl...() methods invalid
    3373 *
    3374 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3375 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3376 *
    3377 * @pre This method can be called if @p scip is in one of the following stages:
    3378 * - \ref SCIP_STAGE_PROBLEM
    3379 * - \ref SCIP_STAGE_PRESOLVING
    3380 * - \ref SCIP_STAGE_SOLVING
    3381 */
    3382SCIP_EXPORT
    3383SCIP_RETCODE SCIPfixVarExact(
    3384 SCIP* scip, /**< SCIP data structure */
    3385 SCIP_VAR* var, /**< variable to fix */
    3386 SCIP_RATIONAL* fixedval, /**< value to fix variable to */
    3387 SCIP_Bool* infeasible, /**< pointer to store whether the fixing is infeasible */
    3388 SCIP_Bool* fixed /**< pointer to store whether the fixing was performed (variable was unfixed) */
    3389 );
    3390
    3391/** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
    3392 * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
    3393 * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
    3394 * In the first step, the equality is transformed into an equality with active problem variables
    3395 * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
    3396 * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
    3397 * infeasibility) otherwise.
    3398 * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
    3399 * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
    3400 * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
    3401 * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
    3402 * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
    3403 * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
    3404 *
    3405 * The output flags have the following meaning:
    3406 * - infeasible: the problem is infeasible
    3407 * - redundant: the equality can be deleted from the constraint set
    3408 * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
    3409 *
    3410 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3411 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3412 *
    3413 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
    3414 */
    3415SCIP_EXPORT
    3416SCIP_RETCODE SCIPaggregateVars(
    3417 SCIP* scip, /**< SCIP data structure */
    3418 SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
    3419 SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
    3420 SCIP_Real scalarx, /**< multiplier a in equality a*x + b*y == c */
    3421 SCIP_Real scalary, /**< multiplier b in equality a*x + b*y == c */
    3422 SCIP_Real rhs, /**< right hand side c in equality a*x + b*y == c */
    3423 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
    3424 SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
    3425 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
    3426 );
    3427
    3428/** From a given equality a*x + b*y == c, aggregates one of the variables and removes it from the set of
    3429 * active problem variables. This changes the vars array returned from SCIPgetVars() and SCIPgetVarsData(),
    3430 * and also renders the arrays returned from the SCIPvarGetImpl...() methods for the two variables invalid.
    3431 * In the first step, the equality is transformed into an equality with active problem variables
    3432 * a'*x' + b'*y' == c'. If x' == y', this leads to the detection of redundancy if a' == -b' and c' == 0,
    3433 * of infeasibility, if a' == -b' and c' != 0, or to a variable fixing x' == c'/(a'+b') (and possible
    3434 * infeasibility) otherwise.
    3435 * In the second step, the variable to be aggregated is chosen among x' and y', prefering a less strict variable
    3436 * type as aggregation variable (i.e. continuous variables are preferred over implicit integers, implicit integers
    3437 * over integers, and integers over binaries). If none of the variables is continuous, it is tried to find an integer
    3438 * aggregation (i.e. integral coefficients a'' and b'', such that a''*x' + b''*y' == c''). This can lead to
    3439 * the detection of infeasibility (e.g. if c'' is fractional), or to a rejection of the aggregation (denoted by
    3440 * aggregated == FALSE), if the resulting integer coefficients are too large and thus numerically instable.
    3441 *
    3442 * The output flags have the following meaning:
    3443 * - infeasible: the problem is infeasible
    3444 * - redundant: the equality can be deleted from the constraint set
    3445 * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
    3446 *
    3447 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3448 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3449 *
    3450 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
    3451 */
    3452SCIP_EXPORT
    3453SCIP_RETCODE SCIPaggregateVarsExact(
    3454 SCIP* scip, /**< SCIP data structure */
    3455 SCIP_VAR* varx, /**< variable x in equality a*x + b*y == c */
    3456 SCIP_VAR* vary, /**< variable y in equality a*x + b*y == c */
    3457 SCIP_RATIONAL* scalarx, /**< multiplier a in equality a*x + b*y == c */
    3458 SCIP_RATIONAL* scalary, /**< multiplier b in equality a*x + b*y == c */
    3459 SCIP_RATIONAL* rhs, /**< right hand side c in equality a*x + b*y == c */
    3460 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
    3461 SCIP_Bool* redundant, /**< pointer to store whether the equality is (now) redundant */
    3462 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
    3463 );
    3464
    3465/** converts variable into multi-aggregated variable; this changes the variable array returned from
    3466 * SCIPgetVars() and SCIPgetVarsData();
    3467 *
    3468 * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
    3469 * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
    3470 * implies integrality on the aggregated variable.
    3471 *
    3472 * The output flags have the following meaning:
    3473 * - infeasible: the problem is infeasible
    3474 * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
    3475 *
    3476 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3477 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3478 *
    3479 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
    3480 */
    3481SCIP_EXPORT
    3482SCIP_RETCODE SCIPmultiaggregateVar(
    3483 SCIP* scip, /**< SCIP data structure */
    3484 SCIP_VAR* var, /**< variable x to aggregate */
    3485 int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3486 SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3487 SCIP_Real* scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3488 SCIP_Real constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3489 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
    3490 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
    3491 );
    3492
    3493/** converts variable into exact multi-aggregated variable; this changes the variable array returned from
    3494 * SCIPgetVars() and SCIPgetVarsData();
    3495 *
    3496 * @warning The integrality condition is not checked anymore on the multi-aggregated variable. You must not
    3497 * multi-aggregate an integer variable without being sure, that integrality on the aggregation variables
    3498 * implies integrality on the aggregated variable.
    3499 *
    3500 * The output flags have the following meaning:
    3501 * - infeasible: the problem is infeasible
    3502 * - aggregated: the aggregation was successfully performed (the variables were not aggregated before)
    3503 *
    3504 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3505 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3506 *
    3507 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
    3508 */
    3509SCIP_EXPORT
    3510SCIP_RETCODE SCIPmultiaggregateVarExact(
    3511 SCIP* scip, /**< SCIP data structure */
    3512 SCIP_VAR* var, /**< variable x to aggregate */
    3513 int naggvars, /**< number n of variables in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3514 SCIP_VAR** aggvars, /**< variables y_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3515 SCIP_RATIONAL** scalars, /**< multipliers a_i in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3516 SCIP_RATIONAL* constant, /**< constant shift c in aggregation x = a_1*y_1 + ... + a_n*y_n + c */
    3517 SCIP_Bool* infeasible, /**< pointer to store whether the aggregation is infeasible */
    3518 SCIP_Bool* aggregated /**< pointer to store whether the aggregation was successful */
    3519 );
    3520
    3521/** returns whether aggregation of variables is not allowed */
    3522SCIP_EXPORT
    3523SCIP_Bool SCIPdoNotAggr(
    3524 SCIP* scip /**< SCIP data structure */
    3525 );
    3526
    3527/** returns whether multi-aggregation is disabled */
    3528SCIP_EXPORT
    3529SCIP_Bool SCIPdoNotMultaggr(
    3530 SCIP* scip /**< SCIP data structure */
    3531 );
    3532
    3533/** returns whether variable is not allowed to be aggregated */
    3534SCIP_EXPORT
    3535SCIP_Bool SCIPdoNotAggrVar(
    3536 SCIP* scip, /**< SCIP data structure */
    3537 SCIP_VAR* var /**< variable x to aggregate */
    3538 );
    3539
    3540/** returns whether variable is not allowed to be multi-aggregated */
    3541SCIP_EXPORT
    3542SCIP_Bool SCIPdoNotMultaggrVar(
    3543 SCIP* scip, /**< SCIP data structure */
    3544 SCIP_VAR* var /**< variable x to aggregate */
    3545 );
    3546
    3547/** checks whether a loose variable can be used in a new aggregation with given coefficient
    3548 *
    3549 * Checks whether multiplying the bounds on the coefficient with which the variable appears in aggregations
    3550 * (SCIPvarGetMinAggrCoef(), SCIPvarGetMaxAggrCoef()) by the given scalar would exceed acceptable values
    3551 * (numerics/sumepsilon and 1.0 / numerics/sumepsilon).
    3552 *
    3553 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_PRESOLVING
    3554 */
    3555SCIP_EXPORT
    3556SCIP_Bool SCIPisVarAggrCoefAcceptable(
    3557 SCIP* scip, /**< SCIP data structure */
    3558 SCIP_VAR* var, /**< problem variable */
    3559 SCIP_Real scalar /**< aggregation scalar */
    3560 );
    3561
    3562/** returns whether strong dual reductions are allowed during propagation and presolving
    3563 *
    3564 * @note A reduction is called strong dual, if it may discard feasible/optimal solutions, but leaves at least one
    3565 * optimal solution intact. Often such reductions are based on analyzing the objective function and variable
    3566 * locks.
    3567 */
    3568SCIP_EXPORT
    3569SCIP_Bool SCIPallowStrongDualReds(
    3570 SCIP* scip /**< SCIP data structure */
    3571 );
    3572
    3573/** returns whether weak dual reductions are allowed during propagation and presolving
    3574 *
    3575 * @note A reduction is called weak dual, if it may discard feasible solutions, but leaves at all optimal solutions
    3576 * intact. Often such reductions are based on analyzing the objective function, reduced costs, and/or dual LPs.
    3577 */
    3578SCIP_EXPORT
    3579SCIP_Bool SCIPallowWeakDualReds(
    3580 SCIP* scip /**< SCIP data structure */
    3581 );
    3582
    3583/** marks the variable that it must not be aggregated
    3584 *
    3585 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3586 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3587 *
    3588 * @pre This method can be called if @p scip is in one of the following stages:
    3589 * - \ref SCIP_STAGE_INIT
    3590 * - \ref SCIP_STAGE_PROBLEM
    3591 * - \ref SCIP_STAGE_TRANSFORMING
    3592 * - \ref SCIP_STAGE_TRANSFORMED
    3593 * - \ref SCIP_STAGE_INITPRESOLVE
    3594 * - \ref SCIP_STAGE_PRESOLVING
    3595 * - \ref SCIP_STAGE_EXITPRESOLVE
    3596 *
    3597 * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
    3598 * aggregated that this is will be the case.
    3599 */
    3600SCIP_EXPORT
    3601SCIP_RETCODE SCIPmarkDoNotAggrVar(
    3602 SCIP* scip, /**< SCIP data structure */
    3603 SCIP_VAR* var /**< variable to delete */
    3604 );
    3605
    3606/** marks the variable that it must not be multi-aggregated
    3607 *
    3608 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3609 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3610 *
    3611 * @pre This method can be called if @p scip is in one of the following stages:
    3612 * - \ref SCIP_STAGE_INIT
    3613 * - \ref SCIP_STAGE_PROBLEM
    3614 * - \ref SCIP_STAGE_TRANSFORMING
    3615 * - \ref SCIP_STAGE_TRANSFORMED
    3616 * - \ref SCIP_STAGE_INITPRESOLVE
    3617 * - \ref SCIP_STAGE_PRESOLVING
    3618 * - \ref SCIP_STAGE_EXITPRESOLVE
    3619 *
    3620 * @note There exists no "unmark" method since it has to be ensured that if a plugin requires that a variable is not
    3621 * multi-aggregated that this is will be the case.
    3622 */
    3623SCIP_EXPORT
    3624SCIP_RETCODE SCIPmarkDoNotMultaggrVar(
    3625 SCIP* scip, /**< SCIP data structure */
    3626 SCIP_VAR* var /**< variable to delete */
    3627 );
    3628
    3629/** enables the collection of statistics for a variable
    3630 *
    3631 * @pre This method can be called if @p scip is in one of the following stages:
    3632 * - \ref SCIP_STAGE_PROBLEM
    3633 * - \ref SCIP_STAGE_INITPRESOLVE
    3634 * - \ref SCIP_STAGE_PRESOLVING
    3635 * - \ref SCIP_STAGE_EXITPRESOLVE
    3636 * - \ref SCIP_STAGE_SOLVING
    3637 * - \ref SCIP_STAGE_SOLVED
    3638 */
    3639SCIP_EXPORT
    3640void SCIPenableVarHistory(
    3641 SCIP* scip /**< SCIP data structure */
    3642 );
    3643
    3644/** disables the collection of any statistic for a variable
    3645 *
    3646 * @pre This method can be called if @p scip is in one of the following stages:
    3647 * - \ref SCIP_STAGE_PROBLEM
    3648 * - \ref SCIP_STAGE_INITPRESOLVE
    3649 * - \ref SCIP_STAGE_PRESOLVING
    3650 * - \ref SCIP_STAGE_EXITPRESOLVE
    3651 * - \ref SCIP_STAGE_SOLVING
    3652 * - \ref SCIP_STAGE_SOLVED
    3653 */
    3654SCIP_EXPORT
    3655void SCIPdisableVarHistory(
    3656 SCIP* scip /**< SCIP data structure */
    3657 );
    3658
    3659/** updates the pseudo costs of the given variable and the global pseudo costs after a change of "solvaldelta" in the
    3660 * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
    3661 * the update is ignored, if the objective value difference is infinite
    3662 *
    3663 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3664 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3665 *
    3666 * @pre This method can be called if @p scip is in one of the following stages:
    3667 * - \ref SCIP_STAGE_SOLVING
    3668 * - \ref SCIP_STAGE_SOLVED
    3669 */
    3670SCIP_EXPORT
    3671SCIP_RETCODE SCIPupdateVarPseudocost(
    3672 SCIP* scip, /**< SCIP data structure */
    3673 SCIP_VAR* var, /**< problem variable */
    3674 SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
    3675 SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
    3676 SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
    3677 );
    3678
    3679/** updates the ancestor pseudo costs of the given variable and the global ancestor pseudo costs after a change of "solvaldelta" in the
    3680 * variable's solution value and resulting change of "objdelta" in the in the LP's objective value;
    3681 * the update is ignored, if the objective value difference is infinite
    3682 *
    3683 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    3684 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    3685 *
    3686 * @pre This method can be called if @p scip is in one of the following stages:
    3687 * - \ref SCIP_STAGE_SOLVING
    3688 * - \ref SCIP_STAGE_SOLVED
    3689 */
    3690SCIP_EXPORT
    3691SCIP_RETCODE SCIPupdateVarAncPseudocost(
    3692 SCIP* scip, /**< SCIP data structure */
    3693 SCIP_VAR* var, /**< problem variable */
    3694 SCIP_Real solvaldelta, /**< difference of variable's new LP value - old LP value */
    3695 SCIP_Real objdelta, /**< difference of new LP's objective value - old LP's objective value */
    3696 SCIP_Real weight /**< weight in (0,1] of this update in pseudo cost sum */
    3697 );
    3698
    3699/** gets the variable's pseudo cost value for the given change of the variable's LP value
    3700 *
    3701 * @return the variable's pseudo cost value for the given change of the variable's LP value
    3702 *
    3703 * @pre This method can be called if @p scip is in one of the following stages:
    3704 * - \ref SCIP_STAGE_INITPRESOLVE
    3705 * - \ref SCIP_STAGE_PRESOLVING
    3706 * - \ref SCIP_STAGE_EXITPRESOLVE
    3707 * - \ref SCIP_STAGE_PRESOLVED
    3708 * - \ref SCIP_STAGE_INITSOLVE
    3709 * - \ref SCIP_STAGE_SOLVING
    3710 * - \ref SCIP_STAGE_SOLVED
    3711 */
    3712SCIP_EXPORT
    3713SCIP_Real SCIPgetVarPseudocostVal(
    3714 SCIP* scip, /**< SCIP data structure */
    3715 SCIP_VAR* var, /**< problem variable */
    3716 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
    3717 );
    3718
    3719/** gets the variable's ancestral pseudo cost value for the given change of the variable's LP value
    3720 *
    3721 * @return the variable's ancestral pseudo cost value for the given change of the variable's LP value
    3722 *
    3723 * @pre This method can be called if @p scip is in one of the following stages:
    3724 * - \ref SCIP_STAGE_INITPRESOLVE
    3725 * - \ref SCIP_STAGE_PRESOLVING
    3726 * - \ref SCIP_STAGE_EXITPRESOLVE
    3727 * - \ref SCIP_STAGE_PRESOLVED
    3728 * - \ref SCIP_STAGE_INITSOLVE
    3729 * - \ref SCIP_STAGE_SOLVING
    3730 * - \ref SCIP_STAGE_SOLVED
    3731 */
    3732SCIP_EXPORT
    3733SCIP_Real SCIPgetVarAncPseudocostVal(
    3734 SCIP* scip, /**< SCIP data structure */
    3735 SCIP_VAR* var, /**< problem variable */
    3736 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
    3737 );
    3738
    3739/** gets the variable's pseudo cost value for the given change of the variable's LP value,
    3740 * only using the pseudo cost information of the current run
    3741 *
    3742 * @return the variable's pseudo cost value for the given change of the variable's LP value,
    3743 * only using the pseudo cost information of the current run
    3744 *
    3745 * @pre This method can be called if @p scip is in one of the following stages:
    3746 * - \ref SCIP_STAGE_INITPRESOLVE
    3747 * - \ref SCIP_STAGE_PRESOLVING
    3748 * - \ref SCIP_STAGE_EXITPRESOLVE
    3749 * - \ref SCIP_STAGE_PRESOLVED
    3750 * - \ref SCIP_STAGE_INITSOLVE
    3751 * - \ref SCIP_STAGE_SOLVING
    3752 * - \ref SCIP_STAGE_SOLVED
    3753 */
    3754SCIP_EXPORT
    3755SCIP_Real SCIPgetVarPseudocostValCurrentRun(
    3756 SCIP* scip, /**< SCIP data structure */
    3757 SCIP_VAR* var, /**< problem variable */
    3758 SCIP_Real solvaldelta /**< difference of variable's new LP value - old LP value */
    3759 );
    3760
    3761/** gets the variable's pseudo cost value for the given direction
    3762 *
    3763 * @return the variable's pseudo cost value for the given direction
    3764 *
    3765 * @pre This method can be called if @p scip is in one of the following stages:
    3766 * - \ref SCIP_STAGE_INITPRESOLVE
    3767 * - \ref SCIP_STAGE_PRESOLVING
    3768 * - \ref SCIP_STAGE_EXITPRESOLVE
    3769 * - \ref SCIP_STAGE_PRESOLVED
    3770 * - \ref SCIP_STAGE_INITSOLVE
    3771 * - \ref SCIP_STAGE_SOLVING
    3772 * - \ref SCIP_STAGE_SOLVED
    3773 */
    3774SCIP_EXPORT
    3775SCIP_Real SCIPgetVarPseudocost(
    3776 SCIP* scip, /**< SCIP data structure */
    3777 SCIP_VAR* var, /**< problem variable */
    3778 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    3779 );
    3780
    3781/** gets the variable's pseudo cost value for the given direction,
    3782 * only using the pseudo cost information of the current run
    3783 *
    3784 * @return the variable's pseudo cost value for the given direction,
    3785 * only using the pseudo cost information of the current run
    3786 *
    3787 * @pre This method can be called if @p scip is in one of the following stages:
    3788 * - \ref SCIP_STAGE_INITPRESOLVE
    3789 * - \ref SCIP_STAGE_PRESOLVING
    3790 * - \ref SCIP_STAGE_EXITPRESOLVE
    3791 * - \ref SCIP_STAGE_PRESOLVED
    3792 * - \ref SCIP_STAGE_INITSOLVE
    3793 * - \ref SCIP_STAGE_SOLVING
    3794 * - \ref SCIP_STAGE_SOLVED
    3795 */
    3796SCIP_EXPORT
    3797SCIP_Real SCIPgetVarPseudocostCurrentRun(
    3798 SCIP* scip, /**< SCIP data structure */
    3799 SCIP_VAR* var, /**< problem variable */
    3800 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    3801 );
    3802
    3803/** gets the variable's (possible fractional) number of pseudo cost updates for the given direction
    3804 *
    3805 * @return the variable's (possible fractional) number of pseudo cost updates for the given direction
    3806 *
    3807 * @pre This method can be called if @p scip is in one of the following stages:
    3808 * - \ref SCIP_STAGE_INITPRESOLVE
    3809 * - \ref SCIP_STAGE_PRESOLVING
    3810 * - \ref SCIP_STAGE_EXITPRESOLVE
    3811 * - \ref SCIP_STAGE_PRESOLVED
    3812 * - \ref SCIP_STAGE_INITSOLVE
    3813 * - \ref SCIP_STAGE_SOLVING
    3814 * - \ref SCIP_STAGE_SOLVED
    3815 */
    3816SCIP_EXPORT
    3817SCIP_Real SCIPgetVarPseudocostCount(
    3818 SCIP* scip, /**< SCIP data structure */
    3819 SCIP_VAR* var, /**< problem variable */
    3820 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    3821 );
    3822
    3823/** gets the variable's (possible fractional) number of pseudo cost updates for the given direction,
    3824 * only using the pseudo cost information of the current run
    3825 *
    3826 * @return the variable's (possible fractional) number of pseudo cost updates for the given direction,
    3827 * only using the pseudo cost information of the current run
    3828 *
    3829 * @pre This method can be called if @p scip is in one of the following stages:
    3830 * - \ref SCIP_STAGE_INITPRESOLVE
    3831 * - \ref SCIP_STAGE_PRESOLVING
    3832 * - \ref SCIP_STAGE_EXITPRESOLVE
    3833 * - \ref SCIP_STAGE_PRESOLVED
    3834 * - \ref SCIP_STAGE_INITSOLVE
    3835 * - \ref SCIP_STAGE_SOLVING
    3836 * - \ref SCIP_STAGE_SOLVED
    3837 */
    3838SCIP_EXPORT
    3839SCIP_Real SCIPgetVarPseudocostCountCurrentRun(
    3840 SCIP* scip, /**< SCIP data structure */
    3841 SCIP_VAR* var, /**< problem variable */
    3842 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    3843 );
    3844
    3845/** gets the variable's (possible fractional) number of ancestor pseudo cost updates for the given direction,
    3846 * only using the pseudo cost information of the current run
    3847 *
    3848 * @return the variable's (possible fractional) number of ancestor pseudo cost updates for the given direction,
    3849 * only using the pseudo cost information of the current run
    3850 *
    3851 * @pre This method can be called if @p scip is in one of the following stages:
    3852 * - \ref SCIP_STAGE_INITPRESOLVE
    3853 * - \ref SCIP_STAGE_PRESOLVING
    3854 * - \ref SCIP_STAGE_EXITPRESOLVE
    3855 * - \ref SCIP_STAGE_PRESOLVED
    3856 * - \ref SCIP_STAGE_INITSOLVE
    3857 * - \ref SCIP_STAGE_SOLVING
    3858 * - \ref SCIP_STAGE_SOLVED
    3859 */
    3860SCIP_EXPORT
    3861SCIP_Real SCIPgetVarAncPseudocostCountCurrentRun(
    3862 SCIP* scip, /**< SCIP data structure */
    3863 SCIP_VAR* var, /**< problem variable */
    3864 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    3865 );
    3866
    3867/** get pseudo cost variance of the variable, either for entire solve or only for current branch and bound run
    3868 *
    3869 * @return returns the (corrected) variance of pseudo code information collected so far.
    3870 *
    3871 * @pre This method can be called if @p scip is in one of the following stages:
    3872 * - \ref SCIP_STAGE_INITPRESOLVE
    3873 * - \ref SCIP_STAGE_PRESOLVING
    3874 * - \ref SCIP_STAGE_EXITPRESOLVE
    3875 * - \ref SCIP_STAGE_PRESOLVED
    3876 * - \ref SCIP_STAGE_INITSOLVE
    3877 * - \ref SCIP_STAGE_SOLVING
    3878 * - \ref SCIP_STAGE_SOLVED
    3879 */
    3880SCIP_EXPORT
    3881SCIP_Real SCIPgetVarPseudocostVariance(
    3882 SCIP* scip, /**< SCIP data structure */
    3883 SCIP_VAR* var, /**< problem variable */
    3884 SCIP_BRANCHDIR dir, /**< branching direction (downwards, or upwards) */
    3885 SCIP_Bool onlycurrentrun /**< only for pseudo costs of current branch and bound run */
    3886 );
    3887
    3888/** calculates a confidence bound for this variable under the assumption of normally distributed pseudo costs
    3889 *
    3890 * The confidence bound \f$ \theta \geq 0\f$ denotes the interval borders \f$ [X - \theta, \ X + \theta]\f$, which contains
    3891 * the true pseudo costs of the variable, i.e., the expected value of the normal distribution, with a probability
    3892 * of 2 * clevel - 1.
    3893 *
    3894 * @return value of confidence bound for this variable
    3895 */
    3896SCIP_EXPORT
    3897SCIP_Real SCIPcalculatePscostConfidenceBound(
    3898 SCIP* scip, /**< SCIP data structure */
    3899 SCIP_VAR* var, /**< variable in question */
    3900 SCIP_BRANCHDIR dir, /**< the branching direction for the confidence bound */
    3901 SCIP_Bool onlycurrentrun, /**< should only the current run be taken into account */
    3902 SCIP_CONFIDENCELEVEL clevel /**< confidence level for the interval */
    3903 );
    3904
    3905/** check if variable pseudo-costs have a significant difference in location. The significance depends on
    3906 * the choice of \p clevel and on the kind of tested hypothesis. The one-sided hypothesis, which
    3907 * should be rejected, is that fracy * mu_y >= fracx * mu_x, where mu_y and mu_x denote the
    3908 * unknown location means of the underlying pseudo-cost distributions of x and y.
    3909 *
    3910 * This method is applied best if variable x has a better pseudo-cost score than y. The method hypothesizes that y were actually
    3911 * better than x (despite the current information), meaning that y can be expected to yield branching
    3912 * decisions as least as good as x in the long run. If the method returns TRUE, the current history information is
    3913 * sufficient to safely rely on the alternative hypothesis that x yields indeed a better branching score (on average)
    3914 * than y.
    3915 *
    3916 * @note The order of x and y matters for the one-sided hypothesis
    3917 *
    3918 * @note set \p onesided to FALSE if you are not sure which variable is better. The hypothesis tested then reads
    3919 * fracy * mu_y == fracx * mu_x vs the alternative hypothesis fracy * mu_y != fracx * mu_x.
    3920 *
    3921 * @return TRUE if the hypothesis can be safely rejected at the given confidence level
    3922 */
    3923SCIP_EXPORT
    3924SCIP_Bool SCIPsignificantVarPscostDifference(
    3925 SCIP* scip, /**< SCIP data structure */
    3926 SCIP_VAR* varx, /**< variable x */
    3927 SCIP_Real fracx, /**< the fractionality of variable x */
    3928 SCIP_VAR* vary, /**< variable y */
    3929 SCIP_Real fracy, /**< the fractionality of variable y */
    3930 SCIP_BRANCHDIR dir, /**< branching direction */
    3931 SCIP_CONFIDENCELEVEL clevel, /**< confidence level for rejecting hypothesis */
    3932 SCIP_Bool onesided /**< should a one-sided hypothesis y >= x be tested? */
    3933 );
    3934
    3935/** tests at a given confidence level whether the variable pseudo-costs only have a small probability to
    3936 * exceed a \p threshold. This is useful to determine if past observations provide enough evidence
    3937 * to skip an expensive strong-branching step if there is already a candidate that has been proven to yield an improvement
    3938 * of at least \p threshold.
    3939 *
    3940 * @note use \p clevel to adjust the level of confidence. For SCIP_CONFIDENCELEVEL_MIN, the method returns TRUE if
    3941 * the estimated probability to exceed \p threshold is less than 25 %.
    3942 *
    3943 * @see SCIP_Confidencelevel for a list of available levels. The used probability limits refer to the one-sided levels
    3944 * of confidence.
    3945 *
    3946 * @return TRUE if the variable pseudo-cost probabilistic model is likely to be smaller than \p threshold
    3947 * at the given confidence level \p clevel.
    3948 */
    3949SCIP_EXPORT
    3950SCIP_Bool SCIPpscostThresholdProbabilityTest(
    3951 SCIP* scip, /**< SCIP data structure */
    3952 SCIP_VAR* var, /**< variable x */
    3953 SCIP_Real frac, /**< the fractionality of variable x */
    3954 SCIP_Real threshold, /**< the threshold to test against */
    3955 SCIP_BRANCHDIR dir, /**< branching direction */
    3956 SCIP_CONFIDENCELEVEL clevel /**< confidence level for rejecting hypothesis */
    3957 );
    3958
    3959/** check if the current pseudo cost relative error in a direction violates the given threshold. The Relative
    3960 * Error is calculated at a specific confidence level
    3961 *
    3962 * @return TRUE if relative error in variable pseudo costs is smaller than \p threshold
    3963 */
    3964SCIP_EXPORT
    3965SCIP_Bool SCIPisVarPscostRelerrorReliable(
    3966 SCIP* scip, /**< SCIP data structure */
    3967 SCIP_VAR* var, /**< variable in question */
    3968 SCIP_Real threshold, /**< threshold for relative errors to be considered reliable (enough) */
    3969 SCIP_CONFIDENCELEVEL clevel /**< a given confidence level */
    3970 );
    3971
    3972/** gets the variable's pseudo cost score value for the given LP solution value
    3973 *
    3974 * @return the variable's pseudo cost score value for the given LP solution value
    3975 *
    3976 * @pre This method can be called if @p scip is in one of the following stages:
    3977 * - \ref SCIP_STAGE_INITPRESOLVE
    3978 * - \ref SCIP_STAGE_PRESOLVING
    3979 * - \ref SCIP_STAGE_EXITPRESOLVE
    3980 * - \ref SCIP_STAGE_PRESOLVED
    3981 * - \ref SCIP_STAGE_INITSOLVE
    3982 * - \ref SCIP_STAGE_SOLVING
    3983 * - \ref SCIP_STAGE_SOLVED
    3984 */
    3985SCIP_EXPORT
    3986SCIP_Real SCIPgetVarPseudocostScore(
    3987 SCIP* scip, /**< SCIP data structure */
    3988 SCIP_VAR* var, /**< problem variable */
    3989 SCIP_Real solval /**< variable's LP solution value */
    3990 );
    3991
    3992/** gets the variable's discounted pseudo cost score value for the given LP solution value.
    3993 *
    3994 * This combines both pscost and ancpscost fields.
    3995 *
    3996 * @return the variable's discounted pseudo cost score value for the given LP solution value,
    3997 * combining both pscost and ancpscost fields.
    3998 *
    3999 * @pre This method can be called if @p scip is in one of the following stages:
    4000 * - \ref SCIP_STAGE_INITPRESOLVE
    4001 * - \ref SCIP_STAGE_PRESOLVING
    4002 * - \ref SCIP_STAGE_EXITPRESOLVE
    4003 * - \ref SCIP_STAGE_PRESOLVED
    4004 * - \ref SCIP_STAGE_INITSOLVE
    4005 * - \ref SCIP_STAGE_SOLVING
    4006 * - \ref SCIP_STAGE_SOLVED
    4007 */
    4008SCIP_EXPORT
    4009SCIP_Real SCIPgetVarDPseudocostScore(
    4010 SCIP* scip, /**< SCIP data structure */
    4011 SCIP_VAR* var, /**< problem variable */
    4012 SCIP_Real solval, /**< variable's LP solution value */
    4013 SCIP_Real discountfac /**< discount factor for discounted pseudocost */
    4014 );
    4015
    4016/** gets the variable's pseudo cost score value for the given LP solution value,
    4017 * only using the pseudo cost information of the current run
    4018 *
    4019 * @return the variable's pseudo cost score value for the given LP solution value,
    4020 * only using the pseudo cost information of the current run
    4021 *
    4022 * @pre This method can be called if @p scip is in one of the following stages:
    4023 * - \ref SCIP_STAGE_INITPRESOLVE
    4024 * - \ref SCIP_STAGE_PRESOLVING
    4025 * - \ref SCIP_STAGE_EXITPRESOLVE
    4026 * - \ref SCIP_STAGE_PRESOLVED
    4027 * - \ref SCIP_STAGE_INITSOLVE
    4028 * - \ref SCIP_STAGE_SOLVING
    4029 * - \ref SCIP_STAGE_SOLVED
    4030 */
    4031SCIP_EXPORT
    4032SCIP_Real SCIPgetVarPseudocostScoreCurrentRun(
    4033 SCIP* scip, /**< SCIP data structure */
    4034 SCIP_VAR* var, /**< problem variable */
    4035 SCIP_Real solval /**< variable's LP solution value */
    4036 );
    4037
    4038/** returns the variable's VSIDS value
    4039 *
    4040 * @return the variable's VSIDS value
    4041 *
    4042 * @pre This method can be called if @p scip is in one of the following stages:
    4043 * - \ref SCIP_STAGE_INITPRESOLVE
    4044 * - \ref SCIP_STAGE_PRESOLVING
    4045 * - \ref SCIP_STAGE_EXITPRESOLVE
    4046 * - \ref SCIP_STAGE_PRESOLVED
    4047 * - \ref SCIP_STAGE_INITSOLVE
    4048 * - \ref SCIP_STAGE_SOLVING
    4049 * - \ref SCIP_STAGE_SOLVED
    4050 */
    4051SCIP_EXPORT
    4052SCIP_Real SCIPgetVarVSIDS(
    4053 SCIP* scip, /**< SCIP data structure */
    4054 SCIP_VAR* var, /**< problem variable */
    4055 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4056 );
    4057
    4058/** returns the variable's VSIDS value only using conflicts of the current run
    4059 *
    4060 * @return the variable's VSIDS value only using conflicts of the current run
    4061 *
    4062 * @pre This method can be called if @p scip is in one of the following stages:
    4063 * - \ref SCIP_STAGE_INITPRESOLVE
    4064 * - \ref SCIP_STAGE_PRESOLVING
    4065 * - \ref SCIP_STAGE_EXITPRESOLVE
    4066 * - \ref SCIP_STAGE_PRESOLVED
    4067 * - \ref SCIP_STAGE_INITSOLVE
    4068 * - \ref SCIP_STAGE_SOLVING
    4069 * - \ref SCIP_STAGE_SOLVED
    4070 */
    4071SCIP_EXPORT
    4072SCIP_Real SCIPgetVarVSIDSCurrentRun(
    4073 SCIP* scip, /**< SCIP data structure */
    4074 SCIP_VAR* var, /**< problem variable */
    4075 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4076 );
    4077
    4078/** returns the variable's conflict score value
    4079 *
    4080 * @return the variable's conflict score value
    4081 *
    4082 * @pre This method can be called if @p scip is in one of the following stages:
    4083 * - \ref SCIP_STAGE_INITPRESOLVE
    4084 * - \ref SCIP_STAGE_PRESOLVING
    4085 * - \ref SCIP_STAGE_EXITPRESOLVE
    4086 * - \ref SCIP_STAGE_PRESOLVED
    4087 * - \ref SCIP_STAGE_INITSOLVE
    4088 * - \ref SCIP_STAGE_SOLVING
    4089 * - \ref SCIP_STAGE_SOLVED
    4090 */
    4091SCIP_EXPORT
    4092SCIP_Real SCIPgetVarConflictScore(
    4093 SCIP* scip, /**< SCIP data structure */
    4094 SCIP_VAR* var /**< problem variable */
    4095 );
    4096
    4097/** returns the variable's conflict score value only using conflicts of the current run
    4098 *
    4099 * @return the variable's conflict score value only using conflicts of the current run
    4100 *
    4101 * @pre This method can be called if @p scip is in one of the following stages:
    4102 * - \ref SCIP_STAGE_INITPRESOLVE
    4103 * - \ref SCIP_STAGE_PRESOLVING
    4104 * - \ref SCIP_STAGE_EXITPRESOLVE
    4105 * - \ref SCIP_STAGE_PRESOLVED
    4106 * - \ref SCIP_STAGE_INITSOLVE
    4107 * - \ref SCIP_STAGE_SOLVING
    4108 * - \ref SCIP_STAGE_SOLVED
    4109 */
    4110SCIP_EXPORT
    4111SCIP_Real SCIPgetVarConflictScoreCurrentRun(
    4112 SCIP* scip, /**< SCIP data structure */
    4113 SCIP_VAR* var /**< problem variable */
    4114 );
    4115
    4116/** returns the variable's conflict length score
    4117 *
    4118 * @return the variable's conflict length score
    4119 *
    4120 * @pre This method can be called if @p scip is in one of the following stages:
    4121 * - \ref SCIP_STAGE_INITPRESOLVE
    4122 * - \ref SCIP_STAGE_PRESOLVING
    4123 * - \ref SCIP_STAGE_EXITPRESOLVE
    4124 * - \ref SCIP_STAGE_PRESOLVED
    4125 * - \ref SCIP_STAGE_INITSOLVE
    4126 * - \ref SCIP_STAGE_SOLVING
    4127 * - \ref SCIP_STAGE_SOLVED
    4128 */
    4129SCIP_EXPORT
    4130SCIP_Real SCIPgetVarConflictlengthScore(
    4131 SCIP* scip, /**< SCIP data structure */
    4132 SCIP_VAR* var /**< problem variable */
    4133 );
    4134
    4135/** returns the variable's conflict length score only using conflicts of the current run
    4136 *
    4137 * @return the variable's conflict length score only using conflicts of the current run
    4138 *
    4139 * @pre This method can be called if @p scip is in one of the following stages:
    4140 * - \ref SCIP_STAGE_INITPRESOLVE
    4141 * - \ref SCIP_STAGE_PRESOLVING
    4142 * - \ref SCIP_STAGE_EXITPRESOLVE
    4143 * - \ref SCIP_STAGE_PRESOLVED
    4144 * - \ref SCIP_STAGE_INITSOLVE
    4145 * - \ref SCIP_STAGE_SOLVING
    4146 * - \ref SCIP_STAGE_SOLVED
    4147 */
    4148SCIP_EXPORT
    4149SCIP_Real SCIPgetVarConflictlengthScoreCurrentRun(
    4150 SCIP* scip, /**< SCIP data structure */
    4151 SCIP_VAR* var /**< problem variable */
    4152 );
    4153
    4154/** returns the variable's average conflict length
    4155 *
    4156 * @return the variable's average conflict length
    4157 *
    4158 * @pre This method can be called if @p scip is in one of the following stages:
    4159 * - \ref SCIP_STAGE_INITPRESOLVE
    4160 * - \ref SCIP_STAGE_PRESOLVING
    4161 * - \ref SCIP_STAGE_EXITPRESOLVE
    4162 * - \ref SCIP_STAGE_PRESOLVED
    4163 * - \ref SCIP_STAGE_INITSOLVE
    4164 * - \ref SCIP_STAGE_SOLVING
    4165 * - \ref SCIP_STAGE_SOLVED
    4166 */
    4167SCIP_EXPORT
    4168SCIP_Real SCIPgetVarAvgConflictlength(
    4169 SCIP* scip, /**< SCIP data structure */
    4170 SCIP_VAR* var, /**< problem variable */
    4171 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4172 );
    4173
    4174/** returns the variable's average conflict length only using conflicts of the current run
    4175 *
    4176 * @return the variable's average conflict length only using conflicts of the current run
    4177 *
    4178 * @pre This method can be called if @p scip is in one of the following stages:
    4179 * - \ref SCIP_STAGE_INITPRESOLVE
    4180 * - \ref SCIP_STAGE_PRESOLVING
    4181 * - \ref SCIP_STAGE_EXITPRESOLVE
    4182 * - \ref SCIP_STAGE_PRESOLVED
    4183 * - \ref SCIP_STAGE_INITSOLVE
    4184 * - \ref SCIP_STAGE_SOLVING
    4185 * - \ref SCIP_STAGE_SOLVED
    4186 */
    4187SCIP_EXPORT
    4188SCIP_Real SCIPgetVarAvgConflictlengthCurrentRun(
    4189 SCIP* scip, /**< SCIP data structure */
    4190 SCIP_VAR* var, /**< problem variable */
    4191 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4192 );
    4193
    4194/** returns the average number of inferences found after branching on the variable in given direction;
    4195 * if branching on the variable in the given direction was yet evaluated, the average number of inferences
    4196 * over all variables for branching in the given direction is returned
    4197 *
    4198 * @return the average number of inferences found after branching on the variable in given direction
    4199 *
    4200 * @pre This method can be called if @p scip is in one of the following stages:
    4201 * - \ref SCIP_STAGE_INITPRESOLVE
    4202 * - \ref SCIP_STAGE_PRESOLVING
    4203 * - \ref SCIP_STAGE_EXITPRESOLVE
    4204 * - \ref SCIP_STAGE_PRESOLVED
    4205 * - \ref SCIP_STAGE_INITSOLVE
    4206 * - \ref SCIP_STAGE_SOLVING
    4207 * - \ref SCIP_STAGE_SOLVED
    4208 */
    4209SCIP_EXPORT
    4210SCIP_Real SCIPgetVarAvgInferences(
    4211 SCIP* scip, /**< SCIP data structure */
    4212 SCIP_VAR* var, /**< problem variable */
    4213 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4214 );
    4215
    4216/** returns the average number of inferences found after branching on the variable in given direction in the current run;
    4217 * if branching on the variable in the given direction was yet evaluated, the average number of inferences
    4218 * over all variables for branching in the given direction is returned
    4219 *
    4220 * @return the average number of inferences found after branching on the variable in given direction in the current run
    4221 *
    4222 * @pre This method can be called if @p scip is in one of the following stages:
    4223 * - \ref SCIP_STAGE_INITPRESOLVE
    4224 * - \ref SCIP_STAGE_PRESOLVING
    4225 * - \ref SCIP_STAGE_EXITPRESOLVE
    4226 * - \ref SCIP_STAGE_PRESOLVED
    4227 * - \ref SCIP_STAGE_INITSOLVE
    4228 * - \ref SCIP_STAGE_SOLVING
    4229 * - \ref SCIP_STAGE_SOLVED
    4230 */
    4231SCIP_EXPORT
    4232SCIP_Real SCIPgetVarAvgInferencesCurrentRun(
    4233 SCIP* scip, /**< SCIP data structure */
    4234 SCIP_VAR* var, /**< problem variable */
    4235 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4236 );
    4237
    4238/** returns the variable's average inference score value
    4239 *
    4240 * @return the variable's average inference score value
    4241 *
    4242 * @pre This method can be called if @p scip is in one of the following stages:
    4243 * - \ref SCIP_STAGE_INITPRESOLVE
    4244 * - \ref SCIP_STAGE_PRESOLVING
    4245 * - \ref SCIP_STAGE_EXITPRESOLVE
    4246 * - \ref SCIP_STAGE_PRESOLVED
    4247 * - \ref SCIP_STAGE_INITSOLVE
    4248 * - \ref SCIP_STAGE_SOLVING
    4249 * - \ref SCIP_STAGE_SOLVED
    4250 */
    4251SCIP_EXPORT
    4252SCIP_Real SCIPgetVarAvgInferenceScore(
    4253 SCIP* scip, /**< SCIP data structure */
    4254 SCIP_VAR* var /**< problem variable */
    4255 );
    4256
    4257/** returns the variable's average inference score value only using inferences of the current run
    4258 *
    4259 * @return the variable's average inference score value only using inferences of the current run
    4260 *
    4261 * @pre This method can be called if @p scip is in one of the following stages:
    4262 * - \ref SCIP_STAGE_INITPRESOLVE
    4263 * - \ref SCIP_STAGE_PRESOLVING
    4264 * - \ref SCIP_STAGE_EXITPRESOLVE
    4265 * - \ref SCIP_STAGE_PRESOLVED
    4266 * - \ref SCIP_STAGE_INITSOLVE
    4267 * - \ref SCIP_STAGE_SOLVING
    4268 * - \ref SCIP_STAGE_SOLVED
    4269 */
    4270SCIP_EXPORT
    4271SCIP_Real SCIPgetVarAvgInferenceScoreCurrentRun(
    4272 SCIP* scip, /**< SCIP data structure */
    4273 SCIP_VAR* var /**< problem variable */
    4274 );
    4275
    4276/** initializes the upwards and downwards pseudocosts, conflict scores, conflict lengths, inference scores, cutoff scores
    4277 * of a variable to the given values
    4278 *
    4279 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4280 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4281 *
    4282 * @pre This method can be called if @p scip is in one of the following stages:
    4283 * - \ref SCIP_STAGE_TRANSFORMED
    4284 * - \ref SCIP_STAGE_INITPRESOLVE
    4285 * - \ref SCIP_STAGE_PRESOLVING
    4286 * - \ref SCIP_STAGE_EXITPRESOLVE
    4287 * - \ref SCIP_STAGE_PRESOLVED
    4288 * - \ref SCIP_STAGE_INITSOLVE
    4289 * - \ref SCIP_STAGE_SOLVING
    4290 */
    4291SCIP_EXPORT
    4292SCIP_RETCODE SCIPinitVarBranchStats(
    4293 SCIP* scip, /**< SCIP data structure */
    4294 SCIP_VAR* var, /**< variable which should be initialized */
    4295 SCIP_Real downpscost, /**< value to which pseudocosts for downwards branching should be initialized */
    4296 SCIP_Real uppscost, /**< value to which pseudocosts for upwards branching should be initialized */
    4297 SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
    4298 SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
    4299 SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
    4300 SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
    4301 SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
    4302 SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
    4303 SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
    4304 SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
    4305 );
    4306
    4307/** initializes the upwards and downwards conflict scores, conflict lengths, inference scores, cutoff scores of a
    4308 * variable w.r.t. a value by the given values (SCIP_VALUEHISTORY)
    4309 *
    4310 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4311 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4312 *
    4313 * @pre This method can be called if @p scip is in one of the following stages:
    4314 * - \ref SCIP_STAGE_TRANSFORMED
    4315 * - \ref SCIP_STAGE_INITPRESOLVE
    4316 * - \ref SCIP_STAGE_PRESOLVING
    4317 * - \ref SCIP_STAGE_EXITPRESOLVE
    4318 * - \ref SCIP_STAGE_PRESOLVED
    4319 * - \ref SCIP_STAGE_INITSOLVE
    4320 * - \ref SCIP_STAGE_SOLVING
    4321 */
    4322SCIP_EXPORT
    4323SCIP_RETCODE SCIPinitVarValueBranchStats(
    4324 SCIP* scip, /**< SCIP data structure */
    4325 SCIP_VAR* var, /**< variable which should be initialized */
    4326 SCIP_Real value, /**< domain value, or SCIP_UNKNOWN */
    4327 SCIP_Real downvsids, /**< value to which VSIDS score for downwards branching should be initialized */
    4328 SCIP_Real upvsids, /**< value to which VSIDS score for upwards branching should be initialized */
    4329 SCIP_Real downconflen, /**< value to which conflict length score for downwards branching should be initialized */
    4330 SCIP_Real upconflen, /**< value to which conflict length score for upwards branching should be initialized */
    4331 SCIP_Real downinfer, /**< value to which inference counter for downwards branching should be initialized */
    4332 SCIP_Real upinfer, /**< value to which inference counter for upwards branching should be initialized */
    4333 SCIP_Real downcutoff, /**< value to which cutoff counter for downwards branching should be initialized */
    4334 SCIP_Real upcutoff /**< value to which cutoff counter for upwards branching should be initialized */
    4335 );
    4336
    4337/** returns the average number of cutoffs found after branching on the variable in given direction;
    4338 * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
    4339 * over all variables for branching in the given direction is returned
    4340 *
    4341 * @return the average number of cutoffs found after branching on the variable in given direction
    4342 *
    4343 * @pre This method can be called if @p scip is in one of the following stages:
    4344 * - \ref SCIP_STAGE_INITPRESOLVE
    4345 * - \ref SCIP_STAGE_PRESOLVING
    4346 * - \ref SCIP_STAGE_EXITPRESOLVE
    4347 * - \ref SCIP_STAGE_PRESOLVED
    4348 * - \ref SCIP_STAGE_INITSOLVE
    4349 * - \ref SCIP_STAGE_SOLVING
    4350 * - \ref SCIP_STAGE_SOLVED
    4351 */
    4352SCIP_EXPORT
    4353SCIP_Real SCIPgetVarAvgCutoffs(
    4354 SCIP* scip, /**< SCIP data structure */
    4355 SCIP_VAR* var, /**< problem variable */
    4356 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4357 );
    4358
    4359/** returns the average number of cutoffs found after branching on the variable in given direction in the current run;
    4360 * if branching on the variable in the given direction was yet evaluated, the average number of cutoffs
    4361 * over all variables for branching in the given direction is returned
    4362 *
    4363 * @return the average number of cutoffs found after branching on the variable in given direction in the current run
    4364 *
    4365 * @pre This method can be called if @p scip is in one of the following stages:
    4366 * - \ref SCIP_STAGE_INITPRESOLVE
    4367 * - \ref SCIP_STAGE_PRESOLVING
    4368 * - \ref SCIP_STAGE_EXITPRESOLVE
    4369 * - \ref SCIP_STAGE_PRESOLVED
    4370 * - \ref SCIP_STAGE_INITSOLVE
    4371 * - \ref SCIP_STAGE_SOLVING
    4372 * - \ref SCIP_STAGE_SOLVED
    4373 */
    4374SCIP_EXPORT
    4375SCIP_Real SCIPgetVarAvgCutoffsCurrentRun(
    4376 SCIP* scip, /**< SCIP data structure */
    4377 SCIP_VAR* var, /**< problem variable */
    4378 SCIP_BRANCHDIR dir /**< branching direction (downwards, or upwards) */
    4379 );
    4380
    4381/** returns the variable's average cutoff score value
    4382 *
    4383 * @return the variable's average cutoff score value
    4384 *
    4385 * @pre This method can be called if @p scip is in one of the following stages:
    4386 * - \ref SCIP_STAGE_INITPRESOLVE
    4387 * - \ref SCIP_STAGE_PRESOLVING
    4388 * - \ref SCIP_STAGE_EXITPRESOLVE
    4389 * - \ref SCIP_STAGE_PRESOLVED
    4390 * - \ref SCIP_STAGE_INITSOLVE
    4391 * - \ref SCIP_STAGE_SOLVING
    4392 * - \ref SCIP_STAGE_SOLVED
    4393 */
    4394SCIP_EXPORT
    4395SCIP_Real SCIPgetVarAvgCutoffScore(
    4396 SCIP* scip, /**< SCIP data structure */
    4397 SCIP_VAR* var /**< problem variable */
    4398 );
    4399
    4400/** returns the variable's average cutoff score value, only using cutoffs of the current run
    4401 *
    4402 * @return the variable's average cutoff score value, only using cutoffs of the current run
    4403 *
    4404 * @pre This method can be called if @p scip is in one of the following stages:
    4405 * - \ref SCIP_STAGE_INITPRESOLVE
    4406 * - \ref SCIP_STAGE_PRESOLVING
    4407 * - \ref SCIP_STAGE_EXITPRESOLVE
    4408 * - \ref SCIP_STAGE_PRESOLVED
    4409 * - \ref SCIP_STAGE_INITSOLVE
    4410 * - \ref SCIP_STAGE_SOLVING
    4411 * - \ref SCIP_STAGE_SOLVED
    4412 */
    4413SCIP_EXPORT
    4414SCIP_Real SCIPgetVarAvgCutoffScoreCurrentRun(
    4415 SCIP* scip, /**< SCIP data structure */
    4416 SCIP_VAR* var /**< problem variable */
    4417 );
    4418
    4419/** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
    4420 * factor
    4421 *
    4422 * @return the variable's average inference/cutoff score value
    4423 *
    4424 * @pre This method can be called if @p scip is in one of the following stages:
    4425 * - \ref SCIP_STAGE_INITPRESOLVE
    4426 * - \ref SCIP_STAGE_PRESOLVING
    4427 * - \ref SCIP_STAGE_EXITPRESOLVE
    4428 * - \ref SCIP_STAGE_PRESOLVED
    4429 * - \ref SCIP_STAGE_INITSOLVE
    4430 * - \ref SCIP_STAGE_SOLVING
    4431 * - \ref SCIP_STAGE_SOLVED
    4432 */
    4433SCIP_EXPORT
    4434SCIP_Real SCIPgetVarAvgInferenceCutoffScore(
    4435 SCIP* scip, /**< SCIP data structure */
    4436 SCIP_VAR* var, /**< problem variable */
    4437 SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
    4438 );
    4439
    4440/** returns the variable's average inference/cutoff score value, weighting the cutoffs of the variable with the given
    4441 * factor, only using inferences and cutoffs of the current run
    4442 *
    4443 * @return the variable's average inference/cutoff score value, only using inferences and cutoffs of the current run
    4444 *
    4445 * @pre This method can be called if @p scip is in one of the following stages:
    4446 * - \ref SCIP_STAGE_INITPRESOLVE
    4447 * - \ref SCIP_STAGE_PRESOLVING
    4448 * - \ref SCIP_STAGE_EXITPRESOLVE
    4449 * - \ref SCIP_STAGE_PRESOLVED
    4450 * - \ref SCIP_STAGE_INITSOLVE
    4451 * - \ref SCIP_STAGE_SOLVING
    4452 * - \ref SCIP_STAGE_SOLVED
    4453 */
    4454SCIP_EXPORT
    4455SCIP_Real SCIPgetVarAvgInferenceCutoffScoreCurrentRun(
    4456 SCIP* scip, /**< SCIP data structure */
    4457 SCIP_VAR* var, /**< problem variable */
    4458 SCIP_Real cutoffweight /**< factor to weigh average number of cutoffs in branching score */
    4459 );
    4460
    4461/** returns the variable's average GMI efficacy score value
    4462 *
    4463 * @return the variable's average GMI efficacy score value (for when it was fractional and basic in the LP)
    4464 *
    4465 * @pre This method can be called if @p scip is in one of the following stages:
    4466 * - \ref SCIP_STAGE_INITPRESOLVE
    4467 * - \ref SCIP_STAGE_PRESOLVING
    4468 * - \ref SCIP_STAGE_EXITPRESOLVE
    4469 * - \ref SCIP_STAGE_PRESOLVED
    4470 * - \ref SCIP_STAGE_INITSOLVE
    4471 * - \ref SCIP_STAGE_SOLVING
    4472 * - \ref SCIP_STAGE_SOLVED
    4473 */
    4474SCIP_EXPORT
    4475SCIP_Real SCIPgetVarAvgGMIScore(
    4476 SCIP* scip, /**< SCIP data structure */
    4477 SCIP_VAR* var /**< problem variable */
    4478 );
    4479
    4480/** sets the variable's avg GMI efficacy score value
    4481 *
    4482 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4483 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4484 *
    4485 * @pre This method can be called if @p scip is in one of the following stages:
    4486 * - \ref SCIP_STAGE_INITPRESOLVE
    4487 * - \ref SCIP_STAGE_PRESOLVING
    4488 * - \ref SCIP_STAGE_EXITPRESOLVE
    4489 * - \ref SCIP_STAGE_PRESOLVED
    4490 * - \ref SCIP_STAGE_INITSOLVE
    4491 * - \ref SCIP_STAGE_SOLVING
    4492 * - \ref SCIP_STAGE_SOLVED
    4493 */
    4494SCIP_EXPORT
    4495SCIP_RETCODE SCIPincVarGMISumScore(
    4496 SCIP* scip, /**< SCIP data structure */
    4497 SCIP_VAR* var, /**< problem variable */
    4498 SCIP_Real gmieff /**< Efficacy of last GMI cut generated from when var was basic /frac */
    4499 );
    4500
    4501/** returns the variable's last GMI efficacy score value
    4502 *
    4503 * @return the variable's last GMI efficacy score value (for when it was fractional and basic in the LP)
    4504 *
    4505 * @pre This method can be called if @p scip is in one of the following stages:
    4506 * - \ref SCIP_STAGE_INITPRESOLVE
    4507 * - \ref SCIP_STAGE_PRESOLVING
    4508 * - \ref SCIP_STAGE_EXITPRESOLVE
    4509 * - \ref SCIP_STAGE_PRESOLVED
    4510 * - \ref SCIP_STAGE_INITSOLVE
    4511 * - \ref SCIP_STAGE_SOLVING
    4512 * - \ref SCIP_STAGE_SOLVED
    4513 */
    4514SCIP_EXPORT
    4515SCIP_Real SCIPgetVarLastGMIScore(
    4516 SCIP* scip, /**< SCIP data structure */
    4517 SCIP_VAR* var /**< problem variable */
    4518 );
    4519
    4520/** sets the variable's last GMI efficacy score value
    4521 *
    4522 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4523 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4524 *
    4525 * @pre This method can be called if @p scip is in one of the following stages:
    4526 * - \ref SCIP_STAGE_INITPRESOLVE
    4527 * - \ref SCIP_STAGE_PRESOLVING
    4528 * - \ref SCIP_STAGE_EXITPRESOLVE
    4529 * - \ref SCIP_STAGE_PRESOLVED
    4530 * - \ref SCIP_STAGE_INITSOLVE
    4531 * - \ref SCIP_STAGE_SOLVING
    4532 * - \ref SCIP_STAGE_SOLVED
    4533 */
    4534SCIP_EXPORT
    4535SCIP_RETCODE SCIPsetVarLastGMIScore(
    4536 SCIP* scip, /**< SCIP data structure */
    4537 SCIP_VAR* var, /**< problem variable */
    4538 SCIP_Real gmieff /**< Efficacy of last GMI cut generated from when var was basic /frac */
    4539 );
    4540
    4541/** outputs variable information to file stream via the message system
    4542 *
    4543 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4544 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4545 *
    4546 * @pre This method can be called if @p scip is in one of the following stages:
    4547 * - \ref SCIP_STAGE_PROBLEM
    4548 * - \ref SCIP_STAGE_TRANSFORMING
    4549 * - \ref SCIP_STAGE_TRANSFORMED
    4550 * - \ref SCIP_STAGE_INITPRESOLVE
    4551 * - \ref SCIP_STAGE_PRESOLVING
    4552 * - \ref SCIP_STAGE_EXITPRESOLVE
    4553 * - \ref SCIP_STAGE_PRESOLVED
    4554 * - \ref SCIP_STAGE_INITSOLVE
    4555 * - \ref SCIP_STAGE_SOLVING
    4556 * - \ref SCIP_STAGE_SOLVED
    4557 * - \ref SCIP_STAGE_EXITSOLVE
    4558 * - \ref SCIP_STAGE_FREETRANS
    4559 *
    4560 * @note If the message handler is set to a NULL pointer nothing will be printed
    4561 */
    4562SCIP_EXPORT
    4563SCIP_RETCODE SCIPprintVar(
    4564 SCIP* scip, /**< SCIP data structure */
    4565 SCIP_VAR* var, /**< problem variable */
    4566 FILE* file /**< output file (or NULL for standard output) */
    4567 );
    4568
    4569/** changes variable's exact objective value
    4570 *
    4571 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4572 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4573 *
    4574 * @pre This method can be called if @p scip is in one of the following stages:
    4575 * - \ref SCIP_STAGE_PROBLEM
    4576 * - \ref SCIP_STAGE_TRANSFORMING
    4577 * - \ref SCIP_STAGE_PRESOLVING
    4578 * - \ref SCIP_STAGE_PRESOLVED
    4579 */
    4580SCIP_EXPORT
    4581SCIP_RETCODE SCIPchgVarObjExact(
    4582 SCIP* scip, /**< SCIP data structure */
    4583 SCIP_VAR* var, /**< variable to change the objective value for */
    4584 SCIP_RATIONAL* newobj /**< new objective value */
    4585 );
    4586
    4587/** changes exact global upper bound of variable;
    4588 *
    4589 *
    4590 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4591 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4592 *
    4593 * @pre This method can be called if @p scip is in one of the following stages:
    4594 * - \ref SCIP_STAGE_PROBLEM
    4595 *
    4596 */
    4597SCIP_RETCODE SCIPchgVarUbGlobalExact(
    4598 SCIP* scip, /**< SCIP data structure */
    4599 SCIP_VAR* var, /**< variable to change the bound for */
    4600 SCIP_RATIONAL* newbound /**< new value for bound */
    4601 );
    4602
    4603/** changes exact global lower bound of variable;
    4604 *
    4605 *
    4606 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4607 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4608 *
    4609 * @pre This method can be called if @p scip is in one of the following stages:
    4610 * - \ref SCIP_STAGE_PROBLEM
    4611 *
    4612 */
    4613SCIP_RETCODE SCIPchgVarLbGlobalExact(
    4614 SCIP* scip, /**< SCIP data structure */
    4615 SCIP_VAR* var, /**< variable to change the bound for */
    4616 SCIP_RATIONAL* newbound /**< new value for bound */
    4617 );
    4618
    4619/** print the given variables and rational coefficients as linear sum in the following form
    4620 * c1 <x1> + c2 <x2> ... + cn <xn>
    4621 *
    4622 * This string can be parsed by the method SCIPparseVarsLinearsum().
    4623 *
    4624 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4625 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4626 *
    4627 * @pre This method can be called if @p scip is in one of the following stages:
    4628 * - \ref SCIP_STAGE_PROBLEM
    4629 * - \ref SCIP_STAGE_TRANSFORMING
    4630 * - \ref SCIP_STAGE_TRANSFORMED
    4631 * - \ref SCIP_STAGE_INITPRESOLVE
    4632 * - \ref SCIP_STAGE_PRESOLVING
    4633 * - \ref SCIP_STAGE_EXITPRESOLVE
    4634 * - \ref SCIP_STAGE_PRESOLVED
    4635 * - \ref SCIP_STAGE_INITSOLVE
    4636 * - \ref SCIP_STAGE_SOLVING
    4637 * - \ref SCIP_STAGE_SOLVED
    4638 * - \ref SCIP_STAGE_EXITSOLVE
    4639 * - \ref SCIP_STAGE_FREETRANS
    4640 *
    4641 * @note The printing process is done via the message handler system.
    4642 */
    4643SCIP_EXPORT
    4644SCIP_RETCODE SCIPwriteVarsLinearsumExact(
    4645 SCIP* scip, /**< SCIP data structure */
    4646 FILE* file, /**< output file, or NULL for stdout */
    4647 SCIP_VAR** vars, /**< variable array to output */
    4648 SCIP_RATIONAL** vals, /**< array of coefficients or NULL if all coefficients are 1.0 */
    4649 int nvars, /**< number of variables */
    4650 SCIP_Bool type /**< should the variable type be also posted */
    4651 );
    4652
    4653/** Transforms a given linear sum of variables, that is a_1*x_1 + ... + a_n*x_n + c into a corresponding linear sum of
    4654 * active variables, that is b_1*y_1 + ... + b_m*y_m + d.
    4655 *
    4656 * If the number of needed active variables is greater than the available slots in the variable array, nothing happens
    4657 * except that the required size is stored in the corresponding variable (requiredsize). Otherwise, the active variable
    4658 * representation is stored in the variable array, scalar array and constant.
    4659 *
    4660 * The reason for this approach is that we cannot reallocate memory, since we do not know how the memory has been
    4661 * allocated (e.g., by a C++ 'new' or SCIP functions).
    4662 *
    4663 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    4664 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    4665 *
    4666 * @pre This method can be called if @p scip is in one of the following stages:
    4667 * - \ref SCIP_STAGE_TRANSFORMED
    4668 * - \ref SCIP_STAGE_INITPRESOLVE
    4669 * - \ref SCIP_STAGE_PRESOLVING
    4670 * - \ref SCIP_STAGE_EXITPRESOLVE
    4671 * - \ref SCIP_STAGE_PRESOLVED
    4672 * - \ref SCIP_STAGE_INITSOLVE
    4673 * - \ref SCIP_STAGE_SOLVING
    4674 * - \ref SCIP_STAGE_SOLVED
    4675 * - \ref SCIP_STAGE_EXITSOLVE
    4676 * - \ref SCIP_STAGE_FREETRANS
    4677 *
    4678 * @note The resulting linear sum is stored into the given variable array, scalar array, and constant. That means the
    4679 * given entries are overwritten.
    4680 *
    4681 * @note That method can be used to convert a single variables into variable space of active variables. Therefore call
    4682 * the method with the linear sum 1.0*x + 0.0.
    4683 */
    4684SCIP_EXPORT
    4685SCIP_RETCODE SCIPgetProbvarLinearSumExact(
    4686 SCIP* scip, /**< SCIP data structure */
    4687 SCIP_VAR** vars, /**< variable array x_1, ..., x_n in the linear sum which will be
    4688 * overwritten by the variable array y_1, ..., y_m in the linear sum
    4689 * w.r.t. active variables */
    4690 SCIP_RATIONAL** scalars, /**< scalars a_1, ..., a_n in linear sum which will be overwritten to the
    4691 * scalars b_1, ..., b_m in the linear sum of the active variables */
    4692 int* nvars, /**< pointer to number of variables in the linear sum which will be
    4693 * overwritten by the number of variables in the linear sum corresponding
    4694 * to the active variables */
    4695 int varssize, /**< available slots in vars and scalars array which is needed to check if
    4696 * the array are large enough for the linear sum w.r.t. active
    4697 * variables */
    4698 SCIP_RATIONAL* constant, /**< pointer to constant c in linear sum a_1*x_1 + ... + a_n*x_n + c which
    4699 * will chnage to constant d in the linear sum b_1*y_1 + ... + b_m*y_m +
    4700 * d w.r.t. the active variables */
    4701 int* requiredsize, /**< pointer to store the required array size for the linear sum w.r.t. the
    4702 * active variables */
    4703 SCIP_Bool mergemultiples /**< should multiple occurrences of a var be replaced by a single coeff? */
    4704 );
    4705
    4706/**@} */
    4707
    4708#ifdef __cplusplus
    4709}
    4710#endif
    4711
    4712#endif
    def.h
    common defines and data types used in all packages of SCIP
    SCIP_Longint
    #define SCIP_Longint
    Definition: def.h:141
    SCIP_Bool
    #define SCIP_Bool
    Definition: def.h:91
    SCIP_Real
    #define SCIP_Real
    Definition: def.h:156
    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