Scippy

    SCIP

    Solving Constraint Integer Programs

    scip_cons.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_cons.h
    26 * @ingroup PUBLICCOREAPI
    27 * @brief public methods for constraint handler plugins and constraints
    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 * @author Christopher Hojny
    37 */
    38
    39/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
    40
    41#ifndef __SCIP_SCIP_CONS_H__
    42#define __SCIP_SCIP_CONS_H__
    43
    44
    45#include "scip/def.h"
    46#include "scip/type_cons.h"
    47#include "scip/type_heur.h"
    48#include "scip/type_lp.h"
    49#include "scip/type_misc.h"
    50#include "scip/type_result.h"
    51#include "scip/type_retcode.h"
    52#include "scip/type_scip.h"
    53#include "scip/type_sol.h"
    54#include "scip/type_timing.h"
    55#include "scip/type_var.h"
    56
    57/* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
    58 * this structure except the interface methods in scip.c.
    59 * In optimized mode, the structure is included in scip.h, because some of the methods
    60 * are implemented as defines for performance reasons (e.g. the numerical comparisons).
    61 * Additionally, the internal "set.h" is included, such that the defines in set.h are
    62 * available in optimized mode.
    63 */
    64#ifdef NDEBUG
    65#include "scip/struct_scip.h"
    66#include "scip/cons.h"
    67#endif
    68
    69#ifdef __cplusplus
    70extern "C" {
    71#endif
    72
    73/**@addtogroup PublicConshdlrMethods
    74 *
    75 * @{
    76 */
    77
    78/** creates a constraint handler and includes it in SCIP.
    79 *
    80 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    81 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    82 *
    83 * @pre This method can be called if SCIP is in one of the following stages:
    84 * - \ref SCIP_STAGE_INIT
    85 * - \ref SCIP_STAGE_PROBLEM
    86 *
    87 * @note method has all constraint handler callbacks as arguments and is thus changed every time a new
    88 * callback is added
    89 * in future releases; consider using SCIPincludeConshdlrBasic() and setter functions
    90 * if you seek for a method which is less likely to change in future releases
    91 */
    92SCIP_EXPORT
    93SCIP_RETCODE SCIPincludeConshdlr(
    94 SCIP* scip, /**< SCIP data structure */
    95 const char* name, /**< name of constraint handler */
    96 const char* desc, /**< description of constraint handler */
    97 int sepapriority, /**< priority of the constraint handler for separation */
    98 int enfopriority, /**< priority of the constraint handler for constraint enforcing */
    99 int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
    100 int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
    101 int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
    102 int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
    103 * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
    104 int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
    105 SCIP_Bool delaysepa, /**< should separation method be delayed, if other separators found cuts? */
    106 SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
    107 SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
    108 SCIP_PROPTIMING proptiming, /**< positions in the node solving loop where propagation method of constraint handlers should be executed */
    109 SCIP_PRESOLTIMING presoltiming, /**< timing mask of the constraint handler's presolving method */
    110 SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
    111 SCIP_DECL_CONSFREE ((*consfree)), /**< destructor of constraint handler */
    112 SCIP_DECL_CONSINIT ((*consinit)), /**< initialize constraint handler */
    113 SCIP_DECL_CONSEXIT ((*consexit)), /**< deinitialize constraint handler */
    114 SCIP_DECL_CONSINITPRE ((*consinitpre)), /**< presolving initialization method of constraint handler */
    115 SCIP_DECL_CONSEXITPRE ((*consexitpre)), /**< presolving deinitialization method of constraint handler */
    116 SCIP_DECL_CONSINITSOL ((*consinitsol)), /**< solving process initialization method of constraint handler */
    117 SCIP_DECL_CONSEXITSOL ((*consexitsol)), /**< solving process deinitialization method of constraint handler */
    118 SCIP_DECL_CONSDELETE ((*consdelete)), /**< free specific constraint data */
    119 SCIP_DECL_CONSTRANS ((*constrans)), /**< transform constraint data into data belonging to the transformed problem */
    120 SCIP_DECL_CONSINITLP ((*consinitlp)), /**< initialize LP with relaxations of "initial" constraints */
    121 SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
    122 SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
    123 SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
    124 SCIP_DECL_CONSENFORELAX ((*consenforelax)), /**< enforcing constraints for relaxation solutions */
    125 SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
    126 SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
    127 SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
    128 SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method */
    129 SCIP_DECL_CONSRESPROP ((*consresprop)), /**< propagation conflict resolving method */
    130 SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
    131 SCIP_DECL_CONSACTIVE ((*consactive)), /**< activation notification method */
    132 SCIP_DECL_CONSDEACTIVE((*consdeactive)), /**< deactivation notification method */
    133 SCIP_DECL_CONSENABLE ((*consenable)), /**< enabling notification method */
    134 SCIP_DECL_CONSDISABLE ((*consdisable)), /**< disabling notification method */
    135 SCIP_DECL_CONSDELVARS ((*consdelvars)), /**< variable deletion method */
    136 SCIP_DECL_CONSPRINT ((*consprint)), /**< constraint display method */
    137 SCIP_DECL_CONSCOPY ((*conscopy)), /**< constraint copying method */
    138 SCIP_DECL_CONSPARSE ((*consparse)), /**< constraint parsing method */
    139 SCIP_DECL_CONSGETVARS ((*consgetvars)), /**< constraint get variables method */
    140 SCIP_DECL_CONSGETNVARS((*consgetnvars)), /**< constraint get number of variable method */
    141 SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), /**< constraint handler diving solution enforcement method */
    142 SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), /**< constraint permutation symmetry detection graph
    143 * getter method */
    144 SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), /**< constraint signed permutation symmetry
    145 * detection graph getter method */
    146 SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
    147 );
    148
    149/** creates a constraint handler and includes it in SCIP. All non-fundamental (or optional) callbacks will be set to NULL.
    150 * Optional callbacks can be set via specific setter functions, see SCIPsetConshdlrInit(), SCIPsetConshdlrExit(),
    151 * SCIPsetConshdlrCopy(), SCIPsetConshdlrFree(), SCIPsetConshdlrInitsol(), SCIPsetConshdlrExitsol(),
    152 * SCIPsetConshdlrInitpre(), SCIPsetConshdlrExitpre(), SCIPsetConshdlrPresol(), SCIPsetConshdlrDelete(),
    153 * SCIPsetConshdlrDelvars(), SCIPsetConshdlrInitlp(), SCIPsetConshdlrActive(), SCIPsetConshdlrDeactive(),
    154 * SCIPsetConshdlrEnable(), SCIPsetConshdlrDisable(), SCIPsetConshdlrResprop(), SCIPsetConshdlrTrans(),
    155 * SCIPsetConshdlrPrint(), SCIPsetConshdlrParse(), SCIPsetConshdlrGetVars(), SCIPsetConshdlrGetNVars(), and
    156 * SCIPsetConshdlrGetDiveBdChgs().
    157 *
    158 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    159 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    160 *
    161 * @pre This method can be called if SCIP is in one of the following stages:
    162 * - \ref SCIP_STAGE_INIT
    163 * - \ref SCIP_STAGE_PROBLEM
    164 *
    165 * @note if you want to set all callbacks with a single method call, consider using SCIPincludeConshdlr() instead
    166 */
    167SCIP_EXPORT
    168SCIP_RETCODE SCIPincludeConshdlrBasic(
    169 SCIP* scip, /**< SCIP data structure */
    170 SCIP_CONSHDLR** conshdlrptr, /**< reference to a constraint handler pointer, or NULL */
    171 const char* name, /**< name of constraint handler */
    172 const char* desc, /**< description of constraint handler */
    173 int enfopriority, /**< priority of the constraint handler for constraint enforcing */
    174 int chckpriority, /**< priority of the constraint handler for checking feasibility (and propagation) */
    175 int eagerfreq, /**< frequency for using all instead of only the useful constraints in separation,
    176 * propagation and enforcement, -1 for no eager evaluations, 0 for first only */
    177 SCIP_Bool needscons, /**< should the constraint handler be skipped, if no constraints are available? */
    178 SCIP_DECL_CONSENFOLP ((*consenfolp)), /**< enforcing constraints for LP solutions */
    179 SCIP_DECL_CONSENFOPS ((*consenfops)), /**< enforcing constraints for pseudo solutions */
    180 SCIP_DECL_CONSCHECK ((*conscheck)), /**< check feasibility of primal solution */
    181 SCIP_DECL_CONSLOCK ((*conslock)), /**< variable rounding lock method */
    182 SCIP_CONSHDLRDATA* conshdlrdata /**< constraint handler data */
    183 );
    184
    185/** sets all separation related callbacks/parameters of the constraint handler
    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 SCIP is in one of the following stages:
    191 * - \ref SCIP_STAGE_INIT
    192 * - \ref SCIP_STAGE_PROBLEM
    193 */
    194SCIP_EXPORT
    195SCIP_RETCODE SCIPsetConshdlrSepa(
    196 SCIP* scip, /**< SCIP data structure */
    197 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    198 SCIP_DECL_CONSSEPALP ((*conssepalp)), /**< separate cutting planes for LP solution */
    199 SCIP_DECL_CONSSEPASOL ((*conssepasol)), /**< separate cutting planes for arbitrary primal solution */
    200 int sepafreq, /**< frequency for separating cuts; zero means to separate only in the root node */
    201 int sepapriority, /**< priority of the constraint handler for separation */
    202 SCIP_Bool delaysepa /**< should separation method be delayed, if other separators found cuts? */
    203 );
    204
    205/** sets both the propagation callback and the propagation frequency of the constraint handler
    206 *
    207 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    208 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    209 *
    210 * @pre This method can be called if SCIP is in one of the following stages:
    211 * - \ref SCIP_STAGE_INIT
    212 * - \ref SCIP_STAGE_PROBLEM
    213 */
    214SCIP_EXPORT
    215SCIP_RETCODE SCIPsetConshdlrProp(
    216 SCIP* scip, /**< SCIP data structure */
    217 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    218 SCIP_DECL_CONSPROP ((*consprop)), /**< propagate variable domains */
    219 int propfreq, /**< frequency for propagating domains; zero means only preprocessing propagation */
    220 SCIP_Bool delayprop, /**< should propagation method be delayed, if other propagators found reductions? */
    221 SCIP_PROPTIMING proptiming /**< positions in the node solving loop where propagation should be executed */
    222 );
    223
    224/** sets relaxation enforcement method of the constraint handler
    225 *
    226 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    227 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    228 *
    229 * @pre This method can be called if SCIP is in one of the following stages:
    230 * - \ref SCIP_STAGE_INIT
    231 * - \ref SCIP_STAGE_PROBLEM
    232 */
    233SCIP_EXPORT
    234SCIP_RETCODE SCIPsetConshdlrEnforelax(
    235 SCIP* scip, /**< SCIP data structure */
    236 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    237 SCIP_DECL_CONSENFORELAX ((*consenforelax)) /**< enforcement method for relaxation solution of constraint handler (might be NULL) */
    238 );
    239
    240/** sets copy method of both the constraint handler and each associated constraint
    241 *
    242 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    243 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    244 *
    245 * @pre This method can be called if SCIP is in one of the following stages:
    246 * - \ref SCIP_STAGE_INIT
    247 * - \ref SCIP_STAGE_PROBLEM
    248 */
    249SCIP_EXPORT
    250SCIP_RETCODE SCIPsetConshdlrCopy(
    251 SCIP* scip, /**< SCIP data structure */
    252 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    253 SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), /**< copy method of constraint handler or NULL if you don't want to copy your plugin into sub-SCIPs */
    254 SCIP_DECL_CONSCOPY ((*conscopy)) /**< constraint copying method */
    255 );
    256
    257/** sets destructor method of constraint handler
    258 *
    259 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    260 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    261 *
    262 * @pre This method can be called if SCIP is in one of the following stages:
    263 * - \ref SCIP_STAGE_INIT
    264 * - \ref SCIP_STAGE_PROBLEM
    265 */
    266SCIP_EXPORT
    267SCIP_RETCODE SCIPsetConshdlrFree(
    268 SCIP* scip, /**< SCIP data structure */
    269 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    270 SCIP_DECL_CONSFREE ((*consfree)) /**< destructor of constraint handler */
    271 );
    272
    273/** sets initialization method of constraint handler
    274 *
    275 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    276 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    277 *
    278 * @pre This method can be called if SCIP is in one of the following stages:
    279 * - \ref SCIP_STAGE_INIT
    280 * - \ref SCIP_STAGE_PROBLEM
    281 */
    282SCIP_EXPORT
    283SCIP_RETCODE SCIPsetConshdlrInit(
    284 SCIP* scip, /**< SCIP data structure */
    285 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    286 SCIP_DECL_CONSINIT ((*consinit)) /**< initialize constraint handler */
    287 );
    288
    289/** sets deinitialization method of constraint handler
    290 *
    291 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    292 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    293 *
    294 * @pre This method can be called if SCIP is in one of the following stages:
    295 * - \ref SCIP_STAGE_INIT
    296 * - \ref SCIP_STAGE_PROBLEM
    297 */
    298SCIP_EXPORT
    299SCIP_RETCODE SCIPsetConshdlrExit(
    300 SCIP* scip, /**< SCIP data structure */
    301 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    302 SCIP_DECL_CONSEXIT ((*consexit)) /**< deinitialize constraint handler */
    303 );
    304
    305/** sets solving process initialization method of constraint handler
    306 *
    307 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    308 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    309 *
    310 * @pre This method can be called if SCIP is in one of the following stages:
    311 * - \ref SCIP_STAGE_INIT
    312 * - \ref SCIP_STAGE_PROBLEM
    313 */
    314SCIP_EXPORT
    315SCIP_RETCODE SCIPsetConshdlrInitsol(
    316 SCIP* scip, /**< SCIP data structure */
    317 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    318 SCIP_DECL_CONSINITSOL((*consinitsol)) /**< solving process initialization method of constraint handler */
    319 );
    320
    321/** sets solving process deinitialization method of constraint handler
    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 SCIP is in one of the following stages:
    327 * - \ref SCIP_STAGE_INIT
    328 * - \ref SCIP_STAGE_PROBLEM
    329 */
    330SCIP_EXPORT
    331SCIP_RETCODE SCIPsetConshdlrExitsol(
    332 SCIP* scip, /**< SCIP data structure */
    333 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    334 SCIP_DECL_CONSEXITSOL ((*consexitsol))/**< solving process deinitialization method of constraint handler */
    335 );
    336
    337/** sets preprocessing initialization method of constraint handler
    338 *
    339 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    340 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    341 *
    342 * @pre This method can be called if SCIP is in one of the following stages:
    343 * - \ref SCIP_STAGE_INIT
    344 * - \ref SCIP_STAGE_PROBLEM
    345 */
    346SCIP_EXPORT
    347SCIP_RETCODE SCIPsetConshdlrInitpre(
    348 SCIP* scip, /**< SCIP data structure */
    349 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    350 SCIP_DECL_CONSINITPRE((*consinitpre)) /**< preprocessing initialization method of constraint handler */
    351 );
    352
    353/** sets preprocessing deinitialization method of constraint handler
    354 *
    355 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    356 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    357 *
    358 * @pre This method can be called if SCIP is in one of the following stages:
    359 * - \ref SCIP_STAGE_INIT
    360 * - \ref SCIP_STAGE_PROBLEM
    361 */
    362SCIP_EXPORT
    363SCIP_RETCODE SCIPsetConshdlrExitpre(
    364 SCIP* scip, /**< SCIP data structure */
    365 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    366 SCIP_DECL_CONSEXITPRE((*consexitpre)) /**< preprocessing deinitialization method of constraint handler */
    367 );
    368
    369/** sets presolving method of constraint handler
    370 *
    371 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    372 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    373 *
    374 * @pre This method can be called if SCIP is in one of the following stages:
    375 * - \ref SCIP_STAGE_INIT
    376 * - \ref SCIP_STAGE_PROBLEM
    377 */
    378SCIP_EXPORT
    379SCIP_RETCODE SCIPsetConshdlrPresol(
    380 SCIP* scip, /**< SCIP data structure */
    381 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    382 SCIP_DECL_CONSPRESOL ((*conspresol)), /**< presolving method of constraint handler */
    383 int maxprerounds, /**< maximal number of presolving rounds the constraint handler participates in (-1: no limit) */
    384 SCIP_PRESOLTIMING presoltiming /**< timing mask of the constraint handler's presolving method */
    385 );
    386
    387/** sets method of constraint handler to free specific constraint data
    388 *
    389 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    390 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    391 *
    392 * @pre This method can be called if SCIP is in one of the following stages:
    393 * - \ref SCIP_STAGE_INIT
    394 * - \ref SCIP_STAGE_PROBLEM
    395 */
    396SCIP_EXPORT
    397SCIP_RETCODE SCIPsetConshdlrDelete(
    398 SCIP* scip, /**< SCIP data structure */
    399 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    400 SCIP_DECL_CONSDELETE ((*consdelete)) /**< free specific constraint data */
    401 );
    402
    403/** sets method of constraint handler to transform constraint data into data belonging to the transformed problem
    404 *
    405 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    406 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    407 *
    408 * @pre This method can be called if SCIP is in one of the following stages:
    409 * - \ref SCIP_STAGE_INIT
    410 * - \ref SCIP_STAGE_PROBLEM
    411 */
    412SCIP_EXPORT
    413SCIP_RETCODE SCIPsetConshdlrTrans(
    414 SCIP* scip, /**< SCIP data structure */
    415 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    416 SCIP_DECL_CONSTRANS ((*constrans)) /**< transform constraint data into data belonging to the transformed problem */
    417 );
    418
    419/** sets method of constraint handler to initialize LP with relaxations of "initial" constraints
    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 SCIP is in one of the following stages:
    425 * - \ref SCIP_STAGE_INIT
    426 * - \ref SCIP_STAGE_PROBLEM
    427 */
    428SCIP_EXPORT
    429SCIP_RETCODE SCIPsetConshdlrInitlp(
    430 SCIP* scip, /**< SCIP data structure */
    431 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    432 SCIP_DECL_CONSINITLP ((*consinitlp)) /**< initialize LP with relaxations of "initial" constraints */
    433 );
    434
    435/** sets propagation conflict resolving method of constraint handler
    436 *
    437 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    438 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    439 *
    440 * @pre This method can be called if SCIP is in one of the following stages:
    441 * - \ref SCIP_STAGE_INIT
    442 * - \ref SCIP_STAGE_PROBLEM
    443 */
    444SCIP_EXPORT
    445SCIP_RETCODE SCIPsetConshdlrResprop(
    446 SCIP* scip, /**< SCIP data structure */
    447 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    448 SCIP_DECL_CONSRESPROP ((*consresprop)) /**< propagation conflict resolving method */
    449 );
    450
    451/** sets activation notification method of constraint handler
    452 *
    453 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    454 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    455 *
    456 * @pre This method can be called if SCIP is in one of the following stages:
    457 * - \ref SCIP_STAGE_INIT
    458 * - \ref SCIP_STAGE_PROBLEM
    459 */
    460SCIP_EXPORT
    461SCIP_RETCODE SCIPsetConshdlrActive(
    462 SCIP* scip, /**< SCIP data structure */
    463 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    464 SCIP_DECL_CONSACTIVE ((*consactive)) /**< activation notification method */
    465 );
    466
    467/** sets deactivation notification method of constraint handler
    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 SCIP is in one of the following stages:
    473 * - \ref SCIP_STAGE_INIT
    474 * - \ref SCIP_STAGE_PROBLEM
    475 */
    476SCIP_EXPORT
    477SCIP_RETCODE SCIPsetConshdlrDeactive(
    478 SCIP* scip, /**< SCIP data structure */
    479 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    480 SCIP_DECL_CONSDEACTIVE((*consdeactive)) /**< deactivation notification method */
    481 );
    482
    483/** sets enabling notification method of constraint handler
    484 *
    485 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    486 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    487 *
    488 * @pre This method can be called if SCIP is in one of the following stages:
    489 * - \ref SCIP_STAGE_INIT
    490 * - \ref SCIP_STAGE_PROBLEM
    491 */
    492SCIP_EXPORT
    493SCIP_RETCODE SCIPsetConshdlrEnable(
    494 SCIP* scip, /**< SCIP data structure */
    495 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    496 SCIP_DECL_CONSENABLE ((*consenable)) /**< enabling notification method */
    497 );
    498
    499/** sets disabling notification method of constraint handler
    500 *
    501 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    502 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    503 *
    504 * @pre This method can be called if SCIP is in one of the following stages:
    505 * - \ref SCIP_STAGE_INIT
    506 * - \ref SCIP_STAGE_PROBLEM
    507 */
    508SCIP_EXPORT
    509SCIP_RETCODE SCIPsetConshdlrDisable(
    510 SCIP* scip, /**< SCIP data structure */
    511 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    512 SCIP_DECL_CONSDISABLE ((*consdisable)) /**< disabling notification method */
    513 );
    514
    515/** sets variable deletion method of constraint handler
    516 *
    517 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    518 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    519 *
    520 * @pre This method can be called if SCIP is in one of the following stages:
    521 * - \ref SCIP_STAGE_INIT
    522 * - \ref SCIP_STAGE_PROBLEM
    523 */
    524SCIP_EXPORT
    525SCIP_RETCODE SCIPsetConshdlrDelvars(
    526 SCIP* scip, /**< SCIP data structure */
    527 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    528 SCIP_DECL_CONSDELVARS ((*consdelvars)) /**< variable deletion method */
    529 );
    530
    531/** sets constraint display method of constraint handler
    532 *
    533 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    534 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    535 *
    536 * @pre This method can be called if SCIP is in one of the following stages:
    537 * - \ref SCIP_STAGE_INIT
    538 * - \ref SCIP_STAGE_PROBLEM
    539 */
    540SCIP_EXPORT
    541SCIP_RETCODE SCIPsetConshdlrPrint(
    542 SCIP* scip, /**< SCIP data structure */
    543 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    544 SCIP_DECL_CONSPRINT ((*consprint)) /**< constraint display method */
    545 );
    546
    547/** sets constraint parsing method of constraint handler
    548 *
    549 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    550 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    551 *
    552 * @pre This method can be called if SCIP is in one of the following stages:
    553 * - \ref SCIP_STAGE_INIT
    554 * - \ref SCIP_STAGE_PROBLEM
    555 */
    556SCIP_EXPORT
    557SCIP_RETCODE SCIPsetConshdlrParse(
    558 SCIP* scip, /**< SCIP data structure */
    559 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    560 SCIP_DECL_CONSPARSE ((*consparse)) /**< constraint parsing method */
    561 );
    562
    563/** sets constraint variable getter method of constraint handler
    564 *
    565 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    566 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    567 *
    568 * @pre This method can be called if SCIP is in one of the following stages:
    569 * - \ref SCIP_STAGE_INIT
    570 * - \ref SCIP_STAGE_PROBLEM
    571 */
    572SCIP_EXPORT
    573SCIP_RETCODE SCIPsetConshdlrGetVars(
    574 SCIP* scip, /**< SCIP data structure */
    575 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    576 SCIP_DECL_CONSGETVARS ((*consgetvars)) /**< constraint variable getter method */
    577 );
    578
    579/** sets constraint variable number getter method of constraint handler
    580 *
    581 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    582 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    583 *
    584 * @pre This method can be called if SCIP is in one of the following stages:
    585 * - \ref SCIP_STAGE_INIT
    586 * - \ref SCIP_STAGE_PROBLEM
    587 */
    588SCIP_EXPORT
    589SCIP_RETCODE SCIPsetConshdlrGetNVars(
    590 SCIP* scip, /**< SCIP data structure */
    591 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    592 SCIP_DECL_CONSGETNVARS((*consgetnvars)) /**< constraint variable number getter method */
    593 );
    594
    595/** sets diving enforcement method of constraint handler
    596 *
    597 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    598 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    599 *
    600 * @pre This method can be called if SCIP is in one of the following stages:
    601 * - \ref SCIP_STAGE_INIT
    602 * - \ref SCIP_STAGE_PROBLEM
    603 */
    604SCIP_EXPORT
    605SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(
    606 SCIP* scip, /**< SCIP data structure */
    607 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    608 SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)) /**< constraint handler diving solution enforcement method */
    609 );
    610
    611/** sets permutation symmetry detection graph getter method of constraint handler
    612 *
    613 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    614 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    615 *
    616 * @pre This method can be called if SCIP is in one of the following stages:
    617 * - \ref SCIP_STAGE_TRANSFORMED
    618 * - \ref SCIP_STAGE_INITPRESOLVE
    619 * - \ref SCIP_STAGE_PRESOLVING
    620 * - \ref SCIP_STAGE_EXITPRESOLVE
    621 * - \ref SCIP_STAGE_PRESOLVED
    622 * - \ref SCIP_STAGE_INITSOLVE
    623 * - \ref SCIP_STAGE_SOLVING
    624 */
    625SCIP_EXPORT
    626SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(
    627 SCIP* scip, /**< SCIP data structure */
    628 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    629 SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)) /**< constraint permutation symmetry detection graph
    630 * getter method */
    631 );
    632
    633/** sets signed permutation symmetry detection graph getter method of constraint handler
    634 *
    635 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    636 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    637 *
    638 * @pre This method can be called if SCIP is in one of the following stages:
    639 * - \ref SCIP_STAGE_TRANSFORMED
    640 * - \ref SCIP_STAGE_INITPRESOLVE
    641 * - \ref SCIP_STAGE_PRESOLVING
    642 * - \ref SCIP_STAGE_EXITPRESOLVE
    643 * - \ref SCIP_STAGE_PRESOLVED
    644 * - \ref SCIP_STAGE_INITSOLVE
    645 * - \ref SCIP_STAGE_SOLVING
    646 */
    647SCIP_EXPORT
    648SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(
    649 SCIP* scip, /**< SCIP data structure */
    650 SCIP_CONSHDLR* conshdlr, /**< constraint handler */
    651 SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)) /**< constraint signed permutation symmetry
    652 * detection graph getter method */
    653 );
    654
    655/** returns the constraint handler of the given name, or NULL if not existing */
    656SCIP_EXPORT
    657SCIP_CONSHDLR* SCIPfindConshdlr(
    658 SCIP* scip, /**< SCIP data structure */
    659 const char* name /**< name of constraint handler */
    660 );
    661
    662/** returns the array of currently available constraint handlers */
    663SCIP_EXPORT
    664SCIP_CONSHDLR** SCIPgetConshdlrs(
    665 SCIP* scip /**< SCIP data structure */
    666 );
    667
    668/** returns the number of currently available constraint handlers */
    669SCIP_EXPORT
    670int SCIPgetNConshdlrs(
    671 SCIP* scip /**< SCIP data structure */
    672 );
    673
    674/** @} */
    675
    676/**@addtogroup PublicConstraintMethods
    677 *
    678 * @{
    679 */
    680
    681/** creates and captures a constraint of the given constraint handler
    682 *
    683 * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
    684 * be declared feasible even if it violates this particular constraint. This constellation should only be
    685 * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
    686 * to the variable's local bounds.
    687 *
    688 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    689 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    690 *
    691 * @pre This method can be called if @p scip is in one of the following stages:
    692 * - \ref SCIP_STAGE_PROBLEM
    693 * - \ref SCIP_STAGE_TRANSFORMING
    694 * - \ref SCIP_STAGE_INITPRESOLVE
    695 * - \ref SCIP_STAGE_PRESOLVING
    696 * - \ref SCIP_STAGE_EXITPRESOLVE
    697 * - \ref SCIP_STAGE_PRESOLVED
    698 * - \ref SCIP_STAGE_INITSOLVE
    699 * - \ref SCIP_STAGE_SOLVING
    700 * - \ref SCIP_STAGE_EXITSOLVE
    701 *
    702 * @note the constraint gets captured, hence at one point you have to release it using the method SCIPreleaseCons()
    703 */
    704SCIP_EXPORT
    705SCIP_RETCODE SCIPcreateCons(
    706 SCIP* scip, /**< SCIP data structure */
    707 SCIP_CONS** cons, /**< pointer to constraint */
    708 const char* name, /**< name of constraint */
    709 SCIP_CONSHDLR* conshdlr, /**< constraint handler for this constraint */
    710 SCIP_CONSDATA* consdata, /**< data for this specific constraint */
    711 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
    712 * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
    713 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
    714 * Usually set to TRUE. */
    715 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
    716 * TRUE for model constraints, FALSE for additional, redundant constraints. */
    717 SCIP_Bool check, /**< should the constraint be checked for feasibility?
    718 * TRUE for model constraints, FALSE for additional, redundant constraints. */
    719 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
    720 * Usually set to TRUE. */
    721 SCIP_Bool local, /**< is constraint only valid locally?
    722 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
    723 SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
    724 * Usually set to FALSE. In column generation applications, set to TRUE if pricing
    725 * adds coefficients to this constraint. */
    726 SCIP_Bool dynamic, /**< is constraint subject to aging?
    727 * Usually set to FALSE. Set to TRUE for own cuts which
    728 * are separated as constraints. */
    729 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
    730 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
    731 SCIP_Bool stickingatnode /**< should the constraint always be kept at the node where it was added, even
    732 * if it may be moved to a more global node?
    733 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
    734 );
    735
    736/** parses constraint information (in cip format) out of a string; if the parsing process was successful a constraint is
    737 * creates and captures;
    738 *
    739 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    740 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    741 *
    742 * @pre This method can be called if @p scip is in one of the following stages:
    743 * - \ref SCIP_STAGE_PROBLEM
    744 * - \ref SCIP_STAGE_TRANSFORMING
    745 * - \ref SCIP_STAGE_INITPRESOLVE
    746 * - \ref SCIP_STAGE_PRESOLVING
    747 * - \ref SCIP_STAGE_EXITPRESOLVE
    748 * - \ref SCIP_STAGE_PRESOLVED
    749 * - \ref SCIP_STAGE_SOLVING
    750 * - \ref SCIP_STAGE_EXITSOLVE
    751 *
    752 * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
    753 * be declared feasible even if it violates this particular constraint. This constellation should only be
    754 * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
    755 * to the variable's local bounds.
    756 */
    757SCIP_EXPORT
    758SCIP_RETCODE SCIPparseCons(
    759 SCIP* scip, /**< SCIP data structure */
    760 SCIP_CONS** cons, /**< pointer to store constraint */
    761 const char* str, /**< string to parse for constraint */
    762 SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP?
    763 * Usually set to TRUE. Set to FALSE for 'lazy constraints'. */
    764 SCIP_Bool separate, /**< should the constraint be separated during LP processing?
    765 * Usually set to TRUE. */
    766 SCIP_Bool enforce, /**< should the constraint be enforced during node processing?
    767 * TRUE for model constraints, FALSE for additional, redundant constraints. */
    768 SCIP_Bool check, /**< should the constraint be checked for feasibility?
    769 * TRUE for model constraints, FALSE for additional, redundant constraints. */
    770 SCIP_Bool propagate, /**< should the constraint be propagated during node processing?
    771 * Usually set to TRUE. */
    772 SCIP_Bool local, /**< is constraint only valid locally?
    773 * Usually set to FALSE. Has to be set to TRUE, e.g., for branching constraints. */
    774 SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)?
    775 * Usually set to FALSE. In column generation applications, set to TRUE if pricing
    776 * adds coefficients to this constraint. */
    777 SCIP_Bool dynamic, /**< is constraint subject to aging?
    778 * Usually set to FALSE. Set to TRUE for own cuts which
    779 * are separated as constraints. */
    780 SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup?
    781 * Usually set to FALSE. Set to TRUE for 'lazy constraints' and 'user cuts'. */
    782 SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
    783 * if it may be moved to a more global node?
    784 * Usually set to FALSE. Set to TRUE to for constraints that represent node data. */
    785 SCIP_Bool* success /**< pointer to store if the paring process was successful */
    786 );
    787
    788/** increases usage counter of constraint
    789 *
    790 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    791 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    792 *
    793 * @pre This method can be called if @p scip is in one of the following stages:
    794 * - \ref SCIP_STAGE_PROBLEM
    795 * - \ref SCIP_STAGE_TRANSFORMING
    796 * - \ref SCIP_STAGE_TRANSFORMED
    797 * - \ref SCIP_STAGE_INITPRESOLVE
    798 * - \ref SCIP_STAGE_PRESOLVING
    799 * - \ref SCIP_STAGE_EXITPRESOLVE
    800 * - \ref SCIP_STAGE_PRESOLVED
    801 * - \ref SCIP_STAGE_INITSOLVE
    802 * - \ref SCIP_STAGE_SOLVING
    803 * - \ref SCIP_STAGE_SOLVED
    804 */
    805SCIP_EXPORT
    806SCIP_RETCODE SCIPcaptureCons(
    807 SCIP* scip, /**< SCIP data structure */
    808 SCIP_CONS* cons /**< constraint to capture */
    809 );
    810
    811/** decreases usage counter of constraint, if the usage pointer reaches zero the constraint gets freed
    812 *
    813 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    814 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    815 *
    816 * @pre This method can be called if @p scip is in one of the following stages:
    817 * - \ref SCIP_STAGE_PROBLEM
    818 * - \ref SCIP_STAGE_TRANSFORMING
    819 * - \ref SCIP_STAGE_TRANSFORMED
    820 * - \ref SCIP_STAGE_INITPRESOLVE
    821 * - \ref SCIP_STAGE_PRESOLVING
    822 * - \ref SCIP_STAGE_EXITPRESOLVE
    823 * - \ref SCIP_STAGE_PRESOLVED
    824 * - \ref SCIP_STAGE_INITSOLVE
    825 * - \ref SCIP_STAGE_SOLVING
    826 * - \ref SCIP_STAGE_SOLVED
    827 * - \ref SCIP_STAGE_EXITSOLVE
    828 * - \ref SCIP_STAGE_FREETRANS
    829 *
    830 * @note the pointer of the constraint will be NULLed
    831 */
    832SCIP_EXPORT
    833SCIP_RETCODE SCIPreleaseCons(
    834 SCIP* scip, /**< SCIP data structure */
    835 SCIP_CONS** cons /**< pointer to constraint */
    836 );
    837
    838/** change constraint name
    839 *
    840 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    841 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    842 *
    843 * @pre This method can be called if @p scip is in one of the following stages:
    844 * - \ref SCIP_STAGE_PROBLEM
    845 *
    846 * @note to get the current name of a constraint, use SCIPconsGetName() from pub_cons.h
    847 */
    848SCIP_EXPORT
    849SCIP_RETCODE SCIPchgConsName(
    850 SCIP* scip, /**< SCIP data structure */
    851 SCIP_CONS* cons, /**< constraint */
    852 const char* name /**< new name of constraint */
    853 );
    854
    855/** sets the initial flag of the given constraint
    856 *
    857 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    858 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    859 *
    860 * @pre This method can be called if @p scip is in one of the following stages:
    861 * - \ref SCIP_STAGE_PROBLEM
    862 * - \ref SCIP_STAGE_TRANSFORMING
    863 * - \ref SCIP_STAGE_PRESOLVING
    864 * - \ref SCIP_STAGE_PRESOLVED
    865 * - \ref SCIP_STAGE_SOLVING
    866 */
    867SCIP_EXPORT
    868SCIP_RETCODE SCIPsetConsInitial(
    869 SCIP* scip, /**< SCIP data structure */
    870 SCIP_CONS* cons, /**< constraint */
    871 SCIP_Bool initial /**< new value */
    872 );
    873
    874/** sets the separate flag of the given constraint
    875 *
    876 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    877 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    878 *
    879 * @pre This method can be called if @p scip is in one of the following stages:
    880 * - \ref SCIP_STAGE_PROBLEM
    881 * - \ref SCIP_STAGE_TRANSFORMING
    882 * - \ref SCIP_STAGE_PRESOLVING
    883 * - \ref SCIP_STAGE_PRESOLVED
    884 * - \ref SCIP_STAGE_SOLVING
    885 */
    886SCIP_EXPORT
    887SCIP_RETCODE SCIPsetConsSeparated(
    888 SCIP* scip, /**< SCIP data structure */
    889 SCIP_CONS* cons, /**< constraint */
    890 SCIP_Bool separate /**< new value */
    891 );
    892
    893/** sets the enforce flag of the given constraint
    894 *
    895 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    896 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    897 *
    898 * @pre This method can be called if @p scip is in one of the following stages:
    899 * - \ref SCIP_STAGE_PROBLEM
    900 * - \ref SCIP_STAGE_TRANSFORMING
    901 * - \ref SCIP_STAGE_PRESOLVING
    902 * - \ref SCIP_STAGE_PRESOLVED
    903 * - \ref SCIP_STAGE_SOLVING
    904 */
    905SCIP_EXPORT
    906SCIP_RETCODE SCIPsetConsEnforced(
    907 SCIP* scip, /**< SCIP data structure */
    908 SCIP_CONS* cons, /**< constraint */
    909 SCIP_Bool enforce /**< new value */
    910 );
    911
    912/** sets the check flag of the given constraint
    913 *
    914 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    915 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    916 *
    917 * @pre This method can be called if @p scip is in one of the following stages:
    918 * - \ref SCIP_STAGE_PROBLEM
    919 * - \ref SCIP_STAGE_TRANSFORMING
    920 * - \ref SCIP_STAGE_PRESOLVING
    921 * - \ref SCIP_STAGE_PRESOLVED
    922 * - \ref SCIP_STAGE_SOLVING
    923 */
    924SCIP_EXPORT
    925SCIP_RETCODE SCIPsetConsChecked(
    926 SCIP* scip, /**< SCIP data structure */
    927 SCIP_CONS* cons, /**< constraint */
    928 SCIP_Bool check /**< new value */
    929 );
    930
    931/** sets the propagate flag of the given constraint
    932 *
    933 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    934 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    935 *
    936 * @pre This method can be called if @p scip is in one of the following stages:
    937 * - \ref SCIP_STAGE_PROBLEM
    938 * - \ref SCIP_STAGE_TRANSFORMING
    939 * - \ref SCIP_STAGE_PRESOLVING
    940 * - \ref SCIP_STAGE_PRESOLVED
    941 * - \ref SCIP_STAGE_SOLVING
    942 */
    943SCIP_EXPORT
    944SCIP_RETCODE SCIPsetConsPropagated(
    945 SCIP* scip, /**< SCIP data structure */
    946 SCIP_CONS* cons, /**< constraint */
    947 SCIP_Bool propagate /**< new value */
    948 );
    949
    950/** sets the local flag of the given constraint
    951 *
    952 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    953 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    954 *
    955 * @pre This method can be called if @p scip is in one of the following stages:
    956 * - \ref SCIP_STAGE_PROBLEM
    957 * - \ref SCIP_STAGE_TRANSFORMING
    958 * - \ref SCIP_STAGE_INITPRESOLVE
    959 * - \ref SCIP_STAGE_PRESOLVING
    960 * - \ref SCIP_STAGE_PRESOLVED
    961 * - \ref SCIP_STAGE_INITSOLVE
    962 * - \ref SCIP_STAGE_SOLVING
    963 */
    964SCIP_EXPORT
    965SCIP_RETCODE SCIPsetConsLocal(
    966 SCIP* scip, /**< SCIP data structure */
    967 SCIP_CONS* cons, /**< constraint */
    968 SCIP_Bool local /**< new value */
    969 );
    970
    971/** sets the modifiable flag of the given constraint
    972 *
    973 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    974 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    975 *
    976 * @pre This method can be called if @p scip is in one of the following stages:
    977 * - \ref SCIP_STAGE_PROBLEM
    978 * - \ref SCIP_STAGE_TRANSFORMING
    979 * - \ref SCIP_STAGE_PRESOLVING
    980 * - \ref SCIP_STAGE_PRESOLVED
    981 * - \ref SCIP_STAGE_SOLVING
    982 * - \ref SCIP_STAGE_EXITSOLVE
    983 */
    984SCIP_EXPORT
    985SCIP_RETCODE SCIPsetConsModifiable(
    986 SCIP* scip, /**< SCIP data structure */
    987 SCIP_CONS* cons, /**< constraint */
    988 SCIP_Bool modifiable /**< new value */
    989 );
    990
    991/** sets the dynamic flag of the given constraint
    992 *
    993 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    994 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    995 *
    996 * @pre This method can be called if @p scip is in one of the following stages:
    997 * - \ref SCIP_STAGE_PROBLEM
    998 * - \ref SCIP_STAGE_TRANSFORMING
    999 * - \ref SCIP_STAGE_PRESOLVING
    1000 * - \ref SCIP_STAGE_PRESOLVED
    1001 * - \ref SCIP_STAGE_SOLVING
    1002 */
    1003SCIP_EXPORT
    1004SCIP_RETCODE SCIPsetConsDynamic(
    1005 SCIP* scip, /**< SCIP data structure */
    1006 SCIP_CONS* cons, /**< constraint */
    1007 SCIP_Bool dynamic /**< new value */
    1008 );
    1009
    1010/** sets the removable flag of the given constraint
    1011 *
    1012 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1013 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1014 *
    1015 * @pre This method can be called if @p scip is in one of the following stages:
    1016 * - \ref SCIP_STAGE_PROBLEM
    1017 * - \ref SCIP_STAGE_TRANSFORMING
    1018 * - \ref SCIP_STAGE_PRESOLVING
    1019 * - \ref SCIP_STAGE_PRESOLVED
    1020 * - \ref SCIP_STAGE_SOLVING
    1021 */
    1022SCIP_EXPORT
    1023SCIP_RETCODE SCIPsetConsRemovable(
    1024 SCIP* scip, /**< SCIP data structure */
    1025 SCIP_CONS* cons, /**< constraint */
    1026 SCIP_Bool removable /**< new value */
    1027 );
    1028
    1029/** sets the stickingatnode flag of the given constraint
    1030 *
    1031 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1032 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1033 *
    1034 * @pre This method can be called if @p scip is in one of the following stages:
    1035 * - \ref SCIP_STAGE_PROBLEM
    1036 * - \ref SCIP_STAGE_TRANSFORMING
    1037 * - \ref SCIP_STAGE_PRESOLVING
    1038 * - \ref SCIP_STAGE_PRESOLVED
    1039 * - \ref SCIP_STAGE_SOLVING
    1040 */
    1041SCIP_EXPORT
    1042SCIP_RETCODE SCIPsetConsStickingAtNode(
    1043 SCIP* scip, /**< SCIP data structure */
    1044 SCIP_CONS* cons, /**< constraint */
    1045 SCIP_Bool stickingatnode /**< new value */
    1046 );
    1047
    1048/** updates the flags of the first constraint according to the ones of the second constraint
    1049 *
    1050 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1051 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1052 *
    1053 * @pre This method can be called if @p scip is in one of the following stages:
    1054 * - \ref SCIP_STAGE_PROBLEM
    1055 * - \ref SCIP_STAGE_TRANSFORMING
    1056 * - \ref SCIP_STAGE_PRESOLVING
    1057 * - \ref SCIP_STAGE_PRESOLVED
    1058 * - \ref SCIP_STAGE_SOLVING
    1059 */
    1060SCIP_EXPORT
    1061SCIP_RETCODE SCIPupdateConsFlags(
    1062 SCIP* scip, /**< SCIP data structure */
    1063 SCIP_CONS* cons0, /**< constraint that should stay */
    1064 SCIP_CONS* cons1 /**< constraint that should be deleted */
    1065 );
    1066
    1067/** gets and captures transformed constraint of a given constraint; if the constraint is not yet transformed,
    1068 * a new transformed constraint for this constraint is created
    1069 *
    1070 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1071 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1072 *
    1073 * @pre This method can be called if @p scip is in one of the following stages:
    1074 * - \ref SCIP_STAGE_TRANSFORMING
    1075 * - \ref SCIP_STAGE_TRANSFORMED
    1076 * - \ref SCIP_STAGE_INITPRESOLVE
    1077 * - \ref SCIP_STAGE_PRESOLVING
    1078 * - \ref SCIP_STAGE_EXITPRESOLVE
    1079 * - \ref SCIP_STAGE_PRESOLVED
    1080 * - \ref SCIP_STAGE_INITSOLVE
    1081 * - \ref SCIP_STAGE_SOLVING
    1082 */
    1083SCIP_EXPORT
    1084SCIP_RETCODE SCIPtransformCons(
    1085 SCIP* scip, /**< SCIP data structure */
    1086 SCIP_CONS* cons, /**< constraint to get/create transformed constraint for */
    1087 SCIP_CONS** transcons /**< pointer to store the transformed constraint */
    1088 );
    1089
    1090/** gets and captures transformed constraints for an array of constraints;
    1091 * if a constraint in the array is not yet transformed, a new transformed constraint for this constraint is created;
    1092 * it is possible to call this method with conss == transconss
    1093 *
    1094 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1095 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1096 *
    1097 * @pre This method can be called if @p scip is in one of the following stages:
    1098 * - \ref SCIP_STAGE_TRANSFORMING
    1099 * - \ref SCIP_STAGE_TRANSFORMED
    1100 * - \ref SCIP_STAGE_INITPRESOLVE
    1101 * - \ref SCIP_STAGE_PRESOLVING
    1102 * - \ref SCIP_STAGE_EXITPRESOLVE
    1103 * - \ref SCIP_STAGE_PRESOLVED
    1104 * - \ref SCIP_STAGE_INITSOLVE
    1105 * - \ref SCIP_STAGE_SOLVING
    1106 */
    1107SCIP_EXPORT
    1108SCIP_RETCODE SCIPtransformConss(
    1109 SCIP* scip, /**< SCIP data structure */
    1110 int nconss, /**< number of constraints to get/create transformed constraints for */
    1111 SCIP_CONS** conss, /**< array with constraints to get/create transformed constraints for */
    1112 SCIP_CONS** transconss /**< array to store the transformed constraints */
    1113 );
    1114
    1115/** gets corresponding transformed constraint of a given constraint;
    1116 * returns NULL as transcons, if transformed constraint is not yet existing
    1117 *
    1118 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1119 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1120 *
    1121 * @pre This method can be called if @p scip is in one of the following stages:
    1122 * - \ref SCIP_STAGE_TRANSFORMING
    1123 * - \ref SCIP_STAGE_TRANSFORMED
    1124 * - \ref SCIP_STAGE_INITPRESOLVE
    1125 * - \ref SCIP_STAGE_PRESOLVING
    1126 * - \ref SCIP_STAGE_EXITPRESOLVE
    1127 * - \ref SCIP_STAGE_PRESOLVED
    1128 * - \ref SCIP_STAGE_INITSOLVE
    1129 * - \ref SCIP_STAGE_SOLVING
    1130 * - \ref SCIP_STAGE_SOLVED
    1131 * - \ref SCIP_STAGE_EXITSOLVE
    1132 * - \ref SCIP_STAGE_FREETRANS
    1133 */
    1134SCIP_EXPORT
    1135SCIP_RETCODE SCIPgetTransformedCons(
    1136 SCIP* scip, /**< SCIP data structure */
    1137 SCIP_CONS* cons, /**< constraint to get the transformed constraint for */
    1138 SCIP_CONS** transcons /**< pointer to store the transformed constraint */
    1139 );
    1140
    1141/** gets corresponding transformed constraints for an array of constraints;
    1142 * stores NULL in a transconss slot, if the transformed constraint is not yet existing;
    1143 * it is possible to call this method with conss == transconss, but remember that constraints that are not
    1144 * yet transformed will be replaced with NULL
    1145 *
    1146 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1147 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1148 *
    1149 * @pre This method can be called if @p scip is in one of the following stages:
    1150 * - \ref SCIP_STAGE_TRANSFORMING
    1151 * - \ref SCIP_STAGE_TRANSFORMED
    1152 * - \ref SCIP_STAGE_INITPRESOLVE
    1153 * - \ref SCIP_STAGE_PRESOLVING
    1154 * - \ref SCIP_STAGE_EXITPRESOLVE
    1155 * - \ref SCIP_STAGE_PRESOLVED
    1156 * - \ref SCIP_STAGE_INITSOLVE
    1157 * - \ref SCIP_STAGE_SOLVING
    1158 * - \ref SCIP_STAGE_SOLVED
    1159 * - \ref SCIP_STAGE_EXITSOLVE
    1160 * - \ref SCIP_STAGE_FREETRANS
    1161 */
    1162SCIP_EXPORT
    1163SCIP_RETCODE SCIPgetTransformedConss(
    1164 SCIP* scip, /**< SCIP data structure */
    1165 int nconss, /**< number of constraints to get the transformed constraints for */
    1166 SCIP_CONS** conss, /**< constraints to get the transformed constraints for */
    1167 SCIP_CONS** transconss /**< array to store the transformed constraints */
    1168 );
    1169
    1170/** adds given value to age of constraint, but age can never become negative;
    1171 * should be called
    1172 * - in constraint separation, if no cut was found for this constraint,
    1173 * - in constraint enforcing, if constraint was feasible, and
    1174 * - in constraint propagation, if no domain reduction was deduced;
    1175 *
    1176 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1177 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1178 *
    1179 * @pre This method can be called if @p scip is in one of the following stages:
    1180 * - \ref SCIP_STAGE_TRANSFORMED
    1181 * - \ref SCIP_STAGE_PRESOLVING
    1182 * - \ref SCIP_STAGE_PRESOLVED
    1183 * - \ref SCIP_STAGE_SOLVING
    1184 * - \ref SCIP_STAGE_SOLVED
    1185 */
    1186SCIP_EXPORT
    1187SCIP_RETCODE SCIPaddConsAge(
    1188 SCIP* scip, /**< SCIP data structure */
    1189 SCIP_CONS* cons, /**< constraint */
    1190 SCIP_Real deltaage /**< value to add to the constraint's age */
    1191 );
    1192
    1193/** increases age of constraint by 1.0;
    1194 * should be called
    1195 * - in constraint separation, if no cut was found for this constraint,
    1196 * - in constraint enforcing, if constraint was feasible, and
    1197 * - in constraint propagation, if no domain reduction was deduced;
    1198 *
    1199 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1200 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1201 *
    1202 * @pre This method can be called if @p scip is in one of the following stages:
    1203 * - \ref SCIP_STAGE_TRANSFORMED
    1204 * - \ref SCIP_STAGE_PRESOLVING
    1205 * - \ref SCIP_STAGE_PRESOLVED
    1206 * - \ref SCIP_STAGE_SOLVING
    1207 * - \ref SCIP_STAGE_SOLVED
    1208 */
    1209SCIP_EXPORT
    1210SCIP_RETCODE SCIPincConsAge(
    1211 SCIP* scip, /**< SCIP data structure */
    1212 SCIP_CONS* cons /**< constraint */
    1213 );
    1214
    1215/** resets age of constraint to zero;
    1216 * should be called
    1217 * - in constraint separation, if a cut was found for this constraint,
    1218 * - in constraint enforcing, if the constraint was violated, and
    1219 * - in constraint propagation, if a domain reduction was deduced;
    1220 *
    1221 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1222 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1223 *
    1224 * @pre This method can be called if @p scip is in one of the following stages:
    1225 * - \ref SCIP_STAGE_TRANSFORMED
    1226 * - \ref SCIP_STAGE_PRESOLVING
    1227 * - \ref SCIP_STAGE_PRESOLVED
    1228 * - \ref SCIP_STAGE_SOLVING
    1229 * - \ref SCIP_STAGE_SOLVED
    1230 */
    1231SCIP_EXPORT
    1232SCIP_RETCODE SCIPresetConsAge(
    1233 SCIP* scip, /**< SCIP data structure */
    1234 SCIP_CONS* cons /**< constraint */
    1235 );
    1236
    1237/** enables constraint's separation, propagation, and enforcing capabilities
    1238 *
    1239 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1240 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1241 *
    1242 * @pre This method can be called if @p scip is in one of the following stages:
    1243 * - \ref SCIP_STAGE_TRANSFORMED
    1244 * - \ref SCIP_STAGE_PRESOLVING
    1245 * - \ref SCIP_STAGE_PRESOLVED
    1246 * - \ref SCIP_STAGE_INITSOLVE
    1247 * - \ref SCIP_STAGE_SOLVING
    1248 * - \ref SCIP_STAGE_SOLVED
    1249 */
    1250SCIP_EXPORT
    1251SCIP_RETCODE SCIPenableCons(
    1252 SCIP* scip, /**< SCIP data structure */
    1253 SCIP_CONS* cons /**< constraint */
    1254 );
    1255
    1256/** disables constraint's separation, propagation, and enforcing capabilities, s.t. the constraint is not propagated,
    1257 * separated, and enforced anymore until it is enabled again with a call to SCIPenableCons();
    1258 * in contrast to SCIPdelConsLocal() and SCIPdelConsNode(), the disabling is not associated to a node in the tree and
    1259 * does not consume memory; therefore, the constraint is neither automatically enabled on leaving the node nor
    1260 * automatically disabled again on entering the node again;
    1261 * note that the constraints enforcing capabilities are necessary for the solution's feasibility, if the constraint
    1262 * is a model constraint; that means, you must be sure that the constraint cannot be violated in the current subtree,
    1263 * and you have to enable it again manually by calling SCIPenableCons(), if this subtree is left (e.g. by using
    1264 * an appropriate event handler that watches the corresponding variables' domain changes)
    1265 *
    1266 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1267 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1268 *
    1269 * @pre This method can be called if @p scip is in one of the following stages:
    1270 * - \ref SCIP_STAGE_TRANSFORMED
    1271 * - \ref SCIP_STAGE_INITPRESOLVE
    1272 * - \ref SCIP_STAGE_PRESOLVING
    1273 * - \ref SCIP_STAGE_PRESOLVED
    1274 * - \ref SCIP_STAGE_INITSOLVE
    1275 * - \ref SCIP_STAGE_SOLVING
    1276 * - \ref SCIP_STAGE_SOLVED
    1277 */
    1278SCIP_EXPORT
    1279SCIP_RETCODE SCIPdisableCons(
    1280 SCIP* scip, /**< SCIP data structure */
    1281 SCIP_CONS* cons /**< constraint */
    1282 );
    1283
    1284/** enables constraint's separation capabilities
    1285 *
    1286 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1287 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1288 *
    1289 * @pre This method can be called if @p scip is in one of the following stages:
    1290 * - \ref SCIP_STAGE_TRANSFORMED
    1291 * - \ref SCIP_STAGE_PRESOLVING
    1292 * - \ref SCIP_STAGE_PRESOLVED
    1293 * - \ref SCIP_STAGE_INITSOLVE
    1294 * - \ref SCIP_STAGE_SOLVING
    1295 * - \ref SCIP_STAGE_SOLVED
    1296 */
    1297SCIP_EXPORT
    1298SCIP_RETCODE SCIPenableConsSeparation(
    1299 SCIP* scip, /**< SCIP data structure */
    1300 SCIP_CONS* cons /**< constraint */
    1301 );
    1302
    1303/** disables constraint's separation capabilities s.t. the constraint is not propagated anymore until the separation
    1304 * is enabled again with a call to SCIPenableConsSeparation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
    1305 * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
    1306 * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
    1307 *
    1308 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1309 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1310 *
    1311 * @pre This method can be called if @p scip is in one of the following stages:
    1312 * - \ref SCIP_STAGE_TRANSFORMED
    1313 * - \ref SCIP_STAGE_PRESOLVING
    1314 * - \ref SCIP_STAGE_PRESOLVED
    1315 * - \ref SCIP_STAGE_INITSOLVE
    1316 * - \ref SCIP_STAGE_SOLVING
    1317 * - \ref SCIP_STAGE_SOLVED
    1318 */
    1319SCIP_EXPORT
    1320SCIP_RETCODE SCIPdisableConsSeparation(
    1321 SCIP* scip, /**< SCIP data structure */
    1322 SCIP_CONS* cons /**< constraint */
    1323 );
    1324
    1325/** enables constraint's propagation capabilities
    1326 *
    1327 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1328 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1329 *
    1330 * @pre This method can be called if @p scip is in one of the following stages:
    1331 * - \ref SCIP_STAGE_TRANSFORMED
    1332 * - \ref SCIP_STAGE_INITPRESOLVE
    1333 * - \ref SCIP_STAGE_PRESOLVING
    1334 * - \ref SCIP_STAGE_EXITPRESOLVE
    1335 * - \ref SCIP_STAGE_PRESOLVED
    1336 * - \ref SCIP_STAGE_INITSOLVE
    1337 * - \ref SCIP_STAGE_SOLVING
    1338 * - \ref SCIP_STAGE_SOLVED
    1339 */
    1340SCIP_EXPORT
    1341SCIP_RETCODE SCIPenableConsPropagation(
    1342 SCIP* scip, /**< SCIP data structure */
    1343 SCIP_CONS* cons /**< constraint */
    1344 );
    1345
    1346/** disables constraint's propagation capabilities s.t. the constraint is not propagated anymore until the propagation
    1347 * is enabled again with a call to SCIPenableConsPropagation(); in contrast to SCIPdelConsLocal() and SCIPdelConsNode(),
    1348 * the disabling is not associated to a node in the tree and does not consume memory; therefore, the constraint
    1349 * is neither automatically enabled on leaving the node nor automatically disabled again on entering the node again
    1350 *
    1351 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1352 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1353 *
    1354 * @pre This method can be called if @p scip is in one of the following stages:
    1355 * - \ref SCIP_STAGE_TRANSFORMED
    1356 * - \ref SCIP_STAGE_INITPRESOLVE
    1357 * - \ref SCIP_STAGE_PRESOLVING
    1358 * - \ref SCIP_STAGE_EXITPRESOLVE
    1359 * - \ref SCIP_STAGE_PRESOLVED
    1360 * - \ref SCIP_STAGE_INITSOLVE
    1361 * - \ref SCIP_STAGE_SOLVING
    1362 * - \ref SCIP_STAGE_SOLVED
    1363 */
    1364SCIP_EXPORT
    1365SCIP_RETCODE SCIPdisableConsPropagation(
    1366 SCIP* scip, /**< SCIP data structure */
    1367 SCIP_CONS* cons /**< constraint */
    1368 );
    1369
    1370
    1371/** marks constraint to be propagated
    1372 *
    1373 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1374 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1375 *
    1376 * @pre This method can be called if @p scip is in one of the following stages:
    1377 * - \ref SCIP_STAGE_TRANSFORMING
    1378 * - \ref SCIP_STAGE_TRANSFORMED
    1379 * - \ref SCIP_STAGE_PRESOLVING
    1380 * - \ref SCIP_STAGE_EXITPRESOLVE
    1381 * - \ref SCIP_STAGE_PRESOLVED
    1382 * - \ref SCIP_STAGE_INITSOLVE
    1383 * - \ref SCIP_STAGE_SOLVING
    1384 * - \ref SCIP_STAGE_SOLVED
    1385 *
    1386 * @note if a constraint is marked to be propagated, the age of the constraint will be ignored for propagation
    1387 */
    1388SCIP_EXPORT
    1389SCIP_RETCODE SCIPmarkConsPropagate(
    1390 SCIP* scip, /**< SCIP data structure */
    1391 SCIP_CONS* cons /**< constraint */
    1392 );
    1393
    1394/** unmarks the constraint to be propagated
    1395 *
    1396 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1397 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1398 *
    1399 * @pre This method can be called if @p scip is in one of the following stages:
    1400 * - \ref SCIP_STAGE_TRANSFORMED
    1401 * - \ref SCIP_STAGE_PRESOLVING
    1402 * - \ref SCIP_STAGE_EXITPRESOLVE
    1403 * - \ref SCIP_STAGE_PRESOLVED
    1404 * - \ref SCIP_STAGE_INITSOLVE
    1405 * - \ref SCIP_STAGE_SOLVING
    1406 * - \ref SCIP_STAGE_SOLVED
    1407 */
    1408SCIP_EXPORT
    1409SCIP_RETCODE SCIPunmarkConsPropagate(
    1410 SCIP* scip, /**< SCIP data structure */
    1411 SCIP_CONS* cons /**< constraint */
    1412 );
    1413
    1414/** adds given values to lock status of type @p locktype of the constraint and updates the rounding locks of the involved variables
    1415 *
    1416 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1417 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1418 *
    1419 * @pre This method can be called if @p scip is in one of the following stages:
    1420 * - \ref SCIP_STAGE_PROBLEM
    1421 * - \ref SCIP_STAGE_TRANSFORMING
    1422 * - \ref SCIP_STAGE_INITPRESOLVE
    1423 * - \ref SCIP_STAGE_PRESOLVING
    1424 * - \ref SCIP_STAGE_EXITPRESOLVE
    1425 * - \ref SCIP_STAGE_INITSOLVE
    1426 * - \ref SCIP_STAGE_SOLVING
    1427 * - \ref SCIP_STAGE_EXITSOLVE
    1428 * - \ref SCIP_STAGE_FREETRANS
    1429 */
    1430SCIP_EXPORT
    1431SCIP_RETCODE SCIPaddConsLocksType(
    1432 SCIP* scip, /**< SCIP data structure */
    1433 SCIP_CONS* cons, /**< constraint */
    1434 SCIP_LOCKTYPE locktype, /**< type of the variable locks */
    1435 int nlockspos, /**< increase in number of rounding locks for constraint */
    1436 int nlocksneg /**< increase in number of rounding locks for constraint's negation */
    1437 );
    1438
    1439/** adds given values to lock status of the constraint and updates the rounding locks of the involved variables
    1440 *
    1441 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1442 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1443 *
    1444 * @pre This method can be called if @p scip is in one of the following stages:
    1445 * - \ref SCIP_STAGE_PROBLEM
    1446 * - \ref SCIP_STAGE_TRANSFORMING
    1447 * - \ref SCIP_STAGE_INITPRESOLVE
    1448 * - \ref SCIP_STAGE_PRESOLVING
    1449 * - \ref SCIP_STAGE_EXITPRESOLVE
    1450 * - \ref SCIP_STAGE_INITSOLVE
    1451 * - \ref SCIP_STAGE_SOLVING
    1452 * - \ref SCIP_STAGE_EXITSOLVE
    1453 * - \ref SCIP_STAGE_FREETRANS
    1454 *
    1455 * @note This methods always adds locks of type model
    1456 */
    1457SCIP_EXPORT
    1458SCIP_RETCODE SCIPaddConsLocks(
    1459 SCIP* scip, /**< SCIP data structure */
    1460 SCIP_CONS* cons, /**< constraint */
    1461 int nlockspos, /**< increase in number of rounding locks for constraint */
    1462 int nlocksneg /**< increase in number of rounding locks for constraint's negation */
    1463 );
    1464
    1465/** checks single constraint for feasibility of the given solution
    1466 *
    1467 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1468 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1469 *
    1470 * @pre This method can be called if @p scip is in one of the following stages:
    1471 * - \ref SCIP_STAGE_TRANSFORMED
    1472 * - \ref SCIP_STAGE_INITPRESOLVE
    1473 * - \ref SCIP_STAGE_PRESOLVING
    1474 * - \ref SCIP_STAGE_EXITPRESOLVE
    1475 * - \ref SCIP_STAGE_PRESOLVED
    1476 * - \ref SCIP_STAGE_INITSOLVE
    1477 * - \ref SCIP_STAGE_SOLVING
    1478 * - \ref SCIP_STAGE_SOLVED
    1479 */
    1480SCIP_EXPORT
    1481SCIP_RETCODE SCIPcheckCons(
    1482 SCIP* scip, /**< SCIP data structure */
    1483 SCIP_CONS* cons, /**< constraint to check */
    1484 SCIP_SOL* sol, /**< primal CIP solution */
    1485 SCIP_Bool checkintegrality, /**< Has integrality to be checked? */
    1486 SCIP_Bool checklprows, /**< Do constraints represented by rows in the current LP have to be checked? */
    1487 SCIP_Bool printreason, /**< Should the reason for the violation be printed? */
    1488 SCIP_RESULT* result /**< pointer to store the result of the callback method */
    1489 );
    1490
    1491/** enforces single constraint for a given pseudo solution
    1492 *
    1493 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1494 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1495 *
    1496 * @pre This method can be called if @p scip is in one of the following stages:
    1497 * - \ref SCIP_STAGE_SOLVING
    1498 *
    1499 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
    1500 * added to SCIP beforehand.
    1501 */
    1502SCIP_EXPORT
    1503SCIP_RETCODE SCIPenfopsCons(
    1504 SCIP* scip, /**< SCIP data structure */
    1505 SCIP_CONS* cons, /**< constraint to enforce */
    1506 SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
    1507 SCIP_Bool objinfeasible, /**< is the solution infeasible anyway due to violating lower objective bound? */
    1508 SCIP_RESULT* result /**< pointer to store the result of the callback method */
    1509 );
    1510
    1511/** enforces single constraint for a given LP solution
    1512 *
    1513 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1514 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1515 *
    1516 * @pre This method can be called if @p scip is in one of the following stages:
    1517 * - \ref SCIP_STAGE_SOLVING
    1518 *
    1519 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
    1520 * added to SCIP beforehand.
    1521 */
    1522SCIP_EXPORT
    1523SCIP_RETCODE SCIPenfolpCons(
    1524 SCIP* scip, /**< SCIP data structure */
    1525 SCIP_CONS* cons, /**< constraint to enforce */
    1526 SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
    1527 SCIP_RESULT* result /**< pointer to store the result of the callback method */
    1528 );
    1529
    1530/** enforces single constraint for a given relaxation solution
    1531 *
    1532 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1533 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1534 *
    1535 * @pre This method can be called if @p scip is in one of the following stages:
    1536 * - \ref SCIP_STAGE_SOLVING
    1537 *
    1538 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
    1539 * added to SCIP beforehand.
    1540 */
    1541SCIP_RETCODE SCIPenforelaxCons(
    1542 SCIP* scip, /**< SCIP data structure */
    1543 SCIP_CONS* cons, /**< constraint to enforce */
    1544 SCIP_SOL* sol, /**< solution to enforce */
    1545 SCIP_Bool solinfeasible, /**< was the solution already declared infeasible by a constraint handler? */
    1546 SCIP_RESULT* result /**< pointer to store the result of the callback method */
    1547 );
    1548
    1549/** calls LP initialization method for single constraint
    1550 *
    1551 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1552 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1553 *
    1554 * @pre This method can be called if @p scip is in one of the following stages:
    1555 * - \ref SCIP_STAGE_SOLVING
    1556 *
    1557 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
    1558 * added to SCIP beforehand.
    1559 */
    1560SCIP_EXPORT
    1561SCIP_RETCODE SCIPinitlpCons(
    1562 SCIP* scip, /**< SCIP data structure */
    1563 SCIP_CONS* cons, /**< constraint to initialize */
    1564 SCIP_Bool* infeasible /**< pointer to store whether infeasibility was detected while building the LP */
    1565
    1566 );
    1567
    1568/** calls separation method of single constraint for LP solution
    1569 *
    1570 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1571 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1572 *
    1573 * @pre This method can be called if @p scip is in one of the following stages:
    1574 * - \ref SCIP_STAGE_SOLVING
    1575 *
    1576 * @note This is an advanced method and should be used with caution.
    1577 */
    1578SCIP_EXPORT
    1579SCIP_RETCODE SCIPsepalpCons(
    1580 SCIP* scip, /**< SCIP data structure */
    1581 SCIP_CONS* cons, /**< constraint to separate */
    1582 SCIP_RESULT* result /**< pointer to store the result of the separation call */
    1583 );
    1584
    1585/** calls separation method of single constraint for given primal solution
    1586 *
    1587 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1588 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1589 *
    1590 * @pre This method can be called if @p scip is in one of the following stages:
    1591 * - \ref SCIP_STAGE_SOLVING
    1592 *
    1593 * @note This is an advanced method and should be used with caution.
    1594 */
    1595SCIP_EXPORT
    1596SCIP_RETCODE SCIPsepasolCons(
    1597 SCIP* scip, /**< SCIP data structure */
    1598 SCIP_CONS* cons, /**< constraint to separate */
    1599 SCIP_SOL* sol, /**< primal solution that should be separated*/
    1600 SCIP_RESULT* result /**< pointer to store the result of the separation call */
    1601 );
    1602
    1603/** calls domain propagation method of single constraint
    1604 *
    1605 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1606 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1607 *
    1608 * @pre This method can be called if @p scip is in one of the following stages:
    1609 * - \ref SCIP_STAGE_PRESOLVING
    1610 * - \ref SCIP_STAGE_SOLVING
    1611 *
    1612 * @note This is an advanced method and should be used with caution.
    1613 */
    1614SCIP_EXPORT
    1615SCIP_RETCODE SCIPpropCons(
    1616 SCIP* scip, /**< SCIP data structure */
    1617 SCIP_CONS* cons, /**< constraint to propagate */
    1618 SCIP_PROPTIMING proptiming, /**< current point in the node solving loop */
    1619 SCIP_RESULT* result /**< pointer to store the result of the callback method */
    1620 );
    1621
    1622/** resolves propagation conflict of single constraint
    1623 *
    1624 *
    1625 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1626 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1627 *
    1628 * @pre This method can be called if @p scip is in one of the following stages:
    1629 * - \ref SCIP_STAGE_PRESOLVING
    1630 * - \ref SCIP_STAGE_SOLVING
    1631 *
    1632 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
    1633 * added to SCIP beforehand.
    1634 */
    1635SCIP_EXPORT
    1636SCIP_RETCODE SCIPrespropCons(
    1637 SCIP* scip, /**< SCIP data structure */
    1638 SCIP_CONS* cons, /**< constraint to resolve conflict for */
    1639 SCIP_VAR* infervar, /**< the conflict variable whose bound change has to be resolved */
    1640 int inferinfo, /**< the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call */
    1641 SCIP_BOUNDTYPE boundtype, /**< the type of the changed bound (lower or upper bound) */
    1642 SCIP_BDCHGIDX* bdchgidx, /**< the index of the bound change, representing the point of time where the change took place */
    1643 SCIP_Real relaxedbd, /**< the relaxed bound which is sufficient to be explained */
    1644 SCIP_RESULT* result /**< pointer to store the result of the callback method */
    1645 );
    1646
    1647/** presolves of single constraint
    1648 *
    1649 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1650 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1651 *
    1652 * @pre This method can be called if @p scip is in one of the following stages:
    1653 * - \ref SCIP_STAGE_PRESOLVING
    1654 *
    1655 * @note This is an advanced method and should be used with caution.
    1656 */
    1657SCIP_EXPORT
    1658SCIP_RETCODE SCIPpresolCons(
    1659 SCIP* scip, /**< SCIP data structure */
    1660 SCIP_CONS* cons, /**< constraint to presolve */
    1661 int nrounds, /**< number of presolving rounds already done */
    1662 SCIP_PRESOLTIMING presoltiming, /**< presolving timing(s) to be performed */
    1663 int nnewfixedvars, /**< number of variables fixed since the last call to the presolving method */
    1664 int nnewaggrvars, /**< number of variables aggregated since the last call to the presolving method */
    1665 int nnewchgvartypes, /**< number of variable type changes since the last call to the presolving method */
    1666 int nnewchgbds, /**< number of variable bounds tightened since the last call to the presolving method */
    1667 int nnewholes, /**< number of domain holes added since the last call to the presolving method */
    1668 int nnewdelconss, /**< number of deleted constraints since the last call to the presolving method */
    1669 int nnewaddconss, /**< number of added constraints since the last call to the presolving method */
    1670 int nnewupgdconss, /**< number of upgraded constraints since the last call to the presolving method */
    1671 int nnewchgcoefs, /**< number of changed coefficients since the last call to the presolving method */
    1672 int nnewchgsides, /**< number of changed left or right hand sides since the last call to the presolving method */
    1673 int* nfixedvars, /**< pointer to count total number of variables fixed of all presolvers */
    1674 int* naggrvars, /**< pointer to count total number of variables aggregated of all presolvers */
    1675 int* nchgvartypes, /**< pointer to count total number of variable type changes of all presolvers */
    1676 int* nchgbds, /**< pointer to count total number of variable bounds tightened of all presolvers */
    1677 int* naddholes, /**< pointer to count total number of domain holes added of all presolvers */
    1678 int* ndelconss, /**< pointer to count total number of deleted constraints of all presolvers */
    1679 int* naddconss, /**< pointer to count total number of added constraints of all presolvers */
    1680 int* nupgdconss, /**< pointer to count total number of upgraded constraints of all presolvers */
    1681 int* nchgcoefs, /**< pointer to count total number of changed coefficients of all presolvers */
    1682 int* nchgsides, /**< pointer to count total number of changed left/right hand sides of all presolvers */
    1683 SCIP_RESULT* result /**< pointer to store the result of the callback method */
    1684 );
    1685
    1686/** calls constraint activation notification method of single constraint
    1687 *
    1688 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1689 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1690 *
    1691 * @pre This method can be called if @p scip is in one of the following stages:
    1692 * - \ref SCIP_STAGE_TRANSFORMING
    1693 *
    1694 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
    1695 * added to SCIP beforehand.
    1696 */
    1697SCIP_EXPORT
    1698SCIP_RETCODE SCIPactiveCons(
    1699 SCIP* scip, /**< SCIP data structure */
    1700 SCIP_CONS* cons /**< constraint to notify */
    1701 );
    1702
    1703/** calls constraint deactivation notification method of single constraint
    1704 *
    1705 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1706 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1707 *
    1708 * @pre This method can be called if @p scip is in one of the following stages:
    1709 * - \ref SCIP_STAGE_PRESOLVING
    1710 * - \ref SCIP_STAGE_SOLVING
    1711 *
    1712 * @note This is an advanced method and should be used with caution. It may only be called for constraints that were not
    1713 * added to SCIP beforehand.
    1714 */
    1715SCIP_EXPORT
    1716SCIP_RETCODE SCIPdeactiveCons(
    1717 SCIP* scip, /**< SCIP data structure */
    1718 SCIP_CONS* cons /**< constraint to notify */
    1719 );
    1720
    1721/** outputs constraint information to file stream via the message handler system
    1722 *
    1723 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1724 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1725 *
    1726 * @pre This method can be called if @p scip is in one of the following stages:
    1727 * - \ref SCIP_STAGE_PROBLEM
    1728 * - \ref SCIP_STAGE_TRANSFORMING
    1729 * - \ref SCIP_STAGE_TRANSFORMED
    1730 * - \ref SCIP_STAGE_INITPRESOLVE
    1731 * - \ref SCIP_STAGE_PRESOLVING
    1732 * - \ref SCIP_STAGE_EXITPRESOLVE
    1733 * - \ref SCIP_STAGE_PRESOLVED
    1734 * - \ref SCIP_STAGE_INITSOLVE
    1735 * - \ref SCIP_STAGE_SOLVING
    1736 * - \ref SCIP_STAGE_SOLVED
    1737 * - \ref SCIP_STAGE_EXITSOLVE
    1738 * - \ref SCIP_STAGE_FREETRANS
    1739 *
    1740 * @note If the message handler is set to a NULL pointer nothing will be printed.
    1741 * @note The file stream will not be flushed directly, this can be achieved by calling SCIPinfoMessage() printing a
    1742 * newline character.
    1743 */
    1744SCIP_EXPORT
    1745SCIP_RETCODE SCIPprintCons(
    1746 SCIP* scip, /**< SCIP data structure */
    1747 SCIP_CONS* cons, /**< constraint */
    1748 FILE* file /**< output file (or NULL for standard output) */
    1749 );
    1750
    1751/** method to collect the variables of a constraint
    1752 *
    1753 * If the number of variables is greater than the available slots in the variable array, nothing happens except that
    1754 * the success point is set to FALSE. With the method SCIPgetConsNVars() it is possible to get the number of variables
    1755 * a constraint has in its scope.
    1756 *
    1757 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1758 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1759 *
    1760 * @pre This method can be called if @p scip is in one of the following stages:
    1761 * - \ref SCIP_STAGE_PROBLEM
    1762 * - \ref SCIP_STAGE_TRANSFORMING
    1763 * - \ref SCIP_STAGE_TRANSFORMED
    1764 * - \ref SCIP_STAGE_INITPRESOLVE
    1765 * - \ref SCIP_STAGE_PRESOLVING
    1766 * - \ref SCIP_STAGE_EXITPRESOLVE
    1767 * - \ref SCIP_STAGE_PRESOLVED
    1768 * - \ref SCIP_STAGE_INITSOLVE
    1769 * - \ref SCIP_STAGE_SOLVING
    1770 * - \ref SCIP_STAGE_SOLVED
    1771 * - \ref SCIP_STAGE_EXITSOLVE
    1772 * - \ref SCIP_STAGE_FREETRANS
    1773 *
    1774 * @note The success pointer indicates if all variables were copied into the vars arrray.
    1775 *
    1776 * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
    1777 * set to FALSE.
    1778 */
    1779SCIP_EXPORT
    1780SCIP_RETCODE SCIPgetConsVars(
    1781 SCIP* scip, /**< SCIP data structure */
    1782 SCIP_CONS* cons, /**< constraint for which the variables are wanted */
    1783 SCIP_VAR** vars, /**< array to store the involved variable of the constraint */
    1784 int varssize, /**< available slots in vars array which is needed to check if the array is large enough */
    1785 SCIP_Bool* success /**< pointer to store whether the variables are successfully copied */
    1786 );
    1787
    1788/** method to collect the number of variables of a constraint
    1789 *
    1790 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1791 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1792 *
    1793 * @pre This method can be called if @p scip is in one of the following stages:
    1794 * - \ref SCIP_STAGE_PROBLEM
    1795 * - \ref SCIP_STAGE_TRANSFORMING
    1796 * - \ref SCIP_STAGE_TRANSFORMED
    1797 * - \ref SCIP_STAGE_INITPRESOLVE
    1798 * - \ref SCIP_STAGE_PRESOLVING
    1799 * - \ref SCIP_STAGE_EXITPRESOLVE
    1800 * - \ref SCIP_STAGE_PRESOLVED
    1801 * - \ref SCIP_STAGE_INITSOLVE
    1802 * - \ref SCIP_STAGE_SOLVING
    1803 * - \ref SCIP_STAGE_SOLVED
    1804 * - \ref SCIP_STAGE_EXITSOLVE
    1805 * - \ref SCIP_STAGE_FREETRANS
    1806 *
    1807 * @note The success pointer indicates if the contraint handler was able to return the number of variables
    1808 *
    1809 * @note It might be that a constraint handler does not support this functionality, in that case the success pointer is
    1810 * set to FALSE
    1811 */
    1812SCIP_EXPORT
    1813SCIP_RETCODE SCIPgetConsNVars(
    1814 SCIP* scip, /**< SCIP data structure */
    1815 SCIP_CONS* cons, /**< constraint for which the number of variables is wanted */
    1816 int* nvars, /**< pointer to store the number of variables */
    1817 SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the number of variables */
    1818 );
    1819
    1820/** method to get the permutation symmetry detection graph of a constraint
    1821 *
    1822 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1823 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1824 *
    1825 * @pre This method can be called if SCIP is in one of the following stages:
    1826 * - \ref SCIP_STAGE_TRANSFORMED
    1827 * - \ref SCIP_STAGE_INITPRESOLVE
    1828 * - \ref SCIP_STAGE_PRESOLVING
    1829 * - \ref SCIP_STAGE_EXITPRESOLVE
    1830 * - \ref SCIP_STAGE_PRESOLVED
    1831 * - \ref SCIP_STAGE_INITSOLVE
    1832 * - \ref SCIP_STAGE_SOLVING
    1833 */
    1834SCIP_EXPORT
    1835SCIP_RETCODE SCIPgetConsPermsymGraph(
    1836 SCIP* scip, /**< SCIP data structure */
    1837 SCIP_CONS* cons, /**< constraint for which the symmetry graph is requested */
    1838 SYM_GRAPH* graph, /**< symmetry detection graph */
    1839 SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the graph */
    1840 );
    1841
    1842/** method to get the signed permutation symmetry detection graph of a constraint
    1843 *
    1844 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
    1845 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
    1846 *
    1847 * @pre This method can be called if SCIP is in one of the following stages:
    1848 * - \ref SCIP_STAGE_TRANSFORMED
    1849 * - \ref SCIP_STAGE_INITPRESOLVE
    1850 * - \ref SCIP_STAGE_PRESOLVING
    1851 * - \ref SCIP_STAGE_EXITPRESOLVE
    1852 * - \ref SCIP_STAGE_PRESOLVED
    1853 * - \ref SCIP_STAGE_INITSOLVE
    1854 * - \ref SCIP_STAGE_SOLVING
    1855 */
    1856SCIP_EXPORT
    1857SCIP_RETCODE SCIPgetConsSignedPermsymGraph(
    1858 SCIP* scip, /**< SCIP data structure */
    1859 SCIP_CONS* cons, /**< constraint for which the symmetry graph is requested */
    1860 SYM_GRAPH* graph, /**< symmetry detection graph */
    1861 SCIP_Bool* success /**< pointer to store whether the constraint successfully returned the graph */
    1862 );
    1863
    1864/* In optimized mode, the function calls are overwritten by defines to reduce the number of function calls and
    1865 * speed up the algorithms.
    1866 */
    1867#ifdef NDEBUG
    1868#define SCIPmarkConsPropagate(scip, cons) SCIPconsMarkPropagate(cons, (scip)->set)
    1869#endif
    1870
    1871/**@} */
    1872
    1873#ifdef __cplusplus
    1874}
    1875#endif
    1876
    1877#endif
    SCIP_DECL_CONSENFOPS
    SCIP_DECL_CONSENFOPS(ConshdlrSubtour::scip_enfops)
    Definition: ConshdlrSubtour.cpp:394
    SCIP_DECL_CONSSEPASOL
    SCIP_DECL_CONSSEPASOL(ConshdlrSubtour::scip_sepasol)
    Definition: ConshdlrSubtour.cpp:312
    SCIP_DECL_CONSLOCK
    SCIP_DECL_CONSLOCK(ConshdlrSubtour::scip_lock)
    Definition: ConshdlrSubtour.cpp:534
    SCIP_DECL_CONSDELETE
    SCIP_DECL_CONSDELETE(ConshdlrSubtour::scip_delete)
    Definition: ConshdlrSubtour.cpp:232
    SCIP_DECL_CONSCOPY
    SCIP_DECL_CONSCOPY(ConshdlrSubtour::scip_copy)
    Definition: ConshdlrSubtour.cpp:603
    SCIP_DECL_CONSSEPALP
    SCIP_DECL_CONSSEPALP(ConshdlrSubtour::scip_sepalp)
    Definition: ConshdlrSubtour.cpp:285
    SCIP_DECL_CONSTRANS
    SCIP_DECL_CONSTRANS(ConshdlrSubtour::scip_trans)
    Definition: ConshdlrSubtour.cpp:244
    SCIP_DECL_CONSDELVARS
    SCIP_DECL_CONSDELVARS(ConshdlrSubtour::scip_delvars)
    Definition: ConshdlrSubtour.cpp:564
    SCIP_DECL_CONSPRINT
    SCIP_DECL_CONSPRINT(ConshdlrSubtour::scip_print)
    Definition: ConshdlrSubtour.cpp:574
    SCIP_DECL_CONSCHECK
    SCIP_DECL_CONSCHECK(ConshdlrSubtour::scip_check)
    Definition: ConshdlrSubtour.cpp:429
    SCIP_DECL_CONSPROP
    SCIP_DECL_CONSPROP(ConshdlrSubtour::scip_prop)
    Definition: ConshdlrSubtour.cpp:476
    SCIP_DECL_CONSENFOLP
    SCIP_DECL_CONSENFOLP(ConshdlrSubtour::scip_enfolp)
    Definition: ConshdlrSubtour.cpp:350
    cons.h
    internal methods for constraints and constraint handlers
    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
    SCIPsetConshdlrParse
    SCIP_RETCODE SCIPsetConshdlrParse(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPARSE((*consparse)))
    Definition: scip_cons.c:808
    SCIPsetConshdlrEnable
    SCIP_RETCODE SCIPsetConshdlrEnable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENABLE((*consenable)))
    Definition: scip_cons.c:716
    SCIPsetConshdlrPresol
    SCIP_RETCODE SCIPsetConshdlrPresol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRESOL((*conspresol)), int maxprerounds, SCIP_PRESOLTIMING presoltiming)
    Definition: scip_cons.c:540
    SCIPsetConshdlrInit
    SCIP_RETCODE SCIPsetConshdlrInit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINIT((*consinit)))
    Definition: scip_cons.c:396
    SCIPsetConshdlrGetVars
    SCIP_RETCODE SCIPsetConshdlrGetVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETVARS((*consgetvars)))
    Definition: scip_cons.c:831
    SCIPsetConshdlrInitpre
    SCIP_RETCODE SCIPsetConshdlrInitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITPRE((*consinitpre)))
    Definition: scip_cons.c:492
    SCIPsetConshdlrSepa
    SCIP_RETCODE SCIPsetConshdlrSepa(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), int sepafreq, int sepapriority, SCIP_Bool delaysepa)
    Definition: scip_cons.c:235
    SCIPsetConshdlrProp
    SCIP_RETCODE SCIPsetConshdlrProp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPROP((*consprop)), int propfreq, SCIP_Bool delayprop, SCIP_PROPTIMING proptiming)
    Definition: scip_cons.c:281
    SCIPgetNConshdlrs
    int SCIPgetNConshdlrs(SCIP *scip)
    Definition: scip_cons.c:964
    SCIPincludeConshdlrBasic
    SCIP_RETCODE SCIPincludeConshdlrBasic(SCIP *scip, SCIP_CONSHDLR **conshdlrptr, const char *name, const char *desc, int enfopriority, int chckpriority, int eagerfreq, SCIP_Bool needscons, SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_CONSHDLRDATA *conshdlrdata)
    Definition: scip_cons.c:181
    SCIPsetConshdlrDisable
    SCIP_RETCODE SCIPsetConshdlrDisable(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDISABLE((*consdisable)))
    Definition: scip_cons.c:739
    SCIPsetConshdlrDeactive
    SCIP_RETCODE SCIPsetConshdlrDeactive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDEACTIVE((*consdeactive)))
    Definition: scip_cons.c:693
    SCIPsetConshdlrGetPermsymGraph
    SCIP_RETCODE SCIPsetConshdlrGetPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)))
    Definition: scip_cons.c:900
    SCIPsetConshdlrDelete
    SCIP_RETCODE SCIPsetConshdlrDelete(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELETE((*consdelete)))
    Definition: scip_cons.c:578
    SCIPsetConshdlrFree
    SCIP_RETCODE SCIPsetConshdlrFree(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSFREE((*consfree)))
    Definition: scip_cons.c:372
    SCIPsetConshdlrEnforelax
    SCIP_RETCODE SCIPsetConshdlrEnforelax(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSENFORELAX((*consenforelax)))
    Definition: scip_cons.c:323
    SCIPsetConshdlrGetDiveBdChgs
    SCIP_RETCODE SCIPsetConshdlrGetDiveBdChgs(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)))
    Definition: scip_cons.c:877
    SCIPsetConshdlrExit
    SCIP_RETCODE SCIPsetConshdlrExit(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXIT((*consexit)))
    Definition: scip_cons.c:420
    SCIPsetConshdlrExitpre
    SCIP_RETCODE SCIPsetConshdlrExitpre(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITPRE((*consexitpre)))
    Definition: scip_cons.c:516
    SCIPsetConshdlrCopy
    SCIP_RETCODE SCIPsetConshdlrCopy(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSCOPY((*conscopy)))
    Definition: scip_cons.c:347
    SCIPfindConshdlr
    SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
    Definition: scip_cons.c:940
    SCIPsetConshdlrGetSignedPermsymGraph
    SCIP_RETCODE SCIPsetConshdlrGetSignedPermsymGraph(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)))
    Definition: scip_cons.c:924
    SCIPsetConshdlrExitsol
    SCIP_RETCODE SCIPsetConshdlrExitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSEXITSOL((*consexitsol)))
    Definition: scip_cons.c:468
    SCIPsetConshdlrDelvars
    SCIP_RETCODE SCIPsetConshdlrDelvars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSDELVARS((*consdelvars)))
    Definition: scip_cons.c:762
    SCIPsetConshdlrInitlp
    SCIP_RETCODE SCIPsetConshdlrInitlp(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITLP((*consinitlp)))
    Definition: scip_cons.c:624
    SCIPsetConshdlrInitsol
    SCIP_RETCODE SCIPsetConshdlrInitsol(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSINITSOL((*consinitsol)))
    Definition: scip_cons.c:444
    SCIPsetConshdlrTrans
    SCIP_RETCODE SCIPsetConshdlrTrans(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSTRANS((*constrans)))
    Definition: scip_cons.c:601
    SCIPsetConshdlrResprop
    SCIP_RETCODE SCIPsetConshdlrResprop(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSRESPROP((*consresprop)))
    Definition: scip_cons.c:647
    SCIPsetConshdlrGetNVars
    SCIP_RETCODE SCIPsetConshdlrGetNVars(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSGETNVARS((*consgetnvars)))
    Definition: scip_cons.c:854
    SCIPincludeConshdlr
    SCIP_RETCODE SCIPincludeConshdlr(SCIP *scip, const char *name, const char *desc, int sepapriority, int enfopriority, int chckpriority, int sepafreq, int propfreq, int eagerfreq, int maxprerounds, SCIP_Bool delaysepa, SCIP_Bool delayprop, SCIP_Bool needscons, SCIP_PROPTIMING proptiming, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_CONSHDLRCOPY((*conshdlrcopy)), SCIP_DECL_CONSFREE((*consfree)), SCIP_DECL_CONSINIT((*consinit)), SCIP_DECL_CONSEXIT((*consexit)), SCIP_DECL_CONSINITPRE((*consinitpre)), SCIP_DECL_CONSEXITPRE((*consexitpre)), SCIP_DECL_CONSINITSOL((*consinitsol)), SCIP_DECL_CONSEXITSOL((*consexitsol)), SCIP_DECL_CONSDELETE((*consdelete)), SCIP_DECL_CONSTRANS((*constrans)), SCIP_DECL_CONSINITLP((*consinitlp)), SCIP_DECL_CONSSEPALP((*conssepalp)), SCIP_DECL_CONSSEPASOL((*conssepasol)), SCIP_DECL_CONSENFOLP((*consenfolp)), SCIP_DECL_CONSENFORELAX((*consenforelax)), SCIP_DECL_CONSENFOPS((*consenfops)), SCIP_DECL_CONSCHECK((*conscheck)), SCIP_DECL_CONSPROP((*consprop)), SCIP_DECL_CONSPRESOL((*conspresol)), SCIP_DECL_CONSRESPROP((*consresprop)), SCIP_DECL_CONSLOCK((*conslock)), SCIP_DECL_CONSACTIVE((*consactive)), SCIP_DECL_CONSDEACTIVE((*consdeactive)), SCIP_DECL_CONSENABLE((*consenable)), SCIP_DECL_CONSDISABLE((*consdisable)), SCIP_DECL_CONSDELVARS((*consdelvars)), SCIP_DECL_CONSPRINT((*consprint)), SCIP_DECL_CONSCOPY((*conscopy)), SCIP_DECL_CONSPARSE((*consparse)), SCIP_DECL_CONSGETVARS((*consgetvars)), SCIP_DECL_CONSGETNVARS((*consgetnvars)), SCIP_DECL_CONSGETDIVEBDCHGS((*consgetdivebdchgs)), SCIP_DECL_CONSGETPERMSYMGRAPH((*consgetpermsymgraph)), SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH((*consgetsignedpermsymgraph)), SCIP_CONSHDLRDATA *conshdlrdata)
    Definition: scip_cons.c:83
    SCIPsetConshdlrActive
    SCIP_RETCODE SCIPsetConshdlrActive(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSACTIVE((*consactive)))
    Definition: scip_cons.c:670
    SCIPgetConshdlrs
    SCIP_CONSHDLR ** SCIPgetConshdlrs(SCIP *scip)
    Definition: scip_cons.c:953
    SCIPsetConshdlrPrint
    SCIP_RETCODE SCIPsetConshdlrPrint(SCIP *scip, SCIP_CONSHDLR *conshdlr, SCIP_DECL_CONSPRINT((*consprint)))
    Definition: scip_cons.c:785
    SCIPgetConsNVars
    SCIP_RETCODE SCIPgetConsNVars(SCIP *scip, SCIP_CONS *cons, int *nvars, SCIP_Bool *success)
    Definition: scip_cons.c:2621
    SCIPgetConsSignedPermsymGraph
    SCIP_RETCODE SCIPgetConsSignedPermsymGraph(SCIP *scip, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
    Definition: scip_cons.c:2687
    SCIPenfopsCons
    SCIP_RETCODE SCIPenfopsCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT *result)
    Definition: scip_cons.c:2163
    SCIPdisableConsSeparation
    SCIP_RETCODE SCIPdisableConsSeparation(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:1924
    SCIPgetTransformedConss
    SCIP_RETCODE SCIPgetTransformedConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
    Definition: scip_cons.c:1714
    SCIPcheckCons
    SCIP_RETCODE SCIPcheckCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
    Definition: scip_cons.c:2135
    SCIPenableCons
    SCIP_RETCODE SCIPenableCons(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:1837
    SCIPpresolCons
    SCIP_RETCODE SCIPpresolCons(SCIP *scip, SCIP_CONS *cons, int nrounds, SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
    Definition: scip_cons.c:2406
    SCIPsetConsStickingAtNode
    SCIP_RETCODE SCIPsetConsStickingAtNode(SCIP *scip, SCIP_CONS *cons, SCIP_Bool stickingatnode)
    Definition: scip_cons.c:1499
    SCIPchgConsName
    SCIP_RETCODE SCIPchgConsName(SCIP *scip, SCIP_CONS *cons, const char *name)
    Definition: scip_cons.c:1224
    SCIPenfolpCons
    SCIP_RETCODE SCIPenfolpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool solinfeasible, SCIP_RESULT *result)
    Definition: scip_cons.c:2194
    SCIPprintCons
    SCIP_RETCODE SCIPprintCons(SCIP *scip, SCIP_CONS *cons, FILE *file)
    Definition: scip_cons.c:2536
    SCIPpropCons
    SCIP_RETCODE SCIPpropCons(SCIP *scip, SCIP_CONS *cons, SCIP_PROPTIMING proptiming, SCIP_RESULT *result)
    Definition: scip_cons.c:2340
    SCIPtransformConss
    SCIP_RETCODE SCIPtransformConss(SCIP *scip, int nconss, SCIP_CONS **conss, SCIP_CONS **transconss)
    Definition: scip_cons.c:1625
    SCIPenableConsPropagation
    SCIP_RETCODE SCIPenableConsPropagation(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:1951
    SCIPgetConsPermsymGraph
    SCIP_RETCODE SCIPgetConsPermsymGraph(SCIP *scip, SCIP_CONS *cons, SYM_GRAPH *graph, SCIP_Bool *success)
    Definition: scip_cons.c:2654
    SCIPdeactiveCons
    SCIP_RETCODE SCIPdeactiveCons(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:2497
    SCIPsetConsSeparated
    SCIP_RETCODE SCIPsetConsSeparated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool separate)
    Definition: scip_cons.c:1296
    SCIPsepalpCons
    SCIP_RETCODE SCIPsepalpCons(SCIP *scip, SCIP_CONS *cons, SCIP_RESULT *result)
    Definition: scip_cons.c:2283
    SCIPsetConsDynamic
    SCIP_RETCODE SCIPsetConsDynamic(SCIP *scip, SCIP_CONS *cons, SCIP_Bool dynamic)
    Definition: scip_cons.c:1449
    SCIPgetConsVars
    SCIP_RETCODE SCIPgetConsVars(SCIP *scip, SCIP_CONS *cons, SCIP_VAR **vars, int varssize, SCIP_Bool *success)
    Definition: scip_cons.c:2577
    SCIPsetConsInitial
    SCIP_RETCODE SCIPsetConsInitial(SCIP *scip, SCIP_CONS *cons, SCIP_Bool initial)
    Definition: scip_cons.c:1271
    SCIPsetConsEnforced
    SCIP_RETCODE SCIPsetConsEnforced(SCIP *scip, SCIP_CONS *cons, SCIP_Bool enforce)
    Definition: scip_cons.c:1321
    SCIPactiveCons
    SCIP_RETCODE SCIPactiveCons(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:2468
    SCIPunmarkConsPropagate
    SCIP_RETCODE SCIPunmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:2042
    SCIPenableConsSeparation
    SCIP_RETCODE SCIPenableConsSeparation(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:1896
    SCIPcreateCons
    SCIP_RETCODE SCIPcreateCons(SCIP *scip, SCIP_CONS **cons, const char *name, SCIP_CONSHDLR *conshdlr, SCIP_CONSDATA *consdata, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
    Definition: scip_cons.c:997
    SCIPaddConsLocksType
    SCIP_RETCODE SCIPaddConsLocksType(SCIP *scip, SCIP_CONS *cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
    Definition: scip_cons.c:2072
    SCIPdisableCons
    SCIP_RETCODE SCIPdisableCons(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:1871
    SCIPresetConsAge
    SCIP_RETCODE SCIPresetConsAge(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:1812
    SCIPsetConsModifiable
    SCIP_RETCODE SCIPsetConsModifiable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool modifiable)
    Definition: scip_cons.c:1424
    SCIPmarkConsPropagate
    SCIP_RETCODE SCIPmarkConsPropagate(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:2014
    SCIPinitlpCons
    SCIP_RETCODE SCIPinitlpCons(SCIP *scip, SCIP_CONS *cons, SCIP_Bool *infeasible)
    Definition: scip_cons.c:2256
    SCIPsetConsRemovable
    SCIP_RETCODE SCIPsetConsRemovable(SCIP *scip, SCIP_CONS *cons, SCIP_Bool removable)
    Definition: scip_cons.c:1474
    SCIPrespropCons
    SCIP_RETCODE SCIPrespropCons(SCIP *scip, SCIP_CONS *cons, SCIP_VAR *infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX *bdchgidx, SCIP_Real relaxedbd, SCIP_RESULT *result)
    Definition: scip_cons.c:2371
    SCIPsetConsLocal
    SCIP_RETCODE SCIPsetConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_Bool local)
    Definition: scip_cons.c:1398
    SCIPaddConsLocks
    SCIP_RETCODE SCIPaddConsLocks(SCIP *scip, SCIP_CONS *cons, int nlockspos, int nlocksneg)
    Definition: scip_cons.c:2105
    SCIPgetTransformedCons
    SCIP_RETCODE SCIPgetTransformedCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
    Definition: scip_cons.c:1674
    SCIPenforelaxCons
    SCIP_RETCODE SCIPenforelaxCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool solinfeasible, SCIP_RESULT *result)
    Definition: scip_cons.c:2224
    SCIPupdateConsFlags
    SCIP_RETCODE SCIPupdateConsFlags(SCIP *scip, SCIP_CONS *cons0, SCIP_CONS *cons1)
    Definition: scip_cons.c:1524
    SCIPdisableConsPropagation
    SCIP_RETCODE SCIPdisableConsPropagation(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:1981
    SCIPaddConsAge
    SCIP_RETCODE SCIPaddConsAge(SCIP *scip, SCIP_CONS *cons, SCIP_Real deltaage)
    Definition: scip_cons.c:1755
    SCIPparseCons
    SCIP_RETCODE SCIPparseCons(SCIP *scip, SCIP_CONS **cons, const char *str, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool *success)
    Definition: scip_cons.c:1081
    SCIPsepasolCons
    SCIP_RETCODE SCIPsepasolCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_RESULT *result)
    Definition: scip_cons.c:2310
    SCIPreleaseCons
    SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
    Definition: scip_cons.c:1173
    SCIPsetConsPropagated
    SCIP_RETCODE SCIPsetConsPropagated(SCIP *scip, SCIP_CONS *cons, SCIP_Bool propagate)
    Definition: scip_cons.c:1371
    SCIPtransformCons
    SCIP_RETCODE SCIPtransformCons(SCIP *scip, SCIP_CONS *cons, SCIP_CONS **transcons)
    Definition: scip_cons.c:1584
    SCIPsetConsChecked
    SCIP_RETCODE SCIPsetConsChecked(SCIP *scip, SCIP_CONS *cons, SCIP_Bool check)
    Definition: scip_cons.c:1346
    SCIPcaptureCons
    SCIP_RETCODE SCIPcaptureCons(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:1138
    SCIPincConsAge
    SCIP_RETCODE SCIPincConsAge(SCIP *scip, SCIP_CONS *cons)
    Definition: scip_cons.c:1784
    separate
    static SCIP_RETCODE separate(SCIP *scip, SCIP_SEPA *sepa, SCIP_SOL *sol, SCIP_RESULT *result)
    Main separation function.
    Definition: sepa_flower.c:1221
    SCIP_BdChgIdx
    Definition: struct_var.h:114
    SCIP_Cons
    Definition: struct_cons.h:47
    SCIP_Conshdlr
    Definition: struct_cons.h:128
    SCIP_Sol
    Definition: struct_sol.h:74
    SCIP_Var
    Definition: struct_var.h:262
    SYM_Graph
    Definition: struct_symmetry.h:46
    struct_scip.h
    SCIP main data structure.
    type_cons.h
    type definitions for constraints and constraint handlers
    SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH
    #define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x)
    Definition: type_cons.h:955
    SCIP_DECL_CONSGETPERMSYMGRAPH
    #define SCIP_DECL_CONSGETPERMSYMGRAPH(x)
    Definition: type_cons.h:937
    SCIP_DECL_CONSINITPRE
    #define SCIP_DECL_CONSINITPRE(x)
    Definition: type_cons.h:156
    SCIP_DECL_CONSEXIT
    #define SCIP_DECL_CONSEXIT(x)
    Definition: type_cons.h:136
    SCIP_DECL_CONSGETVARS
    #define SCIP_DECL_CONSGETVARS(x)
    Definition: type_cons.h:866
    SCIP_DECL_CONSINITSOL
    #define SCIP_DECL_CONSINITSOL(x)
    Definition: type_cons.h:201
    SCIP_CONSHDLRDATA
    struct SCIP_ConshdlrData SCIP_CONSHDLRDATA
    Definition: type_cons.h:64
    SCIP_DECL_CONSDISABLE
    #define SCIP_DECL_CONSDISABLE(x)
    Definition: type_cons.h:735
    SCIP_DECL_CONSENFORELAX
    #define SCIP_DECL_CONSENFORELAX(x)
    Definition: type_cons.h:388
    SCIP_DECL_CONSGETDIVEBDCHGS
    #define SCIP_DECL_CONSGETDIVEBDCHGS(x)
    Definition: type_cons.h:919
    SCIP_DECL_CONSGETNVARS
    #define SCIP_DECL_CONSGETNVARS(x)
    Definition: type_cons.h:884
    SCIP_DECL_CONSRESPROP
    #define SCIP_DECL_CONSRESPROP(x)
    Definition: type_cons.h:611
    SCIP_DECL_CONSACTIVE
    #define SCIP_DECL_CONSACTIVE(x)
    Definition: type_cons.h:690
    SCIP_DECL_CONSPARSE
    #define SCIP_DECL_CONSPARSE(x)
    Definition: type_cons.h:844
    SCIP_DECL_CONSDEACTIVE
    #define SCIP_DECL_CONSDEACTIVE(x)
    Definition: type_cons.h:705
    SCIP_DECL_CONSPRESOL
    #define SCIP_DECL_CONSPRESOL(x)
    Definition: type_cons.h:560
    SCIP_DECL_CONSENABLE
    #define SCIP_DECL_CONSENABLE(x)
    Definition: type_cons.h:720
    SCIP_DECL_CONSINITLP
    #define SCIP_DECL_CONSINITLP(x)
    Definition: type_cons.h:259
    SCIP_DECL_CONSEXITPRE
    #define SCIP_DECL_CONSEXITPRE(x)
    Definition: type_cons.h:180
    SCIP_DECL_CONSINIT
    #define SCIP_DECL_CONSINIT(x)
    Definition: type_cons.h:126
    SCIP_CONSDATA
    struct SCIP_ConsData SCIP_CONSDATA
    Definition: type_cons.h:65
    SCIP_DECL_CONSHDLRCOPY
    #define SCIP_DECL_CONSHDLRCOPY(x)
    Definition: type_cons.h:108
    SCIP_DECL_CONSEXITSOL
    #define SCIP_DECL_CONSEXITSOL(x)
    Definition: type_cons.h:216
    SCIP_DECL_CONSFREE
    #define SCIP_DECL_CONSFREE(x)
    Definition: type_cons.h:116
    type_heur.h
    type definitions for primal heuristics
    type_lp.h
    type definitions for LP management
    SCIP_BOUNDTYPE
    enum SCIP_BoundType SCIP_BOUNDTYPE
    Definition: type_lp.h:60
    type_misc.h
    type definitions for miscellaneous datastructures
    type_result.h
    result codes for SCIP callback methods
    SCIP_RESULT
    enum SCIP_Result SCIP_RESULT
    Definition: type_result.h:61
    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_timing.h
    timing definitions for SCIP
    SCIP_PROPTIMING
    unsigned int SCIP_PROPTIMING
    Definition: type_timing.h:75
    SCIP_PRESOLTIMING
    unsigned int SCIP_PRESOLTIMING
    Definition: type_timing.h:61
    type_var.h
    type definitions for problem variables
    SCIP_LOCKTYPE
    enum SCIP_LockType SCIP_LOCKTYPE
    Definition: type_var.h:144