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-2019 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 #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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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  */
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 /** stores the candidate score and preferred rounding direction for a candidate variable */
414  SCIP* scip, /**< SCIP data structure */
415  SCIP_DIVESET* diveset, /**< general diving settings */
416  SCIP_DIVETYPE divetype, /**< represents different methods for a dive set to explore the next children */
417  SCIP_VAR* divecand, /**< the candidate for which the branching direction is requested */
418  SCIP_Real divecandsol, /**< LP solution value of the candidate */
419  SCIP_Real divecandfrac, /**< fractionality of the candidate */
420  SCIP_Real* candscore, /**< pointer to store the candidate score */
421  SCIP_Bool* roundup /**< pointer to store whether preferred direction for diving is upwards */
422  );
423 
424 /** update diveset LP statistics, should be called after every LP solved by this diving heuristic */
427  SCIP* scip, /**< SCIP data structure */
428  SCIP_DIVESET* diveset, /**< diving settings */
429  SCIP_Longint niterstoadd /**< additional number of LP iterations to be added */
430  );
431 
432 /** update diveset statistics and global diveset statistics */
435  SCIP* scip, /**< SCIP data structure */
436  SCIP_DIVESET* diveset, /**< diveset to be reset */
437  int nprobingnodes, /**< the number of probing nodes explored this time */
438  int nbacktracks, /**< the number of backtracks during probing this time */
439  SCIP_Longint nsolsfound, /**< the number of solutions found */
440  SCIP_Longint nbestsolsfound, /**< the number of best solutions found */
441  SCIP_Longint nconflictsfound, /**< number of new conflicts found this time */
442  SCIP_Bool leavewassol /**< was a solution found at the leaf? */
443  );
444 
445 /** enforces a probing/diving solution by suggesting bound changes that maximize the score w.r.t. the current diving settings
446  *
447  * the process is guided by the enforcement priorities of the constraint handlers and the scoring mechanism provided by
448  * the dive set.
449  * Constraint handlers may suggest diving bound changes in decreasing order of their enforcement priority, based on the
450  * solution values in the solution @p sol and the current local bounds of the variables. A diving bound change
451  * is a triple (variable,branching direction,value) and is used inside SCIPperformGenericDivingAlgorithm().
452  *
453  * After a successful call, SCIP holds two arrays of suggested dive bound changes, one for the preferred child
454  * and one for the alternative.
455  *
456  * @see SCIPgetDiveBoundChangeData() for retrieving the dive bound change suggestions.
457  *
458  * The method stops after the first constraint handler was successful
459  *
460  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
461  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
462  *
463  * @pre This method can be called if @p scip is in one of the following stages:
464  * - \ref SCIP_STAGE_SOLVING
465  *
466  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
467  */
470  SCIP* scip, /**< SCIP data structure */
471  SCIP_DIVESET* diveset, /**< diving settings to control scoring */
472  SCIP_SOL* sol, /**< current solution of diving mode */
473  SCIP_Bool* success, /**< pointer to store whether constraint handler successfully found a variable */
474  SCIP_Bool* infeasible /**< pointer to store whether the current node was detected to be infeasible */
475  );
476 
477 /** adds a diving bound change to the diving bound change storage of SCIP together with the information if this is a
478  * bound change for the preferred direction or not
479  *
480  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
481  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
482  *
483  * @pre This method can be called if @p scip is in one of the following stages:
484  * - \ref SCIP_STAGE_SOLVING
485  *
486  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
487  */
490  SCIP* scip, /**< SCIP data structure */
491  SCIP_VAR* var, /**< variable to apply the bound change to */
492  SCIP_BRANCHDIR dir, /**< direction of the bound change */
493  SCIP_Real value, /**< value to adjust this variable bound to */
494  SCIP_Bool preferred /**< is this a bound change for the preferred child? */
495  );
496 
497 /** get the dive bound change data for the preferred or the alternative direction
498  *
499  * @pre This method can be called if @p scip is in one of the following stages:
500  * - \ref SCIP_STAGE_SOLVING
501  *
502  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
503  */
506  SCIP* scip, /**< SCIP data structure */
507  SCIP_VAR*** variables, /**< pointer to store variables for the specified direction */
508  SCIP_BRANCHDIR** directions, /**< pointer to store the branching directions */
509  SCIP_Real** values, /**< pointer to store bound change values */
510  int* ndivebdchgs, /**< pointer to store the number of dive bound changes */
511  SCIP_Bool preferred /**< should the dive bound changes for the preferred child be output? */
512  );
513 
514 /** clear the dive bound change data structures
515  *
516  * @pre This method can be called if @p scip is in one of the following stages:
517  * - \ref SCIP_STAGE_SOLVING
518  *
519  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
520  */
523  SCIP* scip /**< SCIP data structure */
524  );
525 
526 /**@} */
527 
528 #ifdef __cplusplus
529 }
530 #endif
531 
532 #endif
SCIP_EXPORT SCIP_RETCODE SCIPapplyCutsProbing(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_probing.c:929
SCIP_EXPORT SCIP_RETCODE SCIPfixVarProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
Definition: scip_probing.c:408
SCIP_EXPORT SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
Definition: scip_probing.c:155
SCIP_EXPORT SCIP_RETCODE SCIPsolveProbingRelax(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_probing.c:958
SCIP_EXPORT SCIP_RETCODE SCIPpropagateProbingImplications(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_probing.c:671
#define SCIP_EXPORT
Definition: def.h:98
struct SCIP_LPiNorms SCIP_LPINORMS
Definition: type_lpi.h:98
SCIP_EXPORT SCIP_RETCODE SCIPgetDiveBoundChanges(SCIP *scip, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:53
type definitions for return codes for SCIP methods
unsigned int SCIP_DIVETYPE
Definition: type_heur.h:48
SCIP_EXPORT SCIP_RETCODE SCIPsolveProbingLPWithPricing(SCIP *scip, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip_probing.c:825
SCIP_EXPORT SCIP_RETCODE SCIPaddDiveBoundChange(SCIP *scip, SCIP_VAR *var, SCIP_BRANCHDIR dir, SCIP_Real value, SCIP_Bool preferred)
SCIP_EXPORT 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)
type definitions for LP management
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:39
SCIP_EXPORT SCIP_Bool SCIPisObjChangedProbing(SCIP *scip)
Definition: scip_probing.c:542
type definitions for primal heuristics
SCIP_EXPORT SCIP_RETCODE SCIPsetProbingLPState(SCIP *scip, SCIP_LPISTATE **lpistate, SCIP_LPINORMS **lpinorms, SCIP_Bool primalfeas, SCIP_Bool dualfeas)
Definition: scip_probing.c:858
type definitions for SCIP&#39;s main datastructure
SCIP_EXPORT int SCIPgetProbingDepth(SCIP *scip)
Definition: scip_probing.c:188
SCIP_EXPORT SCIP_Bool SCIPinProbing(SCIP *scip)
Definition: scip_probing.c:87
type definitions for specific LP solvers interface
struct SCIP_LPiState SCIP_LPISTATE
Definition: type_lpi.h:97
SCIP_EXPORT SCIP_RETCODE SCIPendProbing(SCIP *scip)
Definition: scip_probing.c:250
SCIP_EXPORT SCIP_RETCODE SCIPaddRowProbing(SCIP *scip, SCIP_ROW *row)
Definition: scip_probing.c:889
type definitions for problem variables
SCIP_EXPORT SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
Definition: scip_probing.c:215
SCIP_EXPORT SCIP_Real SCIPgetVarObjProbing(SCIP *scip, SCIP_VAR *var)
Definition: scip_probing.c:378
#define SCIP_Bool
Definition: def.h:70
SCIP_EXPORT SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
Definition: scip_probing.c:565
type definitions for storing primal CIP solutions
SCIP_EXPORT void SCIPupdateDivesetStats(SCIP *scip, SCIP_DIVESET *diveset, int nprobingnodes, int nbacktracks, SCIP_Longint nsolsfound, SCIP_Longint nbestsolsfound, SCIP_Longint nconflictsfound, SCIP_Bool leavewassol)
SCIP_EXPORT void SCIPclearDiveBoundChanges(SCIP *scip)
SCIP_EXPORT SCIP_RETCODE SCIPstartProbing(SCIP *scip)
Definition: scip_probing.c:109
SCIP_EXPORT SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_probing.c:291
#define SCIP_Real
Definition: def.h:164
type definitions for branching and inference history
SCIP_EXPORT SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_probing.c:335
#define SCIP_Longint
Definition: def.h:149
SCIP_EXPORT void SCIPupdateDivesetLPStats(SCIP *scip, SCIP_DIVESET *diveset, SCIP_Longint niterstoadd)
common defines and data types used in all packages of SCIP
SCIP_EXPORT void SCIPgetDiveBoundChangeData(SCIP *scip, SCIP_VAR ***variables, SCIP_BRANCHDIR **directions, SCIP_Real **values, int *ndivebdchgs, SCIP_Bool preferred)
SCIP_EXPORT SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip_probing.c:801
SCIP_EXPORT SCIP_RETCODE SCIPchgVarObjProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_probing.c:464