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