1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 2 /* */ 3 /* This file is part of the program and library */ 4 /* SCIP --- Solving Constraint Integer Programs */ 5 /* */ 6 /* Copyright (C) 2002-2021 Konrad-Zuse-Zentrum */ 7 /* fuer Informationstechnik Berlin */ 8 /* */ 9 /* SCIP is distributed under the terms of the ZIB Academic License. */ 10 /* */ 11 /* You should have received a copy of the ZIB Academic License */ 12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */ 13 /* */ 14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 15 16 /**@file scip_probing.h 17 * @ingroup PUBLICCOREAPI 18 * @brief public methods for the probing mode 19 * @author Tobias Achterberg 20 * @author Timo Berthold 21 * @author Thorsten Koch 22 * @author Alexander Martin 23 * @author Marc Pfetsch 24 * @author Kati Wolter 25 * @author Gregor Hendel 26 * @author Leona Gottwald 27 */ 28 29 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/ 30 31 #ifndef __SCIP_SCIP_PROBING_H__ 32 #define __SCIP_SCIP_PROBING_H__ 33 34 35 #include "lpi/type_lpi.h" 36 #include "scip/def.h" 37 #include "scip/type_heur.h" 38 #include "scip/type_history.h" 39 #include "scip/type_lp.h" 40 #include "scip/type_retcode.h" 41 #include "scip/type_scip.h" 42 #include "scip/type_sol.h" 43 #include "scip/type_var.h" 44 45 #ifdef __cplusplus 46 extern "C" { 47 #endif 48 49 /**@addtogroup PublicProbingMethods 50 * 51 * @{ 52 */ 53 54 /** returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped 55 * via SCIPendProbing() 56 * 57 * @return TRUE, if SCIP is currently in probing mode, otherwise FALSE 58 * 59 * @pre This method can be called if @p scip is in one of the following stages: 60 * - \ref SCIP_STAGE_TRANSFORMED 61 * - \ref SCIP_STAGE_INITPRESOLVE 62 * - \ref SCIP_STAGE_PRESOLVING 63 * - \ref SCIP_STAGE_EXITPRESOLVE 64 * - \ref SCIP_STAGE_PRESOLVED 65 * - \ref SCIP_STAGE_INITSOLVE 66 * - \ref SCIP_STAGE_SOLVING 67 * - \ref SCIP_STAGE_SOLVED 68 * - \ref SCIP_STAGE_EXITSOLVE 69 */ 70 SCIP_EXPORT 71 SCIP_Bool SCIPinProbing( 72 SCIP* scip /**< SCIP data structure */ 73 ); 74 75 /** initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(), 76 * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available 77 * 78 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 79 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 80 * 81 * @pre This method can be called if @p scip is in one of the following stages: 82 * - \ref SCIP_STAGE_PRESOLVING 83 * - \ref SCIP_STAGE_SOLVING 84 * 85 * @note The collection of variable statistics is turned off during probing. If these statistics should be collected 86 * during probing use the method SCIPenableVarHistory() to turn the collection explicitly on. 87 */ 88 SCIP_EXPORT 89 SCIP_RETCODE SCIPstartProbing( 90 SCIP* scip /**< SCIP data structure */ 91 ); 92 93 /** creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path 94 * with a call to SCIPbacktrackProbing(); 95 * using a sub node for each set of probing bound changes can improve conflict analysis 96 * 97 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 98 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 99 * 100 * @pre This method can be called if @p scip is in one of the following stages: 101 * - \ref SCIP_STAGE_PRESOLVING 102 * - \ref SCIP_STAGE_SOLVING 103 */ 104 SCIP_EXPORT 105 SCIP_RETCODE SCIPnewProbingNode( 106 SCIP* scip /**< SCIP data structure */ 107 ); 108 109 /** returns the current probing depth 110 * 111 * @return the probing depth, i.e. the number of probing sub nodes existing in the probing path 112 * 113 * @pre This method can be called if @p scip is in one of the following stages: 114 * - \ref SCIP_STAGE_PRESOLVING 115 * - \ref SCIP_STAGE_SOLVING 116 */ 117 SCIP_EXPORT 118 int SCIPgetProbingDepth( 119 SCIP* scip /**< SCIP data structure */ 120 ); 121 122 /** undoes all changes to the problem applied in probing up to the given probing depth; 123 * the changes of the probing node of the given probing depth are the last ones that remain active; 124 * changes that were applied before calling SCIPnewProbingNode() cannot be undone 125 * 126 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 127 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 128 * 129 * @pre This method can be called if @p scip is in one of the following stages: 130 * - \ref SCIP_STAGE_PRESOLVING 131 * - \ref SCIP_STAGE_SOLVING 132 */ 133 SCIP_EXPORT 134 SCIP_RETCODE SCIPbacktrackProbing( 135 SCIP* scip, /**< SCIP data structure */ 136 int probingdepth /**< probing depth of the node in the probing path that should be reactivated */ 137 ); 138 139 /** quits probing and resets bounds and constraints to the focus node's environment 140 * 141 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 142 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 143 * 144 * @pre This method can be called if @p scip is in one of the following stages: 145 * - \ref SCIP_STAGE_PRESOLVING 146 * - \ref SCIP_STAGE_SOLVING 147 */ 148 SCIP_EXPORT 149 SCIP_RETCODE SCIPendProbing( 150 SCIP* scip /**< SCIP data structure */ 151 ); 152 153 /** injects a change of variable's lower bound into current probing node; the same can also be achieved with a call to 154 * SCIPchgVarLb(), but in this case, the bound change would be treated like a deduction instead of a branching decision 155 * 156 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 157 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 158 * 159 * @pre This method can be called if @p scip is in one of the following stages: 160 * - \ref SCIP_STAGE_PRESOLVING 161 * - \ref SCIP_STAGE_SOLVING 162 */ 163 SCIP_EXPORT 164 SCIP_RETCODE SCIPchgVarLbProbing( 165 SCIP* scip, /**< SCIP data structure */ 166 SCIP_VAR* var, /**< variable to change the bound for */ 167 SCIP_Real newbound /**< new value for bound */ 168 ); 169 170 /** injects a change of variable's upper bound into current probing node; the same can also be achieved with a call to 171 * SCIPchgVarUb(), but in this case, the bound change would be treated like a deduction instead of a branching decision 172 * 173 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 174 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 175 * 176 * @pre This method can be called if @p scip is in one of the following stages: 177 * - \ref SCIP_STAGE_PRESOLVING 178 * - \ref SCIP_STAGE_SOLVING 179 */ 180 SCIP_EXPORT 181 SCIP_RETCODE SCIPchgVarUbProbing( 182 SCIP* scip, /**< SCIP data structure */ 183 SCIP_VAR* var, /**< variable to change the bound for */ 184 SCIP_Real newbound /**< new value for bound */ 185 ); 186 187 /** gets variable's objective value in current probing 188 * 189 * @return the variable's objective value in current probing. 190 * 191 * @pre This method can be called if @p scip is in one of the following stages: 192 * - \ref SCIP_STAGE_SOLVING 193 * 194 * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. 195 */ 196 SCIP_EXPORT 197 SCIP_Real SCIPgetVarObjProbing( 198 SCIP* scip, /**< SCIP data structure */ 199 SCIP_VAR* var /**< variable to get the bound for */ 200 ); 201 202 /** injects a change of variable's bounds into current probing node to fix the variable to the specified value; 203 * the same can also be achieved with a call to SCIPfixVar(), but in this case, the bound changes would be treated 204 * like deductions instead of branching decisions 205 * 206 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 207 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 208 * 209 * @pre This method can be called if @p scip is in one of the following stages: 210 * - \ref SCIP_STAGE_PRESOLVING 211 * - \ref SCIP_STAGE_SOLVING 212 */ 213 SCIP_EXPORT 214 SCIP_RETCODE SCIPfixVarProbing( 215 SCIP* scip, /**< SCIP data structure */ 216 SCIP_VAR* var, /**< variable to change the bound for */ 217 SCIP_Real fixedval /**< value to fix variable to */ 218 ); 219 220 /** changes (column) variable's objective value during probing mode 221 * 222 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 223 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 224 * 225 * @pre This method can be called if @p scip is in one of the following stages: 226 * - \ref SCIP_STAGE_PRESOLVING 227 * - \ref SCIP_STAGE_SOLVING 228 * 229 * @pre The variable needs to be a column variable. 230 */ 231 SCIP_EXPORT 232 SCIP_RETCODE SCIPchgVarObjProbing( 233 SCIP* scip, /**< SCIP data structure */ 234 SCIP_VAR* var, /**< variable to change the objective for */ 235 SCIP_Real newobj /**< new objective function value */ 236 ); 237 238 /** returns whether the objective function has changed during probing mode 239 * 240 * @return \ref TRUE if objective has changed, \ref FALSE otherwise 241 * 242 * @pre This method can be called if @p scip is in one of the following stages: 243 * - \ref SCIP_STAGE_TRANSFORMED 244 * - \ref SCIP_STAGE_INITPRESOLVE 245 * - \ref SCIP_STAGE_PRESOLVING 246 * - \ref SCIP_STAGE_EXITPRESOLVE 247 * - \ref SCIP_STAGE_PRESOLVED 248 * - \ref SCIP_STAGE_INITSOLVE 249 * - \ref SCIP_STAGE_SOLVING 250 * - \ref SCIP_STAGE_SOLVED 251 * - \ref SCIP_STAGE_EXITSOLVE 252 */ 253 SCIP_EXPORT 254 SCIP_Bool SCIPisObjChangedProbing( 255 SCIP* scip /**< SCIP data structure */ 256 ); 257 258 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; 259 * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() 260 * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed 261 * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation 262 * 263 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 264 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 265 * 266 * @pre This method can be called if @p scip is in one of the following stages: 267 * - \ref SCIP_STAGE_PRESOLVING 268 * - \ref SCIP_STAGE_SOLVING 269 */ 270 SCIP_EXPORT 271 SCIP_RETCODE SCIPpropagateProbing( 272 SCIP* scip, /**< SCIP data structure */ 273 int maxproprounds, /**< maximal number of propagation rounds (-1: no limit, 0: parameter settings) */ 274 SCIP_Bool* cutoff, /**< pointer to store whether the probing node can be cut off */ 275 SCIP_Longint* ndomredsfound /**< pointer to store the number of domain reductions found, or NULL */ 276 ); 277 278 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called; 279 * only propagations of the binary variables fixed at the current probing node that are triggered by the implication 280 * graph and the clique table are applied; 281 * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal() 282 * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed 283 * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation 284 * 285 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 286 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 287 * 288 * @pre This method can be called if @p scip is in one of the following stages: 289 * - \ref SCIP_STAGE_PRESOLVING 290 * - \ref SCIP_STAGE_SOLVING 291 */ 292 SCIP_EXPORT 293 SCIP_RETCODE SCIPpropagateProbingImplications( 294 SCIP* scip, /**< SCIP data structure */ 295 SCIP_Bool* cutoff /**< pointer to store whether the probing node can be cut off */ 296 ); 297 298 /** solves the LP at the current probing node (cannot be applied at preprocessing stage); 299 * no separation or pricing is applied 300 * 301 * The LP has to be constructed before (you can use SCIPisLPConstructed() or SCIPconstructLP()). 302 * 303 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 304 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 305 * 306 * @pre This method can be called if @p scip is in one of the following stages: 307 * - \ref SCIP_STAGE_SOLVING 308 */ 309 SCIP_EXPORT 310 SCIP_RETCODE SCIPsolveProbingLP( 311 SCIP* scip, /**< SCIP data structure */ 312 int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */ 313 SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */ 314 SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective 315 * limit was reached (or NULL, if not needed) */ 316 ); 317 318 /** solves the LP at the current probing node (cannot be applied at preprocessing stage) and applies pricing 319 * until the LP is solved to optimality; no separation is applied 320 * 321 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed . See \ref 322 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 323 * 324 * @pre This method can be called if @p scip is in one of the following stages: 325 * - \ref SCIP_STAGE_SOLVING 326 */ 327 SCIP_EXPORT 328 SCIP_RETCODE SCIPsolveProbingLPWithPricing( 329 SCIP* scip, /**< SCIP data structure */ 330 SCIP_Bool pretendroot, /**< should the pricers be called as if we are at the root node? */ 331 SCIP_Bool displayinfo, /**< should info lines be displayed after each pricing round? */ 332 int maxpricerounds, /**< maximal number of pricing rounds (-1: no limit); 333 * a finite limit means that the LP might not be solved to optimality! */ 334 SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */ 335 SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective 336 * limit was reached (or NULL, if not needed) */ 337 ); 338 339 /** sets the LP state for the current probing node 340 * 341 * @note state and norms are stored at the node and later released by SCIP; therefore, the pointers are set 342 * to NULL by the method 343 * 344 * @note the pointers to state and norms must not be NULL; however, they may point to a NULL pointer if the 345 * respective information should not be set 346 * 347 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 348 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 349 * 350 * @pre This method can be called if @p scip is in one of the following stages: 351 * - \ref SCIP_STAGE_PRESOLVING 352 * - \ref SCIP_STAGE_SOLVING 353 */ 354 SCIP_EXPORT 355 SCIP_RETCODE SCIPsetProbingLPState( 356 SCIP* scip, /**< SCIP data structure */ 357 SCIP_LPISTATE** lpistate, /**< pointer to LP state information (like basis information) */ 358 SCIP_LPINORMS** lpinorms, /**< pointer to LP pricing norms information */ 359 SCIP_Bool primalfeas, /**< primal feasibility when LP state information was stored */ 360 SCIP_Bool dualfeas /**< dual feasibility when LP state information was stored */ 361 ); 362 363 /** adds a row to the LP in the current probing node 364 * 365 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 366 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 367 * 368 * @pre This method can be called if @p scip is in one of the following stages: 369 * - \ref SCIP_STAGE_SOLVING 370 * 371 * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. 372 */ 373 SCIP_EXPORT 374 SCIP_RETCODE SCIPaddRowProbing( 375 SCIP* scip, /**< SCIP data structure */ 376 SCIP_ROW* row /**< row to be added */ 377 ); 378 379 /** applies the cuts in the separation storage to the LP and clears the storage afterwards; 380 * this method can only be applied during probing; the user should resolve the probing LP afterwards 381 * in order to get a new solution 382 * 383 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 384 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 385 * 386 * @pre This method can be called if @p scip is in one of the following stages: 387 * - \ref SCIP_STAGE_SOLVING 388 */ 389 SCIP_EXPORT 390 SCIP_RETCODE SCIPapplyCutsProbing( 391 SCIP* scip, /**< SCIP data structure */ 392 SCIP_Bool* cutoff /**< pointer to store whether an empty domain was created */ 393 ); 394 395 /** solves relaxation(s) at the current probing node (cannot be applied at preprocessing stage); 396 * no separation or pricing is applied 397 * 398 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 399 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 400 * 401 * @pre This method can be called if @p scip is in one of the following stages: 402 * - \ref SCIP_STAGE_SOLVING 403 */ 404 SCIP_EXPORT 405 SCIP_RETCODE SCIPsolveProbingRelax( 406 SCIP* scip, /**< SCIP data structure */ 407 SCIP_Bool* cutoff /**< pointer to store whether a relaxation was infeasible or the objective 408 * limit was reached (or NULL, if not needed) */ 409 ); 410 411 /** print statistics of probing */ 412 SCIP_EXPORT 413 char* SCIPsnprintfProbingStats( 414 SCIP* scip, /**< SCIP data structure */ 415 char* strbuf, /**< string buffer */ 416 int len /**< length of string buffer */ 417 ); 418 419 /** stores the candidate score and preferred rounding direction for a candidate variable */ 420 SCIP_EXPORT 421 SCIP_RETCODE SCIPgetDivesetScore( 422 SCIP* scip, /**< SCIP data structure */ 423 SCIP_DIVESET* diveset, /**< general diving settings */ 424 SCIP_DIVETYPE divetype, /**< represents different methods for a dive set to explore the next children */ 425 SCIP_VAR* divecand, /**< the candidate for which the branching direction is requested */ 426 SCIP_Real divecandsol, /**< LP solution value of the candidate */ 427 SCIP_Real divecandfrac, /**< fractionality of the candidate */ 428 SCIP_Real* candscore, /**< pointer to store the candidate score */ 429 SCIP_Bool* roundup /**< pointer to store whether preferred direction for diving is upwards */ 430 ); 431 432 /** update diveset LP statistics, should be called after every LP solved by this diving heuristic */ 433 SCIP_EXPORT 434 void SCIPupdateDivesetLPStats( 435 SCIP* scip, /**< SCIP data structure */ 436 SCIP_DIVESET* diveset, /**< diving settings */ 437 SCIP_Longint niterstoadd, /**< additional number of LP iterations to be added */ 438 SCIP_DIVECONTEXT divecontext /**< context for diving statistics */ 439 ); 440 441 /** update diveset statistics and global diveset statistics */ 442 SCIP_EXPORT 443 void SCIPupdateDivesetStats( 444 SCIP* scip, /**< SCIP data structure */ 445 SCIP_DIVESET* diveset, /**< diveset to be reset */ 446 int nprobingnodes, /**< the number of probing nodes explored this time */ 447 int nbacktracks, /**< the number of backtracks during probing this time */ 448 SCIP_Longint nsolsfound, /**< the number of solutions found */ 449 SCIP_Longint nbestsolsfound, /**< the number of best solutions found */ 450 SCIP_Longint nconflictsfound, /**< number of new conflicts found this time */ 451 SCIP_Bool leavewassol, /**< was a solution found at the leaf? */ 452 SCIP_DIVECONTEXT divecontext /**< context for diving statistics */ 453 ); 454 455 /** enforces a probing/diving solution by suggesting bound changes that maximize the score w.r.t. the current diving settings 456 * 457 * the process is guided by the enforcement priorities of the constraint handlers and the scoring mechanism provided by 458 * the dive set. 459 * Constraint handlers may suggest diving bound changes in decreasing order of their enforcement priority, based on the 460 * solution values in the solution @p sol and the current local bounds of the variables. A diving bound change 461 * is a triple (variable,branching direction,value) and is used inside SCIPperformGenericDivingAlgorithm(). 462 * 463 * After a successful call, SCIP holds two arrays of suggested dive bound changes, one for the preferred child 464 * and one for the alternative. 465 * 466 * @see SCIPgetDiveBoundChangeData() for retrieving the dive bound change suggestions. 467 * 468 * The method stops after the first constraint handler was successful 469 * 470 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 471 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 472 * 473 * @pre This method can be called if @p scip is in one of the following stages: 474 * - \ref SCIP_STAGE_SOLVING 475 * 476 * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. 477 */ 478 SCIP_EXPORT 479 SCIP_RETCODE SCIPgetDiveBoundChanges( 480 SCIP* scip, /**< SCIP data structure */ 481 SCIP_DIVESET* diveset, /**< diving settings to control scoring */ 482 SCIP_SOL* sol, /**< current solution of diving mode */ 483 SCIP_Bool* success, /**< pointer to store whether constraint handler successfully found a variable */ 484 SCIP_Bool* infeasible /**< pointer to store whether the current node was detected to be infeasible */ 485 ); 486 487 /** adds a diving bound change to the diving bound change storage of SCIP together with the information if this is a 488 * bound change for the preferred direction or not 489 * 490 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref 491 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes. 492 * 493 * @pre This method can be called if @p scip is in one of the following stages: 494 * - \ref SCIP_STAGE_SOLVING 495 * 496 * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. 497 */ 498 SCIP_EXPORT 499 SCIP_RETCODE SCIPaddDiveBoundChange( 500 SCIP* scip, /**< SCIP data structure */ 501 SCIP_VAR* var, /**< variable to apply the bound change to */ 502 SCIP_BRANCHDIR dir, /**< direction of the bound change */ 503 SCIP_Real value, /**< value to adjust this variable bound to */ 504 SCIP_Bool preferred /**< is this a bound change for the preferred child? */ 505 ); 506 507 /** get the dive bound change data for the preferred or the alternative direction 508 * 509 * @pre This method can be called if @p scip is in one of the following stages: 510 * - \ref SCIP_STAGE_SOLVING 511 * 512 * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. 513 */ 514 SCIP_EXPORT 515 void SCIPgetDiveBoundChangeData( 516 SCIP* scip, /**< SCIP data structure */ 517 SCIP_VAR*** variables, /**< pointer to store variables for the specified direction */ 518 SCIP_BRANCHDIR** directions, /**< pointer to store the branching directions */ 519 SCIP_Real** values, /**< pointer to store bound change values */ 520 int* ndivebdchgs, /**< pointer to store the number of dive bound changes */ 521 SCIP_Bool preferred /**< should the dive bound changes for the preferred child be output? */ 522 ); 523 524 /** clear the dive bound change data structures 525 * 526 * @pre This method can be called if @p scip is in one of the following stages: 527 * - \ref SCIP_STAGE_SOLVING 528 * 529 * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages. 530 */ 531 SCIP_EXPORT 532 void SCIPclearDiveBoundChanges( 533 SCIP* scip /**< SCIP data structure */ 534 ); 535 536 /**@} */ 537 538 #ifdef __cplusplus 539 } 540 #endif 541 542 #endif 543