Scippy

    SCIP

    Solving Constraint Integer Programs

    scip_prob.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_prob.h
    26 * @ingroup PUBLICCOREAPI
    27 * @brief public methods for global and local (sub)problems
    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_PROB_H__
    41#define __SCIP_SCIP_PROB_H__
    42
    43
    44#include "scip/def.h"
    45#include "scip/type_conflict.h"
    46#include "scip/type_cons.h"
    47#include "scip/type_event.h"
    48#include "scip/type_misc.h"
    49#include "scip/type_prob.h"
    50#include "scip/type_rational.h"
    51#include "scip/type_result.h"
    52#include "scip/type_retcode.h"
    53#include "scip/type_scip.h"
    54#include "scip/type_sol.h"
    55#include "scip/type_tree.h"
    56#include "scip/type_var.h"
    57
    58#ifdef __cplusplus
    59extern "C" {
    60#endif
    61
    62/**@addtogroup GlobalProblemMethods
    63 *
    64 * @{
    65 */
    66
    67/** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
    68 * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
    69 * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
    70 *
    71 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    72 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    73 *
    74 * @pre This method can be called if @p scip is in one of the following stages:
    75 * - \ref SCIP_STAGE_INIT
    76 * - \ref SCIP_STAGE_PROBLEM
    77 * - \ref SCIP_STAGE_TRANSFORMED
    78 * - \ref SCIP_STAGE_PRESOLVING
    79 * - \ref SCIP_STAGE_PRESOLVED
    80 * - \ref SCIP_STAGE_SOLVING
    81 * - \ref SCIP_STAGE_SOLVED
    82 * - \ref SCIP_STAGE_FREE
    83 *
    84 * @post After calling this method, \SCIP reaches the following stage:
    85 * - \ref SCIP_STAGE_PROBLEM
    86 */
    87SCIP_EXPORT
    88SCIP_RETCODE SCIPcreateProb(
    89 SCIP* scip, /**< SCIP data structure */
    90 const char* name, /**< problem name */
    91 SCIP_DECL_PROBDELORIG ((*probdelorig)), /**< frees user data of original problem */
    92 SCIP_DECL_PROBTRANS ((*probtrans)), /**< creates user data of transformed problem by transforming original user data */
    93 SCIP_DECL_PROBDELTRANS((*probdeltrans)), /**< frees user data of transformed problem */
    94 SCIP_DECL_PROBINITSOL ((*probinitsol)), /**< solving process initialization method of transformed data */
    95 SCIP_DECL_PROBEXITSOL ((*probexitsol)), /**< solving process deinitialization method of transformed data */
    96 SCIP_DECL_PROBCOPY ((*probcopy)), /**< copies user data if you want to copy it to a subscip, or NULL */
    97 SCIP_PROBDATA* probdata /**< user problem data set by the reader */
    98 );
    99
    100/** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
    101 * all callback methods will be set to NULL and can be set afterwards, if needed, via SCIPsetProbDelorig(),
    102 * SCIPsetProbTrans(), SCIPsetProbDeltrans(), SCIPsetProbInitsol(), SCIPsetProbExitsol(), and
    103 * SCIPsetProbCopy()
    104 * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
    105 * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
    106 *
    107 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    108 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    109 *
    110 * @pre This method can be called if @p scip is in one of the following stages:
    111 * - \ref SCIP_STAGE_INIT
    112 * - \ref SCIP_STAGE_PROBLEM
    113 * - \ref SCIP_STAGE_TRANSFORMED
    114 * - \ref SCIP_STAGE_PRESOLVING
    115 * - \ref SCIP_STAGE_PRESOLVED
    116 * - \ref SCIP_STAGE_SOLVING
    117 * - \ref SCIP_STAGE_SOLVED
    118 * - \ref SCIP_STAGE_FREE
    119 *
    120 * @post After calling this method, \SCIP reaches the following stage:
    121 * - \ref SCIP_STAGE_PROBLEM
    122 */
    123SCIP_EXPORT
    124SCIP_RETCODE SCIPcreateProbBasic(
    125 SCIP* scip, /**< SCIP data structure */
    126 const char* name /**< problem name */
    127 );
    128
    129/** sets callback to free user data of original problem
    130 *
    131 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    132 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    133 *
    134 * @pre This method can be called if @p scip is in one of the following stages:
    135 * - \ref SCIP_STAGE_PROBLEM
    136 */
    137SCIP_EXPORT
    138SCIP_RETCODE SCIPsetProbDelorig(
    139 SCIP* scip, /**< SCIP data structure */
    140 SCIP_DECL_PROBDELORIG ((*probdelorig)) /**< frees user data of original problem */
    141 );
    142
    143/** sets callback to create user data of transformed problem by transforming original user data
    144 *
    145 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    146 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    147 *
    148 * @pre This method can be called if @p scip is in one of the following stages:
    149 * - \ref SCIP_STAGE_PROBLEM
    150 */
    151SCIP_EXPORT
    152SCIP_RETCODE SCIPsetProbTrans(
    153 SCIP* scip, /**< SCIP data structure */
    154 SCIP_DECL_PROBTRANS ((*probtrans)) /**< creates user data of transformed problem by transforming original user data */
    155 );
    156
    157/** sets callback to free user data of transformed problem
    158 *
    159 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    160 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    161 *
    162 * @pre This method can be called if @p scip is in one of the following stages:
    163 * - \ref SCIP_STAGE_PROBLEM
    164 */
    165SCIP_EXPORT
    166SCIP_RETCODE SCIPsetProbDeltrans(
    167 SCIP* scip, /**< SCIP data structure */
    168 SCIP_DECL_PROBDELTRANS((*probdeltrans)) /**< frees user data of transformed problem */
    169 );
    170
    171/** sets solving process initialization callback of transformed data
    172 *
    173 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    174 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    175 *
    176 * @pre This method can be called if @p scip is in one of the following stages:
    177 * - \ref SCIP_STAGE_PROBLEM
    178 */
    179SCIP_EXPORT
    180SCIP_RETCODE SCIPsetProbInitsol(
    181 SCIP* scip, /**< SCIP data structure */
    182 SCIP_DECL_PROBINITSOL ((*probinitsol)) /**< solving process initialization method of transformed data */
    183 );
    184
    185/** sets solving process deinitialization callback of transformed data
    186 *
    187 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    188 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    189 *
    190 * @pre This method can be called if @p scip is in one of the following stages:
    191 * - \ref SCIP_STAGE_PROBLEM
    192 */
    193SCIP_EXPORT
    194SCIP_RETCODE SCIPsetProbExitsol(
    195 SCIP* scip, /**< SCIP data structure */
    196 SCIP_DECL_PROBEXITSOL ((*probexitsol)) /**< solving process deinitialization method of transformed data */
    197 );
    198
    199/** sets callback to copy user data to a subscip
    200 *
    201 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    202 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    203 *
    204 * @pre This method can be called if @p scip is in one of the following stages:
    205 * - \ref SCIP_STAGE_PROBLEM
    206 */
    207SCIP_EXPORT
    208SCIP_RETCODE SCIPsetProbCopy(
    209 SCIP* scip, /**< SCIP data structure */
    210 SCIP_DECL_PROBCOPY ((*probcopy)) /**< copies user data if you want to copy it to a subscip, or NULL */
    211 );
    212
    213/** reads problem from file and initializes all solving data structures
    214 *
    215 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    216 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    217 *
    218 * @pre This method can be called if @p scip is in one of the following stages:
    219 * - \ref SCIP_STAGE_INIT
    220 * - \ref SCIP_STAGE_PROBLEM
    221 * - \ref SCIP_STAGE_TRANSFORMED
    222 * - \ref SCIP_STAGE_INITPRESOLVE
    223 * - \ref SCIP_STAGE_PRESOLVING
    224 * - \ref SCIP_STAGE_EXITPRESOLVE
    225 * - \ref SCIP_STAGE_PRESOLVED
    226 * - \ref SCIP_STAGE_SOLVING
    227 * - \ref SCIP_STAGE_EXITSOLVE
    228 *
    229 * @post After the method was called, \SCIP is in one of the following stages:
    230 * - \ref SCIP_STAGE_INIT if reading failed (usually, when a SCIP_READERROR occurs)
    231 * - \ref SCIP_STAGE_PROBLEM if the problem file was successfully read
    232 */
    233SCIP_EXPORT
    234SCIP_RETCODE SCIPreadProb(
    235 SCIP* scip, /**< SCIP data structure */
    236 const char* filename, /**< problem file name */
    237 const char* extension /**< extension of the desired file reader,
    238 * or NULL if file extension should be used */
    239 );
    240
    241/** outputs original problem to file stream
    242 *
    243 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    244 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    245 *
    246 * @pre This method can be called if SCIP is in one of the following stages:
    247 * - \ref SCIP_STAGE_PROBLEM
    248 * - \ref SCIP_STAGE_TRANSFORMING
    249 * - \ref SCIP_STAGE_TRANSFORMED
    250 * - \ref SCIP_STAGE_INITPRESOLVE
    251 * - \ref SCIP_STAGE_PRESOLVING
    252 * - \ref SCIP_STAGE_EXITPRESOLVE
    253 * - \ref SCIP_STAGE_PRESOLVED
    254 * - \ref SCIP_STAGE_INITSOLVE
    255 * - \ref SCIP_STAGE_SOLVING
    256 * - \ref SCIP_STAGE_SOLVED
    257 * - \ref SCIP_STAGE_EXITSOLVE
    258 * - \ref SCIP_STAGE_FREETRANS
    259 */
    260SCIP_EXPORT
    261SCIP_RETCODE SCIPprintOrigProblem(
    262 SCIP* scip, /**< SCIP data structure */
    263 FILE* file, /**< output file (or NULL for standard output) */
    264 const char* extension, /**< file format (or NULL for default CIP format)*/
    265 SCIP_Bool genericnames /**< using generic variable and constraint names? */
    266 );
    267
    268/** outputs transformed problem of the current node to file stream
    269 *
    270 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    271 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    272 *
    273 * @pre This method can be called if SCIP is in one of the following stages:
    274 * - \ref SCIP_STAGE_TRANSFORMED
    275 * - \ref SCIP_STAGE_INITPRESOLVE
    276 * - \ref SCIP_STAGE_PRESOLVING
    277 * - \ref SCIP_STAGE_EXITPRESOLVE
    278 * - \ref SCIP_STAGE_PRESOLVED
    279 * - \ref SCIP_STAGE_INITSOLVE
    280 * - \ref SCIP_STAGE_SOLVING
    281 * - \ref SCIP_STAGE_SOLVED
    282 * - \ref SCIP_STAGE_EXITSOLVE
    283 * - \ref SCIP_STAGE_FREETRANS
    284 */
    285SCIP_EXPORT
    286SCIP_RETCODE SCIPprintTransProblem(
    287 SCIP* scip, /**< SCIP data structure */
    288 FILE* file, /**< output file (or NULL for standard output) */
    289 const char* extension, /**< file format (or NULL for default CIP format)*/
    290 SCIP_Bool genericnames /**< using generic variable and constraint names? */
    291 );
    292
    293/** writes original problem to file
    294 *
    295 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    296 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    297 *
    298 * @pre This method can be called if @p scip is in one of the following stages:
    299 * - \ref SCIP_STAGE_PROBLEM
    300 * - \ref SCIP_STAGE_TRANSFORMING
    301 * - \ref SCIP_STAGE_TRANSFORMED
    302 * - \ref SCIP_STAGE_INITPRESOLVE
    303 * - \ref SCIP_STAGE_PRESOLVING
    304 * - \ref SCIP_STAGE_EXITPRESOLVE
    305 * - \ref SCIP_STAGE_PRESOLVED
    306 * - \ref SCIP_STAGE_INITSOLVE
    307 * - \ref SCIP_STAGE_SOLVING
    308 * - \ref SCIP_STAGE_SOLVED
    309 * - \ref SCIP_STAGE_EXITSOLVE
    310 * - \ref SCIP_STAGE_FREETRANS
    311 */
    312SCIP_EXPORT
    313SCIP_RETCODE SCIPwriteOrigProblem(
    314 SCIP* scip, /**< SCIP data structure */
    315 const char* filename, /**< output file (or NULL for standard output) */
    316 const char* extension, /**< extension of the desired file reader,
    317 * or NULL if file extension should be used */
    318 SCIP_Bool genericnames /**< use generic variable and constraint names? */
    319 );
    320
    321/** writes transformed problem which are valid in the current node to file
    322 *
    323 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    324 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    325 *
    326 * @pre This method can be called if @p scip is in one of the following stages:
    327 * - \ref SCIP_STAGE_TRANSFORMED
    328 * - \ref SCIP_STAGE_INITPRESOLVE
    329 * - \ref SCIP_STAGE_PRESOLVING
    330 * - \ref SCIP_STAGE_EXITPRESOLVE
    331 * - \ref SCIP_STAGE_PRESOLVED
    332 * - \ref SCIP_STAGE_INITSOLVE
    333 * - \ref SCIP_STAGE_SOLVING
    334 * - \ref SCIP_STAGE_SOLVED
    335 * - \ref SCIP_STAGE_EXITSOLVE
    336 *
    337 * @note If you want the write all constraints (including the once which are redundant for example), you need to set
    338 * the parameter <write/allconss> to TRUE
    339 */
    340SCIP_EXPORT
    341SCIP_RETCODE SCIPwriteTransProblem(
    342 SCIP* scip, /**< SCIP data structure */
    343 const char* filename, /**< output file (or NULL for standard output) */
    344 const char* extension, /**< extension of the desired file reader,
    345 * or NULL if file extension should be used */
    346 SCIP_Bool genericnames /**< using generic variable and constraint names? */
    347 );
    348
    349/** frees problem and solution process data
    350 *
    351 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    352 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    353 *
    354 * @pre This method can be called if @p scip is in one of the following stages:
    355 * - \ref SCIP_STAGE_INIT
    356 * - \ref SCIP_STAGE_PROBLEM
    357 * - \ref SCIP_STAGE_TRANSFORMED
    358 * - \ref SCIP_STAGE_PRESOLVING
    359 * - \ref SCIP_STAGE_PRESOLVED
    360 * - \ref SCIP_STAGE_SOLVING
    361 * - \ref SCIP_STAGE_SOLVED
    362 * - \ref SCIP_STAGE_FREE
    363 *
    364 * @post After this method was called, SCIP is in the following stage:
    365 * - \ref SCIP_STAGE_INIT
    366 */
    367SCIP_EXPORT
    368SCIP_RETCODE SCIPfreeProb(
    369 SCIP* scip /**< SCIP data structure */
    370 );
    371
    372/** permutes parts of the problem data structure
    373 *
    374 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    375 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    376 *
    377 * @pre This method can be called if @p scip is in one of the following stages:
    378 * - \ref SCIP_STAGE_PROBLEM
    379 * - \ref SCIP_STAGE_TRANSFORMED
    380 *
    381 * @todo This need to be changed to use the new random number generator implemented in random.c
    382 */
    383SCIP_EXPORT
    384SCIP_RETCODE SCIPpermuteProb(
    385 SCIP* scip, /**< SCIP data structure */
    386 unsigned int randseed, /**< seed value for random generator */
    387 SCIP_Bool permuteconss, /**< should the list of constraints in each constraint handler be permuted? */
    388 SCIP_Bool permutebinvars, /**< should the list of binary variables be permuted? */
    389 SCIP_Bool permuteintvars, /**< should the list of integer variables be permuted? */
    390 SCIP_Bool permutebinimplvars, /**< should the list of binary implied integral vars be permuted? */
    391 SCIP_Bool permuteintimplvars, /**< should the list of integer implied integral vars be permuted? */
    392 SCIP_Bool permutecontimplvars, /**< should the list of continuous implied integral vars be permuted? */
    393 SCIP_Bool permutecontvars /**< should the list of continuous variables be permuted? */
    394 );
    395
    396/** gets user problem data
    397 *
    398 * @return a SCIP_PROBDATA pointer, or NULL if no problem data was allocated
    399 *
    400 * @pre This method can be called if @p scip is in one of the following stages:
    401 * - \ref SCIP_STAGE_PROBLEM
    402 * - \ref SCIP_STAGE_TRANSFORMING
    403 * - \ref SCIP_STAGE_TRANSFORMED
    404 * - \ref SCIP_STAGE_INITPRESOLVE
    405 * - \ref SCIP_STAGE_PRESOLVING
    406 * - \ref SCIP_STAGE_EXITPRESOLVE
    407 * - \ref SCIP_STAGE_PRESOLVED
    408 * - \ref SCIP_STAGE_INITSOLVE
    409 * - \ref SCIP_STAGE_SOLVING
    410 * - \ref SCIP_STAGE_SOLVED
    411 * - \ref SCIP_STAGE_EXITSOLVE
    412 * - \ref SCIP_STAGE_FREETRANS
    413 */
    414SCIP_EXPORT
    415SCIP_PROBDATA* SCIPgetProbData(
    416 SCIP* scip /**< SCIP data structure */
    417 );
    418
    419/** sets user problem data
    420 *
    421 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    422 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    423 *
    424 * @pre This method can be called if @p scip is in one of the following stages:
    425 * - \ref SCIP_STAGE_PROBLEM
    426 * - \ref SCIP_STAGE_TRANSFORMING
    427 * - \ref SCIP_STAGE_TRANSFORMED
    428 * - \ref SCIP_STAGE_INITPRESOLVE
    429 * - \ref SCIP_STAGE_PRESOLVING
    430 * - \ref SCIP_STAGE_EXITPRESOLVE
    431 * - \ref SCIP_STAGE_PRESOLVED
    432 * - \ref SCIP_STAGE_INITSOLVE
    433 * - \ref SCIP_STAGE_SOLVING
    434 * - \ref SCIP_STAGE_SOLVED
    435 * - \ref SCIP_STAGE_EXITSOLVE
    436 * - \ref SCIP_STAGE_FREETRANS
    437 */
    438SCIP_EXPORT
    439SCIP_RETCODE SCIPsetProbData(
    440 SCIP* scip, /**< SCIP data structure */
    441 SCIP_PROBDATA* probdata /**< user problem data to use */
    442 );
    443
    444/** returns name of the current problem instance
    445 *
    446 * @return name of the current problem instance
    447 *
    448 * @pre This method can be called if @p scip is in one of the following stages:
    449 * - \ref SCIP_STAGE_PROBLEM
    450 * - \ref SCIP_STAGE_TRANSFORMING
    451 * - \ref SCIP_STAGE_TRANSFORMED
    452 * - \ref SCIP_STAGE_INITPRESOLVE
    453 * - \ref SCIP_STAGE_PRESOLVING
    454 * - \ref SCIP_STAGE_EXITPRESOLVE
    455 * - \ref SCIP_STAGE_PRESOLVED
    456 * - \ref SCIP_STAGE_INITSOLVE
    457 * - \ref SCIP_STAGE_SOLVING
    458 * - \ref SCIP_STAGE_SOLVED
    459 * - \ref SCIP_STAGE_EXITSOLVE
    460 * - \ref SCIP_STAGE_FREETRANS
    461 */
    462SCIP_EXPORT
    463const char* SCIPgetProbName(
    464 SCIP* scip /**< SCIP data structure */
    465 );
    466
    467/** sets name of the current problem instance
    468 *
    469 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    470 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    471 *
    472 * @pre This method can be called if @p scip is in one of the following stages:
    473 * - \ref SCIP_STAGE_PROBLEM
    474 * - \ref SCIP_STAGE_TRANSFORMING
    475 * - \ref SCIP_STAGE_TRANSFORMED
    476 * - \ref SCIP_STAGE_INITPRESOLVE
    477 * - \ref SCIP_STAGE_PRESOLVING
    478 * - \ref SCIP_STAGE_EXITPRESOLVE
    479 * - \ref SCIP_STAGE_PRESOLVED
    480 * - \ref SCIP_STAGE_INITSOLVE
    481 * - \ref SCIP_STAGE_SOLVING
    482 * - \ref SCIP_STAGE_SOLVED
    483 * - \ref SCIP_STAGE_EXITSOLVE
    484 * - \ref SCIP_STAGE_FREETRANS
    485 */
    486SCIP_EXPORT
    487SCIP_RETCODE SCIPsetProbName(
    488 SCIP* scip, /**< SCIP data structure */
    489 const char* name /**< name to be set */
    490 );
    491
    492/** changes the objective function of the original problem.
    493 *
    494 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    495 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    496 *
    497 * @pre This method can be called if @p scip is in one of the following stages:
    498 * - \ref SCIP_STAGE_PROBLEM
    499 * - \ref SCIP_STAGE_PRESOLVED
    500 *
    501 * @note This method should be only used to change the objective function during two reoptimization runs and is only
    502 * recommended to an experienced user.
    503 *
    504 * @note All variables not given in \p vars array are assumed to have an objective coefficient of zero.
    505 */
    506SCIP_EXPORT
    507SCIP_RETCODE SCIPchgReoptObjective(
    508 SCIP* scip, /**< SCIP data structure */
    509 SCIP_OBJSENSE objsense, /**< new objective function */
    510 SCIP_VAR** vars, /**< problem variables */
    511 SCIP_Real* coefs, /**< objective coefficients */
    512 int nvars /**< variables in vars array */
    513 );
    514
    515/** returns objective sense of original problem
    516 *
    517 * @return objective sense of original problem
    518 *
    519 * @pre This method can be called if @p scip is in one of the following stages:
    520 * - \ref SCIP_STAGE_PROBLEM
    521 * - \ref SCIP_STAGE_TRANSFORMING
    522 * - \ref SCIP_STAGE_TRANSFORMED
    523 * - \ref SCIP_STAGE_INITPRESOLVE
    524 * - \ref SCIP_STAGE_PRESOLVING
    525 * - \ref SCIP_STAGE_EXITPRESOLVE
    526 * - \ref SCIP_STAGE_PRESOLVED
    527 * - \ref SCIP_STAGE_INITSOLVE
    528 * - \ref SCIP_STAGE_SOLVING
    529 * - \ref SCIP_STAGE_SOLVED
    530 * - \ref SCIP_STAGE_EXITSOLVE
    531 * - \ref SCIP_STAGE_FREETRANS
    532 */
    533SCIP_EXPORT
    534SCIP_OBJSENSE SCIPgetObjsense(
    535 SCIP* scip /**< SCIP data structure */
    536 );
    537
    538/** sets objective sense of problem
    539 *
    540 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    541 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    542 *
    543 * @pre This method can be called if @p scip is in one of the following stages:
    544 * - \ref SCIP_STAGE_PROBLEM
    545 */
    546SCIP_EXPORT
    547SCIP_RETCODE SCIPsetObjsense(
    548 SCIP* scip, /**< SCIP data structure */
    549 SCIP_OBJSENSE objsense /**< new objective sense */
    550 );
    551
    552/** adds offset of objective function
    553 *
    554 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    555 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    556 *
    557 * @pre This method can be called if @p scip is in one of the following stages:
    558 * - \ref SCIP_STAGE_PRESOLVING
    559 */
    560SCIP_EXPORT
    561SCIP_RETCODE SCIPaddObjoffset(
    562 SCIP* scip, /**< SCIP data structure */
    563 SCIP_Real addval /**< value to add to objective offset */
    564 );
    565
    566/** adds offset of objective function to original problem and to all existing solution in original space
    567 *
    568 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    569 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    570 *
    571 * @pre This method can be called if @p scip is in one of the following stages:
    572 * - \ref SCIP_STAGE_PROBLEM
    573 */
    574SCIP_EXPORT
    575SCIP_RETCODE SCIPaddOrigObjoffsetExact(
    576 SCIP* scip, /**< SCIP data structure */
    577 SCIP_RATIONAL* addval /**< value to add to objective offset */
    578 );
    579
    580/** adds offset of objective function to original problem and to all existing solution in original space
    581 *
    582 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    583 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    584 *
    585 * @pre This method can be called if @p scip is in one of the following stages:
    586 * - \ref SCIP_STAGE_PROBLEM
    587 */
    588SCIP_EXPORT
    589SCIP_RETCODE SCIPaddOrigObjoffset(
    590 SCIP* scip, /**< SCIP data structure */
    591 SCIP_Real addval /**< value to add to objective offset */
    592 );
    593
    594/** returns the objective offset of the original problem
    595 *
    596 * @return the objective offset of the original problem
    597 *
    598 * @pre This method can be called if @p scip is in one of the following stages:
    599 * - \ref SCIP_STAGE_PROBLEM
    600 * - \ref SCIP_STAGE_TRANSFORMING
    601 * - \ref SCIP_STAGE_TRANSFORMED
    602 * - \ref SCIP_STAGE_INITPRESOLVE
    603 * - \ref SCIP_STAGE_PRESOLVING
    604 * - \ref SCIP_STAGE_EXITPRESOLVE
    605 * - \ref SCIP_STAGE_PRESOLVED
    606 * - \ref SCIP_STAGE_INITSOLVE
    607 * - \ref SCIP_STAGE_SOLVING
    608 * - \ref SCIP_STAGE_SOLVED
    609 */
    610SCIP_EXPORT
    611SCIP_Real SCIPgetOrigObjoffset(
    612 SCIP* scip /**< SCIP data structure */
    613 );
    614
    615/** returns the exact objective offset of the original problem
    616 *
    617 * DO NOT MODIFY THE POINTER RETURNED BY THIS METHOD
    618 *
    619 * @return the exact objective offset of the original problem
    620 *
    621 * @pre This method can be called if @p scip is in one of the following stages:
    622 * - \ref SCIP_STAGE_PROBLEM
    623 * - \ref SCIP_STAGE_TRANSFORMING
    624 * - \ref SCIP_STAGE_TRANSFORMED
    625 * - \ref SCIP_STAGE_INITPRESOLVE
    626 * - \ref SCIP_STAGE_PRESOLVING
    627 * - \ref SCIP_STAGE_EXITPRESOLVE
    628 * - \ref SCIP_STAGE_PRESOLVED
    629 * - \ref SCIP_STAGE_INITSOLVE
    630 * - \ref SCIP_STAGE_SOLVING
    631 * - \ref SCIP_STAGE_SOLVED
    632 */
    633SCIP_EXPORT
    634SCIP_RATIONAL* SCIPgetOrigObjoffsetExact(
    635 SCIP* scip /**< SCIP data structure */
    636 );
    637
    638/** returns the objective scale of the original problem
    639 *
    640 * @return the objective scale of the original problem
    641 *
    642 * @pre This method can be called if @p scip is in one of the following stages:
    643 * - \ref SCIP_STAGE_PROBLEM
    644 * - \ref SCIP_STAGE_TRANSFORMING
    645 * - \ref SCIP_STAGE_TRANSFORMED
    646 * - \ref SCIP_STAGE_INITPRESOLVE
    647 * - \ref SCIP_STAGE_PRESOLVING
    648 * - \ref SCIP_STAGE_EXITPRESOLVE
    649 * - \ref SCIP_STAGE_PRESOLVED
    650 * - \ref SCIP_STAGE_INITSOLVE
    651 * - \ref SCIP_STAGE_SOLVING
    652 * - \ref SCIP_STAGE_SOLVED
    653 */
    654SCIP_EXPORT
    655SCIP_Real SCIPgetOrigObjscale(
    656 SCIP* scip /**< SCIP data structure */
    657 );
    658
    659/** returns the objective offset of the transformed problem
    660 *
    661 * @return the objective offset of the transformed problem
    662 *
    663 * @pre This method can be called if @p scip is in one of the following stages:
    664 * - \ref SCIP_STAGE_TRANSFORMED
    665 * - \ref SCIP_STAGE_INITPRESOLVE
    666 * - \ref SCIP_STAGE_PRESOLVING
    667 * - \ref SCIP_STAGE_EXITPRESOLVE
    668 * - \ref SCIP_STAGE_PRESOLVED
    669 * - \ref SCIP_STAGE_INITSOLVE
    670 * - \ref SCIP_STAGE_SOLVING
    671 * - \ref SCIP_STAGE_SOLVED
    672 */
    673SCIP_EXPORT
    674SCIP_Real SCIPgetTransObjoffset(
    675 SCIP* scip /**< SCIP data structure */
    676 );
    677
    678/** returns the objective scale of the transformed problem
    679 *
    680 * @return the objective scale of the transformed problem
    681 *
    682 * @pre This method can be called if @p scip is in one of the following stages:
    683 * - \ref SCIP_STAGE_TRANSFORMED
    684 * - \ref SCIP_STAGE_INITPRESOLVE
    685 * - \ref SCIP_STAGE_PRESOLVING
    686 * - \ref SCIP_STAGE_EXITPRESOLVE
    687 * - \ref SCIP_STAGE_PRESOLVED
    688 * - \ref SCIP_STAGE_INITSOLVE
    689 * - \ref SCIP_STAGE_SOLVING
    690 * - \ref SCIP_STAGE_SOLVED
    691 */
    692SCIP_EXPORT
    693SCIP_Real SCIPgetTransObjscale(
    694 SCIP* scip /**< SCIP data structure */
    695 );
    696
    697/** sets limit on objective function, such that only solutions better than this limit are accepted
    698 *
    699 * @note SCIP will only look for solutions with a strictly better objective value, thus, e.g., prune
    700 * all branch-and-bound nodes with dual bound equal or worse to the objective limit.
    701 * However, SCIP will also collect solutions with objective value worse than the objective limit and
    702 * use them to run improvement heuristics on them.
    703 * @note If SCIP can prove that there exists no solution with a strictly better objective value, the solving status
    704 * will normally be infeasible (the objective limit is interpreted as part of the problem).
    705 * The only exception is that by chance, SCIP found a solution with the same objective value and thus
    706 * proved the optimality of this solution, resulting in solution status optimal.
    707 *
    708 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
    709 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    710 *
    711 * @pre This method can be called if @p scip is in one of the following stages:
    712 * - \ref SCIP_STAGE_PROBLEM
    713 * - \ref SCIP_STAGE_TRANSFORMED
    714 * - \ref SCIP_STAGE_INITPRESOLVE
    715 * - \ref SCIP_STAGE_PRESOLVING
    716 * - \ref SCIP_STAGE_EXITPRESOLVE
    717 * - \ref SCIP_STAGE_PRESOLVED
    718 * - \ref SCIP_STAGE_SOLVING
    719 */
    720SCIP_EXPORT
    721SCIP_RETCODE SCIPsetObjlimit(
    722 SCIP* scip, /**< SCIP data structure */
    723 SCIP_Real objlimit /**< new primal objective limit */
    724 );
    725
    726/** returns current limit on objective function
    727 *
    728 * @return the current objective limit of the original problem
    729 *
    730 * @pre This method can be called if @p scip is in one of the following stages:
    731 * - \ref SCIP_STAGE_PROBLEM
    732 * - \ref SCIP_STAGE_TRANSFORMING
    733 * - \ref SCIP_STAGE_TRANSFORMED
    734 * - \ref SCIP_STAGE_INITPRESOLVE
    735 * - \ref SCIP_STAGE_PRESOLVING
    736 * - \ref SCIP_STAGE_EXITPRESOLVE
    737 * - \ref SCIP_STAGE_PRESOLVED
    738 * - \ref SCIP_STAGE_INITSOLVE
    739 * - \ref SCIP_STAGE_SOLVING
    740 * - \ref SCIP_STAGE_SOLVED
    741 */
    742SCIP_EXPORT
    743SCIP_Real SCIPgetObjlimit(
    744 SCIP* scip /**< SCIP data structure */
    745 );
    746
    747/** informs SCIP, that the objective value is always integral in every feasible solution
    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_PROBLEM
    754 * - \ref SCIP_STAGE_TRANSFORMING
    755 * - \ref SCIP_STAGE_INITPRESOLVE
    756 * - \ref SCIP_STAGE_EXITPRESOLVE
    757 * - \ref SCIP_STAGE_SOLVING
    758 *
    759 * @note This function should be used to inform SCIP that the objective function is integral, helping to improve the
    760 * performance. This is useful when using column generation. If no column generation (pricing) is used, SCIP
    761 * automatically detects whether the objective function is integral or can be scaled to be integral. However, in
    762 * any case, the user has to make sure that no variable is added during the solving process that destroys this
    763 * property.
    764 */
    765SCIP_EXPORT
    766SCIP_RETCODE SCIPsetObjIntegral(
    767 SCIP* scip /**< SCIP data structure */
    768 );
    769
    770/** returns whether the objective value is known to be integral in every feasible solution
    771 *
    772 * @return TRUE, if objective value is known to be always integral, otherwise FALSE
    773 *
    774 * @pre This method can be called if @p scip is in one of the following stages:
    775 * - \ref SCIP_STAGE_PROBLEM
    776 * - \ref SCIP_STAGE_TRANSFORMING
    777 * - \ref SCIP_STAGE_INITPRESOLVE
    778 * - \ref SCIP_STAGE_PRESOLVING
    779 * - \ref SCIP_STAGE_EXITPRESOLVE
    780 * - \ref SCIP_STAGE_PRESOLVED
    781 * - \ref SCIP_STAGE_SOLVING
    782 *
    783 * @note If no pricing is performed, SCIP automatically detects whether the objective function is integral or can be
    784 * scaled to be integral, helping to improve performance. This function returns the result. Otherwise
    785 * SCIPsetObjIntegral() can be used to inform SCIP. However, in any case, the user has to make sure that no
    786 * variable is added during the solving process that destroys this property.
    787 */
    788SCIP_EXPORT
    789SCIP_Bool SCIPisObjIntegral(
    790 SCIP* scip /**< SCIP data structure */
    791 );
    792
    793/** returns the Euclidean norm of the objective function vector (available only for transformed problem)
    794 *
    795 * @return the Euclidean norm of the transformed objective function vector
    796 *
    797 * @pre This method can be called if @p scip is in one of the following stages:
    798 * - \ref SCIP_STAGE_TRANSFORMED
    799 * - \ref SCIP_STAGE_INITPRESOLVE
    800 * - \ref SCIP_STAGE_PRESOLVING
    801 * - \ref SCIP_STAGE_EXITPRESOLVE
    802 * - \ref SCIP_STAGE_PRESOLVED
    803 * - \ref SCIP_STAGE_INITSOLVE
    804 * - \ref SCIP_STAGE_SOLVING
    805 * - \ref SCIP_STAGE_SOLVED
    806 * - \ref SCIP_STAGE_EXITSOLVE
    807 */
    808SCIP_EXPORT
    809SCIP_Real SCIPgetObjNorm(
    810 SCIP* scip /**< SCIP data structure */
    811 );
    812
    813/** adds variable to the problem
    814 *
    815 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    816 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    817 *
    818 * @pre This method can be called if @p scip is in one of the following stages:
    819 * - \ref SCIP_STAGE_PROBLEM
    820 * - \ref SCIP_STAGE_TRANSFORMING
    821 * - \ref SCIP_STAGE_INITPRESOLVE
    822 * - \ref SCIP_STAGE_PRESOLVING
    823 * - \ref SCIP_STAGE_EXITPRESOLVE
    824 * - \ref SCIP_STAGE_PRESOLVED
    825 * - \ref SCIP_STAGE_SOLVING
    826 */
    827SCIP_EXPORT
    828SCIP_RETCODE SCIPaddVar(
    829 SCIP* scip, /**< SCIP data structure */
    830 SCIP_VAR* var /**< variable to add */
    831 );
    832
    833/** adds variable to the problem and uses it as pricing candidate to enter the LP
    834 *
    835 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    836 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    837 *
    838 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
    839 */
    840SCIP_EXPORT
    841SCIP_RETCODE SCIPaddPricedVar(
    842 SCIP* scip, /**< SCIP data structure */
    843 SCIP_VAR* var, /**< variable to add */
    844 SCIP_Real score /**< pricing score of variable (the larger, the better the variable) */
    845 );
    846
    847/** removes variable from the problem
    848 *
    849 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    850 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    851 *
    852 * @warning The variable is not deleted from the constraints when in SCIP_STAGE_PROBLEM. In this stage, it is the
    853 * user's responsibility to ensure the variable has been removed from all constraints or the constraints
    854 * deleted.
    855 *
    856 * @pre This method can be called if @p scip is in one of the following stages:
    857 * - \ref SCIP_STAGE_PROBLEM
    858 * - \ref SCIP_STAGE_TRANSFORMING
    859 * - \ref SCIP_STAGE_TRANSFORMED
    860 * - \ref SCIP_STAGE_PRESOLVING
    861 * - \ref SCIP_STAGE_FREETRANS
    862 *
    863 * @warning The variable is not deleted from the constraints when in SCIP_STAGE_PROBLEM. In this stage, it is the
    864 * user's responsibility to ensure the variable has been removed from all constraints or the constraints
    865 * deleted.
    866 */
    867SCIP_EXPORT
    868SCIP_RETCODE SCIPdelVar(
    869 SCIP* scip, /**< SCIP data structure */
    870 SCIP_VAR* var, /**< variable to delete */
    871 SCIP_Bool* deleted /**< pointer to store whether marking variable to be deleted was successful */
    872 );
    873
    874/** gets variables of the problem along with the numbers of different variable types; data may become invalid after
    875 * calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
    876 *
    877 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    878 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    879 *
    880 * @pre This method can be called if @p scip is in one of the following stages:
    881 * - \ref SCIP_STAGE_PROBLEM
    882 * - \ref SCIP_STAGE_TRANSFORMED
    883 * - \ref SCIP_STAGE_INITPRESOLVE
    884 * - \ref SCIP_STAGE_PRESOLVING
    885 * - \ref SCIP_STAGE_EXITPRESOLVE
    886 * - \ref SCIP_STAGE_PRESOLVED
    887 * - \ref SCIP_STAGE_INITSOLVE
    888 * - \ref SCIP_STAGE_SOLVING
    889 * - \ref SCIP_STAGE_SOLVED
    890 * - \ref SCIP_STAGE_EXITSOLVE
    891 */
    892SCIP_EXPORT
    893SCIP_RETCODE SCIPgetVarsData(
    894 SCIP* scip, /**< SCIP data structure */
    895 SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
    896 int* nvars, /**< pointer to store number of variables or NULL if not needed */
    897 int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
    898 int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
    899 int* nimplvars, /**< pointer to store number of implied integral vars or NULL if not needed */
    900 int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
    901 );
    902
    903/** gets array with active problem variables
    904 *
    905 * @return array with active problem variables
    906 *
    907 * @note Variables in the array are grouped in following order:
    908 * - binaries
    909 * - integers
    910 * - implied integral binaries
    911 * - implied integral integers
    912 * - implied integral continuous
    913 * - continuous
    914 *
    915 * @warning Modifying a variable status (e.g. with SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar())
    916 * or a variable type (e.g. with SCIPchgVarType() and SCIPchgVarImplType())
    917 * may invalidate or resort the data array.
    918 *
    919 * @pre This method can be called if @p scip is in one of the following stages:
    920 * - \ref SCIP_STAGE_PROBLEM
    921 * - \ref SCIP_STAGE_TRANSFORMED
    922 * - \ref SCIP_STAGE_INITPRESOLVE
    923 * - \ref SCIP_STAGE_PRESOLVING
    924 * - \ref SCIP_STAGE_EXITPRESOLVE
    925 * - \ref SCIP_STAGE_PRESOLVED
    926 * - \ref SCIP_STAGE_INITSOLVE
    927 * - \ref SCIP_STAGE_SOLVING
    928 * - \ref SCIP_STAGE_SOLVED
    929 * - \ref SCIP_STAGE_EXITSOLVE
    930 */
    931SCIP_EXPORT
    932SCIP_VAR** SCIPgetVars(
    933 SCIP* scip /**< SCIP data structure */
    934 );
    935
    936/** gets number of active problem variables
    937 *
    938 * @return the number of active problem variables
    939 *
    940 * @pre This method can be called if @p scip is in one of the following stages:
    941 * - \ref SCIP_STAGE_PROBLEM
    942 * - \ref SCIP_STAGE_TRANSFORMED
    943 * - \ref SCIP_STAGE_INITPRESOLVE
    944 * - \ref SCIP_STAGE_PRESOLVING
    945 * - \ref SCIP_STAGE_EXITPRESOLVE
    946 * - \ref SCIP_STAGE_PRESOLVED
    947 * - \ref SCIP_STAGE_INITSOLVE
    948 * - \ref SCIP_STAGE_SOLVING
    949 * - \ref SCIP_STAGE_SOLVED
    950 * - \ref SCIP_STAGE_EXITSOLVE
    951 */
    952SCIP_EXPORT
    953int SCIPgetNVars(
    954 SCIP* scip /**< SCIP data structure */
    955 );
    956
    957/** gets number of binary active problem variables
    958 *
    959 * @return the number of binary active problem variables
    960 *
    961 * @note This function does not count binary variables which are implied integral.
    962 *
    963 * @pre This method can be called if @p scip is in one of the following stages:
    964 * - \ref SCIP_STAGE_PROBLEM
    965 * - \ref SCIP_STAGE_TRANSFORMED
    966 * - \ref SCIP_STAGE_INITPRESOLVE
    967 * - \ref SCIP_STAGE_PRESOLVING
    968 * - \ref SCIP_STAGE_EXITPRESOLVE
    969 * - \ref SCIP_STAGE_PRESOLVED
    970 * - \ref SCIP_STAGE_INITSOLVE
    971 * - \ref SCIP_STAGE_SOLVING
    972 * - \ref SCIP_STAGE_SOLVED
    973 * - \ref SCIP_STAGE_EXITSOLVE
    974 */
    975SCIP_EXPORT
    976int SCIPgetNBinVars(
    977 SCIP* scip /**< SCIP data structure */
    978 );
    979
    980/** gets number of integer active problem variables
    981 *
    982 * @return the number of integer active problem variables
    983 *
    984 * @note This function does not count integer variables which are implied integral.
    985 *
    986 * @pre This method can be called if @p scip is in one of the following stages:
    987 * - \ref SCIP_STAGE_PROBLEM
    988 * - \ref SCIP_STAGE_TRANSFORMED
    989 * - \ref SCIP_STAGE_INITPRESOLVE
    990 * - \ref SCIP_STAGE_PRESOLVING
    991 * - \ref SCIP_STAGE_EXITPRESOLVE
    992 * - \ref SCIP_STAGE_PRESOLVED
    993 * - \ref SCIP_STAGE_INITSOLVE
    994 * - \ref SCIP_STAGE_SOLVING
    995 * - \ref SCIP_STAGE_SOLVED
    996 * - \ref SCIP_STAGE_EXITSOLVE
    997 */
    998SCIP_EXPORT
    999int SCIPgetNIntVars(
    1000 SCIP* scip /**< SCIP data structure */
    1001 );
    1002
    1003/** gets number of implied integral active problem variables
    1004 *
    1005 * @return the number of implied integral active problem variables
    1006 *
    1007 * @note This function counts binary, integer, and continuous variables which are implied integral.
    1008 *
    1009 * @pre This method can be called if @p scip is in one of the following stages:
    1010 * - \ref SCIP_STAGE_PROBLEM
    1011 * - \ref SCIP_STAGE_TRANSFORMED
    1012 * - \ref SCIP_STAGE_INITPRESOLVE
    1013 * - \ref SCIP_STAGE_PRESOLVING
    1014 * - \ref SCIP_STAGE_EXITPRESOLVE
    1015 * - \ref SCIP_STAGE_PRESOLVED
    1016 * - \ref SCIP_STAGE_INITSOLVE
    1017 * - \ref SCIP_STAGE_SOLVING
    1018 * - \ref SCIP_STAGE_SOLVED
    1019 * - \ref SCIP_STAGE_EXITSOLVE
    1020 */
    1021SCIP_EXPORT
    1022int SCIPgetNImplVars(
    1023 SCIP* scip /**< SCIP data structure */
    1024 );
    1025
    1026/** gets number of binary implied integral active problem variables
    1027 *
    1028 * @return the number of binary implied integral active problem variables
    1029 *
    1030 * @pre This method can be called if @p scip is in one of the following stages:
    1031 * - \ref SCIP_STAGE_PROBLEM
    1032 * - \ref SCIP_STAGE_TRANSFORMED
    1033 * - \ref SCIP_STAGE_INITPRESOLVE
    1034 * - \ref SCIP_STAGE_PRESOLVING
    1035 * - \ref SCIP_STAGE_EXITPRESOLVE
    1036 * - \ref SCIP_STAGE_PRESOLVED
    1037 * - \ref SCIP_STAGE_INITSOLVE
    1038 * - \ref SCIP_STAGE_SOLVING
    1039 * - \ref SCIP_STAGE_SOLVED
    1040 * - \ref SCIP_STAGE_EXITSOLVE
    1041 */
    1042SCIP_EXPORT
    1043int SCIPgetNBinImplVars(
    1044 SCIP* scip /**< SCIP data structure */
    1045 );
    1046
    1047/** gets number of integer implied integral active problem variables
    1048 *
    1049 * @return the number of integer implied integral active problem variables
    1050 *
    1051 * @pre This method can be called if @p scip is in one of the following stages:
    1052 * - \ref SCIP_STAGE_PROBLEM
    1053 * - \ref SCIP_STAGE_TRANSFORMED
    1054 * - \ref SCIP_STAGE_INITPRESOLVE
    1055 * - \ref SCIP_STAGE_PRESOLVING
    1056 * - \ref SCIP_STAGE_EXITPRESOLVE
    1057 * - \ref SCIP_STAGE_PRESOLVED
    1058 * - \ref SCIP_STAGE_INITSOLVE
    1059 * - \ref SCIP_STAGE_SOLVING
    1060 * - \ref SCIP_STAGE_SOLVED
    1061 * - \ref SCIP_STAGE_EXITSOLVE
    1062 */
    1063SCIP_EXPORT
    1064int SCIPgetNIntImplVars(
    1065 SCIP* scip /**< SCIP data structure */
    1066 );
    1067
    1068/** gets number of continuous implied integral active problem variables
    1069 *
    1070 * @return the number of continuous implied integral active problem variables
    1071 *
    1072 * @pre This method can be called if @p scip is in one of the following stages:
    1073 * - \ref SCIP_STAGE_PROBLEM
    1074 * - \ref SCIP_STAGE_TRANSFORMED
    1075 * - \ref SCIP_STAGE_INITPRESOLVE
    1076 * - \ref SCIP_STAGE_PRESOLVING
    1077 * - \ref SCIP_STAGE_EXITPRESOLVE
    1078 * - \ref SCIP_STAGE_PRESOLVED
    1079 * - \ref SCIP_STAGE_INITSOLVE
    1080 * - \ref SCIP_STAGE_SOLVING
    1081 * - \ref SCIP_STAGE_SOLVED
    1082 * - \ref SCIP_STAGE_EXITSOLVE
    1083 */
    1084SCIP_EXPORT
    1085int SCIPgetNContImplVars(
    1086 SCIP* scip /**< SCIP data structure */
    1087 );
    1088
    1089/** gets number of continuous active problem variables
    1090 *
    1091 * @return the number of continuous active problem variables
    1092 *
    1093 * @note This function does not count continuous variables which are implied integral.
    1094 *
    1095 * @pre This method can be called if @p scip is in one of the following stages:
    1096 * - \ref SCIP_STAGE_PROBLEM
    1097 * - \ref SCIP_STAGE_TRANSFORMED
    1098 * - \ref SCIP_STAGE_INITPRESOLVE
    1099 * - \ref SCIP_STAGE_PRESOLVING
    1100 * - \ref SCIP_STAGE_EXITPRESOLVE
    1101 * - \ref SCIP_STAGE_PRESOLVED
    1102 * - \ref SCIP_STAGE_INITSOLVE
    1103 * - \ref SCIP_STAGE_SOLVING
    1104 * - \ref SCIP_STAGE_SOLVED
    1105 * - \ref SCIP_STAGE_EXITSOLVE
    1106 */
    1107SCIP_EXPORT
    1108int SCIPgetNContVars(
    1109 SCIP* scip /**< SCIP data structure */
    1110 );
    1111
    1112/** gets number of active problem variables with a non-zero objective coefficient
    1113 *
    1114 * @note In case of the original problem the number of variables is counted. In case of the transformed problem the
    1115 * number of variables is just returned since it is stored internally
    1116 *
    1117 * @return the number of active problem variables with a non-zero objective coefficient
    1118 *
    1119 * @pre This method can be called if @p scip is in one of the following stages:
    1120 * - \ref SCIP_STAGE_PROBLEM
    1121 * - \ref SCIP_STAGE_TRANSFORMED
    1122 * - \ref SCIP_STAGE_INITPRESOLVE
    1123 * - \ref SCIP_STAGE_PRESOLVING
    1124 * - \ref SCIP_STAGE_EXITPRESOLVE
    1125 * - \ref SCIP_STAGE_PRESOLVED
    1126 * - \ref SCIP_STAGE_INITSOLVE
    1127 * - \ref SCIP_STAGE_SOLVING
    1128 * - \ref SCIP_STAGE_SOLVED
    1129 */
    1130SCIP_EXPORT
    1131int SCIPgetNObjVars(
    1132 SCIP* scip /**< SCIP data structure */
    1133 );
    1134
    1135/** gets array with fixed and aggregated problem variables; data may become invalid after
    1136 * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
    1137 *
    1138 * @return an array with fixed and aggregated problem variables; data may become invalid after
    1139 * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
    1140 *
    1141 * @pre This method can be called if @p scip is in one of the following stages:
    1142 * - \ref SCIP_STAGE_PROBLEM
    1143 * - \ref SCIP_STAGE_TRANSFORMED
    1144 * - \ref SCIP_STAGE_INITPRESOLVE
    1145 * - \ref SCIP_STAGE_PRESOLVING
    1146 * - \ref SCIP_STAGE_EXITPRESOLVE
    1147 * - \ref SCIP_STAGE_PRESOLVED
    1148 * - \ref SCIP_STAGE_INITSOLVE
    1149 * - \ref SCIP_STAGE_SOLVING
    1150 * - \ref SCIP_STAGE_SOLVED
    1151 */
    1152SCIP_EXPORT
    1153SCIP_VAR** SCIPgetFixedVars(
    1154 SCIP* scip /**< SCIP data structure */
    1155 );
    1156
    1157/** gets number of fixed or aggregated problem variables
    1158 *
    1159 * @return the number of fixed or aggregated problem variables
    1160 *
    1161 * @pre This method can be called if @p scip is in one of the following stages:
    1162 * - \ref SCIP_STAGE_PROBLEM
    1163 * - \ref SCIP_STAGE_TRANSFORMED
    1164 * - \ref SCIP_STAGE_INITPRESOLVE
    1165 * - \ref SCIP_STAGE_PRESOLVING
    1166 * - \ref SCIP_STAGE_EXITPRESOLVE
    1167 * - \ref SCIP_STAGE_PRESOLVED
    1168 * - \ref SCIP_STAGE_INITSOLVE
    1169 * - \ref SCIP_STAGE_SOLVING
    1170 * - \ref SCIP_STAGE_SOLVED
    1171 */
    1172SCIP_EXPORT
    1173int SCIPgetNFixedVars(
    1174 SCIP* scip /**< SCIP data structure */
    1175 );
    1176
    1177/** gets variables of the original problem along with the numbers of different variable types; data may become invalid
    1178 * after a call to SCIPchgVarType()
    1179 *
    1180 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1181 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1182 *
    1183 * @pre This method can be called if @p scip is in one of the following stages:
    1184 * - \ref SCIP_STAGE_PROBLEM
    1185 * - \ref SCIP_STAGE_TRANSFORMING
    1186 * - \ref SCIP_STAGE_TRANSFORMED
    1187 * - \ref SCIP_STAGE_INITPRESOLVE
    1188 * - \ref SCIP_STAGE_PRESOLVING
    1189 * - \ref SCIP_STAGE_EXITPRESOLVE
    1190 * - \ref SCIP_STAGE_PRESOLVED
    1191 * - \ref SCIP_STAGE_INITSOLVE
    1192 * - \ref SCIP_STAGE_SOLVING
    1193 * - \ref SCIP_STAGE_SOLVED
    1194 * - \ref SCIP_STAGE_EXITSOLVE
    1195 * - \ref SCIP_STAGE_FREETRANS
    1196 */
    1197SCIP_EXPORT
    1198SCIP_RETCODE SCIPgetOrigVarsData(
    1199 SCIP* scip, /**< SCIP data structure */
    1200 SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
    1201 int* nvars, /**< pointer to store number of variables or NULL if not needed */
    1202 int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
    1203 int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
    1204 int* nimplvars, /**< pointer to store number of implied integral vars or NULL if not needed */
    1205 int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
    1206 );
    1207
    1208/** gets array with original problem variables
    1209 *
    1210 * @return array with original problem variables
    1211 *
    1212 * @note Variables in the array are grouped in following order:
    1213 * - binaries
    1214 * - integers
    1215 * - implied integral binaries
    1216 * - implied integral integers
    1217 * - implied integral continuous
    1218 * - continuous
    1219 *
    1220 * @warning Modifying the variable number (e.g. with SCIPaddVar() and SCIPdelVar())
    1221 * or a variable type (e.g. with SCIPchgVarType() and SCIPchgVarImplType())
    1222 * may invalidate or resort the data array.
    1223 *
    1224 * @pre This method can be called if @p scip is in one of the following stages:
    1225 * - \ref SCIP_STAGE_PROBLEM
    1226 * - \ref SCIP_STAGE_TRANSFORMING
    1227 * - \ref SCIP_STAGE_TRANSFORMED
    1228 * - \ref SCIP_STAGE_INITPRESOLVE
    1229 * - \ref SCIP_STAGE_PRESOLVING
    1230 * - \ref SCIP_STAGE_EXITPRESOLVE
    1231 * - \ref SCIP_STAGE_PRESOLVED
    1232 * - \ref SCIP_STAGE_INITSOLVE
    1233 * - \ref SCIP_STAGE_SOLVING
    1234 * - \ref SCIP_STAGE_SOLVED
    1235 * - \ref SCIP_STAGE_EXITSOLVE
    1236 * - \ref SCIP_STAGE_FREETRANS
    1237 */
    1238SCIP_EXPORT
    1239SCIP_VAR** SCIPgetOrigVars(
    1240 SCIP* scip /**< SCIP data structure */
    1241 );
    1242
    1243/** gets number of original problem variables
    1244 *
    1245 * @return the number of original problem variables
    1246 *
    1247 * @pre This method can be called if @p scip is in one of the following stages:
    1248 * - \ref SCIP_STAGE_PROBLEM
    1249 * - \ref SCIP_STAGE_TRANSFORMING
    1250 * - \ref SCIP_STAGE_TRANSFORMED
    1251 * - \ref SCIP_STAGE_INITPRESOLVE
    1252 * - \ref SCIP_STAGE_PRESOLVING
    1253 * - \ref SCIP_STAGE_EXITPRESOLVE
    1254 * - \ref SCIP_STAGE_PRESOLVED
    1255 * - \ref SCIP_STAGE_INITSOLVE
    1256 * - \ref SCIP_STAGE_SOLVING
    1257 * - \ref SCIP_STAGE_SOLVED
    1258 * - \ref SCIP_STAGE_EXITSOLVE
    1259 * - \ref SCIP_STAGE_FREETRANS
    1260 */
    1261SCIP_EXPORT
    1262int SCIPgetNOrigVars(
    1263 SCIP* scip /**< SCIP data structure */
    1264 );
    1265
    1266/** gets number of binary variables in the original problem
    1267 *
    1268 * @return the number of binary variables in the original problem
    1269 *
    1270 * @note This function does not count binary variables which are implied integral.
    1271 *
    1272 * @pre This method can be called if @p scip is in one of the following stages:
    1273 * - \ref SCIP_STAGE_PROBLEM
    1274 * - \ref SCIP_STAGE_TRANSFORMING
    1275 * - \ref SCIP_STAGE_TRANSFORMED
    1276 * - \ref SCIP_STAGE_INITPRESOLVE
    1277 * - \ref SCIP_STAGE_PRESOLVING
    1278 * - \ref SCIP_STAGE_EXITPRESOLVE
    1279 * - \ref SCIP_STAGE_PRESOLVED
    1280 * - \ref SCIP_STAGE_INITSOLVE
    1281 * - \ref SCIP_STAGE_SOLVING
    1282 * - \ref SCIP_STAGE_SOLVED
    1283 * - \ref SCIP_STAGE_EXITSOLVE
    1284 * - \ref SCIP_STAGE_FREETRANS
    1285 */
    1286SCIP_EXPORT
    1287int SCIPgetNOrigBinVars(
    1288 SCIP* scip /**< SCIP data structure */
    1289 );
    1290
    1291/** gets the number of integer variables in the original problem
    1292 *
    1293 * @return the number of integer variables in the original problem
    1294 *
    1295 * @note This function does not count integer variables which are implied integral.
    1296 *
    1297 * @pre This method can be called if @p scip is in one of the following stages:
    1298 * - \ref SCIP_STAGE_PROBLEM
    1299 * - \ref SCIP_STAGE_TRANSFORMING
    1300 * - \ref SCIP_STAGE_TRANSFORMED
    1301 * - \ref SCIP_STAGE_INITPRESOLVE
    1302 * - \ref SCIP_STAGE_PRESOLVING
    1303 * - \ref SCIP_STAGE_EXITPRESOLVE
    1304 * - \ref SCIP_STAGE_PRESOLVED
    1305 * - \ref SCIP_STAGE_INITSOLVE
    1306 * - \ref SCIP_STAGE_SOLVING
    1307 * - \ref SCIP_STAGE_SOLVED
    1308 * - \ref SCIP_STAGE_EXITSOLVE
    1309 * - \ref SCIP_STAGE_FREETRANS
    1310 */
    1311SCIP_EXPORT
    1312int SCIPgetNOrigIntVars(
    1313 SCIP* scip /**< SCIP data structure */
    1314 );
    1315
    1316/** gets number of implied integral variables in the original problem
    1317 *
    1318 * @return the number of implied integral variables in the original problem
    1319 *
    1320 * @note This function counts binary, integer, and continuous variables which are implied integral.
    1321 *
    1322 * @pre This method can be called if @p scip is in one of the following stages:
    1323 * - \ref SCIP_STAGE_PROBLEM
    1324 * - \ref SCIP_STAGE_TRANSFORMING
    1325 * - \ref SCIP_STAGE_TRANSFORMED
    1326 * - \ref SCIP_STAGE_INITPRESOLVE
    1327 * - \ref SCIP_STAGE_PRESOLVING
    1328 * - \ref SCIP_STAGE_EXITPRESOLVE
    1329 * - \ref SCIP_STAGE_PRESOLVED
    1330 * - \ref SCIP_STAGE_INITSOLVE
    1331 * - \ref SCIP_STAGE_SOLVING
    1332 * - \ref SCIP_STAGE_SOLVED
    1333 * - \ref SCIP_STAGE_EXITSOLVE
    1334 * - \ref SCIP_STAGE_FREETRANS
    1335 */
    1336SCIP_EXPORT
    1337int SCIPgetNOrigImplVars(
    1338 SCIP* scip /**< SCIP data structure */
    1339 );
    1340
    1341/** gets number of binary implied integral variables in the original problem
    1342 *
    1343 * @return the number of binary implied integral variables in the original problem
    1344 *
    1345 * @pre This method can be called if @p scip is in one of the following stages:
    1346 * - \ref SCIP_STAGE_PROBLEM
    1347 * - \ref SCIP_STAGE_TRANSFORMING
    1348 * - \ref SCIP_STAGE_TRANSFORMED
    1349 * - \ref SCIP_STAGE_INITPRESOLVE
    1350 * - \ref SCIP_STAGE_PRESOLVING
    1351 * - \ref SCIP_STAGE_EXITPRESOLVE
    1352 * - \ref SCIP_STAGE_PRESOLVED
    1353 * - \ref SCIP_STAGE_INITSOLVE
    1354 * - \ref SCIP_STAGE_SOLVING
    1355 * - \ref SCIP_STAGE_SOLVED
    1356 * - \ref SCIP_STAGE_EXITSOLVE
    1357 * - \ref SCIP_STAGE_FREETRANS
    1358 */
    1359SCIP_EXPORT
    1360int SCIPgetNOrigBinImplVars(
    1361 SCIP* scip /**< SCIP data structure */
    1362 );
    1363
    1364/** gets number of integer implied integral variables in the original problem
    1365 *
    1366 * @return the number of integer implied integral variables in the original problem
    1367 *
    1368 * @pre This method can be called if @p scip is in one of the following stages:
    1369 * - \ref SCIP_STAGE_PROBLEM
    1370 * - \ref SCIP_STAGE_TRANSFORMING
    1371 * - \ref SCIP_STAGE_TRANSFORMED
    1372 * - \ref SCIP_STAGE_INITPRESOLVE
    1373 * - \ref SCIP_STAGE_PRESOLVING
    1374 * - \ref SCIP_STAGE_EXITPRESOLVE
    1375 * - \ref SCIP_STAGE_PRESOLVED
    1376 * - \ref SCIP_STAGE_INITSOLVE
    1377 * - \ref SCIP_STAGE_SOLVING
    1378 * - \ref SCIP_STAGE_SOLVED
    1379 * - \ref SCIP_STAGE_EXITSOLVE
    1380 * - \ref SCIP_STAGE_FREETRANS
    1381 */
    1382SCIP_EXPORT
    1383int SCIPgetNOrigIntImplVars(
    1384 SCIP* scip /**< SCIP data structure */
    1385 );
    1386
    1387/** gets number of continuous implied integral variables in the original problem
    1388 *
    1389 * @return the number of continuous implied integral variables in the original problem
    1390 *
    1391 * @pre This method can be called if @p scip is in one of the following stages:
    1392 * - \ref SCIP_STAGE_PROBLEM
    1393 * - \ref SCIP_STAGE_TRANSFORMING
    1394 * - \ref SCIP_STAGE_TRANSFORMED
    1395 * - \ref SCIP_STAGE_INITPRESOLVE
    1396 * - \ref SCIP_STAGE_PRESOLVING
    1397 * - \ref SCIP_STAGE_EXITPRESOLVE
    1398 * - \ref SCIP_STAGE_PRESOLVED
    1399 * - \ref SCIP_STAGE_INITSOLVE
    1400 * - \ref SCIP_STAGE_SOLVING
    1401 * - \ref SCIP_STAGE_SOLVED
    1402 * - \ref SCIP_STAGE_EXITSOLVE
    1403 * - \ref SCIP_STAGE_FREETRANS
    1404 */
    1405SCIP_EXPORT
    1406int SCIPgetNOrigContImplVars(
    1407 SCIP* scip /**< SCIP data structure */
    1408 );
    1409
    1410/** gets number of continuous variables in the original problem
    1411 *
    1412 * @return the number of continuous variables in the original problem
    1413 *
    1414 * @note This function does not count continuous variables which are implied integral.
    1415 *
    1416 * @pre This method can be called if @p scip is in one of the following stages:
    1417 * - \ref SCIP_STAGE_PROBLEM
    1418 * - \ref SCIP_STAGE_TRANSFORMING
    1419 * - \ref SCIP_STAGE_TRANSFORMED
    1420 * - \ref SCIP_STAGE_INITPRESOLVE
    1421 * - \ref SCIP_STAGE_PRESOLVING
    1422 * - \ref SCIP_STAGE_EXITPRESOLVE
    1423 * - \ref SCIP_STAGE_PRESOLVED
    1424 * - \ref SCIP_STAGE_INITSOLVE
    1425 * - \ref SCIP_STAGE_SOLVING
    1426 * - \ref SCIP_STAGE_SOLVED
    1427 * - \ref SCIP_STAGE_EXITSOLVE
    1428 * - \ref SCIP_STAGE_FREETRANS
    1429 */
    1430SCIP_EXPORT
    1431int SCIPgetNOrigContVars(
    1432 SCIP* scip /**< SCIP data structure */
    1433 );
    1434
    1435/** gets number of all problem variables created during creation and solving of problem;
    1436 * this includes also variables that were deleted in the meantime
    1437 *
    1438 * @return the number of all problem variables created during creation and solving of problem;
    1439 * this includes also variables that were deleted in the meantime
    1440 *
    1441 * @pre This method can be called if @p scip is in one of the following stages:
    1442 * - \ref SCIP_STAGE_PROBLEM
    1443 * - \ref SCIP_STAGE_TRANSFORMING
    1444 * - \ref SCIP_STAGE_TRANSFORMED
    1445 * - \ref SCIP_STAGE_INITPRESOLVE
    1446 * - \ref SCIP_STAGE_PRESOLVING
    1447 * - \ref SCIP_STAGE_EXITPRESOLVE
    1448 * - \ref SCIP_STAGE_PRESOLVED
    1449 * - \ref SCIP_STAGE_INITSOLVE
    1450 * - \ref SCIP_STAGE_SOLVING
    1451 * - \ref SCIP_STAGE_SOLVED
    1452 * - \ref SCIP_STAGE_EXITSOLVE
    1453 * - \ref SCIP_STAGE_FREETRANS
    1454 */
    1455SCIP_EXPORT
    1456int SCIPgetNTotalVars(
    1457 SCIP* scip /**< SCIP data structure */
    1458 );
    1459
    1460/** gets variables of the original or transformed problem along with the numbers of different variable types;
    1461 * the returned problem space (original or transformed) corresponds to the given solution;
    1462 * data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and
    1463 * SCIPmultiaggregateVar()
    1464 *
    1465 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1466 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1467 *
    1468 * @pre This method can be called if @p scip is in one of the following stages:
    1469 * - \ref SCIP_STAGE_PROBLEM
    1470 * - \ref SCIP_STAGE_TRANSFORMED
    1471 * - \ref SCIP_STAGE_INITPRESOLVE
    1472 * - \ref SCIP_STAGE_PRESOLVING
    1473 * - \ref SCIP_STAGE_EXITPRESOLVE
    1474 * - \ref SCIP_STAGE_PRESOLVED
    1475 * - \ref SCIP_STAGE_INITSOLVE
    1476 * - \ref SCIP_STAGE_SOLVING
    1477 * - \ref SCIP_STAGE_SOLVED
    1478 */
    1479SCIP_EXPORT
    1480SCIP_RETCODE SCIPgetSolVarsData(
    1481 SCIP* scip, /**< SCIP data structure */
    1482 SCIP_SOL* sol, /**< primal solution that selects the problem space, NULL for current solution */
    1483 SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
    1484 int* nvars, /**< pointer to store number of variables or NULL if not needed */
    1485 int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
    1486 int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
    1487 int* nbinimplvars, /**< pointer to store number of binary implied integral vars or NULL if not needed */
    1488 int* nintimplvars, /**< pointer to store number of integer implied integral vars or NULL if not needed */
    1489 int* ncontimplvars, /**< pointer to store number of continuous implied integral vars or NULL if not needed */
    1490 int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
    1491 );
    1492
    1493/** returns variable of given name in the problem, or NULL if not existing
    1494 *
    1495 * @return variable of given name in the problem, or NULL if not existing
    1496 *
    1497 * @pre This method can be called if @p scip is in one of the following stages:
    1498 * - \ref SCIP_STAGE_PROBLEM
    1499 * - \ref SCIP_STAGE_TRANSFORMING
    1500 * - \ref SCIP_STAGE_TRANSFORMED
    1501 * - \ref SCIP_STAGE_INITPRESOLVE
    1502 * - \ref SCIP_STAGE_PRESOLVING
    1503 * - \ref SCIP_STAGE_EXITPRESOLVE
    1504 * - \ref SCIP_STAGE_PRESOLVED
    1505 * - \ref SCIP_STAGE_INITSOLVE
    1506 * - \ref SCIP_STAGE_SOLVING
    1507 * - \ref SCIP_STAGE_SOLVED
    1508 * - \ref SCIP_STAGE_EXITSOLVE
    1509 * - \ref SCIP_STAGE_FREETRANS
    1510 */
    1511SCIP_EXPORT
    1512SCIP_VAR* SCIPfindVar(
    1513 SCIP* scip, /**< SCIP data structure */
    1514 const char* name /**< name of variable to find */
    1515 );
    1516
    1517/** returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables,
    1518 * that will be added in pricing and improve the objective value
    1519 *
    1520 * @return TRUE, if all potential variables exist in the problem; FALSE, otherwise
    1521 *
    1522 * @pre This method can be called if @p scip is in one of the following stages:
    1523 * - \ref SCIP_STAGE_TRANSFORMING
    1524 * - \ref SCIP_STAGE_TRANSFORMED
    1525 * - \ref SCIP_STAGE_INITPRESOLVE
    1526 * - \ref SCIP_STAGE_PRESOLVING
    1527 * - \ref SCIP_STAGE_EXITPRESOLVE
    1528 * - \ref SCIP_STAGE_PRESOLVED
    1529 * - \ref SCIP_STAGE_INITSOLVE
    1530 * - \ref SCIP_STAGE_SOLVING
    1531 * - \ref SCIP_STAGE_SOLVED
    1532 * - \ref SCIP_STAGE_EXITSOLVE
    1533 * - \ref SCIP_STAGE_FREETRANS
    1534 */
    1535SCIP_EXPORT
    1536SCIP_Bool SCIPallVarsInProb(
    1537 SCIP* scip /**< SCIP data structure */
    1538 );
    1539
    1540/** adds constraint to the problem; if constraint is only valid locally, it is added to the local subproblem of the
    1541 * current node (and all of its subnodes); otherwise it is added to the global problem;
    1542 * if a local constraint is added at the root node, it is automatically upgraded into a global constraint
    1543 *
    1544 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1545 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1546 *
    1547 * @pre This method can be called if @p scip is in one of the following stages:
    1548 * - \ref SCIP_STAGE_PROBLEM
    1549 * - \ref SCIP_STAGE_TRANSFORMED
    1550 * - \ref SCIP_STAGE_INITPRESOLVE
    1551 * - \ref SCIP_STAGE_PRESOLVING
    1552 * - \ref SCIP_STAGE_EXITPRESOLVE
    1553 * - \ref SCIP_STAGE_PRESOLVED
    1554 * - \ref SCIP_STAGE_INITSOLVE
    1555 * - \ref SCIP_STAGE_SOLVING
    1556 * - \ref SCIP_STAGE_EXITSOLVE
    1557 */
    1558SCIP_EXPORT
    1559SCIP_RETCODE SCIPaddCons(
    1560 SCIP* scip, /**< SCIP data structure */
    1561 SCIP_CONS* cons /**< constraint to add */
    1562 );
    1563
    1564/** adds constraint to the problem and upgrades conflict in the conflict store; if oldcons is valid globally, newcons
    1565 * is added to the global problem; otherwise it is added to the local subproblem of the current node
    1566 *
    1567 * @note must only be called once for both constraints
    1568 *
    1569 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1570 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1571 *
    1572 * @pre this method can be called if @p scip is in one of the following stages:
    1573 * - \ref SCIP_STAGE_PROBLEM
    1574 * - \ref SCIP_STAGE_TRANSFORMED
    1575 * - \ref SCIP_STAGE_INITPRESOLVE
    1576 * - \ref SCIP_STAGE_PRESOLVING
    1577 * - \ref SCIP_STAGE_EXITPRESOLVE
    1578 * - \ref SCIP_STAGE_PRESOLVED
    1579 * - \ref SCIP_STAGE_INITSOLVE
    1580 * - \ref SCIP_STAGE_SOLVING
    1581 * - \ref SCIP_STAGE_EXITSOLVE
    1582 *
    1583 * @note this method will release the upgraded constraint
    1584 */
    1585SCIP_EXPORT
    1586SCIP_RETCODE SCIPaddConsUpgrade(
    1587 SCIP* scip, /**< SCIP data structure */
    1588 SCIP_CONS* oldcons, /**< underlying constraint to upgrade */
    1589 SCIP_CONS** newcons /**< upgraded constraint to add */
    1590 );
    1591
    1592/** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
    1593 * node, where it was added, or from the problem, if it was a problem constraint
    1594 *
    1595 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1596 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1597 *
    1598 * @pre This method can be called if @p scip is in one of the following stages:
    1599 * - \ref SCIP_STAGE_PROBLEM
    1600 * - \ref SCIP_STAGE_INITPRESOLVE
    1601 * - \ref SCIP_STAGE_PRESOLVING
    1602 * - \ref SCIP_STAGE_EXITPRESOLVE
    1603 * - \ref SCIP_STAGE_INITSOLVE
    1604 * - \ref SCIP_STAGE_SOLVING
    1605 * - \ref SCIP_STAGE_EXITSOLVE
    1606 */
    1607SCIP_EXPORT
    1608SCIP_RETCODE SCIPdelCons(
    1609 SCIP* scip, /**< SCIP data structure */
    1610 SCIP_CONS* cons /**< constraint to delete */
    1611 );
    1612
    1613/** returns original constraint of given name in the problem, or NULL if not existing
    1614 *
    1615 * @return original constraint of given name in the problem, or NULL if not existing
    1616 *
    1617 * @pre This method can be called if @p scip is in one of the following stages:
    1618 * - \ref SCIP_STAGE_PROBLEM
    1619 * - \ref SCIP_STAGE_TRANSFORMING
    1620 * - \ref SCIP_STAGE_TRANSFORMED
    1621 * - \ref SCIP_STAGE_INITPRESOLVE
    1622 * - \ref SCIP_STAGE_PRESOLVING
    1623 * - \ref SCIP_STAGE_EXITPRESOLVE
    1624 * - \ref SCIP_STAGE_PRESOLVED
    1625 * - \ref SCIP_STAGE_INITSOLVE
    1626 * - \ref SCIP_STAGE_SOLVING
    1627 * - \ref SCIP_STAGE_SOLVED
    1628 * - \ref SCIP_STAGE_EXITSOLVE
    1629 * - \ref SCIP_STAGE_FREETRANS
    1630 */
    1631SCIP_EXPORT
    1632SCIP_CONS* SCIPfindOrigCons(
    1633 SCIP* scip, /**< SCIP data structure */
    1634 const char* name /**< name of constraint to find */
    1635 );
    1636
    1637/** returns constraint of given name in the problem, or NULL if not existing
    1638 *
    1639 * @return constraint of given name in the problem, or NULL if not existing
    1640 *
    1641 * @pre This method can be called if @p scip is in one of the following stages:
    1642 * - \ref SCIP_STAGE_PROBLEM
    1643 * - \ref SCIP_STAGE_TRANSFORMING
    1644 * - \ref SCIP_STAGE_TRANSFORMED
    1645 * - \ref SCIP_STAGE_INITPRESOLVE
    1646 * - \ref SCIP_STAGE_PRESOLVING
    1647 * - \ref SCIP_STAGE_EXITPRESOLVE
    1648 * - \ref SCIP_STAGE_PRESOLVED
    1649 * - \ref SCIP_STAGE_INITSOLVE
    1650 * - \ref SCIP_STAGE_SOLVING
    1651 * - \ref SCIP_STAGE_SOLVED
    1652 * - \ref SCIP_STAGE_EXITSOLVE
    1653 * - \ref SCIP_STAGE_FREETRANS
    1654 */
    1655SCIP_EXPORT
    1656SCIP_CONS* SCIPfindCons(
    1657 SCIP* scip, /**< SCIP data structure */
    1658 const char* name /**< name of constraint to find */
    1659 );
    1660
    1661/** gets number of upgraded constraints
    1662 *
    1663 * @return number of upgraded constraints
    1664 *
    1665 * @pre This method can be called if @p scip is in one of the following stages:
    1666 * - \ref SCIP_STAGE_PROBLEM
    1667 * - \ref SCIP_STAGE_TRANSFORMED
    1668 * - \ref SCIP_STAGE_INITPRESOLVE
    1669 * - \ref SCIP_STAGE_PRESOLVING
    1670 * - \ref SCIP_STAGE_PRESOLVED
    1671 * - \ref SCIP_STAGE_EXITPRESOLVE
    1672 * - \ref SCIP_STAGE_SOLVING
    1673 * - \ref SCIP_STAGE_SOLVED
    1674 */
    1675SCIP_EXPORT
    1676int SCIPgetNUpgrConss(
    1677 SCIP* scip /**< SCIP data structure */
    1678 );
    1679
    1680/** gets total number of globally valid constraints currently in the problem
    1681 *
    1682 * @return total number of globally valid constraints currently in the problem
    1683 *
    1684 * @pre This method can be called if @p scip is in one of the following stages:
    1685 * - \ref SCIP_STAGE_PROBLEM
    1686 * - \ref SCIP_STAGE_TRANSFORMED
    1687 * - \ref SCIP_STAGE_INITPRESOLVE
    1688 * - \ref SCIP_STAGE_PRESOLVING
    1689 * - \ref SCIP_STAGE_EXITPRESOLVE
    1690 * - \ref SCIP_STAGE_PRESOLVED
    1691 * - \ref SCIP_STAGE_INITSOLVE
    1692 * - \ref SCIP_STAGE_SOLVING
    1693 * - \ref SCIP_STAGE_SOLVED
    1694 */
    1695SCIP_EXPORT
    1696int SCIPgetNConss(
    1697 SCIP* scip /**< SCIP data structure */
    1698 );
    1699
    1700/** gets array of globally valid constraints currently in the problem
    1701 *
    1702 * @return array of globally valid constraints currently in the problem
    1703 *
    1704 * @pre This method can be called if @p scip is in one of the following stages:
    1705 * - \ref SCIP_STAGE_PROBLEM
    1706 * - \ref SCIP_STAGE_TRANSFORMED
    1707 * - \ref SCIP_STAGE_INITPRESOLVE
    1708 * - \ref SCIP_STAGE_PRESOLVING
    1709 * - \ref SCIP_STAGE_EXITPRESOLVE
    1710 * - \ref SCIP_STAGE_PRESOLVED
    1711 * - \ref SCIP_STAGE_INITSOLVE
    1712 * - \ref SCIP_STAGE_SOLVING
    1713 * - \ref SCIP_STAGE_SOLVED
    1714 *
    1715 * @warning If your are using the method SCIPaddCons(), it can happen that the internal constraint array (which is
    1716 * accessed via this method) gets resized. This can invalid the pointer which is returned by this method.
    1717 */
    1718SCIP_EXPORT
    1719SCIP_CONS** SCIPgetConss(
    1720 SCIP* scip /**< SCIP data structure */
    1721 );
    1722
    1723/** gets total number of constraints in the original problem
    1724 *
    1725 * @return total number of constraints in the original problem
    1726 *
    1727 * @pre This method can be called if @p scip is in one of the following stages:
    1728 * - \ref SCIP_STAGE_PROBLEM
    1729 * - \ref SCIP_STAGE_TRANSFORMING
    1730 * - \ref SCIP_STAGE_TRANSFORMED
    1731 * - \ref SCIP_STAGE_INITPRESOLVE
    1732 * - \ref SCIP_STAGE_PRESOLVING
    1733 * - \ref SCIP_STAGE_EXITPRESOLVE
    1734 * - \ref SCIP_STAGE_PRESOLVED
    1735 * - \ref SCIP_STAGE_INITSOLVE
    1736 * - \ref SCIP_STAGE_SOLVING
    1737 * - \ref SCIP_STAGE_SOLVED
    1738 * - \ref SCIP_STAGE_EXITSOLVE
    1739 * - \ref SCIP_STAGE_FREETRANS
    1740 */
    1741SCIP_EXPORT
    1742int SCIPgetNOrigConss(
    1743 SCIP* scip /**< SCIP data structure */
    1744 );
    1745
    1746/** gets array of constraints in the original problem
    1747 *
    1748 * @return array of constraints in the original problem
    1749 *
    1750 * @pre This method can be called if @p scip is in one of the following stages:
    1751 * - \ref SCIP_STAGE_PROBLEM
    1752 * - \ref SCIP_STAGE_TRANSFORMING
    1753 * - \ref SCIP_STAGE_TRANSFORMED
    1754 * - \ref SCIP_STAGE_INITPRESOLVE
    1755 * - \ref SCIP_STAGE_PRESOLVING
    1756 * - \ref SCIP_STAGE_EXITPRESOLVE
    1757 * - \ref SCIP_STAGE_PRESOLVED
    1758 * - \ref SCIP_STAGE_INITSOLVE
    1759 * - \ref SCIP_STAGE_SOLVING
    1760 * - \ref SCIP_STAGE_SOLVED
    1761 * - \ref SCIP_STAGE_EXITSOLVE
    1762 * - \ref SCIP_STAGE_FREETRANS
    1763 */
    1764SCIP_EXPORT
    1765SCIP_CONS** SCIPgetOrigConss(
    1766 SCIP* scip /**< SCIP data structure */
    1767 );
    1768
    1769/** computes the number of check constraint in the current node (loop over all constraint handler and cumulates the
    1770 * number of check constraints)
    1771 *
    1772 * @return returns the number of check constraints
    1773 *
    1774 * @pre This method can be called if @p scip is in one of the following stages:
    1775 * - \ref SCIP_STAGE_TRANSFORMED
    1776 * - \ref SCIP_STAGE_INITPRESOLVE
    1777 * - \ref SCIP_STAGE_PRESOLVING
    1778 * - \ref SCIP_STAGE_EXITPRESOLVE
    1779 * - \ref SCIP_STAGE_PRESOLVED
    1780 * - \ref SCIP_STAGE_INITSOLVE
    1781 * - \ref SCIP_STAGE_SOLVING
    1782 */
    1783SCIP_EXPORT
    1784int SCIPgetNCheckConss(
    1785 SCIP* scip /**< SCIP data structure */
    1786 );
    1787
    1788/**@} */
    1789
    1790/**@addtogroup LocalSubproblemMethods
    1791 *
    1792 * @{
    1793 */
    1794
    1795/** adds a conflict to a given node or globally to the problem if @p node == NULL.
    1796 *
    1797 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1798 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1799 *
    1800 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1801 * - \ref SCIP_STAGE_INITPRESOLVE
    1802 * - \ref SCIP_STAGE_PRESOLVING
    1803 * - \ref SCIP_STAGE_EXITPRESOLVE
    1804 * - \ref SCIP_STAGE_SOLVING
    1805 *
    1806 * @note this method will release the constraint
    1807 */
    1808SCIP_EXPORT
    1809SCIP_RETCODE SCIPaddConflict(
    1810 SCIP* scip, /**< SCIP data structure */
    1811 SCIP_NODE* node, /**< node to add conflict (or NULL if global) */
    1812 SCIP_CONS** cons, /**< constraint representing the conflict */
    1813 SCIP_NODE* validnode, /**< node at which the constraint is valid (or NULL) */
    1814 SCIP_CONFTYPE conftype, /**< type of the conflict */
    1815 SCIP_Bool iscutoffinvolved /**< is a cutoff bound involved in this conflict */
    1816 );
    1817
    1818/** tries to remove conflicts depending on an old cutoff bound if the improvement of the new incumbent is good enough
    1819 *
    1820 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1821 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1822 *
    1823 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1824 * - \ref SCIP_STAGE_PRESOLVING
    1825 * - \ref SCIP_STAGE_SOLVING
    1826 */
    1827SCIP_EXPORT
    1828SCIP_RETCODE SCIPclearConflictStore(
    1829 SCIP* scip, /**< SCIP data structure */
    1830 SCIP_EVENT* event /**< event data */
    1831 );
    1832
    1833/** adds constraint to the given node (and all of its subnodes), even if it is a global constraint;
    1834 * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
    1835 * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
    1836 * only active in a small part of the tree although it is valid in a larger part.
    1837 * In this case, one should pass the more global node where the constraint is valid as "validnode".
    1838 * Note that the same constraint cannot be added twice to the branching tree with different "validnode" parameters.
    1839 * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
    1840 * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
    1841 * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
    1842 *
    1843 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1844 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1845 *
    1846 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1847 * - \ref SCIP_STAGE_INITPRESOLVE
    1848 * - \ref SCIP_STAGE_PRESOLVING
    1849 * - \ref SCIP_STAGE_EXITPRESOLVE
    1850 * - \ref SCIP_STAGE_SOLVING
    1851 */
    1852SCIP_EXPORT
    1853SCIP_RETCODE SCIPaddConsNode(
    1854 SCIP* scip, /**< SCIP data structure */
    1855 SCIP_NODE* node, /**< node to add constraint to */
    1856 SCIP_CONS* cons, /**< constraint to add */
    1857 SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
    1858 );
    1859
    1860/** adds constraint locally to the current node (and all of its subnodes), even if it is a global constraint;
    1861 * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
    1862 * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
    1863 * only active in a small part of the tree although it is valid in a larger part.
    1864 *
    1865 * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
    1866 * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
    1867 * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
    1868 *
    1869 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1870 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1871 *
    1872 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1873 * - \ref SCIP_STAGE_INITPRESOLVE
    1874 * - \ref SCIP_STAGE_PRESOLVING
    1875 * - \ref SCIP_STAGE_EXITPRESOLVE
    1876 * - \ref SCIP_STAGE_SOLVING
    1877 *
    1878 * @note The same constraint cannot be added twice to the branching tree with different "validnode" parameters. This is
    1879 * the case due to internal data structures and performance issues. In such a case you should try to realize your
    1880 * issue using the method SCIPdisableCons() and SCIPenableCons() and control these via the event system of SCIP.
    1881 */
    1882SCIP_EXPORT
    1883SCIP_RETCODE SCIPaddConsLocal(
    1884 SCIP* scip, /**< SCIP data structure */
    1885 SCIP_CONS* cons, /**< constraint to add */
    1886 SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
    1887 );
    1888
    1889/** disables constraint's separation, enforcing, and propagation capabilities at the given node (and all subnodes);
    1890 * if the method is called at the root node, the constraint is globally deleted from the problem;
    1891 * the constraint deletion is being remembered at the given node, s.t. after leaving the node's subtree, the constraint
    1892 * is automatically enabled again, and after entering the node's subtree, it is automatically disabled;
    1893 * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
    1894 * alternatively, use SCIPdisableCons()
    1895 *
    1896 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1897 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1898 *
    1899 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1900 * - \ref SCIP_STAGE_INITPRESOLVE
    1901 * - \ref SCIP_STAGE_PRESOLVING
    1902 * - \ref SCIP_STAGE_EXITPRESOLVE
    1903 * - \ref SCIP_STAGE_SOLVING
    1904 */
    1905SCIP_EXPORT
    1906SCIP_RETCODE SCIPdelConsNode(
    1907 SCIP* scip, /**< SCIP data structure */
    1908 SCIP_NODE* node, /**< node to disable constraint in */
    1909 SCIP_CONS* cons /**< constraint to locally delete */
    1910 );
    1911
    1912/** disables constraint's separation, enforcing, and propagation capabilities at the current node (and all subnodes);
    1913 * if the method is called during problem modification or at the root node, the constraint is globally deleted from
    1914 * the problem;
    1915 * the constraint deletion is being remembered at the current node, s.t. after leaving the current subtree, the
    1916 * constraint is automatically enabled again, and after reentering the current node's subtree, it is automatically
    1917 * disabled again;
    1918 * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
    1919 * alternatively, use SCIPdisableCons()
    1920 *
    1921 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1922 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1923 *
    1924 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1925 * - \ref SCIP_STAGE_PROBLEM
    1926 * - \ref SCIP_STAGE_INITPRESOLVE
    1927 * - \ref SCIP_STAGE_PRESOLVING
    1928 * - \ref SCIP_STAGE_EXITPRESOLVE
    1929 * - \ref SCIP_STAGE_SOLVING
    1930 *
    1931 * @note SCIP stage does not get changed
    1932 *
    1933 */
    1934SCIP_EXPORT
    1935SCIP_RETCODE SCIPdelConsLocal(
    1936 SCIP* scip, /**< SCIP data structure */
    1937 SCIP_CONS* cons /**< constraint to locally delete */
    1938 );
    1939
    1940/** gets estimate of best primal solution w.r.t. original problem contained in current subtree
    1941 *
    1942 * @return estimate of best primal solution w.r.t. original problem contained in current subtree
    1943 *
    1944 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1945 * - \ref SCIP_STAGE_SOLVING
    1946 */
    1947SCIP_EXPORT
    1948SCIP_Real SCIPgetLocalOrigEstimate(
    1949 SCIP* scip /**< SCIP data structure */
    1950 );
    1951
    1952/** gets estimate of best primal solution w.r.t. transformed problem contained in current subtree
    1953 *
    1954 * @return estimate of best primal solution w.r.t. transformed problem contained in current subtree
    1955 *
    1956 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1957 * - \ref SCIP_STAGE_SOLVING
    1958 */
    1959SCIP_EXPORT
    1960SCIP_Real SCIPgetLocalTransEstimate(
    1961 SCIP* scip /**< SCIP data structure */
    1962 );
    1963
    1964/** gets dual bound of current node
    1965 *
    1966 * @return dual bound of current node
    1967 *
    1968 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1969 * - \ref SCIP_STAGE_SOLVING
    1970 */
    1971SCIP_EXPORT
    1972SCIP_Real SCIPgetLocalDualbound(
    1973 SCIP* scip /**< SCIP data structure */
    1974 );
    1975
    1976/** gets lower bound of current node in transformed problem
    1977 *
    1978 * @return lower bound of current node in transformed problem
    1979 *
    1980 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1981 * - \ref SCIP_STAGE_SOLVING
    1982 */
    1983SCIP_EXPORT
    1984SCIP_Real SCIPgetLocalLowerbound(
    1985 SCIP* scip /**< SCIP data structure */
    1986 );
    1987
    1988/** gets dual bound of given node
    1989 *
    1990 * @return dual bound of a given node
    1991 *
    1992 * @pre this method can be called in one of the following stages of the SCIP solving process:
    1993 * - \ref SCIP_STAGE_SOLVING
    1994 */
    1995SCIP_EXPORT
    1996SCIP_Real SCIPgetNodeDualbound(
    1997 SCIP* scip, /**< SCIP data structure */
    1998 SCIP_NODE* node /**< node to get dual bound for */
    1999 );
    2000
    2001/** gets lower bound of given node in transformed problem
    2002 *
    2003 * @return lower bound of given node in transformed problem
    2004 *
    2005 * @pre this method can be called in one of the following stages of the SCIP solving process:
    2006 * - \ref SCIP_STAGE_SOLVING
    2007 */
    2008SCIP_EXPORT
    2009SCIP_Real SCIPgetNodeLowerbound(
    2010 SCIP* scip, /**< SCIP data structure */
    2011 SCIP_NODE* node /**< node to get dual bound for */
    2012 );
    2013
    2014/** if given value is tighter (larger for minimization, smaller for maximization) than the current node's dual bound (in
    2015 * original problem space), sets the current node's dual bound to the new value
    2016 *
    2017 * @note the given new bound has to be a dual bound, i.e., it has to be valid for the original problem.
    2018 *
    2019 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2020 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2021 *
    2022 * @pre this method can be called in one of the following stages of the SCIP solving process:
    2023 * - \ref SCIP_STAGE_PROBLEM
    2024 * - \ref SCIP_STAGE_PRESOLVING
    2025 * - \ref SCIP_STAGE_PRESOLVED
    2026 * - \ref SCIP_STAGE_SOLVING
    2027 */
    2028SCIP_EXPORT
    2029SCIP_RETCODE SCIPupdateLocalDualbound(
    2030 SCIP* scip, /**< SCIP data structure */
    2031 SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
    2032 );
    2033
    2034/** if given value is larger than the current node's lower bound (in transformed problem), sets the current node's
    2035 * lower bound to the new value
    2036 *
    2037 * @note the given new bound has to be a lower bound, i.e., it has to be valid for the transformed problem.
    2038 *
    2039 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2040 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2041 *
    2042 * @pre this method can be called in one of the following stages of the SCIP solving process:
    2043 * - \ref SCIP_STAGE_PRESOLVING
    2044 * - \ref SCIP_STAGE_PRESOLVED
    2045 * - \ref SCIP_STAGE_SOLVING
    2046 */
    2047SCIP_EXPORT
    2048SCIP_RETCODE SCIPupdateLocalLowerbound(
    2049 SCIP* scip, /**< SCIP data structure */
    2050 SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
    2051 );
    2052
    2053/** if given value is tighter (higher for minimization, lower for maximization) than the node's dual bound, sets the
    2054 * node's dual bound to the new value.
    2055 *
    2056 * @note must not be used on a leaf because the node priority queue remains untouched
    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 be called in one of the following stages of the SCIP solving process:
    2062 * - \ref SCIP_STAGE_SOLVING
    2063 */
    2064SCIP_EXPORT
    2065SCIP_RETCODE SCIPupdateNodeDualbound(
    2066 SCIP* scip, /**< SCIP data structure */
    2067 SCIP_NODE* node, /**< node to update dual bound for */
    2068 SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
    2069 );
    2070
    2071/** if given value is higher than the node's lower bound (in transformed problem), sets the node's lower bound to the
    2072 * new value.
    2073 *
    2074 * @note must not be used on a leaf because the node priority queue remains untouched
    2075 *
    2076 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2077 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2078 *
    2079 * @pre this method can be called in one of the following stages of the SCIP solving process:
    2080 * - \ref SCIP_STAGE_SOLVING
    2081 */
    2082SCIP_EXPORT
    2083SCIP_RETCODE SCIPupdateNodeLowerbound(
    2084 SCIP* scip, /**< SCIP data structure */
    2085 SCIP_NODE* node, /**< node to update lower bound for */
    2086 SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
    2087 );
    2088
    2089/** change the node selection priority of the given child
    2090 *
    2091 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    2092 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    2093 *
    2094 * @pre this method can be called in one of the following stages of the SCIP solving process:
    2095 * - \ref SCIP_STAGE_SOLVING
    2096 */
    2097SCIP_EXPORT
    2098SCIP_RETCODE SCIPchgChildPrio(
    2099 SCIP* scip, /**< SCIP data structure */
    2100 SCIP_NODE* child, /**< child to update the node selection priority */
    2101 SCIP_Real priority /**< node selection priority value */
    2102 );
    2103
    2104/**@} */
    2105
    2106#ifdef __cplusplus
    2107}
    2108#endif
    2109
    2110#endif
    def.h
    common defines and data types used in all packages of SCIP
    SCIP_Bool
    #define SCIP_Bool
    Definition: def.h:91
    SCIP_Real
    #define SCIP_Real
    Definition: def.h:156
    SCIPgetNObjVars
    int SCIPgetNObjVars(SCIP *scip)
    Definition: scip_prob.c:2616
    SCIPaddVar
    SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
    Definition: scip_prob.c:1907
    SCIPgetNIntVars
    int SCIPgetNIntVars(SCIP *scip)
    Definition: scip_prob.c:2340
    SCIPpermuteProb
    SCIP_RETCODE SCIPpermuteProb(SCIP *scip, unsigned int randseed, SCIP_Bool permuteconss, SCIP_Bool permutebinvars, SCIP_Bool permuteintvars, SCIP_Bool permutebinimplvars, SCIP_Bool permuteintimplvars, SCIP_Bool permutecontimplvars, SCIP_Bool permutecontvars)
    Definition: scip_prob.c:922
    SCIPaddConsUpgrade
    SCIP_RETCODE SCIPaddConsUpgrade(SCIP *scip, SCIP_CONS *oldcons, SCIP_CONS **newcons)
    Definition: scip_prob.c:3368
    SCIPsetObjIntegral
    SCIP_RETCODE SCIPsetObjIntegral(SCIP *scip)
    Definition: scip_prob.c:1758
    SCIPgetOrigVarsData
    SCIP_RETCODE SCIPgetOrigVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
    Definition: scip_prob.c:2753
    SCIPgetNImplVars
    int SCIPgetNImplVars(SCIP *scip)
    Definition: scip_prob.c:2387
    SCIPgetProbName
    const char * SCIPgetProbName(SCIP *scip)
    Definition: scip_prob.c:1242
    SCIPgetNContVars
    int SCIPgetNContVars(SCIP *scip)
    Definition: scip_prob.c:2569
    SCIPgetNCheckConss
    int SCIPgetNCheckConss(SCIP *scip)
    Definition: scip_prob.c:3762
    SCIPaddPricedVar
    SCIP_RETCODE SCIPaddPricedVar(SCIP *scip, SCIP_VAR *var, SCIP_Real score)
    Definition: scip_prob.c:1984
    SCIPgetOrigObjscale
    SCIP_Real SCIPgetOrigObjscale(SCIP *scip)
    Definition: scip_prob.c:1583
    SCIPgetSolVarsData
    SCIP_RETCODE SCIPgetSolVarsData(SCIP *scip, SCIP_SOL *sol, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nbinimplvars, int *nintimplvars, int *ncontimplvars, int *ncontvars)
    Definition: scip_prob.c:3114
    SCIPwriteOrigProblem
    SCIP_RETCODE SCIPwriteOrigProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
    Definition: scip_prob.c:742
    SCIPsetProbName
    SCIP_RETCODE SCIPsetProbName(SCIP *scip, const char *name)
    Definition: scip_prob.c:1270
    SCIPsetObjlimit
    SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
    Definition: scip_prob.c:1661
    SCIPsetProbDeltrans
    SCIP_RETCODE SCIPsetProbDeltrans(SCIP *scip, SCIP_DECL_PROBDELTRANS((*probdeltrans)))
    Definition: scip_prob.c:244
    SCIPgetTransObjoffset
    SCIP_Real SCIPgetTransObjoffset(SCIP *scip)
    Definition: scip_prob.c:1606
    SCIPgetNBinImplVars
    int SCIPgetNBinImplVars(SCIP *scip)
    Definition: scip_prob.c:2432
    SCIPgetNOrigBinVars
    int SCIPgetNOrigBinVars(SCIP *scip)
    Definition: scip_prob.c:2867
    SCIPgetVarsData
    SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
    Definition: scip_prob.c:2115
    SCIPgetNOrigConss
    int SCIPgetNOrigConss(SCIP *scip)
    Definition: scip_prob.c:3712
    SCIPgetOrigObjoffset
    SCIP_Real SCIPgetOrigObjoffset(SCIP *scip)
    Definition: scip_prob.c:1529
    SCIPgetNOrigContImplVars
    int SCIPgetNOrigContImplVars(SCIP *scip)
    Definition: scip_prob.c:3006
    SCIPgetOrigVars
    SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)
    Definition: scip_prob.c:2811
    SCIPgetNOrigContVars
    int SCIPgetNOrigContVars(SCIP *scip)
    Definition: scip_prob.c:3035
    SCIPsetProbExitsol
    SCIP_RETCODE SCIPsetProbExitsol(SCIP *scip, SCIP_DECL_PROBEXITSOL((*probexitsol)))
    Definition: scip_prob.c:287
    SCIPgetNOrigIntVars
    int SCIPgetNOrigIntVars(SCIP *scip)
    Definition: scip_prob.c:2896
    SCIPgetConss
    SCIP_CONS ** SCIPgetConss(SCIP *scip)
    Definition: scip_prob.c:3666
    SCIPsetProbTrans
    SCIP_RETCODE SCIPsetProbTrans(SCIP *scip, SCIP_DECL_PROBTRANS((*probtrans)))
    Definition: scip_prob.c:223
    SCIPsetProbDelorig
    SCIP_RETCODE SCIPsetProbDelorig(SCIP *scip, SCIP_DECL_PROBDELORIG((*probdelorig)))
    Definition: scip_prob.c:202
    SCIPgetNOrigImplVars
    int SCIPgetNOrigImplVars(SCIP *scip)
    Definition: scip_prob.c:2925
    SCIPgetObjlimit
    SCIP_Real SCIPgetObjlimit(SCIP *scip)
    Definition: scip_prob.c:1731
    SCIPaddObjoffset
    SCIP_RETCODE SCIPaddObjoffset(SCIP *scip, SCIP_Real addval)
    Definition: scip_prob.c:1443
    SCIPgetNUpgrConss
    int SCIPgetNUpgrConss(SCIP *scip)
    Definition: scip_prob.c:3578
    SCIPgetNVars
    int SCIPgetNVars(SCIP *scip)
    Definition: scip_prob.c:2246
    SCIPaddCons
    SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_prob.c:3274
    SCIPchgReoptObjective
    SCIP_RETCODE SCIPchgReoptObjective(SCIP *scip, SCIP_OBJSENSE objsense, SCIP_VAR **vars, SCIP_Real *coefs, int nvars)
    Definition: scip_prob.c:1294
    SCIPfindOrigCons
    SCIP_CONS * SCIPfindOrigCons(SCIP *scip, const char *name)
    Definition: scip_prob.c:3476
    SCIPdelCons
    SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_prob.c:3420
    SCIPgetNConss
    int SCIPgetNConss(SCIP *scip)
    Definition: scip_prob.c:3620
    SCIPfreeProb
    SCIP_RETCODE SCIPfreeProb(SCIP *scip)
    Definition: scip_prob.c:835
    SCIPgetProbData
    SCIP_PROBDATA * SCIPgetProbData(SCIP *scip)
    Definition: scip_prob.c:1139
    SCIPgetVars
    SCIP_VAR ** SCIPgetVars(SCIP *scip)
    Definition: scip_prob.c:2201
    SCIPgetObjNorm
    SCIP_Real SCIPgetObjNorm(SCIP *scip)
    Definition: scip_prob.c:1880
    SCIPallVarsInProb
    SCIP_Bool SCIPallVarsInProb(SCIP *scip)
    Definition: scip_prob.c:3247
    SCIPgetNOrigVars
    int SCIPgetNOrigVars(SCIP *scip)
    Definition: scip_prob.c:2838
    SCIPprintTransProblem
    SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
    Definition: scip_prob.c:696
    SCIPprintOrigProblem
    SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
    Definition: scip_prob.c:652
    SCIPgetNOrigBinImplVars
    int SCIPgetNOrigBinImplVars(SCIP *scip)
    Definition: scip_prob.c:2952
    SCIPsetProbInitsol
    SCIP_RETCODE SCIPsetProbInitsol(SCIP *scip, SCIP_DECL_PROBINITSOL((*probinitsol)))
    Definition: scip_prob.c:265
    SCIPgetNOrigIntImplVars
    int SCIPgetNOrigIntImplVars(SCIP *scip)
    Definition: scip_prob.c:2979
    SCIPgetNIntImplVars
    int SCIPgetNIntImplVars(SCIP *scip)
    Definition: scip_prob.c:2477
    SCIPgetNContImplVars
    int SCIPgetNContImplVars(SCIP *scip)
    Definition: scip_prob.c:2522
    SCIPdelVar
    SCIP_RETCODE SCIPdelVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)
    Definition: scip_prob.c:2041
    SCIPsetObjsense
    SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
    Definition: scip_prob.c:1417
    SCIPaddOrigObjoffset
    SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)
    Definition: scip_prob.c:1486
    SCIPcreateProbBasic
    SCIP_RETCODE SCIPcreateProbBasic(SCIP *scip, const char *name)
    Definition: scip_prob.c:182
    SCIPgetOrigConss
    SCIP_CONS ** SCIPgetOrigConss(SCIP *scip)
    Definition: scip_prob.c:3739
    SCIPgetObjsense
    SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
    Definition: scip_prob.c:1400
    SCIPwriteTransProblem
    SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
    Definition: scip_prob.c:789
    SCIPgetNFixedVars
    int SCIPgetNFixedVars(SCIP *scip)
    Definition: scip_prob.c:2705
    SCIPcreateProb
    SCIP_RETCODE SCIPcreateProb(SCIP *scip, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata)
    Definition: scip_prob.c:119
    SCIPsetProbData
    SCIP_RETCODE SCIPsetProbData(SCIP *scip, SCIP_PROBDATA *probdata)
    Definition: scip_prob.c:1189
    SCIPgetOrigObjoffsetExact
    SCIP_RATIONAL * SCIPgetOrigObjoffsetExact(SCIP *scip)
    Definition: scip_prob.c:1556
    SCIPgetNBinVars
    int SCIPgetNBinVars(SCIP *scip)
    Definition: scip_prob.c:2293
    SCIPgetFixedVars
    SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
    Definition: scip_prob.c:2662
    SCIPgetNTotalVars
    int SCIPgetNTotalVars(SCIP *scip)
    Definition: scip_prob.c:3064
    SCIPgetTransObjscale
    SCIP_Real SCIPgetTransObjscale(SCIP *scip)
    Definition: scip_prob.c:1629
    SCIPsetProbCopy
    SCIP_RETCODE SCIPsetProbCopy(SCIP *scip, SCIP_DECL_PROBCOPY((*probcopy)))
    Definition: scip_prob.c:308
    SCIPisObjIntegral
    SCIP_Bool SCIPisObjIntegral(SCIP *scip)
    Definition: scip_prob.c:1801
    SCIPfindVar
    SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
    Definition: scip_prob.c:3189
    SCIPfindCons
    SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)
    Definition: scip_prob.c:3525
    SCIPaddOrigObjoffsetExact
    SCIP_RETCODE SCIPaddOrigObjoffsetExact(SCIP *scip, SCIP_RATIONAL *addval)
    Definition: scip_prob.c:1465
    SCIPreadProb
    SCIP_RETCODE SCIPreadProb(SCIP *scip, const char *filename, const char *extension)
    Definition: scip_prob.c:341
    SCIPupdateNodeLowerbound
    SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
    Definition: scip_prob.c:4354
    SCIPupdateLocalLowerbound
    SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)
    Definition: scip_prob.c:4289
    SCIPgetNodeDualbound
    SCIP_Real SCIPgetNodeDualbound(SCIP *scip, SCIP_NODE *node)
    Definition: scip_prob.c:4198
    SCIPdelConsNode
    SCIP_RETCODE SCIPdelConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons)
    Definition: scip_prob.c:4017
    SCIPgetLocalOrigEstimate
    SCIP_Real SCIPgetLocalOrigEstimate(SCIP *scip)
    Definition: scip_prob.c:4120
    SCIPdelConsLocal
    SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_prob.c:4067
    SCIPaddConsNode
    SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
    Definition: scip_prob.c:3901
    SCIPclearConflictStore
    SCIP_RETCODE SCIPclearConflictStore(SCIP *scip, SCIP_EVENT *event)
    Definition: scip_prob.c:3864
    SCIPgetLocalLowerbound
    SCIP_Real SCIPgetLocalLowerbound(SCIP *scip)
    Definition: scip_prob.c:4178
    SCIPupdateLocalDualbound
    SCIP_RETCODE SCIPupdateLocalDualbound(SCIP *scip, SCIP_Real newbound)
    Definition: scip_prob.c:4239
    SCIPaddConflict
    SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS **cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
    Definition: scip_prob.c:3806
    SCIPchgChildPrio
    SCIP_RETCODE SCIPchgChildPrio(SCIP *scip, SCIP_NODE *child, SCIP_Real priority)
    Definition: scip_prob.c:4388
    SCIPupdateNodeDualbound
    SCIP_RETCODE SCIPupdateNodeDualbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
    Definition: scip_prob.c:4330
    SCIPgetLocalDualbound
    SCIP_Real SCIPgetLocalDualbound(SCIP *scip)
    Definition: scip_prob.c:4159
    SCIPaddConsLocal
    SCIP_RETCODE SCIPaddConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_NODE *validnode)
    Definition: scip_prob.c:3986
    SCIPgetNodeLowerbound
    SCIP_Real SCIPgetNodeLowerbound(SCIP *scip, SCIP_NODE *node)
    Definition: scip_prob.c:4215
    SCIPgetLocalTransEstimate
    SCIP_Real SCIPgetLocalTransEstimate(SCIP *scip)
    Definition: scip_prob.c:4139
    SCIP_Cons
    Definition: struct_cons.h:47
    SCIP_Event
    Definition: struct_event.h:174
    SCIP_Node
    Definition: struct_tree.h:142
    SCIP_Rational
    Definition: struct_rational.h:47
    SCIP_Sol
    Definition: struct_sol.h:74
    SCIP_Var
    Definition: struct_var.h:262
    type_conflict.h
    type definitions for conflict analysis
    SCIP_CONFTYPE
    enum SCIP_ConflictType SCIP_CONFTYPE
    Definition: type_conflict.h:68
    type_cons.h
    type definitions for constraints and constraint handlers
    type_event.h
    type definitions for managing events
    type_misc.h
    type definitions for miscellaneous datastructures
    type_prob.h
    type definitions for storing and manipulating the main problem
    SCIP_DECL_PROBCOPY
    #define SCIP_DECL_PROBCOPY(x)
    Definition: type_prob.h:150
    SCIP_DECL_PROBDELTRANS
    #define SCIP_DECL_PROBDELTRANS(x)
    Definition: type_prob.h:95
    SCIP_DECL_PROBEXITSOL
    #define SCIP_DECL_PROBEXITSOL(x)
    Definition: type_prob.h:119
    SCIP_PROBDATA
    struct SCIP_ProbData SCIP_PROBDATA
    Definition: type_prob.h:53
    SCIP_DECL_PROBDELORIG
    #define SCIP_DECL_PROBDELORIG(x)
    Definition: type_prob.h:64
    SCIP_DECL_PROBTRANS
    #define SCIP_DECL_PROBTRANS(x)
    Definition: type_prob.h:83
    SCIP_DECL_PROBINITSOL
    #define SCIP_DECL_PROBINITSOL(x)
    Definition: type_prob.h:106
    SCIP_OBJSENSE
    enum SCIP_Objsense SCIP_OBJSENSE
    Definition: type_prob.h:50
    type_rational.h
    type definitions for rational numbers
    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