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