Scippy

SCIP

Solving Constraint Integer Programs

scip_probing.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-2018 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 scip.zib.de. */
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 Robert Lion 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 /* In debug mode, we include the SCIP's structure in scip.c, such that no one can access
46  * this structure except the interface methods in scip.c.
47  * In optimized mode, the structure is included in scip.h, because some of the methods
48  * are implemented as defines for performance reasons (e.g. the numerical comparisons).
49  * Additionally, the internal "set.h" is included, such that the defines in set.h are
50  * available in optimized mode.
51  */
52 #ifdef NDEBUG
53 #include "scip/struct_scip.h"
54 #include "scip/struct_stat.h"
55 #include "scip/set.h"
56 #include "scip/tree.h"
57 #include "scip/misc.h"
58 #include "scip/var.h"
59 #include "scip/cons.h"
60 #include "scip/solve.h"
61 #include "scip/debug.h"
62 #endif
63 
64 #ifdef __cplusplus
65 extern "C" {
66 #endif
67 
68 /**@addtogroup PublicProbingMethods
69  *
70  * @{
71  */
72 
73 /** returns whether we are in probing mode; probing mode is activated via SCIPstartProbing() and stopped
74  * via SCIPendProbing()
75  *
76  * @return TRUE, if SCIP is currently in probing mode, otherwise FALSE
77  *
78  * @pre This method can be called if @p scip is in one of the following stages:
79  * - \ref SCIP_STAGE_TRANSFORMED
80  * - \ref SCIP_STAGE_INITPRESOLVE
81  * - \ref SCIP_STAGE_PRESOLVING
82  * - \ref SCIP_STAGE_EXITPRESOLVE
83  * - \ref SCIP_STAGE_PRESOLVED
84  * - \ref SCIP_STAGE_INITSOLVE
85  * - \ref SCIP_STAGE_SOLVING
86  * - \ref SCIP_STAGE_SOLVED
87  * - \ref SCIP_STAGE_EXITSOLVE
88  */
89 extern
91  SCIP* scip /**< SCIP data structure */
92  );
93 
94 /** initiates probing, making methods SCIPnewProbingNode(), SCIPbacktrackProbing(), SCIPchgVarLbProbing(),
95  * SCIPchgVarUbProbing(), SCIPfixVarProbing(), SCIPpropagateProbing(), and SCIPsolveProbingLP() available
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  * @note The collection of variable statistics is turned off during probing. If these statistics should be collected
105  * during probing use the method SCIPenableVarHistory() to turn the collection explicitly on.
106  */
107 extern
109  SCIP* scip /**< SCIP data structure */
110  );
111 
112 /** creates a new probing sub node, whose changes can be undone by backtracking to a higher node in the probing path
113  * with a call to SCIPbacktrackProbing();
114  * using a sub node for each set of probing bound changes can improve conflict analysis
115  *
116  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
117  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
118  *
119  * @pre This method can be called if @p scip is in one of the following stages:
120  * - \ref SCIP_STAGE_PRESOLVING
121  * - \ref SCIP_STAGE_SOLVING
122  */
123 extern
125  SCIP* scip /**< SCIP data structure */
126  );
127 
128 /** returns the current probing depth
129  *
130  * @return the probing depth, i.e. the number of probing sub nodes existing in the probing path
131  *
132  * @pre This method can be called if @p scip is in one of the following stages:
133  * - \ref SCIP_STAGE_PRESOLVING
134  * - \ref SCIP_STAGE_SOLVING
135  */
136 extern
138  SCIP* scip /**< SCIP data structure */
139  );
140 
141 /** undoes all changes to the problem applied in probing up to the given probing depth;
142  * the changes of the probing node of the given probing depth are the last ones that remain active;
143  * changes that were applied before calling SCIPnewProbingNode() cannot be undone
144  *
145  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
146  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
147  *
148  * @pre This method can be called if @p scip is in one of the following stages:
149  * - \ref SCIP_STAGE_PRESOLVING
150  * - \ref SCIP_STAGE_SOLVING
151  */
152 extern
154  SCIP* scip, /**< SCIP data structure */
155  int probingdepth /**< probing depth of the node in the probing path that should be reactivated */
156  );
157 
158 /** quits probing and resets bounds and constraints to the focus node's environment
159  *
160  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
161  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
162  *
163  * @pre This method can be called if @p scip is in one of the following stages:
164  * - \ref SCIP_STAGE_PRESOLVING
165  * - \ref SCIP_STAGE_SOLVING
166  */
167 extern
169  SCIP* scip /**< SCIP data structure */
170  );
171 
172 /** injects a change of variable's lower bound into current probing node; the same can also be achieved with a call to
173  * SCIPchgVarLb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
174  *
175  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
176  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
177  *
178  * @pre This method can be called if @p scip is in one of the following stages:
179  * - \ref SCIP_STAGE_PRESOLVING
180  * - \ref SCIP_STAGE_SOLVING
181  */
182 extern
184  SCIP* scip, /**< SCIP data structure */
185  SCIP_VAR* var, /**< variable to change the bound for */
186  SCIP_Real newbound /**< new value for bound */
187  );
188 
189 /** injects a change of variable's upper bound into current probing node; the same can also be achieved with a call to
190  * SCIPchgVarUb(), but in this case, the bound change would be treated like a deduction instead of a branching decision
191  *
192  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
193  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
194  *
195  * @pre This method can be called if @p scip is in one of the following stages:
196  * - \ref SCIP_STAGE_PRESOLVING
197  * - \ref SCIP_STAGE_SOLVING
198  */
199 extern
201  SCIP* scip, /**< SCIP data structure */
202  SCIP_VAR* var, /**< variable to change the bound for */
203  SCIP_Real newbound /**< new value for bound */
204  );
205 
206 /** gets variable's objective value in current probing
207  *
208  * @return the variable's objective value in current probing.
209  *
210  * @pre This method can be called if @p scip is in one of the following stages:
211  * - \ref SCIP_STAGE_SOLVING
212  *
213  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
214  */
215 extern
217  SCIP* scip, /**< SCIP data structure */
218  SCIP_VAR* var /**< variable to get the bound for */
219  );
220 
221 /** injects a change of variable's bounds into current probing node to fix the variable to the specified value;
222  * the same can also be achieved with a call to SCIPfixVar(), but in this case, the bound changes would be treated
223  * like deductions instead of branching decisions
224  *
225  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
226  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
227  *
228  * @pre This method can be called if @p scip is in one of the following stages:
229  * - \ref SCIP_STAGE_PRESOLVING
230  * - \ref SCIP_STAGE_SOLVING
231  */
232 extern
234  SCIP* scip, /**< SCIP data structure */
235  SCIP_VAR* var, /**< variable to change the bound for */
236  SCIP_Real fixedval /**< value to fix variable to */
237  );
238 
239 /** changes (column) variable's objective value during probing mode
240  *
241  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
242  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
243  *
244  * @pre This method can be called if @p scip is in one of the following stages:
245  * - \ref SCIP_STAGE_PRESOLVING
246  * - \ref SCIP_STAGE_SOLVING
247  *
248  * @pre The variable needs to be a column variable.
249  */
250 extern
252  SCIP* scip, /**< SCIP data structure */
253  SCIP_VAR* var, /**< variable to change the objective for */
254  SCIP_Real newobj /**< new objective function value */
255  );
256 
257 /** returns whether the objective function has changed during probing mode
258  *
259  * @return \ref TRUE if objective has changed, \ref FALSE otherwise
260  *
261  * @pre This method can be called if @p scip is in one of the following stages:
262  * - \ref SCIP_STAGE_TRANSFORMED
263  * - \ref SCIP_STAGE_INITPRESOLVE
264  * - \ref SCIP_STAGE_PRESOLVING
265  * - \ref SCIP_STAGE_EXITPRESOLVE
266  * - \ref SCIP_STAGE_PRESOLVED
267  * - \ref SCIP_STAGE_INITSOLVE
268  * - \ref SCIP_STAGE_SOLVING
269  * - \ref SCIP_STAGE_SOLVED
270  * - \ref SCIP_STAGE_EXITSOLVE
271  */
272 extern
274  SCIP* scip /**< SCIP data structure */
275  );
276 
277 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
278  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
279  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
280  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
281  *
282  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
283  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
284  *
285  * @pre This method can be called if @p scip is in one of the following stages:
286  * - \ref SCIP_STAGE_PRESOLVING
287  * - \ref SCIP_STAGE_SOLVING
288  */
289 extern
291  SCIP* scip, /**< SCIP data structure */
292  int maxproprounds, /**< maximal number of propagation rounds (-1: no limit, 0: parameter settings) */
293  SCIP_Bool* cutoff, /**< pointer to store whether the probing node can be cut off */
294  SCIP_Longint* ndomredsfound /**< pointer to store the number of domain reductions found, or NULL */
295  );
296 
297 /** applies domain propagation on the probing sub problem, that was changed after SCIPstartProbing() was called;
298  * only propagations of the binary variables fixed at the current probing node that are triggered by the implication
299  * graph and the clique table are applied;
300  * the propagated domains of the variables can be accessed with the usual bound accessing calls SCIPvarGetLbLocal()
301  * and SCIPvarGetUbLocal(); the propagation is only valid locally, i.e. the local bounds as well as the changed
302  * bounds due to SCIPchgVarLbProbing(), SCIPchgVarUbProbing(), and SCIPfixVarProbing() are used for propagation
303  *
304  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
305  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
306  *
307  * @pre This method can be called if @p scip is in one of the following stages:
308  * - \ref SCIP_STAGE_PRESOLVING
309  * - \ref SCIP_STAGE_SOLVING
310  */
311 extern
313  SCIP* scip, /**< SCIP data structure */
314  SCIP_Bool* cutoff /**< pointer to store whether the probing node can be cut off */
315  );
316 
317 /** solves the LP at the current probing node (cannot be applied at preprocessing stage);
318  * no separation or pricing is applied
319  *
320  * The LP has to be constructed before (you can use SCIPisLPConstructed() or SCIPconstructLP()).
321  *
322  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
323  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
324  *
325  * @pre This method can be called if @p scip is in one of the following stages:
326  * - \ref SCIP_STAGE_SOLVING
327  */
328 extern
330  SCIP* scip, /**< SCIP data structure */
331  int itlim, /**< maximal number of LP iterations to perform, or -1 for no limit */
332  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
333  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
334  * limit was reached (or NULL, if not needed) */
335  );
336 
337 /** solves the LP at the current probing node (cannot be applied at preprocessing stage) and applies pricing
338  * until the LP is solved to optimality; no separation is applied
339  *
340  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed . See \ref
341  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
342  *
343  * @pre This method can be called if @p scip is in one of the following stages:
344  * - \ref SCIP_STAGE_SOLVING
345  */
346 extern
348  SCIP* scip, /**< SCIP data structure */
349  SCIP_Bool pretendroot, /**< should the pricers be called as if we are at the root node? */
350  SCIP_Bool displayinfo, /**< should info lines be displayed after each pricing round? */
351  int maxpricerounds, /**< maximal number of pricing rounds (-1: no limit);
352  * a finite limit means that the LP might not be solved to optimality! */
353  SCIP_Bool* lperror, /**< pointer to store whether an unresolved LP error occurred */
354  SCIP_Bool* cutoff /**< pointer to store whether the probing LP was infeasible or the objective
355  * limit was reached (or NULL, if not needed) */
356  );
357 
358 /** sets the LP state for the current probing node
359  *
360  * @note state and norms are stored at the node and later released by SCIP; therefore, the pointers are set
361  * to NULL by the method
362  *
363  * @note the pointers to state and norms must not be NULL; however, they may point to a NULL pointer if the
364  * respective information should not be set
365  *
366  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
367  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
368  *
369  * @pre This method can be called if @p scip is in one of the following stages:
370  * - \ref SCIP_STAGE_PRESOLVING
371  * - \ref SCIP_STAGE_SOLVING
372  */
373 extern
375  SCIP* scip, /**< SCIP data structure */
376  SCIP_LPISTATE** lpistate, /**< pointer to LP state information (like basis information) */
377  SCIP_LPINORMS** lpinorms, /**< pointer to LP pricing norms information */
378  SCIP_Bool primalfeas, /**< primal feasibility when LP state information was stored */
379  SCIP_Bool dualfeas /**< dual feasibility when LP state information was stored */
380  );
381 
382 /** adds a row to the LP in the current probing node
383  *
384  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
385  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
386  *
387  * @pre This method can be called if @p scip is in one of the following stages:
388  * - \ref SCIP_STAGE_SOLVING
389  *
390  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
391  */
392 extern
394  SCIP* scip, /**< SCIP data structure */
395  SCIP_ROW* row /**< row to be added */
396  );
397 
398 /** applies the cuts in the separation storage to the LP and clears the storage afterwards;
399  * this method can only be applied during probing; the user should resolve the probing LP afterwards
400  * in order to get a new solution
401  *
402  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
403  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
404  *
405  * @pre This method can be called if @p scip is in one of the following stages:
406  * - \ref SCIP_STAGE_SOLVING
407  */
408 extern
410  SCIP* scip, /**< SCIP data structure */
411  SCIP_Bool* cutoff /**< pointer to store whether an empty domain was created */
412  );
413 
414 /** solves relaxation(s) at the current probing node (cannot be applied at preprocessing stage);
415  * no separation or pricing is applied
416  *
417  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
418  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
419  *
420  * @pre This method can be called if @p scip is in one of the following stages:
421  * - \ref SCIP_STAGE_SOLVING
422  */
423 extern
425  SCIP* scip, /**< SCIP data structure */
426  SCIP_Bool* cutoff /**< pointer to store whether a relaxation was infeasible or the objective
427  * limit was reached (or NULL, if not needed) */
428  );
429 
430 /** stores the candidate score and preferred rounding direction for a candidate variable */
431 extern
433  SCIP* scip, /**< SCIP data structure */
434  SCIP_DIVESET* diveset, /**< general diving settings */
435  SCIP_DIVETYPE divetype, /**< represents different methods for a dive set to explore the next children */
436  SCIP_VAR* divecand, /**< the candidate for which the branching direction is requested */
437  SCIP_Real divecandsol, /**< LP solution value of the candidate */
438  SCIP_Real divecandfrac, /**< fractionality of the candidate */
439  SCIP_Real* candscore, /**< pointer to store the candidate score */
440  SCIP_Bool* roundup /**< pointer to store whether preferred direction for diving is upwards */
441  );
442 
443 /** update diveset LP statistics, should be called after every LP solved by this diving heuristic */
444 extern
446  SCIP* scip, /**< SCIP data structure */
447  SCIP_DIVESET* diveset, /**< diving settings */
448  SCIP_Longint niterstoadd /**< additional number of LP iterations to be added */
449  );
450 
451 /** update diveset statistics and global diveset statistics */
452 extern
454  SCIP* scip, /**< SCIP data structure */
455  SCIP_DIVESET* diveset, /**< diveset to be reset */
456  int nprobingnodes, /**< the number of probing nodes explored this time */
457  int nbacktracks, /**< the number of backtracks during probing this time */
458  SCIP_Longint nsolsfound, /**< the number of solutions found */
459  SCIP_Longint nbestsolsfound, /**< the number of best solutions found */
460  SCIP_Longint nconflictsfound, /**< number of new conflicts found this time */
461  SCIP_Bool leavewassol /**< was a solution found at the leaf? */
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 extern
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 extern
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 extern
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 extern
542  SCIP* scip /**< SCIP data structure */
543  );
544 
545 /**@} */
546 
547 #ifdef __cplusplus
548 }
549 #endif
550 
551 #endif
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
Definition: scip_probing.c:280
internal methods for branch and bound tree
void SCIPupdateDivesetStats(SCIP *scip, SCIP_DIVESET *diveset, int nprobingnodes, int nbacktracks, SCIP_Longint nsolsfound, SCIP_Longint nbestsolsfound, SCIP_Longint nconflictsfound, SCIP_Bool leavewassol)
int SCIPgetProbingDepth(SCIP *scip)
Definition: scip_probing.c:253
SCIP_RETCODE SCIPapplyCutsProbing(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_probing.c:994
void SCIPgetDiveBoundChangeData(SCIP *scip, SCIP_VAR ***variables, SCIP_BRANCHDIR **directions, SCIP_Real **values, int *ndivebdchgs, SCIP_Bool preferred)
struct SCIP_LPiNorms SCIP_LPINORMS
Definition: type_lpi.h:98
SCIP_RETCODE SCIPpropagateProbingImplications(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_probing.c:736
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
SCIP_RETCODE SCIPaddDiveBoundChange(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)
type definitions for return codes for SCIP methods
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_probing.c:356
unsigned int SCIP_DIVETYPE
Definition: type_heur.h:48
type definitions for LP management
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
void SCIPclearDiveBoundChanges(SCIP *scip)
SCIP_RETCODE SCIPsolveProbingRelax(SCIP *scip, SCIP_Bool *cutoff)
type definitions for primal heuristics
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
Definition: scip_probing.c:630
SCIP_RETCODE SCIPfixVarProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
Definition: scip_probing.c:473
type definitions for SCIP&#39;s main datastructure
SCIP_RETCODE SCIPendProbing(SCIP *scip)
Definition: scip_probing.c:315
type definitions for specific LP solvers interface
struct SCIP_LPiState SCIP_LPISTATE
Definition: type_lpi.h:97
internal miscellaneous methods
SCIP_Bool SCIPisObjChangedProbing(SCIP *scip)
Definition: scip_probing.c:607
void SCIPupdateDivesetLPStats(SCIP *scip, SCIP_DIVESET *diveset, SCIP_Longint niterstoadd)
SCIP_Real SCIPgetVarObjProbing(SCIP *scip, SCIP_VAR *var)
Definition: scip_probing.c:443
internal methods for global SCIP settings
SCIP main data structure.
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip_probing.c:866
type definitions for problem variables
internal methods for problem variables
#define SCIP_Bool
Definition: def.h:62
SCIP_RETCODE SCIPgetDiveBoundChanges(SCIP *scip, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
methods for debugging
datastructures for problem statistics
type definitions for storing primal CIP solutions
SCIP_Bool SCIPinProbing(SCIP *scip)
Definition: scip_probing.c:152
SCIP_RETCODE SCIPsolveProbingLPWithPricing(SCIP *scip, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip_probing.c:890
internal methods for main solving loop and node processing
SCIP_RETCODE SCIPaddRowProbing(SCIP *scip, SCIP_ROW *row)
Definition: scip_probing.c:954
#define SCIP_Real
Definition: def.h:150
type definitions for branching and inference history
internal methods for constraints and constraint handlers
#define SCIP_Longint
Definition: def.h:135
SCIP_RETCODE SCIPsetProbingLPState(SCIP *scip, SCIP_LPISTATE **lpistate, SCIP_LPINORMS **lpinorms, SCIP_Bool primalfeas, SCIP_Bool dualfeas)
Definition: scip_probing.c:923
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
Definition: scip_probing.c:220
SCIP_RETCODE SCIPgetDivesetScore(SCIP *scip, SCIP_DIVESET *diveset, SCIP_DIVETYPE divetype, SCIP_VAR *divecand, SCIP_Real divecandsol, SCIP_Real divecandfrac, SCIP_Real *candscore, SCIP_Bool *roundup)
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
Definition: scip_probing.c:174
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_probing.c:400
SCIP_RETCODE SCIPchgVarObjProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_probing.c:529