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   type_cons.h
26   	 * @ingroup TYPEDEFINITIONS
27   	 * @brief  type definitions for constraints and constraint handlers
28   	 * @author Tobias Achterberg
29   	 * @author Stefan Heinz
30   	 *
31   	 *  This file defines the interface for constraint handlers implemented in C.
32   	 *
33   	 *  - \ref CONS "Instructions for implementing a constraint handler"
34   	 *  - \ref CONSHDLRS "List of available constraint handlers"
35   	 *  - \ref scip::ObjConshdlr "C++ wrapper class"
36   	 */
37   	
38   	/** @defgroup DEFPLUGINS_CONS Default constraint handlers
39   	 *  @ingroup DEFPLUGINS
40   	 *  @brief implementation files (.c files) of the default constraint handlers of SCIP
41   	 */
42   	
43   	/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
44   	
45   	#ifndef __SCIP_TYPE_CONS_H__
46   	#define __SCIP_TYPE_CONS_H__
47   	
48   	#include "scip/def.h"
49   	#include "scip/type_lp.h"
50   	#include "scip/type_retcode.h"
51   	#include "scip/type_result.h"
52   	#include "scip/type_var.h"
53   	#include "scip/type_sol.h"
54   	#include "scip/type_scip.h"
55   	#include "scip/type_timing.h"
56   	#include "scip/type_heur.h"
57   	
58   	#ifdef __cplusplus
59   	extern "C" {
60   	#endif
61   	
62   	typedef struct SCIP_Conshdlr SCIP_CONSHDLR;       /**< constraint handler for a specific constraint type */
63   	typedef struct SCIP_Cons SCIP_CONS;               /**< constraint data structure */
64   	typedef struct SCIP_ConshdlrData SCIP_CONSHDLRDATA; /**< constraint handler data */
65   	typedef struct SCIP_ConsData SCIP_CONSDATA;       /**< locally defined constraint type specific data */
66   	typedef struct SCIP_ConsSetChg SCIP_CONSSETCHG;   /**< tracks additions and removals of the set of active constraints */
67   	typedef struct SCIP_LinConsStats SCIP_LINCONSSTATS; /**< linear constraint classification statistics used for MIPLIB */
68   	typedef struct SYM_Graph SYM_GRAPH;               /**< data to encode a symmetry detection graph */
69   	
70   	/** linear constraint types recognizable */
71   	enum SCIP_LinConstype
72   	{
73   	   SCIP_LINCONSTYPE_EMPTY         =  0,         /**< linear constraints with no variables */
74   	   SCIP_LINCONSTYPE_FREE          =  1,         /**< linear constraints with no finite side */
75   	   SCIP_LINCONSTYPE_SINGLETON     =  2,         /**< linear constraints with a single variable */
76   	   SCIP_LINCONSTYPE_AGGREGATION   =  3,         /**< linear constraints of the type \f$ ax + by = c\f$ */
77   	   SCIP_LINCONSTYPE_PRECEDENCE    =  4,         /**< linear constraints of the type \f$ a x - a y \leq b\f$ where \f$x\f$ and \f$y\f$ must have the same type */
78   	   SCIP_LINCONSTYPE_VARBOUND      =  5,         /**< linear constraints of the form \f$ ax + by \leq c \, x \in \{0,1\} \f$ */
79   	   SCIP_LINCONSTYPE_SETPARTITION  =  6,         /**< linear constraints of the form \f$ \sum x_i = 1\, x_i \in \{0,1\} \forall i \f$ */
80   	   SCIP_LINCONSTYPE_SETPACKING    =  7,         /**< linear constraints of the form \f$ \sum x_i \leq 1\, x_i \in \{0,1\} \forall i \f$ */
81   	   SCIP_LINCONSTYPE_SETCOVERING   =  8,         /**< linear constraints of the form \f$ \sum x_i \geq 1\, x_i \in \{0,1\} \forall i \f$ */
82   	   SCIP_LINCONSTYPE_CARDINALITY   =  9,         /**< linear constraints of the form \f$ \sum x_i = k\, x_i \in \{0,1\} \forall i, \, k\geq 2 \f$ */
83   	   SCIP_LINCONSTYPE_INVKNAPSACK   = 10,         /**< linear constraints of the form \f$ \sum x_i \leq b\, x_i \in \{0,1\} \forall i, \, b\in \mathbb{n} \geq 2 \f$ */
84   	   SCIP_LINCONSTYPE_EQKNAPSACK    = 11,         /**< linear constraints of the form \f$ \sum a_i x_i = b\, x_i \in \{0,1\} \forall i, \, b\in \mathbb{n} \geq 2 \f$ */
85   	   SCIP_LINCONSTYPE_BINPACKING    = 12,         /**< linear constraints of the form \f$ \sum a_i x_i + a x \leq a\, x, x_i \in \{0,1\} \forall i, \, a\in \mathbb{n} \geq 2 \f$ */
86   	   SCIP_LINCONSTYPE_KNAPSACK      = 13,         /**< linear constraints of the form \f$ \sum a_k x_k \leq b\, x_i \in \{0,1\} \forall i, \, b\in \mathbb{n} \geq 2 \f$ */
87   	   SCIP_LINCONSTYPE_INTKNAPSACK   = 14,         /**< linear constraints of the form \f$ \sum a_k x_k \leq b\, x_i \in \mathbb{Z} \forall i, \, b\in \mathbb{n} \f$ */
88   	   SCIP_LINCONSTYPE_MIXEDBINARY   = 15,         /**< linear constraints of the form \f$ \sum a_k x_k + \sum p_j s_j \leq/= b\, x_i \in \{0,1\} \forall i, s_j \in \text{ cont. } \forall j\f$ */
89   	   SCIP_LINCONSTYPE_GENERAL       = 16          /**< general linear constraints with no special structure */
90   	};
91   	typedef enum SCIP_LinConstype SCIP_LINCONSTYPE;
92   	
93   	#define SCIP_NLINCONSTYPES ((int)SCIP_LINCONSTYPE_GENERAL+1)
94   	
95   	/** copy method for constraint handler plugins (called when SCIP copies plugins)
96   	 *
97   	 *  If the copy process was one to one, the valid pointer can be set to TRUE. Otherwise, this pointer has to be set to
98   	 *  FALSE. If all problem defining objects (constraint handlers and variable pricers) return valid = TRUE for all
99   	 *  their copying calls, SCIP assumes that it is an overall one to one copy of the original instance. In this case any
100  	 *  reductions made in the copied SCIP instance can be transfered to the original SCIP instance. If the valid pointer is
101  	 *  set to TRUE and it was not a one to one copy, it might happen that optimal solutions are cut off.
102  	 *
103  	 *  input:
104  	 *  - scip            : SCIP main data structure
105  	 *  - conshdlr        : the constraint handler itself
106  	 *  - valid           : was the copying process valid?
107  	 */
108  	#define SCIP_DECL_CONSHDLRCOPY(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_Bool* valid)
109  	
110  	/** destructor of constraint handler to free constraint handler data (called when SCIP is exiting)
111  	 *
112  	 *  input:
113  	 *  - scip            : SCIP main data structure
114  	 *  - conshdlr        : the constraint handler itself
115  	 */
116  	#define SCIP_DECL_CONSFREE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr)
117  	
118  	/** initialization method of constraint handler (called after problem was transformed)
119  	 *
120  	 *  input:
121  	 *  - scip            : SCIP main data structure
122  	 *  - conshdlr        : the constraint handler itself
123  	 *  - conss           : array of constraints in transformed problem
124  	 *  - nconss          : number of constraints in transformed problem
125  	 */
126  	#define SCIP_DECL_CONSINIT(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
127  	
128  	/** deinitialization method of constraint handler (called before transformed problem is freed)
129  	 *
130  	 *  input:
131  	 *  - scip            : SCIP main data structure
132  	 *  - conshdlr        : the constraint handler itself
133  	 *  - conss           : array of constraints in transformed problem
134  	 *  - nconss          : number of constraints in transformed problem
135  	 */
136  	#define SCIP_DECL_CONSEXIT(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
137  	
138  	/** presolving initialization method of constraint handler (called when presolving is about to begin)
139  	 *
140  	 *  This method is called when the presolving process is about to begin, even if presolving is turned off.
141  	 *  The constraint handler may use this call to initialize its data structures.
142  	 *
143  	 *  Necessary modifications that have to be performed even if presolving is turned off should be done here or in the
144  	 *  presolving deinitialization call (SCIP_DECL_CONSEXITPRE()).
145  	 *
146  	 *  @note Note that the constraint array might contain constraints that were created but not added to the problem.
147  	 *        Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem
148  	 *        reductions.
149  	 *
150  	 *  input:
151  	 *  - scip            : SCIP main data structure
152  	 *  - conshdlr        : the constraint handler itself
153  	 *  - conss           : array of constraints in transformed problem
154  	 *  - nconss          : number of constraints in transformed problem
155  	 */
156  	#define SCIP_DECL_CONSINITPRE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
157  	
158  	/** presolving deinitialization method of constraint handler (called after presolving has been finished)
159  	 *
160  	 *  This method is called after the presolving has been finished, even if presolving is turned off.
161  	 *  The constraint handler may use this call e.g. to clean up or modify its data structures.
162  	 *
163  	 *  Necessary modifications that have to be performed even if presolving is turned off should be done here or in the
164  	 *  presolving initialization call (SCIP_DECL_CONSINITPRE()).
165  	 *
166  	 *  Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the
167  	 *  problem has already been solved.  Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL,
168  	 *  SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD.
169  	 *
170  	 *  @note Note that the constraint array might contain constraints that were created but not added to the problem.
171  	 *        Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem
172  	 *        reductions.
173  	 *
174  	 *  input:
175  	 *  - scip            : SCIP main data structure
176  	 *  - conshdlr        : the constraint handler itself
177  	 *  - conss           : final array of constraints in transformed problem
178  	 *  - nconss          : final number of constraints in transformed problem
179  	 */
180  	#define SCIP_DECL_CONSEXITPRE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
181  	
182  	/** solving process initialization method of constraint handler (called when branch and bound process is about to begin)
183  	 *
184  	 *  This method is called when the presolving was finished and the branch and bound process is about to begin.
185  	 *  The constraint handler may use this call to initialize its branch and bound specific data.
186  	 *
187  	 *  Besides necessary modifications and clean up, no time consuming operations should be performed, especially if the
188  	 *  problem has already been solved.  Use the method SCIPgetStatus(), which in this case returns SCIP_STATUS_OPTIMAL,
189  	 *  SCIP_STATUS_INFEASIBLE, SCIP_STATUS_UNBOUNDED, or SCIP_STATUS_INFORUNBD.
190  	 *
191  	 *  @note Note that the constraint array might contain constraints that were created but not added to the problem.
192  	 *        Constraints that are not added, i.e., for which SCIPconsIsAdded() returns FALSE, cannot be used for problem
193  	 *        reductions.
194  	 *
195  	 *  input:
196  	 *  - scip            : SCIP main data structure
197  	 *  - conshdlr        : the constraint handler itself
198  	 *  - conss           : array of constraints of the constraint handler
199  	 *  - nconss          : number of constraints of the constraint handler
200  	 */
201  	#define SCIP_DECL_CONSINITSOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
202  	
203  	/** solving process deinitialization method of constraint handler (called before branch and bound process data is freed)
204  	 *
205  	 *  This method is called before the branch and bound process is freed.
206  	 *  The constraint handler should use this call to clean up its branch and bound data, in particular to release
207  	 *  all LP rows that he has created or captured.
208  	 *
209  	 *  input:
210  	 *  - scip            : SCIP main data structure
211  	 *  - conshdlr        : the constraint handler itself
212  	 *  - conss           : array of constraints of the constraint handler
213  	 *  - nconss          : number of constraints of the constraint handler
214  	 *  - restart         : was this exit solve call triggered by a restart?
215  	 */
216  	#define SCIP_DECL_CONSEXITSOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool restart)
217  	
218  	/** frees specific constraint data
219  	 *
220  	 *  @warning There may exist unprocessed events. For example, a variable's bound may have been already changed, but the
221  	 *           corresponding bound change event was not yet processed.
222  	 *
223  	 *  input:
224  	 *  - scip            : SCIP main data structure
225  	 *  - conshdlr        : the constraint handler itself
226  	 *  - cons            : the constraint belonging to the constraint data
227  	 *  - consdata        : pointer to the constraint data to free
228  	 */
229  	#define SCIP_DECL_CONSDELETE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_CONSDATA** consdata)
230  	
231  	/** transforms constraint data into data belonging to the transformed problem
232  	 *
233  	 *  input:
234  	 *  - scip            : SCIP main data structure
235  	 *  - conshdlr        : the constraint handler itself
236  	 *  - sourcecons      : source constraint to transform
237  	 *  - targetcons      : pointer to store created target constraint
238  	 */
239  	#define SCIP_DECL_CONSTRANS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* sourcecons, SCIP_CONS** targetcons)
240  	
241  	/** LP initialization method of constraint handler (called before the initial LP relaxation at a node is solved)
242  	 *
243  	 *  Puts the LP relaxations of all "initial" constraints into the LP. The method should put a canonic LP relaxation
244  	 *  of all given constraints to the LP with calls to SCIPaddRow().
245  	 *
246  	 *  @warning It is not guaranteed that the problem is going to be declared infeasible if the infeasible pointer is set
247  	 *           to TRUE. Therefore, it is recommended that users do not end this method prematurely when an infeasiblity
248  	 *           is detected.
249  	 *
250  	 *  input:
251  	 *  - scip            : SCIP main data structure
252  	 *  - conshdlr        : the constraint handler itself
253  	 *  - conss           : array of constraints to process
254  	 *  - nconss          : number of constraints to process
255  	 *
256  	 *  output:
257  	 *  - infeasible      : pointer to store whether an infeasibility was detected while building the LP
258  	 */
259  	#define SCIP_DECL_CONSINITLP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_Bool* infeasible)
260  	
261  	/** separation method of constraint handler for LP solution
262  	 *
263  	 *  Separates all constraints of the constraint handler. The method is called in the LP solution loop,
264  	 *  which means that a valid LP solution exists.
265  	 *
266  	 *  The first nusefulconss constraints are the ones, that are identified to likely be violated. The separation
267  	 *  method should process only the useful constraints in most runs, and only occasionally the remaining
268  	 *  nconss - nusefulconss constraints.
269  	 *
270  	 *  input:
271  	 *  - scip            : SCIP main data structure
272  	 *  - conshdlr        : the constraint handler itself
273  	 *  - conss           : array of constraints to process
274  	 *  - nconss          : number of constraints to process
275  	 *  - nusefulconss    : number of useful (non-obsolete) constraints to process
276  	 *  - result          : pointer to store the result of the separation call
277  	 *
278  	 *  possible return values for *result (if more than one applies, the first in the list should be used):
279  	 *  - SCIP_CUTOFF     : the node is infeasible in the variable's bounds and can be cut off
280  	 *  - SCIP_CONSADDED  : an additional constraint was generated
281  	 *  - SCIP_REDUCEDDOM : a variable's domain was reduced
282  	 *  - SCIP_SEPARATED  : a cutting plane was generated
283  	 *  - SCIP_NEWROUND   : a cutting plane was generated and a new separation round should immediately start
284  	 *  - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints
285  	 *  - SCIP_DIDNOTRUN  : the separator was skipped
286  	 *  - SCIP_DELAYED    : the separator was skipped, but should be called again
287  	 */
288  	#define SCIP_DECL_CONSSEPALP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, \
289  	      int nconss, int nusefulconss, SCIP_RESULT* result)
290  	
291  	/** separation method of constraint handler for arbitrary primal solution
292  	 *
293  	 *  Separates all constraints of the constraint handler. The method is called outside the LP solution loop (e.g., by
294  	 *  a relaxator or a primal heuristic), which means that there is no valid LP solution.
295  	 *  Instead, the method should produce cuts that separate the given solution.
296  	 *
297  	 *  The first nusefulconss constraints are the ones, that are identified to likely be violated. The separation
298  	 *  method should process only the useful constraints in most runs, and only occasionally the remaining
299  	 *  nconss - nusefulconss constraints.
300  	 *
301  	 *  input:
302  	 *  - scip            : SCIP main data structure
303  	 *  - conshdlr        : the constraint handler itself
304  	 *  - conss           : array of constraints to process
305  	 *  - nconss          : number of constraints to process
306  	 *  - nusefulconss    : number of useful (non-obsolete) constraints to process
307  	 *  - sol             : primal solution that should be separated
308  	 *  - result          : pointer to store the result of the separation call
309  	 *
310  	 *  possible return values for *result (if more than one applies, the first in the list should be used):
311  	 *  - SCIP_CUTOFF     : the node is infeasible in the variable's bounds and can be cut off
312  	 *  - SCIP_CONSADDED  : an additional constraint was generated
313  	 *  - SCIP_REDUCEDDOM : a variable's domain was reduced
314  	 *  - SCIP_SEPARATED  : a cutting plane was generated
315  	 *  - SCIP_NEWROUND   : a cutting plane was generated and a new separation round should immediately start
316  	 *  - SCIP_DIDNOTFIND : the separator searched, but did not find domain reductions, cutting planes, or cut constraints
317  	 *  - SCIP_DIDNOTRUN  : the separator was skipped
318  	 *  - SCIP_DELAYED    : the separator was skipped, but should be called again
319  	 */
320  	#define SCIP_DECL_CONSSEPASOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, \
321  	      int nconss, int nusefulconss, SCIP_SOL* sol, SCIP_RESULT* result)
322  	
323  	/** constraint enforcing method of constraint handler for LP solutions
324  	 *
325  	 *  The method is called at the end of the node processing loop for a node where the LP was solved.
326  	 *  The LP solution has to be checked for feasibility. If possible, an infeasibility should be resolved by
327  	 *  branching, reducing a variable's domain to exclude the solution or separating the solution with a valid
328  	 *  cutting plane.
329  	 *
330  	 *  The enforcing methods of the active constraint handlers are called in decreasing order of their enforcing
331  	 *  priorities until the first constraint handler returned with the value SCIP_CUTOFF, SCIP_SEPARATED,
332  	 *  SCIP_REDUCEDDOM, SCIP_CONSADDED, or SCIP_BRANCHED.
333  	 *  The integrality constraint handler has an enforcing priority of zero. A constraint handler which can
334  	 *  (or wants) to enforce its constraints only for integral solutions should have a negative enforcing priority
335  	 *  (e.g. the alldiff-constraint can only operate on integral solutions).
336  	 *  A constraint handler which wants to incorporate its own branching strategy even on non-integral
337  	 *  solutions must have an enforcing priority greater than zero (e.g. the SOS-constraint incorporates
338  	 *  SOS-branching on non-integral solutions).
339  	 *
340  	 *  The first nusefulconss constraints are the ones, that are identified to likely be violated. The enforcing
341  	 *  method should process the useful constraints first. The other nconss - nusefulconss constraints should only
342  	 *  be enforced, if no violation was found in the useful constraints.
343  	 *
344  	 *  input:
345  	 *  - scip            : SCIP main data structure
346  	 *  - conshdlr        : the constraint handler itself
347  	 *  - conss           : array of constraints to process
348  	 *  - nconss          : number of constraints to process
349  	 *  - nusefulconss    : number of useful (non-obsolete) constraints to process
350  	 *  - solinfeasible   : was the solution already declared infeasible by a constraint handler?
351  	 *  - result          : pointer to store the result of the enforcing call
352  	 *
353  	 *  possible return values for *result (if more than one applies, the first in the list should be used):
354  	 *  - SCIP_CUTOFF     : the node is infeasible in the variable's bounds and can be cut off
355  	 *  - SCIP_CONSADDED  : an additional constraint was generated (added constraints must have initial flag = TRUE)
356  	 *  - SCIP_REDUCEDDOM : a variable's domain was reduced
357  	 *  - SCIP_SEPARATED  : a cutting plane was generated
358  	 *  - SCIP_SOLVELP    : the LP should be solved again because the LP primal feasibility tolerance has been tightened
359  	 *  - SCIP_BRANCHED   : no changes were made to the problem, but a branching was applied to resolve an infeasibility
360  	 *  - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved
361  	 *  - SCIP_FEASIBLE   : all constraints of the handler are feasible
362  	 */
363  	#define SCIP_DECL_CONSENFOLP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \
364  	      SCIP_Bool solinfeasible, SCIP_RESULT* result)
365  	
366  	/** constraint enforcing method of constraint handler for relaxation solutions
367  	 *
368  	 *  input:
369  	 *  - scip            : SCIP main data structure
370  	 *  - sol             : relaxation solution
371  	 *  - conshdlr        : the constraint handler itself
372  	 *  - conss           : array of constraints to process
373  	 *  - nconss          : number of constraints to process
374  	 *  - nusefulconss    : number of useful (non-obsolete) constraints to process
375  	 *  - solinfeasible   : was the solution already declared infeasible by a constraint handler?
376  	 *  - result          : pointer to store the result of the enforcing call
377  	 *
378  	 *  possible return values for *result (if more than one applies, the first in the list should be used):
379  	 *  - SCIP_CUTOFF     : the node is infeasible in the variable's bounds and can be cut off
380  	 *  - SCIP_CONSADDED  : an additional constraint was generated (added constraints must have initial flag = TRUE)
381  	 *  - SCIP_REDUCEDDOM : a variable's domain was reduced
382  	 *  - SCIP_SEPARATED  : a cutting plane was generated
383  	 *  - SCIP_BRANCHED   : no changes were made to the problem, but a branching was applied to resolve an infeasibility
384  	 *  - SCIP_SOLVELP    : at least one constraint is infeasible, and this can only be resolved by solving the LP
385  	 *  - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved
386  	 *  - SCIP_FEASIBLE   : all constraints of the handler are feasible
387  	 */
388  	#define SCIP_DECL_CONSENFORELAX(x) SCIP_RETCODE x (SCIP* scip, SCIP_SOL* sol, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \
389  	      SCIP_Bool solinfeasible, SCIP_RESULT* result)
390  	
391  	/** constraint enforcing method of constraint handler for pseudo solutions
392  	 *
393  	 *  The method is called at the end of the node processing loop for a node where the LP was not solved.
394  	 *  The pseudo solution has to be checked for feasibility. If possible, an infeasibility should be resolved by
395  	 *  branching, reducing a variable's domain to exclude the solution or adding an additional constraint.
396  	 *  Separation is not possible, since the LP is not processed at the current node. All LP informations like
397  	 *  LP solution, slack values, or reduced costs are invalid and must not be accessed.
398  	 *
399  	 *  Like in the enforcing method for LP solutions, the enforcing methods of the active constraint handlers are
400  	 *  called in decreasing order of their enforcing priorities until the first constraint handler returned with
401  	 *  the value SCIP_CUTOFF, SCIP_REDUCEDDOM, SCIP_CONSADDED, SCIP_BRANCHED, or SCIP_SOLVELP.
402  	 *
403  	 *  The first nusefulconss constraints are the ones, that are identified to likely be violated. The enforcing
404  	 *  method should process the useful constraints first. The other nconss - nusefulconss constraints should only
405  	 *  be enforced, if no violation was found in the useful constraints.
406  	 *
407  	 *  If the pseudo solution's objective value is lower than the lower bound of the node, it cannot be feasible
408  	 *  and the enforcing method may skip it's check and set *result to SCIP_DIDNOTRUN. However, it can also process
409  	 *  its constraints and return any other possible result code.
410  	 *
411  	 *  input:
412  	 *  - scip            : SCIP main data structure
413  	 *  - conshdlr        : the constraint handler itself
414  	 *  - conss           : array of constraints to process
415  	 *  - nconss          : number of constraints to process
416  	 *  - nusefulconss    : number of useful (non-obsolete) constraints to process
417  	 *  - solinfeasible   : was the solution already declared infeasible by a constraint handler?
418  	 *  - objinfeasible   : is the solution infeasible anyway due to violating lower objective bound?
419  	 *  - result          : pointer to store the result of the enforcing call
420  	 *
421  	 *  possible return values for *result (if more than one applies, the first in the list should be used):
422  	 *  - SCIP_CUTOFF     : the node is infeasible in the variable's bounds and can be cut off
423  	 *  - SCIP_CONSADDED  : an additional constraint was generated
424  	 *  - SCIP_REDUCEDDOM : a variable's domain was reduced
425  	 *  - SCIP_BRANCHED   : no changes were made to the problem, but a branching was applied to resolve an infeasibility
426  	 *  - SCIP_SOLVELP    : at least one constraint is infeasible, and this can only be resolved by solving the LP
427  	 *  - SCIP_INFEASIBLE : at least one constraint is infeasible, but it was not resolved
428  	 *  - SCIP_FEASIBLE   : all constraints of the handler are feasible
429  	 *  - SCIP_DIDNOTRUN  : the enforcement was skipped (only possible, if objinfeasible is true)
430  	 */
431  	#define SCIP_DECL_CONSENFOPS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \
432  	      SCIP_Bool solinfeasible, SCIP_Bool objinfeasible, SCIP_RESULT* result)
433  	
434  	/** feasibility check method of constraint handler for integral solutions
435  	 *
436  	 *  The given solution has to be checked for feasibility.
437  	 *
438  	 *  The check methods of the active constraint handlers are called in decreasing order of their check
439  	 *  priorities until the first constraint handler returned with the result SCIP_INFEASIBLE.
440  	 *  The integrality constraint handler has a check priority of zero. A constraint handler which can
441  	 *  (or wants) to check its constraints only for integral solutions should have a negative check priority
442  	 *  (e.g. the alldiff-constraint can only operate on integral solutions).
443  	 *  A constraint handler which wants to check feasibility even on non-integral solutions must have a
444  	 *  check priority greater than zero (e.g. if the check is much faster than testing all variables for
445  	 *  integrality).
446  	 *
447  	 *  In some cases, integrality conditions or rows of the current LP don't have to be checked, because their
448  	 *  feasibility is already checked or implicitly given. In these cases, 'checkintegrality' or
449  	 *  'checklprows' is FALSE.
450  	 *
451  	 *  If the solution is not NULL, SCIP should also be informed about the constraint violation with a call to
452  	 *  SCIPupdateSolConsViolation() and additionally SCIPupdateSolLPRowViolation() for every row of the constraint's current
453  	 *  representation in the LP relaxation, if any such rows exist.
454  	 *  As a convenience method, SCIPupdateSolLPConsViolation() can be used if the constraint
455  	 *  is represented completely by a set of LP rows, meaning that the current constraint violation is equal to the maximum
456  	 *  of the contraint violations of the corresponding LP rows.
457  	 *
458  	 *  input:
459  	 *  - scip            : SCIP main data structure
460  	 *  - conshdlr        : the constraint handler itself
461  	 *  - conss           : array of constraints to process
462  	 *  - nconss          : number of constraints to process
463  	 *  - sol             : the solution to check feasibility for
464  	 *  - checkintegrality: Has integrality to be checked?
465  	 *  - checklprows     : Do constraints represented by rows in the current LP have to be checked?
466  	 *  - printreason     : Should the reason for the violation be printed?
467  	 *  - completely      : Should all violations be checked?
468  	 *  - result          : pointer to store the result of the feasibility checking call
469  	 *
470  	 *  possible return values for *result:
471  	 *  - SCIP_INFEASIBLE : at least one constraint of the handler is infeasible
472  	 *  - SCIP_FEASIBLE   : all constraints of the handler are feasible
473  	 */
474  	#define SCIP_DECL_CONSCHECK(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, SCIP_SOL* sol, \
475  	      SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_Bool completely, SCIP_RESULT* result)
476  	
477  	/** domain propagation method of constraint handler
478  	 *
479  	 *  The first nusefulconss constraints are the ones, that are identified to likely be violated. The propagation
480  	 *  method should process only the useful constraints in most runs, and only occasionally the remaining
481  	 *  nconss - nusefulconss constraints.
482  	 *
483  	 *  @note if the constraint handler uses dual information in propagation it is nesassary to check via calling
484  	 *        SCIPallowWeakDualReds and SCIPallowStrongDualReds if dual reductions and propgation with the current cutoff bound, resp.,
485  	 *        are allowed.
486  	 *
487  	 *  input:
488  	 *  - scip            : SCIP main data structure
489  	 *  - conshdlr        : the constraint handler itself
490  	 *  - conss           : array of constraints to process
491  	 *  - nconss          : number of constraints to process
492  	 *  - nusefulconss    : number of useful (non-obsolete) constraints to process
493  	 *  - nmarkedconss    : number of constraints which are marked to be definitely propagated
494  	 *  - proptiming      : current point in the node solving loop
495  	 *  - result          : pointer to store the result of the propagation call
496  	 *
497  	 *  possible return values for *result:
498  	 *  - SCIP_CUTOFF     : the node is infeasible in the variable's bounds and can be cut off
499  	 *  - SCIP_REDUCEDDOM : at least one domain reduction was found
500  	 *  - SCIP_DIDNOTFIND : the propagator searched but did not find any domain reductions
501  	 *  - SCIP_DIDNOTRUN  : the propagator was skipped
502  	 *  - SCIP_DELAYED    : the propagator was skipped, but should be called again
503  	 *  - SCIP_DELAYNODE  : the current node should be postponed (return value only valid for BEFORELP propagation)
504  	 */
505  	#define SCIP_DECL_CONSPROP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nusefulconss, \
506  	      int nmarkedconss, SCIP_PROPTIMING proptiming, SCIP_RESULT* result)
507  	
508  	/** presolving method of constraint handler
509  	 *
510  	 *  The presolver should go through the variables and constraints and tighten the domains or
511  	 *  constraints. Each tightening should increase the given total number of changes.
512  	 *
513  	 *  input:
514  	 *  - scip            : SCIP main data structure
515  	 *  - conshdlr        : the constraint handler itself
516  	 *  - conss           : array of constraints to process
517  	 *  - nconss          : number of constraints to process
518  	 *  - nrounds         : number of presolving rounds already done
519  	 *  - presoltiming    : current presolving timing
520  	 *  - nnewfixedvars   : number of variables fixed since the last call to the presolving method
521  	 *  - nnewaggrvars    : number of variables aggregated since the last call to the presolving method
522  	 *  - nnewchgvartypes : number of variable type changes since the last call to the presolving method
523  	 *  - nnewchgbds      : number of variable bounds tightened since the last call to the presolving method
524  	 *  - nnewholes       : number of domain holes added since the last call to the presolving method
525  	 *  - nnewdelconss    : number of deleted constraints since the last call to the presolving method
526  	 *  - nnewaddconss    : number of added constraints since the last call to the presolving method
527  	 *  - nnewupgdconss   : number of upgraded constraints since the last call to the presolving method
528  	 *  - nnewchgcoefs    : number of changed coefficients since the last call to the presolving method
529  	 *  - nnewchgsides    : number of changed left or right hand sides since the last call to the presolving method
530  	 *
531  	 *  @note the counters state the changes since the last call including the changes of this presolving method during its
532  	 *        call
533  	 *
534  	 *  @note if the constraint handler performs dual presolving it is nesassary to check via calling SCIPallowWeakDualReds
535  	 *        and SCIPallowStrongDualReds if dual reductions are allowed.
536  	 *
537  	 *  input/output:
538  	 *  - nfixedvars      : pointer to count total number of variables fixed of all presolvers
539  	 *  - naggrvars       : pointer to count total number of variables aggregated of all presolvers
540  	 *  - nchgvartypes    : pointer to count total number of variable type changes of all presolvers
541  	 *  - nchgbds         : pointer to count total number of variable bounds tightened of all presolvers
542  	 *  - naddholes       : pointer to count total number of domain holes added of all presolvers
543  	 *  - ndelconss       : pointer to count total number of deleted constraints of all presolvers
544  	 *  - naddconss       : pointer to count total number of added constraints of all presolvers
545  	 *  - nupgdconss      : pointer to count total number of upgraded constraints of all presolvers
546  	 *  - nchgcoefs       : pointer to count total number of changed coefficients of all presolvers
547  	 *  - nchgsides       : pointer to count total number of changed left/right hand sides of all presolvers
548  	 *
549  	 *  output:
550  	 *  - result          : pointer to store the result of the presolving call
551  	 *
552  	 *  possible return values for *result:
553  	 *  - SCIP_UNBOUNDED  : at least one variable is not bounded by any constraint in obj. direction -> problem is unbounded
554  	 *  - SCIP_CUTOFF     : at least one constraint is infeasible in the variable's bounds -> problem is infeasible
555  	 *  - SCIP_SUCCESS    : the presolving method found a reduction
556  	 *  - SCIP_DIDNOTFIND : the presolving method searched, but did not find a presolving change
557  	 *  - SCIP_DIDNOTRUN  : the presolving method was skipped
558  	 *  - SCIP_DELAYED    : the presolving method was skipped, but should be called again
559  	 */
560  	#define SCIP_DECL_CONSPRESOL(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss, int nrounds, \
561  	      SCIP_PRESOLTIMING presoltiming, int nnewfixedvars, int nnewaggrvars, int nnewchgvartypes, int nnewchgbds, int nnewholes, \
562  	      int nnewdelconss, int nnewaddconss, int nnewupgdconss, int nnewchgcoefs, int nnewchgsides, \
563  	      int* nfixedvars, int* naggrvars, int* nchgvartypes, int* nchgbds, int* naddholes, \
564  	      int* ndelconss, int* naddconss, int* nupgdconss, int* nchgcoefs, int* nchgsides, SCIP_RESULT* result)
565  	
566  	/** propagation conflict resolving method of constraint handler
567  	 *
568  	 *  This method is called during conflict analysis. If the constraint handler wants to support conflict analysis,
569  	 *  it should call SCIPinferVarLbCons() or SCIPinferVarUbCons() in domain propagation instead of SCIPchgVarLb() or
570  	 *  SCIPchgVarUb() in order to deduce bound changes on variables.
571  	 *  In the SCIPinferVarLbCons() and SCIPinferVarUbCons() calls, the handler provides the constraint, that deduced the
572  	 *  variable's bound change, and an integer value "inferinfo" that can be arbitrarily chosen.
573  	 *  The propagation conflict resolving method can then be implemented, to provide a "reason" for the bound
574  	 *  changes, i.e., the bounds of variables at the time of the propagation, that forced the constraint to set the
575  	 *  conflict variable's bound to its current value. It can use the "inferinfo" tag to identify its own propagation
576  	 *  rule and thus identify the "reason" bounds. The bounds that form the reason of the assignment must then be provided
577  	 *  by calls to SCIPaddConflictLb(), SCIPaddConflictUb(), SCIPaddConflictBd(), SCIPaddConflictRelaxedLb(),
578  	 *  SCIPaddConflictRelaxedUb(), SCIPaddConflictRelaxedBd(), and/or SCIPaddConflictBinvar() in the propagation conflict
579  	 *  resolving method.
580  	 *
581  	 *  For example, the logicor constraint c = "x or y or z" fixes variable z to TRUE (i.e. changes the lower bound of z
582  	 *  to 1.0), if both, x and y, are assigned to FALSE (i.e. if the upper bounds of these variables are 0.0). It uses
583  	 *  SCIPinferVarLbCons(scip, z, 1.0, c, 0) to apply this assignment (an inference information tag is not needed by the
584  	 *  constraint handler and is set to 0).
585  	 *  In the conflict analysis, the constraint handler may be asked to resolve the lower bound change on z with
586  	 *  constraint c, that was applied at a time given by a bound change index "bdchgidx".
587  	 *  With a call to SCIPgetVarLbAtIndex(scip, z, bdchgidx, TRUE), the handler can find out, that the lower bound of
588  	 *  variable z was set to 1.0 at the given point of time, and should call SCIPaddConflictUb(scip, x, bdchgidx) and
589  	 *  SCIPaddConflictUb(scip, y, bdchgidx) to tell SCIP, that the upper bounds of x and y at this point of time were
590  	 *  the reason for the deduction of the lower bound of z.
591  	 *
592  	 *  input:
593  	 *  - scip            : SCIP main data structure
594  	 *  - conshdlr        : the constraint handler itself
595  	 *  - cons            : the constraint that deduced the bound change of the conflict variable
596  	 *  - infervar        : the conflict variable whose bound change has to be resolved
597  	 *  - inferinfo       : the user information passed to the corresponding SCIPinferVarLbCons() or SCIPinferVarUbCons() call
598  	 *  - boundtype       : the type of the changed bound (lower or upper bound)
599  	 *  - bdchgidx        : the index of the bound change, representing the point of time where the change took place
600  	 *  - relaxedbd       : the relaxed bound which is sufficient to be explained
601  	 *
602  	 *  output:
603  	 *  - result          : pointer to store the result of the propagation conflict resolving call
604  	 *
605  	 *  possible return values for *result:
606  	 *  - SCIP_SUCCESS    : the conflicting bound change has been successfully resolved by adding all reason bounds
607  	 *  - SCIP_DIDNOTFIND : the conflicting bound change could not be resolved and has to be put into the conflict set
608  	 *
609  	 *  @note it is sufficient to explain/resolve the relaxed bound
610  	 */
611  	#define SCIP_DECL_CONSRESPROP(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \
612  	      SCIP_VAR* infervar, int inferinfo, SCIP_BOUNDTYPE boundtype, SCIP_BDCHGIDX* bdchgidx, SCIP_Real relaxedbd, \
613  	      SCIP_RESULT* result)
614  	
615  	/** variable rounding lock method of constraint handler
616  	 *
617  	 *  This method is called, after a constraint is added or removed from the transformed problem.
618  	 *  It should update the rounding locks of the given type of all associated variables with calls to
619  	 *  SCIPaddVarLocksType(), depending on the way, the variable is involved in the constraint:
620  	 *  - If the constraint may get violated by decreasing the value of a variable, it should call
621  	 *    SCIPaddVarLocksType(scip, var, locktype, nlockspos, nlocksneg), saying that rounding down is
622  	 *    potentially rendering the (positive) constraint infeasible and rounding up is potentially rendering the
623  	 *    negation of the constraint infeasible.
624  	 *  - If the constraint may get violated by increasing the value of a variable, it should call
625  	 *    SCIPaddVarLocksType(scip, var, locktype, nlocksneg, nlockspos), saying that rounding up is
626  	 *    potentially rendering the constraint's negation infeasible and rounding up is potentially rendering the
627  	 *    constraint itself infeasible.
628  	 *  - If the constraint may get violated by changing the variable in any direction, it should call
629  	 *    SCIPaddVarLocksType(scip, var, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg).
630  	 *
631  	 *  Consider the linear constraint "3x -5y +2z <= 7" as an example. The variable rounding lock method of the
632  	 *  linear constraint handler should call SCIPaddVarLocksType(scip, x, locktype, nlocksneg, nlockspos),
633  	 *  SCIPaddVarLocksType(scip, y, locktype, nlockspos, nlocksneg) and
634  	 *  SCIPaddVarLocksType(scip, z, type, nlocksneg, nlockspos) to tell SCIP, that rounding up of x and z and rounding
635  	 *  down of y can destroy the feasibility of the constraint, while rounding down of x and z and rounding up of y can
636  	 *  destroy the feasibility of the constraint's negation "3x -5y +2z > 7".
637  	 *  A linear constraint "2 <= 3x -5y +2z <= 7" should call
638  	 *  SCIPaddVarLocksType(scip, ..., nlockspos + nlocksneg, nlockspos + nlocksneg) on all variables, since rounding in both
639  	 *  directions of each variable can destroy both the feasibility of the constraint and it's negation
640  	 *  "3x -5y +2z < 2  or  3x -5y +2z > 7".
641  	 *
642  	 *  If the constraint itself contains other constraints as sub constraints (e.g. the "or" constraint concatenation
643  	 *  "c(x) or d(x)"), the rounding lock methods of these constraints should be called in a proper way.
644  	 *  - If the constraint may get violated by the violation of the sub constraint c, it should call
645  	 *    SCIPaddConsLocksType(scip, c, locktype, nlockspos, nlocksneg), saying that infeasibility of c may lead to
646  	 *    infeasibility of the (positive) constraint, and infeasibility of c's negation (i.e. feasibility of c) may lead
647  	 *    to infeasibility of the constraint's negation (i.e. feasibility of the constraint).
648  	 *  - If the constraint may get violated by the feasibility of the sub constraint c, it should call
649  	 *    SCIPaddConsLocksType(scip, c, locktype, nlocksneg, nlockspos), saying that infeasibility of c may lead to
650  	 *    infeasibility of the constraint's negation (i.e. feasibility of the constraint), and infeasibility of c's negation
651  	 *    (i.e. feasibility of c) may lead to infeasibility of the (positive) constraint.
652  	 *  - If the constraint may get violated by any change in the feasibility of the sub constraint c, it should call
653  	 *    SCIPaddConsLocksType(scip, c, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg).
654  	 *
655  	 *  Consider the or concatenation "c(x) or d(x)". The variable rounding lock method of the or constraint handler
656  	 *  should call SCIPaddConsLocksType(scip, c, locktype, nlockspos, nlocksneg) and
657  	 *  SCIPaddConsLocksType(scip, d, locktype, nlockspos, nlocksneg) to tell SCIP, that infeasibility of c and d can lead
658  	 *  to infeasibility of "c(x) or d(x)".
659  	 *
660  	 *  As a second example, consider the equivalence constraint "y <-> c(x)" with variable y and constraint c. The
661  	 *  constraint demands, that y == 1 if and only if c(x) is satisfied. The variable lock method of the corresponding
662  	 *  constraint handler should call SCIPaddVarLocksType(scip, y, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg) and
663  	 *  SCIPaddConsLocksType(scip, c, locktype, nlockspos + nlocksneg, nlockspos + nlocksneg), because any modification to the
664  	 *  value of y or to the feasibility of c can alter the feasibility of the equivalence constraint.
665  	 *
666  	 *  input:
667  	 *  - scip            : SCIP main data structure
668  	 *  - conshdlr        : the constraint handler itself
669  	 *  - cons            : the constraint that should lock rounding of its variables, or NULL if the constraint handler
670  	 *                      does not need constraints
671  	 *  - locktype        : type of rounding locks, i.e., SCIP_LOCKTYPE_MODEL or SCIP_LOCKTYPE_CONFLICT
672  	 *  - nlockspos       : number of times, the roundings should be locked for the constraint (may be negative)
673  	 *  - nlocksneg       : number of times, the roundings should be locked for the constraint's negation (may be negative)
674  	 */
675  	#define SCIP_DECL_CONSLOCK(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, SCIP_LOCKTYPE locktype, int nlockspos, int nlocksneg)
676  	
677  	/** constraint activation notification method of constraint handler
678  	 *
679  	 *  WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but
680  	 *  the corresponding bound change event was not yet processed.
681  	 *
682  	 *  This method is always called after a constraint of the constraint handler was activated. The constraint
683  	 *  handler may use this call to update his own (statistical) data.
684  	 *
685  	 *  input:
686  	 *  - scip            : SCIP main data structure
687  	 *  - conshdlr        : the constraint handler itself
688  	 *  - cons            : the constraint that has been activated
689  	 */
690  	#define SCIP_DECL_CONSACTIVE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons)
691  	
692  	/** constraint deactivation notification method of constraint handler
693  	 *
694  	 *  WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but
695  	 *  the corresponding bound change event was not yet processed.
696  	 *
697  	 *  This method is always called before a constraint of the constraint handler is deactivated. The constraint
698  	 *  handler may use this call to update his own (statistical) data.
699  	 *
700  	 *  input:
701  	 *  - scip            : SCIP main data structure
702  	 *  - conshdlr        : the constraint handler itself
703  	 *  - cons            : the constraint that will be deactivated
704  	 */
705  	#define SCIP_DECL_CONSDEACTIVE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons)
706  	
707  	/** constraint enabling notification method of constraint handler
708  	 *
709  	 *  WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but
710  	 *  the corresponding bound change event was not yet processed.
711  	 *
712  	 *  This method is always called after a constraint of the constraint handler was enabled. The constraint
713  	 *  handler may use this call to update his own (statistical) data.
714  	 *
715  	 *  input:
716  	 *  - scip            : SCIP main data structure
717  	 *  - conshdlr        : the constraint handler itself
718  	 *  - cons            : the constraint that has been enabled
719  	 */
720  	#define SCIP_DECL_CONSENABLE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons)
721  	
722  	/** constraint disabling notification method of constraint handler
723  	 *
724  	 *  WARNING! There may exist unprocessed events. For example, a variable's bound may have been already changed, but
725  	 *  the corresponding bound change event was not yet processed.
726  	 *
727  	 *  This method is always called before a constraint of the constraint handler is disabled. The constraint
728  	 *  handler may use this call to update his own (statistical) data.
729  	 *
730  	 *  input:
731  	 *  - scip            : SCIP main data structure
732  	 *  - conshdlr        : the constraint handler itself
733  	 *  - cons            : the constraint that will be disabled
734  	 */
735  	#define SCIP_DECL_CONSDISABLE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons)
736  	
737  	/** variable deletion method of constraint handler
738  	 *
739  	 *  This method is optinal and only of interest if you are using SCIP as a branch-and-price framework. That means, you
740  	 *  are generating new variables during the search. If you are not doing that just define the function pointer to be
741  	 *  NULL.
742  	 *
743  	 *  If this method gets implemented you should iterate over all constraints of the constraint handler and delete all
744  	 *  variables that were marked for deletion by SCIPdelVar().
745  	 *
746  	 *  input:
747  	 *  - scip            : SCIP main data structure
748  	 *  - conshdlr        : the constraint handler itself
749  	 *  - conss           : array of constraints in transformed problem
750  	 *  - nconss          : number of constraints in transformed problem
751  	 */
752  	#define SCIP_DECL_CONSDELVARS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** conss, int nconss)
753  	
754  	/** constraint display method of constraint handler
755  	 *
756  	 *  The constraint handler can store a representation of the constraint into the given text file. Use the method
757  	 *  SCIPinfoMessage() to push a string into the file stream.
758  	 *
759  	 *  @note There are several methods which help to display variables. These are SCIPwriteVarName(), SCIPwriteVarsList(),
760  	 *        SCIPwriteVarsLinearsum(), and SCIPwriteVarsPolynomial().
761  	 *
762  	 *  input:
763  	 *  - scip            : SCIP main data structure
764  	 *  - conshdlr        : the constraint handler itself
765  	 *  - cons            : the constraint that should be displayed
766  	 *  - file            : the text file to store the information into
767  	 */
768  	#define SCIP_DECL_CONSPRINT(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, FILE* file)
769  	
770  	/** constraint copying method of constraint handler
771  	 *
772  	 *  The constraint handler can provide a copy method which copies a constraint from one SCIP data structure into an other
773  	 *  SCIP data structure. If a copy of a constraint is created, the constraint has to be captured. (The capture is usually
774  	 *  already done due to the creation of the constraint).
775  	 *
776  	 *  If the copy process was one to one, the valid pointer can be set to TRUE. Otherwise, you have to set this pointer to
777  	 *  FALSE. In case all problem defining objects (constraint handlers and variable pricers) return a TRUE valid for all
778  	 *  their copying calls, SCIP assumes that it is a overall one to one copy of the original instance. In this case any
779  	 *  reductions made in the copied SCIP instance can be transfered to the original SCIP instance. If the valid pointer is
780  	 *  set to TRUE and it was not a one to one copy, it might happen that optimal solutions are cut off.
781  	 *
782  	 *  To get a copy of a variable in the target SCIP you should use the function SCIPgetVarCopy().
783  	 *
784  	 *  input:
785  	 *  - scip            : target SCIP data structure
786  	 *  - cons            : pointer to store the created target constraint
787  	 *  - name            : name of constraint, or NULL if the name of the source constraint should be used
788  	 *  - sourcescip      : source SCIP data structure
789  	 *  - sourceconshdlr  : source constraint handler of the source SCIP
790  	 *  - sourcecons      : source constraint of the source SCIP
791  	 *  - varmap          : a SCIP_HASHMAP mapping variables of the source SCIP to corresponding variables of the target SCIP
792  	 *  - consmap         : a SCIP_HASHMAP mapping constraints of the source SCIP to corresponding constraints of the target SCIP
793  	 *  - initial         : should the LP relaxation of constraint be in the initial LP?
794  	 *  - separate        : should the constraint be separated during LP processing?
795  	 *  - enforce         : should the constraint be enforced during node processing?
796  	 *  - check           : should the constraint be checked for feasibility?
797  	 *  - propagate       : should the constraint be propagated during node processing?
798  	 *  - local           : is constraint only valid locally?
799  	 *  - modifiable      : is constraint modifiable (subject to column generation)?
800  	 *  - dynamic         : is constraint subject to aging?
801  	 *  - removable       : should the relaxation be removed from the LP due to aging or cleanup?
802  	 *  - stickingatnode  : should the constraint always be kept at the node where it was added, even
803  	 *                      if it may be moved to a more global node?
804  	 *  - global          : should a global or a local copy be created?
805  	 *
806  	 *  output:
807  	 *  - valid           : pointer to store whether the copying was valid or not
808  	 */
809  	#define SCIP_DECL_CONSCOPY(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONS** cons, const char* name, \
810  	      SCIP* sourcescip, SCIP_CONSHDLR* sourceconshdlr, SCIP_CONS* sourcecons, SCIP_HASHMAP* varmap, SCIP_HASHMAP* consmap, \
811  	      SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, \
812  	      SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, \
813  	      SCIP_Bool global, SCIP_Bool* valid)
814  	
815  	/** constraint parsing method of constraint handler
816  	 *
817  	 *  The constraint handler can provide a callback to parse the output created by the display method
818  	 *  (\ref SCIP_DECL_CONSPRINT) and to create a constraint out of it.
819  	 *
820  	 *  @note For parsing there are several methods which are handy. Have a look at: SCIPparseVarName(),
821  	 *        SCIPparseVarsList(), SCIPparseVarsLinearsum(), SCIPparseVarsPolynomial(), SCIPstrToRealValue(), and
822  	 *        SCIPstrCopySection().
823  	 *
824  	 *  input:
825  	 *  - scip            : SCIP main data structure
826  	 *  - conshdlr        : the constraint handler itself
827  	 *  - cons            : pointer to store the created constraint
828  	 *  - name            : name of the constraint
829  	 *  - str             : string to parse
830  	 *  - initial         : should the LP relaxation of constraint be in the initial LP?
831  	 *  - separate        : should the constraint be separated during LP processing?
832  	 *  - enforce         : should the constraint be enforced during node processing?
833  	 *  - check           : should the constraint be checked for feasibility?
834  	 *  - propagate       : should the constraint be propagated during node processing?
835  	 *  - local           : is constraint only valid locally?
836  	 *  - modifiable      : is constraint modifiable (subject to column generation)?
837  	 *  - dynamic         : is constraint subject to aging?
838  	 *  - removable       : should the relaxation be removed from the LP due to aging or cleanup?
839  	 *  - stickingatnode  : should the constraint always be kept at the node where it was added, even
840  	 *                      if it may be moved to a more global node?
841  	 *  output:
842  	 *  - success         : pointer to store whether the parsing was successful or not
843  	 */
844  	#define SCIP_DECL_CONSPARSE(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS** cons, \
845  	      const char* name, const char* str, \
846  	      SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, \
847  	      SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool* success)
848  	
849  	/** constraint method of constraint handler which returns the variables (if possible)
850  	 *
851  	 *  The constraint handler can (this callback is optional) provide this callback to return the variables which are
852  	 *  involved in that particular constraint. If this is possible, the variables should be copyied into the variables
853  	 *  array and the success pointers has to be set to TRUE. Otherwise the success has to be set FALSE or the callback
854  	 *  should not be implemented.
855  	 *
856  	 *  input:
857  	 *  - scip            : SCIP main data structure
858  	 *  - conshdlr        : the constraint handler itself
859  	 *  - cons            : the constraint that should return its variable data
860  	 *  - varssize        : available slots in vars array which is needed to check if the array is large enough
861  	 *
862  	 *  output:
863  	 *  - vars            : array to store/copy the involved variables of the constraint
864  	 *  - success         : pointer to store whether the variables are successfully copied
865  	 */
866  	#define SCIP_DECL_CONSGETVARS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \
867  	      SCIP_VAR** vars, int varssize, SCIP_Bool* success)
868  	
869  	/** constraint method of constraint handler which returns the number of variables (if possible)
870  	 *
871  	 *  The constraint handler can (this callback is optional) provide this callback to return the number variable which are
872  	 *  involved in that particular constraint. If this is not possible, the success pointers has to be set to FALSE or the
873  	 *  callback should not be implemented.
874  	 *
875  	 *  input:
876  	 *  - scip            : SCIP main data structure
877  	 *  - conshdlr        : the constraint handler itself
878  	 *  - cons            : constraint for which the number of variables is wanted
879  	 *
880  	 *  output:
881  	 *  - nvars           : pointer to store the number of variables
882  	 *  - success         : pointer to store whether the constraint successfully returned the number of variables
883  	 */
884  	#define SCIP_DECL_CONSGETNVARS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \
885  	      int* nvars, SCIP_Bool* success)
886  	
887  	/** constraint handler method to suggest dive bound changes during the generic diving algorithm
888  	 *
889  	 *  This callback is used inside the various diving heuristics of SCIP and does not affect the normal branching of the
890  	 *  actual search. The constraint handler can provide this callback to render the current solution (even more)
891  	 *  infeasible by suggesting one or several variable bound changes. In fact, since diving heuristics do not necessarily
892  	 *  solve LP relaxations at every probing depth, some of the variable local bounds might already be conflicting with the
893  	 *  solution values.  The solution is rendered infeasible by determining bound changes that should be applied to the
894  	 *  next explored search node via SCIPaddDiveBoundChange().  An alternative in case that the preferred bound change(s)
895  	 *  were detected infeasible must be provided.
896  	 *
897  	 *  The constraint handler must take care to only add bound changes that further shrink the variable domain.
898  	 *
899  	 *  The success pointer must be used to indicate whether the constraint handler succeeded in selecting diving bound
900  	 *  changes. The infeasible pointer should be set to TRUE if the constraint handler found a local infeasibility.  If the
901  	 *  constraint handler needs to select between several candidates, it may use the scoring mechanism of the diveset
902  	 *  argument to control its choice.
903  	 *
904  	 *  This callback is optional.
905  	 *
906  	 *  @note: @p sol is usually the LP relaxation solution unless the caller of the method, usually a diving heuristic,
907  	 *         does not solve LP relaxations at every depth
908  	 *
909  	 *  input:
910  	 *  - scip            : SCIP main data structure
911  	 *  - conshdlr        : the constraint handler itself
912  	 *  - diveset         : diving settings for scoring
913  	 *  - sol             : current diving solution, usually the LP relaxation solution
914  	 *
915  	 *  output:
916  	 *  - success         : pointer to store whether the constraint handler succeeded to determine dive bound changes
917  	 *  - infeasible      : pointer to store whether the constraint handler detected an infeasibility in the local node
918  	 */
919  	#define SCIP_DECL_CONSGETDIVEBDCHGS(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_DIVESET* diveset, \
920  	      SCIP_SOL* sol, SCIP_Bool* success, SCIP_Bool* infeasible)
921  	
922  	/** constraint handler method which returns the permutation symmetry detection graph of a constraint (if possible)
923  	 *
924  	 *  The constraint handler can (this callback is optional) provide this callback to return a graph that encodes the
925  	 *  permutation symmetries of a constraint. If this is not possible, the success pointer has to be set to FALSE or the
926  	 *  callback should not be implemented.
927  	 *
928  	 *  input:
929  	 *  - scip            : SCIP main data structure
930  	 *  - conshdlr        : the constraint handler itself
931  	 *  - cons            : constraint for which the symmetry detection graph is requested
932  	 *
933  	 *  output:
934  	 *  - graph           : symmetry detection graph
935  	 *  - success         : pointer to store whether the constraint successfully returned the symmetry detection graph
936  	 */
937  	#define SCIP_DECL_CONSGETPERMSYMGRAPH(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \
938  	      SYM_GRAPH* graph, SCIP_Bool* success)
939  	
940  	/** constraint handler method providing the signed permutation symmetry detection graph of a constraint (if possible)
941  	 *
942  	 *  The constraint handler can (this callback is optional) provide this callback to return a graph that encodes the
943  	 *  signed permutation symmetries of a constraint. If this is not possible, the success pointer has to be set to FALSE
944  	 *  or the callback should not be implemented.
945  	 *
946  	 *  input:
947  	 *  - scip            : SCIP main data structure
948  	 *  - conshdlr        : the constraint handler itself
949  	 *  - cons            : constraint for which the symmetry detection graph is requested
950  	 *
951  	 *  output:
952  	 *  - graph           : symmetry detection graph
953  	 *  - success         : pointer to store whether the constraint successfully returned the symmetry detection graph
954  	 */
955  	#define SCIP_DECL_CONSGETSIGNEDPERMSYMGRAPH(x) SCIP_RETCODE x (SCIP* scip, SCIP_CONSHDLR* conshdlr, SCIP_CONS* cons, \
956  	      SYM_GRAPH* graph, SCIP_Bool* success)
957  	
958  	#ifdef __cplusplus
959  	}
960  	#endif
961  	
962  	#endif
963