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-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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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:225
int SCIPgetProbingDepth(SCIP *scip)
Definition: scip_probing.c:198
SCIP_RETCODE SCIPapplyCutsProbing(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_probing.c:947
void SCIPgetDiveBoundChangeData(SCIP *scip, SCIP_VAR ***variables, SCIP_BRANCHDIR **directions, SCIP_Real **values, int *ndivebdchgs, SCIP_Bool preferred)
SCIP_RETCODE SCIPpropagateProbingImplications(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_probing.c:686
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
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:301
unsigned int SCIP_DIVETYPE
Definition: type_heur.h:63
type definitions for LP management
enum SCIP_BranchDir SCIP_BRANCHDIR
Definition: type_history.h:48
void SCIPclearDiveBoundChanges(SCIP *scip)
SCIP_RETCODE SCIPsolveProbingRelax(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_probing.c:976
type definitions for primal heuristics
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
Definition: scip_probing.c:580
SCIP_RETCODE SCIPfixVarProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
Definition: scip_probing.c:418
type definitions for SCIP&#39;s main datastructure
SCIP_RETCODE SCIPendProbing(SCIP *scip)
Definition: scip_probing.c:260
char * SCIPsnprintfProbingStats(SCIP *scip, char *strbuf, int len)
type definitions for specific LP solvers interface
SCIP_Bool SCIPisObjChangedProbing(SCIP *scip)
Definition: scip_probing.c:552
SCIP_Real SCIPgetVarObjProbing(SCIP *scip, SCIP_VAR *var)
Definition: scip_probing.c:388
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip_probing.c:819
type definitions for problem variables
void SCIPupdateDivesetStats(SCIP *scip, SCIP_DIVESET *diveset, int nprobingnodes, int nbacktracks, SCIP_Longint nsolsfound, SCIP_Longint nbestsolsfound, SCIP_Longint nconflictsfound, SCIP_Bool leavewassol, SCIP_DIVECONTEXT divecontext)
#define SCIP_Bool
Definition: def.h:93
SCIP_RETCODE SCIPgetDiveBoundChanges(SCIP *scip, SCIP_DIVESET *diveset, SCIP_SOL *sol, SCIP_Bool *success, SCIP_Bool *infeasible)
type definitions for storing primal CIP solutions
SCIP_Bool SCIPinProbing(SCIP *scip)
Definition: scip_probing.c:97
void SCIPupdateDivesetLPStats(SCIP *scip, SCIP_DIVESET *diveset, SCIP_Longint niterstoadd, SCIP_DIVECONTEXT divecontext)
enum SCIP_DiveContext SCIP_DIVECONTEXT
Definition: type_heur.h:72
SCIP_RETCODE SCIPsolveProbingLPWithPricing(SCIP *scip, SCIP_Bool pretendroot, SCIP_Bool displayinfo, int maxpricerounds, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip_probing.c:843
SCIP_RETCODE SCIPaddRowProbing(SCIP *scip, SCIP_ROW *row)
Definition: scip_probing.c:907
#define SCIP_Real
Definition: def.h:186
type definitions for branching and inference history
#define SCIP_Longint
Definition: def.h:171
SCIP_RETCODE SCIPsetProbingLPState(SCIP *scip, SCIP_LPISTATE **lpistate, SCIP_LPINORMS **lpinorms, SCIP_Bool primalfeas, SCIP_Bool dualfeas)
Definition: scip_probing.c:876
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
Definition: scip_probing.c:165
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:119
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:345
SCIP_RETCODE SCIPchgVarObjProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)
Definition: scip_probing.c:474