1    	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2    	/*                                                                           */
3    	/*                  This file is part of the program and library             */
4    	/*         SCIP --- Solving Constraint Integer Programs                      */
5    	/*                                                                           */
6    	/*  Copyright 2002-2022 Zuse Institute Berlin                                */
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   conflict_general.h
26   	 * @ingroup OTHER_CFILES
27   	 * @brief  methods and datastructures for conflict analysis
28   	 * @author Tobias Achterberg
29   	 * @author Timo Berthold
30   	 * @author Stefan Heinz
31   	 * @author Marc Pfetsch
32   	 * @author Michael Winkler
33   	 * @author Jakob Witzig
34   	 *
35   	 * SCIP contains two kinds of conflict analysis:
36   	 *    - In graph based conflict analysis, the graph consisting of derived
37   	 *      is analysed. Code and documentation is available in conflict_graphanalysis.h
38   	 *    - In dual proof analysis, an infeasible LP relaxation is analysed.
39   	 *      Using the dual solution, a valid constraint is derived that is violated
40   	 *      by all values in the domain. This constraint is added to the problem
41   	 *      and can then be used for domain propagation.
42   	 *      Code is available in conflict_dualproofanalysis.h
43   	 * This file contains the methods that are shared by both kinds of conflict analysis.
44   	 */
45   	
46   	/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
47   	
48   	#ifndef __SCIP_CONFLICT_GENERAL_H__
49   	#define __SCIP_CONFLICT_GENERAL_H__
50   	
51   	
52   	#include "blockmemshell/memory.h"
53   	#include "scip/def.h"
54   	#include "scip/type_branch.h"
55   	#include "scip/type_conflict.h"
56   	#include "scip/type_conflictstore.h"
57   	#include "scip/type_event.h"
58   	#include "scip/type_cuts.h"
59   	#include "lpi/type_lpi.h"
60   	#include "scip/type_implics.h"
61   	#include "scip/type_lp.h"
62   	#include "scip/type_prob.h"
63   	#include "scip/type_reopt.h"
64   	#include "scip/type_retcode.h"
65   	#include "scip/type_set.h"
66   	#include "scip/type_stat.h"
67   	#include "scip/type_tree.h"
68   	#include "scip/type_var.h"
69   	
70   	#ifdef __cplusplus
71   	extern "C" {
72   	#endif
73   	
74   	/*
75   	 * Conflict Analysis
76   	 */
77   	
78   	/** creates conflict analysis data for propagation conflicts */
79   	SCIP_RETCODE SCIPconflictCreate(
80   	   SCIP_CONFLICT**       conflict,           /**< pointer to conflict analysis data */
81   	   BMS_BLKMEM*           blkmem,             /**< block memory of transformed problem */
82   	   SCIP_SET*             set                 /**< global SCIP settings */
83   	   );
84   	
85   	/** frees conflict analysis data for propagation conflicts */
86   	SCIP_RETCODE SCIPconflictFree(
87   	   SCIP_CONFLICT**       conflict,           /**< pointer to conflict analysis data */
88   	   BMS_BLKMEM*           blkmem              /**< block memory of transformed problem */
89   	   );
90   	
91   	/** analyzes conflicting bound changes that were added with calls to SCIPconflictAddBound() and
92   	 *  SCIPconflictAddRelaxedBound(), and on success, calls the conflict handlers to create a conflict constraint out of
93   	 *  the resulting conflict set; updates statistics for propagation conflict analysis
94   	 */
95   	SCIP_RETCODE SCIPconflictAnalyze(
96   	   SCIP_CONFLICT*        conflict,           /**< conflict analysis data */
97   	   BMS_BLKMEM*           blkmem,             /**< block memory of transformed problem */
98   	   SCIP_SET*             set,                /**< global SCIP settings */
99   	   SCIP_STAT*            stat,               /**< problem statistics */
100  	   SCIP_PROB*            prob,               /**< problem data */
101  	   SCIP_TREE*            tree,               /**< branch and bound tree */
102  	   int                   validdepth,         /**< minimal depth level at which the initial conflict set is valid */
103  	   SCIP_Bool*            success             /**< pointer to store whether a conflict constraint was created, or NULL */
104  	   );
105  	
106  	/** adds the collected conflict constraints to the corresponding nodes; the best set->conf_maxconss conflict constraints
107  	 *  are added to the node of their validdepth; additionally (if not yet added, and if repropagation is activated), the
108  	 *  conflict constraint that triggers the earliest repropagation is added to the node of its validdepth
109  	 */
110  	SCIP_RETCODE SCIPconflictFlushConss(
111  	   SCIP_CONFLICT*        conflict,           /**< conflict analysis data */
112  	   BMS_BLKMEM*           blkmem,             /**< block memory of transformed problem */
113  	   SCIP_SET*             set,                /**< global SCIP settings */
114  	   SCIP_STAT*            stat,               /**< dynamic problem statistics */
115  	   SCIP_PROB*            transprob,          /**< transformed problem */
116  	   SCIP_PROB*            origprob,           /**< original problem */
117  	   SCIP_TREE*            tree,               /**< branch and bound tree */
118  	   SCIP_REOPT*           reopt,              /**< reoptimization data structure */
119  	   SCIP_LP*              lp,                 /**< current LP data */
120  	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
121  	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
122  	   SCIP_CLIQUETABLE*     cliquetable         /**< clique table data structure */
123  	   );
124  	
125  	/** returns the current number of conflict sets in the conflict set storage */
126  	int SCIPconflictGetNConflicts(
127  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
128  	   );
129  	
130  	/** returns the total number of conflict constraints that were added to the problem */
131  	SCIP_Longint SCIPconflictGetNAppliedConss(
132  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
133  	   );
134  	
135  	/** returns the total number of literals in conflict constraints that were added to the problem */
136  	SCIP_Longint SCIPconflictGetNAppliedLiterals(
137  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
138  	   );
139  	
140  	/** returns the total number of global bound changes applied by the conflict analysis */
141  	SCIP_Longint SCIPconflictGetNGlobalChgBds(
142  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
143  	   );
144  	
145  	/** returns the total number of conflict constraints that were added globally to the problem */
146  	SCIP_Longint SCIPconflictGetNAppliedGlobalConss(
147  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
148  	   );
149  	
150  	/** returns the total number of literals in conflict constraints that were added globally to the problem */
151  	SCIP_Longint SCIPconflictGetNAppliedGlobalLiterals(
152  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
153  	   );
154  	
155  	/** returns the total number of local bound changes applied by the conflict analysis */
156  	SCIP_Longint SCIPconflictGetNLocalChgBds(
157  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
158  	   );
159  	
160  	/** returns the total number of conflict constraints that were added locally to the problem */
161  	SCIP_Longint SCIPconflictGetNAppliedLocalConss(
162  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
163  	   );
164  	
165  	/** returns the total number of literals in conflict constraints that were added locally to the problem */
166  	SCIP_Longint SCIPconflictGetNAppliedLocalLiterals(
167  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
168  	   );
169  	
170  	/** gets time in seconds used for preprocessing global conflict constraint before appliance */
171  	SCIP_Real SCIPconflictGetGlobalApplTime(
172  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
173  	   );
174  	
175  	/** gets time in seconds used for analyzing propagation conflicts */
176  	SCIP_Real SCIPconflictGetPropTime(
177  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
178  	   );
179  	
180  	/** gets number of calls to propagation conflict analysis */
181  	SCIP_Longint SCIPconflictGetNPropCalls(
182  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
183  	   );
184  	
185  	/** gets number of calls to propagation conflict analysis that yield at least one conflict constraint */
186  	SCIP_Longint SCIPconflictGetNPropSuccess(
187  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
188  	   );
189  	
190  	/** gets number of conflict constraints detected in propagation conflict analysis */
191  	SCIP_Longint SCIPconflictGetNPropConflictConss(
192  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
193  	   );
194  	
195  	/** gets total number of literals in conflict constraints created in propagation conflict analysis */
196  	SCIP_Longint SCIPconflictGetNPropConflictLiterals(
197  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
198  	   );
199  	
200  	/** gets number of reconvergence constraints detected in propagation conflict analysis */
201  	SCIP_Longint SCIPconflictGetNPropReconvergenceConss(
202  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
203  	   );
204  	
205  	/** gets total number of literals in reconvergence constraints created in propagation conflict analysis */
206  	SCIP_Longint SCIPconflictGetNPropReconvergenceLiterals(
207  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
208  	   );
209  	
210  	/*
211  	 * Infeasible LP Conflict Analysis
212  	 */
213  	
214  	/** analyzes an infeasible or bound exceeding LP to find out the bound changes on variables that were responsible for the
215  	 *  infeasibility or for exceeding the primal bound;
216  	 *  on success, calls standard conflict analysis with the responsible variables as starting conflict set, thus creating
217  	 *  a conflict constraint out of the resulting conflict set;
218  	 *  updates statistics for infeasible or bound exceeding LP conflict analysis
219  	 */
220  	SCIP_RETCODE SCIPconflictAnalyzeLP(
221  	   SCIP_CONFLICT*        conflict,           /**< conflict analysis data */
222  	   SCIP_CONFLICTSTORE*   conflictstore,      /**< conflict store */
223  	   BMS_BLKMEM*           blkmem,             /**< block memory of transformed problem */
224  	   SCIP_SET*             set,                /**< global SCIP settings */
225  	   SCIP_STAT*            stat,               /**< problem statistics */
226  	   SCIP_PROB*            transprob,          /**< transformed problem */
227  	   SCIP_PROB*            origprob,           /**< original problem */
228  	   SCIP_TREE*            tree,               /**< branch and bound tree */
229  	   SCIP_REOPT*           reopt,              /**< reoptimization data structure */
230  	   SCIP_LP*              lp,                 /**< LP data */
231  	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
232  	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
233  	   SCIP_CLIQUETABLE*     cliquetable,        /**< clique table data structure */
234  	   SCIP_Bool*            success             /**< pointer to store whether a conflict constraint was created, or NULL */
235  	   );
236  	
237  	/** gets time in seconds used for analyzing infeasible LP conflicts */
238  	SCIP_Real SCIPconflictGetInfeasibleLPTime(
239  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
240  	   );
241  	
242  	/** gets number of calls to infeasible LP conflict analysis */
243  	SCIP_Longint SCIPconflictGetNInfeasibleLPCalls(
244  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
245  	   );
246  	
247  	/** gets number of calls to infeasible LP conflict analysis that yield at least one conflict constraint */
248  	SCIP_Longint SCIPconflictGetNInfeasibleLPSuccess(
249  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
250  	   );
251  	
252  	/** gets number of conflict constraints detected in infeasible LP conflict analysis */
253  	SCIP_Longint SCIPconflictGetNInfeasibleLPConflictConss(
254  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
255  	   );
256  	
257  	/** gets total number of literals in conflict constraints created in infeasible LP conflict analysis */
258  	SCIP_Longint SCIPconflictGetNInfeasibleLPConflictLiterals(
259  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
260  	   );
261  	
262  	/** gets number of reconvergence constraints detected in infeasible LP conflict analysis */
263  	SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceConss(
264  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
265  	   );
266  	
267  	/** gets total number of literals in reconvergence constraints created in infeasible LP conflict analysis */
268  	SCIP_Longint SCIPconflictGetNInfeasibleLPReconvergenceLiterals(
269  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
270  	   );
271  	
272  	/** gets number of LP iterations in infeasible LP conflict analysis */
273  	SCIP_Longint SCIPconflictGetNInfeasibleLPIterations(
274  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
275  	   );
276  	
277  	/** gets time in seconds used for analyzing bound exceeding LP conflicts */
278  	SCIP_Real SCIPconflictGetBoundexceedingLPTime(
279  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
280  	   );
281  	
282  	/** gets number of calls to bound exceeding LP conflict analysis */
283  	SCIP_Longint SCIPconflictGetNBoundexceedingLPCalls(
284  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
285  	   );
286  	
287  	/** gets number of calls to bound exceeding LP conflict analysis that yield at least one conflict constraint */
288  	SCIP_Longint SCIPconflictGetNBoundexceedingLPSuccess(
289  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
290  	   );
291  	
292  	/** gets number of conflict constraints detected in bound exceeding LP conflict analysis */
293  	SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictConss(
294  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
295  	   );
296  	
297  	/** gets total number of literals in conflict constraints created in bound exceeding LP conflict analysis */
298  	SCIP_Longint SCIPconflictGetNBoundexceedingLPConflictLiterals(
299  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
300  	   );
301  	
302  	/** gets number of reconvergence constraints detected in bound exceeding LP conflict analysis */
303  	SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceConss(
304  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
305  	   );
306  	
307  	/** gets total number of literals in reconvergence constraints created in bound exceeding LP conflict analysis */
308  	SCIP_Longint SCIPconflictGetNBoundexceedingLPReconvergenceLiterals(
309  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
310  	   );
311  	
312  	/** gets number of LP iterations in bound exceeding LP conflict analysis */
313  	SCIP_Longint SCIPconflictGetNBoundexceedingLPIterations(
314  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
315  	   );
316  	
317  	
318  	
319  	
320  	/*
321  	 * infeasible strong branching conflict analysis
322  	 */
323  	
324  	/** analyses infeasible strong branching sub problems for conflicts */
325  	SCIP_RETCODE SCIPconflictAnalyzeStrongbranch(
326  	   SCIP_CONFLICT*        conflict,           /**< conflict analysis data */
327  	   SCIP_CONFLICTSTORE*   conflictstore,      /**< conflict store */
328  	   BMS_BLKMEM*           blkmem,             /**< block memory buffers */
329  	   SCIP_SET*             set,                /**< global SCIP settings */
330  	   SCIP_STAT*            stat,               /**< dynamic problem statistics */
331  	   SCIP_PROB*            transprob,          /**< transformed problem */
332  	   SCIP_PROB*            origprob,           /**< original problem */
333  	   SCIP_TREE*            tree,               /**< branch and bound tree */
334  	   SCIP_REOPT*           reopt,              /**< reoptimization data structure */
335  	   SCIP_LP*              lp,                 /**< LP data */
336  	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
337  	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
338  	   SCIP_CLIQUETABLE*     cliquetable,        /**< clique table data structure */
339  	   SCIP_COL*             col,                /**< LP column with at least one infeasible strong branching subproblem */
340  	   SCIP_Bool*            downconflict,       /**< pointer to store whether a conflict constraint was created for an
341  	                                              *   infeasible downwards branch, or NULL */
342  	   SCIP_Bool*            upconflict          /**< pointer to store whether a conflict constraint was created for an
343  	                                              *   infeasible upwards branch, or NULL */
344  	   );
345  	
346  	/** gets time in seconds used for analyzing infeasible strong branching conflicts */
347  	SCIP_Real SCIPconflictGetStrongbranchTime(
348  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
349  	   );
350  	
351  	/** gets number of successful calls to dual proof analysis derived from infeasible LPs */
352  	SCIP_Longint SCIPconflictGetNDualproofsInfSuccess(
353  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
354  	   );
355  	
356  	/** gets number of globally valid dual proof constraints derived from infeasible LPs */
357  	SCIP_Longint SCIPconflictGetNDualproofsInfGlobal(
358  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
359  	   );
360  	
361  	/** gets number of locally valid dual proof constraints derived from infeasible LPs */
362  	SCIP_Longint SCIPconflictGetNDualproofsInfLocal(
363  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
364  	   );
365  	
366  	/** gets average length of dual proof constraints derived from infeasible LPs */
367  	SCIP_Longint SCIPconflictGetNDualproofsInfNonzeros(
368  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
369  	   );
370  	
371  	/** gets number of successfully analyzed dual proofs derived from bound exceeding LPs */
372  	SCIP_Longint SCIPconflictGetNDualproofsBndSuccess(
373  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
374  	   );
375  	
376  	/** gets number of globally applied dual proofs derived from bound exceeding LPs */
377  	SCIP_Longint SCIPconflictGetNDualproofsBndGlobal(
378  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
379  	   );
380  	
381  	/** gets number of locally applied dual proofs derived from bound exceeding LPs */
382  	SCIP_Longint SCIPconflictGetNDualproofsBndLocal(
383  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
384  	   );
385  	
386  	/** gets average length of dual proofs derived from bound exceeding LPs */
387  	SCIP_Longint SCIPconflictGetNDualproofsBndNonzeros(
388  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
389  	   );
390  	
391  	/** gets number of calls to infeasible strong branching conflict analysis */
392  	SCIP_Longint SCIPconflictGetNStrongbranchCalls(
393  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
394  	   );
395  	
396  	/** gets number of calls to infeasible strong branching conflict analysis that yield at least one conflict constraint */
397  	SCIP_Longint SCIPconflictGetNStrongbranchSuccess(
398  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
399  	   );
400  	
401  	/** gets number of conflict constraints detected in infeasible strong branching conflict analysis */
402  	SCIP_Longint SCIPconflictGetNStrongbranchConflictConss(
403  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
404  	   );
405  	
406  	/** gets total number of literals in conflict constraints created in infeasible strong branching conflict analysis */
407  	SCIP_Longint SCIPconflictGetNStrongbranchConflictLiterals(
408  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
409  	   );
410  	
411  	/** gets number of reconvergence constraints detected in infeasible strong branching conflict analysis */
412  	SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceConss(
413  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
414  	   );
415  	
416  	/** gets total number of literals in reconvergence constraints created in infeasible strong branching conflict analysis */
417  	SCIP_Longint SCIPconflictGetNStrongbranchReconvergenceLiterals(
418  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
419  	   );
420  	
421  	/** gets number of LP iterations in infeasible strong branching conflict analysis */
422  	SCIP_Longint SCIPconflictGetNStrongbranchIterations(
423  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
424  	   );
425  	
426  	
427  	
428  	
429  	/*
430  	 * pseudo solution conflict analysis
431  	 */
432  	
433  	/** analyzes a pseudo solution with objective value exceeding the current cutoff to find out the bound changes on
434  	 *  variables that were responsible for the objective value degradation;
435  	 *  on success, calls standard conflict analysis with the responsible variables as starting conflict set, thus creating
436  	 *  a conflict constraint out of the resulting conflict set;
437  	 *  updates statistics for pseudo solution conflict analysis
438  	 */
439  	SCIP_RETCODE SCIPconflictAnalyzePseudo(
440  	   SCIP_CONFLICT*        conflict,           /**< conflict analysis data */
441  	   BMS_BLKMEM*           blkmem,             /**< block memory of transformed problem */
442  	   SCIP_SET*             set,                /**< global SCIP settings */
443  	   SCIP_STAT*            stat,               /**< problem statistics */
444  	   SCIP_PROB*            transprob,          /**< transformed problem */
445  	   SCIP_PROB*            origprob,           /**< original problem */
446  	   SCIP_TREE*            tree,               /**< branch and bound tree */
447  	   SCIP_REOPT*           reopt,              /**< reoptimization data structure */
448  	   SCIP_LP*              lp,                 /**< LP data */
449  	   SCIP_BRANCHCAND*      branchcand,         /**< branching candidate storage */
450  	   SCIP_EVENTQUEUE*      eventqueue,         /**< event queue */
451  	   SCIP_CLIQUETABLE*     cliquetable,        /**< clique table data structure */
452  	   SCIP_Bool*            success             /**< pointer to store whether a conflict constraint was created, or NULL */
453  	   );
454  	
455  	/** gets time in seconds used for analyzing pseudo solution conflicts */
456  	SCIP_Real SCIPconflictGetPseudoTime(
457  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
458  	   );
459  	
460  	/** gets number of calls to pseudo solution conflict analysis */
461  	SCIP_Longint SCIPconflictGetNPseudoCalls(
462  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
463  	   );
464  	
465  	/** gets number of calls to pseudo solution conflict analysis that yield at least one conflict constraint */
466  	SCIP_Longint SCIPconflictGetNPseudoSuccess(
467  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
468  	   );
469  	
470  	/** gets number of conflict constraints detected in pseudo solution conflict analysis */
471  	SCIP_Longint SCIPconflictGetNPseudoConflictConss(
472  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
473  	   );
474  	
475  	/** gets total number of literals in conflict constraints created in pseudo solution conflict analysis */
476  	SCIP_Longint SCIPconflictGetNPseudoConflictLiterals(
477  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
478  	   );
479  	
480  	/** gets number of reconvergence constraints detected in pseudo solution conflict analysis */
481  	SCIP_Longint SCIPconflictGetNPseudoReconvergenceConss(
482  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
483  	   );
484  	
485  	/** gets total number of literals in reconvergence constraints created in pseudo solution conflict analysis */
486  	SCIP_Longint SCIPconflictGetNPseudoReconvergenceLiterals(
487  	   SCIP_CONFLICT*        conflict            /**< conflict analysis data */
488  	   );
489  	
490  	/** enables or disables all clocks of \p conflict, depending on the value of the flag */
491  	void SCIPconflictEnableOrDisableClocks(
492  	   SCIP_CONFLICT*        conflict,           /**< the conflict analysis data for which all clocks should be enabled or disabled */
493  	   SCIP_Bool             enable              /**< should the clocks of the conflict analysis data be enabled? */
494  	   );
495  	
496  	/** analyzes conflicting bound changes that were added with calls to SCIPconflictAddBound() and
497  	 *  SCIPconflictAddRelaxedBound(), and on success, calls the conflict handlers to create a conflict constraint out of
498  	 *  the resulting conflict set; afterwards the conflict queue and the conflict set is cleared
499  	 */
500  	SCIP_RETCODE conflictAnalyze(
501  	   SCIP_CONFLICT*        conflict,           /**< conflict analysis data */
502  	   BMS_BLKMEM*           blkmem,             /**< block memory of transformed problem */
503  	   SCIP_SET*             set,                /**< global SCIP settings */
504  	   SCIP_STAT*            stat,               /**< problem statistics */
505  	   SCIP_PROB*            prob,               /**< problem data */
506  	   SCIP_TREE*            tree,               /**< branch and bound tree */
507  	   SCIP_Bool             diving,             /**< are we in strong branching or diving mode? */
508  	   int                   validdepth,         /**< minimal depth level at which the initial conflict set is valid */
509  	   SCIP_Bool             mustresolve,        /**< should the conflict set only be used, if a resolution was applied? */
510  	   int*                  nconss,             /**< pointer to store the number of generated conflict constraints */
511  	   int*                  nliterals,          /**< pointer to store the number of literals in generated conflict constraints */
512  	   int*                  nreconvconss,       /**< pointer to store the number of generated reconvergence constraints */
513  	   int*                  nreconvliterals     /**< pointer to store the number of literals generated reconvergence constraints */
514  	   );
515  	
516  	/** calculates a Farkas proof from the current dual LP solution */
517  	SCIP_RETCODE SCIPgetFarkasProof(
518  	   SCIP_SET*             set,                /**< global SCIP settings */
519  	   SCIP_PROB*            prob,               /**< transformed problem */
520  	   SCIP_LP*              lp,                 /**< LP data */
521  	   SCIP_LPI*             lpi,                /**< LPI data */
522  	   SCIP_TREE*            tree,               /**< tree data */
523  	   SCIP_AGGRROW*         farkasrow,          /**< aggregated row representing the proof */
524  	   SCIP_Real*            farkasact,          /**< maximal activity of the proof constraint */
525  	   int*                  validdepth,         /**< pointer to store the valid depth of the proof constraint */
526  	   SCIP_Real*            curvarlbs,          /**< current lower bounds of active problem variables */
527  	   SCIP_Real*            curvarubs,          /**< current upper bounds of active problem variables */
528  	   SCIP_Bool*            valid               /**< pointer store whether the proof constraint is valid */
529  	   );
530  	
531  	/** calculates a dual proof from the current dual LP solution */
532  	SCIP_RETCODE SCIPgetDualProof(
533  	   SCIP_SET*             set,                /**< global SCIP settings */
534  	   SCIP_PROB*            transprob,          /**< transformed problem */
535  	   SCIP_LP*              lp,                 /**< LP data */
536  	   SCIP_LPI*             lpi,                /**< LPI data */
537  	   SCIP_TREE*            tree,               /**< tree data */
538  	   SCIP_AGGRROW*         farkasrow,          /**< aggregated row representing the proof */
539  	   SCIP_Real*            farkasact,          /**< maximal activity of the proof constraint */
540  	   int*                  validdepth,         /**< pointer to store the valid depth of the proof constraint */
541  	   SCIP_Real*            curvarlbs,          /**< current lower bounds of active problem variables */
542  	   SCIP_Real*            curvarubs,          /**< current upper bounds of active problem variables */
543  	   SCIP_Bool*            valid               /**< pointer store whether the proof constraint is valid */
544  	   );
545  	
546  	/** calculates the minimal activity of a given aggregation row */
547  	SCIP_Real SCIPaggrRowGetMinActivity(
548  	   SCIP_SET*             set,                /**< global SCIP settings */
549  	   SCIP_PROB*            transprob,          /**< transformed problem data */
550  	   SCIP_AGGRROW*         aggrrow,            /**< aggregation row */
551  	   SCIP_Real*            curvarlbs,          /**< current lower bounds of active problem variables (or NULL for global bounds) */
552  	   SCIP_Real*            curvarubs,          /**< current upper bounds of active problem variables (or NULL for global bounds) */
553  	   SCIP_Bool*            infdelta            /**< pointer to store whether at least one variable contributes with an infinite value */
554  	   );
555  	#ifdef __cplusplus
556  	}
557  	#endif
558  	
559  	#endif
560