Scippy

SCIP

Solving Constraint Integer Programs

scip_copy.h
Go to the documentation of this file.
1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* This file is part of the program and library */
4 /* SCIP --- Solving Constraint Integer Programs */
5 /* */
6 /* Copyright (C) 2002-2022 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file scip_copy.h
17  * @ingroup PUBLICCOREAPI
18  * @brief public methods for problem copies
19  * @author Tobias Achterberg
20  * @author Timo Berthold
21  * @author Thorsten Koch
22  * @author Alexander Martin
23  * @author Marc Pfetsch
24  * @author Kati Wolter
25  * @author Gregor Hendel
26  * @author Leona Gottwald
27  */
28 
29 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
30 
31 #ifndef __SCIP_SCIP_COPY_H__
32 #define __SCIP_SCIP_COPY_H__
33 
34 
35 #include "scip/def.h"
36 #include "scip/type_cons.h"
37 #include "scip/type_misc.h"
38 #include "scip/type_retcode.h"
39 #include "scip/type_scip.h"
40 #include "scip/type_var.h"
41 
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45 
46 /**@addtogroup CopyMethods
47  *
48  * @{
49  */
50 
51 /** copies plugins from sourcescip to targetscip; in case that a constraint handler which does not need constraints
52  * cannot be copied, valid will return FALSE. All plugins can declare that, if their copy process failed, the
53  * copied SCIP instance might not represent the same problem semantics as the original.
54  * Note that in this case dual reductions might be invalid.
55  *
56  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
57  * Also, 'passmessagehdlr' should be set to FALSE.
58  *
59  * @note Do not change the source SCIP environment during the copying process.
60  *
61  * @note This method does not copy Benders' plugins. To this end, the method SCIPcopyBenders() must be called
62  * separately.
63  *
64  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
65  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
66  *
67  * @pre This method can be called if sourcescip is in one of the following stages:
68  * - \ref SCIP_STAGE_PROBLEM
69  * - \ref SCIP_STAGE_TRANSFORMED
70  * - \ref SCIP_STAGE_INITPRESOLVE
71  * - \ref SCIP_STAGE_PRESOLVING
72  * - \ref SCIP_STAGE_EXITPRESOLVE
73  * - \ref SCIP_STAGE_PRESOLVED
74  * - \ref SCIP_STAGE_INITSOLVE
75  * - \ref SCIP_STAGE_SOLVING
76  * - \ref SCIP_STAGE_SOLVED
77  *
78  * @pre This method can be called if targetscip is in one of the following stages:
79  * - \ref SCIP_STAGE_INIT
80  * - \ref SCIP_STAGE_FREE
81  *
82  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
83  * process was interrupted:
84  * - \ref SCIP_STAGE_PROBLEM
85  *
86  * @note sourcescip stage does not get changed
87  *
88  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
89  */
90 SCIP_EXPORT
91 SCIP_RETCODE SCIPcopyPlugins(
92  SCIP* sourcescip, /**< source SCIP data structure */
93  SCIP* targetscip, /**< target SCIP data structure */
94  SCIP_Bool copyreaders, /**< should the file readers be copied */
95  SCIP_Bool copypricers, /**< should the variable pricers be copied */
96  SCIP_Bool copyconshdlrs, /**< should the constraint handlers be copied */
97  SCIP_Bool copyconflicthdlrs, /**< should the conflict handlers be copied */
98  SCIP_Bool copypresolvers, /**< should the presolvers be copied */
99  SCIP_Bool copyrelaxators, /**< should the relaxation handler be copied */
100  SCIP_Bool copyseparators, /**< should the separators be copied */
101  SCIP_Bool copycutselectors, /**< should the cut selectors be copied */
102  SCIP_Bool copypropagators, /**< should the propagators be copied */
103  SCIP_Bool copyheuristics, /**< should the heuristics be copied */
104  SCIP_Bool copyeventhdlrs, /**< should the event handlers be copied */
105  SCIP_Bool copynodeselectors, /**< should the node selectors be copied */
106  SCIP_Bool copybranchrules, /**< should the branchrules be copied */
107  SCIP_Bool copydisplays, /**< should the display columns be copied */
108  SCIP_Bool copydialogs, /**< should the dialogs be copied */
109  SCIP_Bool copytables, /**< should the statistics tables be copied */
110  SCIP_Bool copyexprhdlrs, /**< should the expression handlers be copied */
111  SCIP_Bool copynlpis, /**< should the NLPIs be copied */
112  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
113  SCIP_Bool* valid /**< pointer to store whether plugins, in particular all constraint
114  * handlers which do not need constraints were validly copied */
115  );
116 
117 /** copies all Benders' decomposition plugins
118  *
119  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
120  * @note the 'threadsafe' parameter must be set to TRUE if you are absolutely certain that the source and target
121  * SCIP instances will be solved in parallel. The usual case is to set this to FALSE, since thread safety
122  * typically incurs a performance cost.
123  *
124  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
125  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
126  *
127  * @pre This method can be called if sourcescip is in one of the following stages:
128  * - \ref SCIP_STAGE_PROBLEM
129  * - \ref SCIP_STAGE_TRANSFORMED
130  * - \ref SCIP_STAGE_INITPRESOLVE
131  * - \ref SCIP_STAGE_PRESOLVING
132  * - \ref SCIP_STAGE_EXITPRESOLVE
133  * - \ref SCIP_STAGE_PRESOLVED
134  * - \ref SCIP_STAGE_INITSOLVE
135  * - \ref SCIP_STAGE_SOLVING
136  * - \ref SCIP_STAGE_SOLVED
137  *
138  * @pre This method can be called if targetscip is in one of the following stages:
139  * - \ref SCIP_STAGE_INIT
140  * - \ref SCIP_STAGE_FREE
141  *
142  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
143  * process was interrupted:
144  * - \ref SCIP_STAGE_PROBLEM
145  *
146  * @note sourcescip stage does not get changed
147  *
148  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
149  */
150 SCIP_EXPORT
151 SCIP_RETCODE SCIPcopyBenders(
152  SCIP* sourcescip, /**< source SCIP data structure */
153  SCIP* targetscip, /**< target SCIP data structure */
154  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
155  * target variables; if NULL the transfer of cuts is not possible */
156  SCIP_Bool threadsafe, /**< FALSE, if data can be safely shared between the source and target
157  SCIP, otherwise TRUE. This is usually set to FALSE */
158  SCIP_Bool* valid /**< pointer to store whether all plugins were validly copied */
159  );
160 
161 /** create a problem by copying the problem data of the source SCIP
162  *
163  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
164  * @note Do not change the source SCIP environment during the copying process
165  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
166  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
167  *
168  * @pre This method can be called if sourcescip is in one of the following stages:
169  * - \ref SCIP_STAGE_PROBLEM
170  * - \ref SCIP_STAGE_TRANSFORMED
171  * - \ref SCIP_STAGE_INITPRESOLVE
172  * - \ref SCIP_STAGE_PRESOLVING
173  * - \ref SCIP_STAGE_EXITPRESOLVE
174  * - \ref SCIP_STAGE_PRESOLVED
175  * - \ref SCIP_STAGE_INITSOLVE
176  * - \ref SCIP_STAGE_SOLVING
177  * - \ref SCIP_STAGE_SOLVED
178  *
179  * @pre This method can be called if targetscip is in one of the following stages:
180  * - \ref SCIP_STAGE_INIT
181  * - \ref SCIP_STAGE_PROBLEM
182  * - \ref SCIP_STAGE_TRANSFORMED
183  * - \ref SCIP_STAGE_INITPRESOLVE
184  * - \ref SCIP_STAGE_PRESOLVING
185  * - \ref SCIP_STAGE_EXITPRESOLVE
186  * - \ref SCIP_STAGE_PRESOLVED
187  * - \ref SCIP_STAGE_INITSOLVE
188  * - \ref SCIP_STAGE_SOLVING
189  * - \ref SCIP_STAGE_SOLVED
190  * - \ref SCIP_STAGE_FREE
191  *
192  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
193  * process was interrupted:
194  * - \ref SCIP_STAGE_PROBLEM
195  *
196  * @note sourcescip stage does not get changed
197  *
198  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
199  */
200 SCIP_EXPORT
201 SCIP_RETCODE SCIPcopyProb(
202  SCIP* sourcescip, /**< source SCIP data structure */
203  SCIP* targetscip, /**< target SCIP data structure */
204  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
205  * target variables, or NULL */
206  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
207  * target constraints, or NULL */
208  SCIP_Bool global, /**< create a global or a local copy? */
209  const char* name /**< problem name */
210  );
211 
212 /** create a problem by copying the original problem data of the source SCIP
213  *
214  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
215  * @note Do not change the source SCIP environment during the copying process
216  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
217  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
218  *
219  * @pre This method can be called if sourcescip is in one of the following stages:
220  * - \ref SCIP_STAGE_PROBLEM
221  * - \ref SCIP_STAGE_TRANSFORMED
222  * - \ref SCIP_STAGE_INITPRESOLVE
223  * - \ref SCIP_STAGE_PRESOLVING
224  * - \ref SCIP_STAGE_EXITPRESOLVE
225  * - \ref SCIP_STAGE_PRESOLVED
226  * - \ref SCIP_STAGE_INITSOLVE
227  * - \ref SCIP_STAGE_SOLVING
228  * - \ref SCIP_STAGE_SOLVED
229  *
230  * @pre This method can be called if targetscip is in one of the following stages:
231  * - \ref SCIP_STAGE_INIT
232  * - \ref SCIP_STAGE_FREE
233  *
234  * @post After calling this method targetscip reaches one of the following stages depending on if and when the solution
235  * process was interrupted:
236  * - \ref SCIP_STAGE_PROBLEM
237  *
238  * @note sourcescip stage does not get changed
239  *
240  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
241  */
242 SCIP_EXPORT
243 SCIP_RETCODE SCIPcopyOrigProb(
244  SCIP* sourcescip, /**< source SCIP data structure */
245  SCIP* targetscip, /**< target SCIP data structure */
246  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
247  * target variables, or NULL */
248  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
249  * target constraints, or NULL */
250  const char* name /**< problem name of target */
251  );
252 
253 /** enables constraint compression.
254  *
255  * If constraint compression is enabled, fixed variables will be treated as constants
256  * by all constraints that are copied after calling this method.
257  *
258  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
259  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
260  *
261  * @pre This method can be called if scip is in one of the following stages:
262  * - \ref SCIP_STAGE_PROBLEM
263  *
264  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
265  */
266 SCIP_EXPORT
267 SCIP_RETCODE SCIPenableConsCompression(
268  SCIP* scip /**< source SCIP data structure */
269  );
270 
271 /** is constraint compression enabled?
272  *
273  * If constraint compression is enabled, fixed variables can be treated as constants
274  * by all constraints that are copied after calling this method.
275  *
276  * @return TRUE if problem constraint compression is enabled, otherwise FALSE
277  *
278  * @pre This method can be called if scip is in one of the following stages:
279  * - \ref SCIP_STAGE_PROBLEM
280  * - \ref SCIP_STAGE_TRANSFORMING
281  * - \ref SCIP_STAGE_TRANSFORMED
282  * - \ref SCIP_STAGE_INITPRESOLVE
283  * - \ref SCIP_STAGE_PRESOLVING
284  * - \ref SCIP_STAGE_EXITPRESOLVE
285  * - \ref SCIP_STAGE_PRESOLVED
286  * - \ref SCIP_STAGE_INITSOLVE
287  * - \ref SCIP_STAGE_SOLVING
288  * - \ref SCIP_STAGE_SOLVED
289  * - \ref SCIP_STAGE_EXITSOLVE
290  * - \ref SCIP_STAGE_FREETRANS
291  *
292  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
293  */
294 SCIP_EXPORT
295 SCIP_Bool SCIPisConsCompressionEnabled(
296  SCIP* scip /**< source SCIP data structure */
297  );
298 
299 /** returns copy of the source variable; if there already is a copy of the source variable in the variable hash map,
300  * it is just returned as target variable; otherwise, if the variables it not marked as relaxation-only, a new variable
301  * will be created and added to the target SCIP; this created variable is added to the variable hash map and returned as target variable;
302  * relaxation-only variables are not copied and FALSE is returned in *success
303  *
304  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
305  * @note Do not change the source SCIP environment during the copying process
306  * @note if a new variable was created, this variable will be added to the target-SCIP, but it is not captured
307  *
308  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
309  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
310  *
311  * @pre This method can be called if sourcescip is in one of the following stages:
312  * - \ref SCIP_STAGE_PROBLEM
313  * - \ref SCIP_STAGE_TRANSFORMED
314  * - \ref SCIP_STAGE_INITPRESOLVE
315  * - \ref SCIP_STAGE_PRESOLVING
316  * - \ref SCIP_STAGE_EXITPRESOLVE
317  * - \ref SCIP_STAGE_PRESOLVED
318  * - \ref SCIP_STAGE_INITSOLVE
319  * - \ref SCIP_STAGE_SOLVING
320  * - \ref SCIP_STAGE_SOLVED
321  *
322  * @pre This method can be called if targetscip is in one of the following stages:
323  * - \ref SCIP_STAGE_PROBLEM
324  * - \ref SCIP_STAGE_TRANSFORMED
325  * - \ref SCIP_STAGE_INITPRESOLVE
326  * - \ref SCIP_STAGE_PRESOLVING
327  * - \ref SCIP_STAGE_EXITPRESOLVE
328  * - \ref SCIP_STAGE_SOLVING
329  *
330  * @note targetscip stage does not get changed
331  *
332  * @note sourcescip stage does not get changed
333  *
334  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
335  */
336 SCIP_EXPORT
337 SCIP_RETCODE SCIPgetVarCopy(
338  SCIP* sourcescip, /**< source SCIP data structure */
339  SCIP* targetscip, /**< target SCIP data structure */
340  SCIP_VAR* sourcevar, /**< source variable */
341  SCIP_VAR** targetvar, /**< pointer to store the target variable */
342  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
343  * target variables, or NULL */
344  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
345  * target constraints, or NULL */
346  SCIP_Bool global, /**< should global or local bounds be used? */
347  SCIP_Bool* success /**< pointer to store whether the copying was successful or not */
348  );
349 
350 /** Copies all active (thus unfixed) variables from source-SCIP, except those that are marked as relaxation only,
351  * and adds these variable to the target-SCIP.
352  *
353  * The mapping between these variables are stored in the variable hashmap.
354  *
355  * The target-SCIP has to be in problem creation stage.
356  *
357  * @note the variables are added to the target-SCIP but not captured
358  *
359  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
360  * @note Do not change the source SCIP environment during the copying process
361  *
362  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
363  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
364  *
365  * @pre This method can be called if sourcescip is in one of the following stages:
366  * - \ref SCIP_STAGE_PROBLEM
367  * - \ref SCIP_STAGE_TRANSFORMED
368  * - \ref SCIP_STAGE_INITPRESOLVE
369  * - \ref SCIP_STAGE_PRESOLVING
370  * - \ref SCIP_STAGE_EXITPRESOLVE
371  * - \ref SCIP_STAGE_PRESOLVED
372  * - \ref SCIP_STAGE_INITSOLVE
373  * - \ref SCIP_STAGE_SOLVING
374  * - \ref SCIP_STAGE_SOLVED
375  *
376  * @pre This method can be called if targetscip is in one of the following stages:
377  * - \ref SCIP_STAGE_PROBLEM
378  *
379  * @note sourcescip stage does not get changed
380  *
381  * @note targetscip stage does not get changed
382  *
383  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
384  */
385 SCIP_EXPORT
386 SCIP_RETCODE SCIPcopyVars(
387  SCIP* sourcescip, /**< source SCIP data structure */
388  SCIP* targetscip, /**< target SCIP data structure */
389  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
390  * target variables, or NULL */
391  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
392  * target constraints, or NULL */
393  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
394  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
395  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
396  SCIP_Bool global /**< should global or local bounds be used? */
397  );
398 
399 /** copies all original variables from source-SCIP and adds these variable to the target-SCIP; the mapping between these
400  * variables are stored in the variable hashmap, target-SCIP has to be in problem creation stage, fixed and aggregated
401  * variables do not get copied
402  *
403  * @note the variables are added to the target-SCIP but not captured
404  *
405  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
406  * @note Do not change the source SCIP environment during the copying process
407  *
408  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
409  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
410  *
411  * @pre This method can be called if sourcescip is in one of the following stages:
412  * - \ref SCIP_STAGE_PROBLEM
413  * - \ref SCIP_STAGE_TRANSFORMED
414  * - \ref SCIP_STAGE_INITPRESOLVE
415  * - \ref SCIP_STAGE_PRESOLVING
416  * - \ref SCIP_STAGE_EXITPRESOLVE
417  * - \ref SCIP_STAGE_PRESOLVED
418  * - \ref SCIP_STAGE_INITSOLVE
419  * - \ref SCIP_STAGE_SOLVING
420  * - \ref SCIP_STAGE_SOLVED
421  *
422  * @pre This method can be called if targetscip is in one of the following stages:
423  * - \ref SCIP_STAGE_PROBLEM
424  *
425  * @note sourcescip stage does not get changed
426  *
427  * @note targetscip stage does not get changed
428  *
429  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
430  */
431 SCIP_EXPORT
432 SCIP_RETCODE SCIPcopyOrigVars(
433  SCIP* sourcescip, /**< source SCIP data structure */
434  SCIP* targetscip, /**< target SCIP data structure */
435  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables to the corresponding
436  * target variables, or NULL */
437  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
438  * target constraints, or NULL */
439  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
440  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
441  int nfixedvars /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
442  );
443 
444 /** merges the histories of variables from a source SCIP into a target SCIP. The two data structures should point to
445  * different SCIP instances.
446  *
447  * @note the notion of source and target is inverted here; \p sourcescip usually denotes a copied SCIP instance, whereas
448  * \p targetscip denotes the original instance
449  */
450 
451 SCIP_EXPORT
452 SCIP_RETCODE SCIPmergeVariableStatistics(
453  SCIP* sourcescip, /**< source SCIP data structure */
454  SCIP* targetscip, /**< target SCIP data structure */
455  SCIP_VAR** sourcevars, /**< source variables for history merge, NULL entries are ignored */
456  SCIP_VAR** targetvars, /**< target variables for history merge, NULL entries are ignored */
457  int nvars /**< number of variables in both variable arrays */
458  );
459 
460 /** merges the statistics of NLPIs from a source SCIP into a target SCIP
461  *
462  * The two SCIP instances should point to different SCIP instances.
463  *
464  * @note the notion of source and target is inverted here; \p sourcescip usually denotes a copied SCIP instance, whereas
465  * \p targetscip denotes the original instance
466  */
467 SCIP_EXPORT
468 void SCIPmergeNLPIStatistics(
469  SCIP* sourcescip, /**< source SCIP data structure */
470  SCIP* targetscip, /**< target SCIP data structure */
471  SCIP_Bool reset /**< whether to reset statistics in sourcescip */
472  );
473 
474 /** translates a solution from a subscip to the main scip
475  *
476  * Variables that are relaxation-only in the master SCIP are set to 0 or the bound closest to 0. Such variables
477  * are represented as NULL entry in the \p subvars array.
478  *
479  * @note This method allocates a new solution of the main \p scip that needs to be freed by the user.
480  */
481 SCIP_EXPORT
482 SCIP_RETCODE SCIPtranslateSubSol(
483  SCIP* scip, /**< SCIP data structure of the original problem */
484  SCIP* subscip, /**< SCIP data structure of the subproblem */
485  SCIP_SOL* subsol, /**< solution of the subproblem */
486  SCIP_HEUR* heur, /**< heuristic that found the solution */
487  SCIP_VAR** subvars, /**< the variables from the subproblem in the same order as the main \p scip */
488  SCIP_SOL** newsol /**< buffer to store pointer to created solution in main SCIP */
489  );
490 
491 /** checks the solutions from the subscip and adds the first one that is found feasible to the master SCIP
492  *
493  * Variables that are relaxation-only in the master SCIP are set to 0 or the bound closest to 0. Such variables
494  * are represented as NULL entry in the \p subvars array.
495  */
496 SCIP_EXPORT
497 SCIP_RETCODE SCIPtranslateSubSols(
498  SCIP* scip, /**< the SCIP data structure */
499  SCIP* subscip, /**< SCIP data structure of the subproblem */
500  SCIP_HEUR* heur, /**< heuristic that found the solution */
501  SCIP_VAR** subvars, /**< the variables from the subproblem in the same order as the main \p scip */
502  SCIP_Bool* success, /**< pointer to store, whether new solution was found */
503  int* solindex /**< pointer to store solution index of stored solution, or NULL if not of interest */
504  );
505 
506 /** returns copy of the source constraint; if there already is a copy of the source constraint in the constraint hash
507  * map, it is just returned as target constraint; elsewise a new constraint will be created; this created constraint is
508  * added to the constraint hash map and returned as target constraint; the variable map is used to map the variables of
509  * the source SCIP to the variables of the target SCIP
510  *
511  * @warning If a constraint is marked to be checked for feasibility but not to be enforced, a LP or pseudo solution may
512  * be declared feasible even if it violates this particular constraint. This constellation should only be
513  * used, if no LP or pseudo solution can violate the constraint -- e.g. if a local constraint is redundant due
514  * to the variable's local bounds.
515  *
516  * @note The constraint is not added to the target SCIP. You can check whether a constraint is added by calling
517  * SCIPconsIsAdded(). (If you mix SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add
518  * explicitly and what is already added.)
519  *
520  * @note The constraint is always captured, either during the creation of the copy or after finding the copy of the
521  * constraint in the constraint hash map
522  *
523  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
524  * @note Do not change the source SCIP environment during the copying process
525  *
526  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
527  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
528  *
529  * @pre This method can be called if sourcescip is in one of the following stages:
530  * - \ref SCIP_STAGE_PROBLEM
531  * - \ref SCIP_STAGE_TRANSFORMED
532  * - \ref SCIP_STAGE_INITPRESOLVE
533  * - \ref SCIP_STAGE_PRESOLVING
534  * - \ref SCIP_STAGE_EXITPRESOLVE
535  * - \ref SCIP_STAGE_PRESOLVED
536  * - \ref SCIP_STAGE_INITSOLVE
537  * - \ref SCIP_STAGE_SOLVING
538  * - \ref SCIP_STAGE_SOLVED
539  *
540  * @pre This method can be called if targetscip is in one of the following stages:
541  * - \ref SCIP_STAGE_PROBLEM
542  * - \ref SCIP_STAGE_TRANSFORMING
543  * - \ref SCIP_STAGE_INITPRESOLVE
544  * - \ref SCIP_STAGE_PRESOLVING
545  * - \ref SCIP_STAGE_EXITPRESOLVE
546  * - \ref SCIP_STAGE_PRESOLVED
547  * - \ref SCIP_STAGE_SOLVING
548  * - \ref SCIP_STAGE_EXITSOLVE
549  *
550  * @note sourcescip stage does not get changed
551  *
552  * @note targetscip stage does not get changed
553  *
554  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
555  */
556 SCIP_EXPORT
557 SCIP_RETCODE SCIPgetConsCopy(
558  SCIP* sourcescip, /**< source SCIP data structure */
559  SCIP* targetscip, /**< target SCIP data structure */
560  SCIP_CONS* sourcecons, /**< source constraint of the source SCIP */
561  SCIP_CONS** targetcons, /**< pointer to store the created target constraint */
562  SCIP_CONSHDLR* sourceconshdlr, /**< source constraint handler for this constraint */
563  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
564  * variables of the target SCIP, or NULL */
565  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
566  * target constraints, or NULL */
567  const char* name, /**< name of constraint, or NULL if the name of the source constraint should be used */
568  SCIP_Bool initial, /**< should the LP relaxation of constraint be in the initial LP? */
569  SCIP_Bool separate, /**< should the constraint be separated during LP processing? */
570  SCIP_Bool enforce, /**< should the constraint be enforced during node processing? */
571  SCIP_Bool check, /**< should the constraint be checked for feasibility? */
572  SCIP_Bool propagate, /**< should the constraint be propagated during node processing? */
573  SCIP_Bool local, /**< is constraint only valid locally? */
574  SCIP_Bool modifiable, /**< is constraint modifiable (subject to column generation)? */
575  SCIP_Bool dynamic, /**< is constraint subject to aging? */
576  SCIP_Bool removable, /**< should the relaxation be removed from the LP due to aging or cleanup? */
577  SCIP_Bool stickingatnode, /**< should the constraint always be kept at the node where it was added, even
578  * if it may be moved to a more global node? */
579  SCIP_Bool global, /**< create a global or a local copy? */
580  SCIP_Bool* valid /**< pointer to store whether the copying was valid or not */
581  );
582 
583 /** copies constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
584  * variables between the source and the target SCIP a hash map can be given; if the variable hash
585  * map is NULL or necessary variable mapping is missing, the required variables are created in the
586  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
587  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
588  * between the constraints of the source and target-SCIP is stored
589  *
590  * *valid is set to TRUE iff all constraints that are marked as checked or enforced were copied successfully.
591  * If other constraints could not be copied, *valid can still be set to TRUE.
592  *
593  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
594  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
595  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
596  *
597  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
598  * @note Do not change the source SCIP environment during the copying process
599  *
600  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
601  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
602  *
603  * @pre This method can be called if sourcescip is in one of the following stages:
604  * - \ref SCIP_STAGE_PROBLEM
605  * - \ref SCIP_STAGE_TRANSFORMED
606  * - \ref SCIP_STAGE_INITPRESOLVE
607  * - \ref SCIP_STAGE_PRESOLVING
608  * - \ref SCIP_STAGE_EXITPRESOLVE
609  * - \ref SCIP_STAGE_PRESOLVED
610  * - \ref SCIP_STAGE_INITSOLVE
611  * - \ref SCIP_STAGE_SOLVING
612  * - \ref SCIP_STAGE_SOLVED
613  *
614  * @pre This method can be called if targetscip is in one of the following stages:
615  * - \ref SCIP_STAGE_PROBLEM
616  *
617  * @note sourcescip stage does not get changed
618  *
619  * @note targetscip stage does not get changed
620  *
621  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
622  */
623 SCIP_EXPORT
624 SCIP_RETCODE SCIPcopyConss(
625  SCIP* sourcescip, /**< source SCIP data structure */
626  SCIP* targetscip, /**< target SCIP data structure */
627  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
628  * variables of the target SCIP, or NULL */
629  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
630  * target constraints, or NULL */
631  SCIP_Bool global, /**< create a global or a local copy? */
632  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
633  * If TRUE, the modifiable flag of constraints will be copied. */
634  SCIP_Bool* valid /**< pointer to store whether all checked or enforced constraints were validly copied */
635  );
636 
637 /** copies all original constraints from the source-SCIP and adds these to the target-SCIP; for mapping the
638  * variables between the source and the target SCIP a hash map can be given; if the variable hash
639  * map is NULL or necessary variable mapping is missing, the required variables are created in the
640  * target-SCIP and added to the hash map, if not NULL; all variables which are created are added to
641  * the target-SCIP but not (user) captured; if the constraint hash map is not NULL the mapping
642  * between the constraints of the source and target-SCIP is stored
643  *
644  * @note the constraints are added to the target-SCIP but are not (user) captured in the target SCIP. (If you mix
645  * SCIPgetConsCopy() with SCIPcopyConss() you should pay attention to what you add explicitly and what is already
646  * added.) You can check whether a constraint is added by calling SCIPconsIsAdded().
647  *
648  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
649  * @note Do not change the source SCIP environment during the copying process
650  *
651  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
652  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
653  *
654  * @pre This method can be called if sourcescip is in one of the following stages:
655  * - \ref SCIP_STAGE_PROBLEM
656  * - \ref SCIP_STAGE_TRANSFORMED
657  * - \ref SCIP_STAGE_INITPRESOLVE
658  * - \ref SCIP_STAGE_PRESOLVING
659  * - \ref SCIP_STAGE_EXITPRESOLVE
660  * - \ref SCIP_STAGE_PRESOLVED
661  * - \ref SCIP_STAGE_INITSOLVE
662  * - \ref SCIP_STAGE_SOLVING
663  * - \ref SCIP_STAGE_SOLVED
664  *
665  * @pre This method can be called if targetscip is in one of the following stages:
666  * - \ref SCIP_STAGE_PROBLEM
667  *
668  * @note sourcescip stage does not get changed
669  *
670  * @note targetscip stage does not get changed
671  *
672  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
673  */
674 SCIP_EXPORT
675 SCIP_RETCODE SCIPcopyOrigConss(
676  SCIP* sourcescip, /**< source SCIP data structure */
677  SCIP* targetscip, /**< target SCIP data structure */
678  SCIP_HASHMAP* varmap, /**< a SCIP_HASHMAP mapping variables of the source SCIP to the corresponding
679  * variables of the target SCIP, or NULL */
680  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
681  * target constraints, or NULL */
682  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
683  * If TRUE, the modifiable flag of constraints will be copied. */
684  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
685  );
686 
687 /** convert all active cuts from cutpool to linear constraints
688  *
689  * @note Do not change the source SCIP environment during the copying process
690  *
691  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
692  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
693  *
694  * @pre This method can be called if SCIP is in one of the following stages:
695  * - \ref SCIP_STAGE_PROBLEM
696  * - \ref SCIP_STAGE_INITPRESOLVE
697  * - \ref SCIP_STAGE_PRESOLVING
698  * - \ref SCIP_STAGE_EXITPRESOLVE
699  * - \ref SCIP_STAGE_PRESOLVED
700  * - \ref SCIP_STAGE_SOLVING
701  * - \ref SCIP_STAGE_EXITSOLVE
702  *
703  * @note SCIP stage does not get changed
704  *
705  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
706  */
707 SCIP_EXPORT
708 SCIP_RETCODE SCIPconvertCutsToConss(
709  SCIP* scip, /**< SCIP data structure */
710  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
711  * target variables, or NULL */
712  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
713  * target constraints, or NULL */
714  SCIP_Bool global, /**< create a global or a local copy? */
715  int* ncutsadded /**< pointer to store number of added cuts, or NULL */
716  );
717 
718 /** copies all active cuts from cutpool of sourcescip to linear constraints in targetscip
719  *
720  * Cuts that contain variables that are marked as relaxation-only are skipped.
721  *
722  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
723  * @note Do not change the source SCIP environment during the copying process
724  *
725  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
726  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
727  *
728  * @pre This method can be called if sourcescip is in one of the following stages:
729  * - \ref SCIP_STAGE_PROBLEM
730  * - \ref SCIP_STAGE_TRANSFORMED
731  * - \ref SCIP_STAGE_INITPRESOLVE
732  * - \ref SCIP_STAGE_PRESOLVING
733  * - \ref SCIP_STAGE_EXITPRESOLVE
734  * - \ref SCIP_STAGE_PRESOLVED
735  * - \ref SCIP_STAGE_SOLVING
736  * - \ref SCIP_STAGE_SOLVED
737  * - \ref SCIP_STAGE_EXITSOLVE
738  *
739  * @pre This method can be called if targetscip is in one of the following stages:
740  * - \ref SCIP_STAGE_PROBLEM
741  * - \ref SCIP_STAGE_INITPRESOLVE
742  * - \ref SCIP_STAGE_PRESOLVING
743  * - \ref SCIP_STAGE_EXITPRESOLVE
744  * - \ref SCIP_STAGE_PRESOLVED
745  * - \ref SCIP_STAGE_SOLVING
746  * - \ref SCIP_STAGE_EXITSOLVE
747  *
748  * @note sourcescip stage does not get changed
749  *
750  * @note targetscip stage does not get changed
751  *
752  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
753  */
754 SCIP_EXPORT
755 SCIP_RETCODE SCIPcopyCuts(
756  SCIP* sourcescip, /**< source SCIP data structure */
757  SCIP* targetscip, /**< target SCIP data structure */
758  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
759  * target variables, or NULL */
760  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
761  * target constraints, or NULL */
762  SCIP_Bool global, /**< create a global or a local copy? */
763  int* ncutsadded /**< pointer to store number of copied cuts, or NULL */
764  );
765 
766 /** copies all active conflicts from the conflict pool of sourcescip and adds them as linear constraints to targetscip
767  *
768  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
769  * @note Do not change the source SCIP environment during the copying process
770  *
771  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
772  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
773  *
774  * @pre This method can be called if sourcescip is in one of the following stages:
775  * - \ref SCIP_STAGE_PROBLEM
776  * - \ref SCIP_STAGE_TRANSFORMED
777  * - \ref SCIP_STAGE_INITPRESOLVE
778  * - \ref SCIP_STAGE_PRESOLVING
779  * - \ref SCIP_STAGE_EXITPRESOLVE
780  * - \ref SCIP_STAGE_PRESOLVED
781  * - \ref SCIP_STAGE_SOLVING
782  * - \ref SCIP_STAGE_SOLVED
783  * - \ref SCIP_STAGE_EXITSOLVE
784  *
785  * @pre This method can be called if targetscip is in one of the following stages:
786  * - \ref SCIP_STAGE_PROBLEM
787  * - \ref SCIP_STAGE_INITPRESOLVE
788  * - \ref SCIP_STAGE_PRESOLVING
789  * - \ref SCIP_STAGE_EXITPRESOLVE
790  * - \ref SCIP_STAGE_PRESOLVED
791  * - \ref SCIP_STAGE_SOLVING
792  * - \ref SCIP_STAGE_EXITSOLVE
793  *
794  * @note sourcescip stage does not change
795  *
796  * @note targetscip stage does not change
797  *
798  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
799  */
800 SCIP_EXPORT
801 SCIP_RETCODE SCIPcopyConflicts(
802  SCIP* sourcescip, /**< source SCIP data structure */
803  SCIP* targetscip, /**< target SCIP data structure */
804  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
805  * target variables, or NULL */
806  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
807  * target constraints, or NULL */
808  SCIP_Bool global, /**< create a global or a local copy? */
809  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance?
810  * If TRUE, the modifiable flag of constraints will be copied. */
811  SCIP_Bool* valid /**< pointer to store whether all constraints were validly copied */
812  );
813 
814 /** copies implications and cliques of sourcescip to targetscip
815  *
816  * This function should be called for a targetscip in transformed stage. It can save time in presolving of the
817  * targetscip, since implications and cliques are copied.
818  *
819  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
820  * @note Do not change the source SCIP environment during the copying process
821  *
822  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
823  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
824  *
825  * @pre This method can be called if sourcescip is in one of the following stages:
826  * - \ref SCIP_STAGE_TRANSFORMED
827  * - \ref SCIP_STAGE_INITPRESOLVE
828  * - \ref SCIP_STAGE_PRESOLVING
829  * - \ref SCIP_STAGE_EXITPRESOLVE
830  * - \ref SCIP_STAGE_PRESOLVED
831  * - \ref SCIP_STAGE_SOLVING
832  * - \ref SCIP_STAGE_SOLVED
833  * - \ref SCIP_STAGE_EXITSOLVE
834  *
835  * @pre This method can be called if targetscip is in one of the following stages:
836  * - \ref SCIP_STAGE_TRANSFORMED
837  * - \ref SCIP_STAGE_INITPRESOLVE
838  * - \ref SCIP_STAGE_PRESOLVING
839  * - \ref SCIP_STAGE_EXITPRESOLVE
840  * - \ref SCIP_STAGE_PRESOLVED
841  * - \ref SCIP_STAGE_INITSOLVE
842  * - \ref SCIP_STAGE_SOLVING
843  *
844  * @note sourcescip stage does not get changed
845  *
846  * @note targetscip stage does not get changed
847  *
848  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
849  */
850 SCIP_EXPORT
851 SCIP_RETCODE SCIPcopyImplicationsCliques(
852  SCIP* sourcescip, /**< source SCIP data structure */
853  SCIP* targetscip, /**< target SCIP data structure */
854  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
855  * target variables, or NULL */
856  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
857  * target constraints, or NULL */
858  SCIP_Bool global, /**< create a global or a local copy? */
859  SCIP_Bool* infeasible, /**< pointer to store whether an infeasibility was detected */
860  int* nbdchgs, /**< pointer to store the number of performed bound changes, or NULL */
861  int* ncopied /**< pointer to store number of copied implications and cliques, or NULL */
862  );
863 
864 /** copies parameter settings from sourcescip to targetscip
865  *
866  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
867  * @note Do not change the source SCIP environment during the copying process
868  *
869  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
870  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
871  *
872  * @pre This method can be called if sourcescip is in one of the following stages:
873  * - \ref SCIP_STAGE_PROBLEM
874  * - \ref SCIP_STAGE_TRANSFORMED
875  * - \ref SCIP_STAGE_INITPRESOLVE
876  * - \ref SCIP_STAGE_PRESOLVING
877  * - \ref SCIP_STAGE_EXITPRESOLVE
878  * - \ref SCIP_STAGE_PRESOLVED
879  * - \ref SCIP_STAGE_INITSOLVE
880  * - \ref SCIP_STAGE_SOLVING
881  * - \ref SCIP_STAGE_SOLVED
882  *
883  * @pre This method can be called if targetscip is in one of the following stages:
884  * - \ref SCIP_STAGE_INIT
885  * - \ref SCIP_STAGE_PROBLEM
886  * - \ref SCIP_STAGE_FREE
887  *
888  * @note sourcescip stage does not get changed
889  *
890  * @note targetscip stage does not get changed
891  *
892  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
893  */
894 SCIP_EXPORT
895 SCIP_RETCODE SCIPcopyParamSettings(
896  SCIP* sourcescip, /**< source SCIP data structure */
897  SCIP* targetscip /**< target SCIP data structure */
898  );
899 
900 /** gets depth of current scip instance (increased by each copy call)
901  *
902  * @return Depth of subscip of SCIP is returned.
903  *
904  * @pre This method can be called if SCIP is in one of the following stages:
905  * - \ref SCIP_STAGE_PROBLEM
906  * - \ref SCIP_STAGE_TRANSFORMING
907  * - \ref SCIP_STAGE_TRANSFORMED
908  * - \ref SCIP_STAGE_INITPRESOLVE
909  * - \ref SCIP_STAGE_PRESOLVING
910  * - \ref SCIP_STAGE_EXITPRESOLVE
911  * - \ref SCIP_STAGE_PRESOLVED
912  * - \ref SCIP_STAGE_INITSOLVE
913  * - \ref SCIP_STAGE_SOLVING
914  * - \ref SCIP_STAGE_SOLVED
915  * - \ref SCIP_STAGE_EXITSOLVE
916  * - \ref SCIP_STAGE_FREETRANS
917  *
918  * @note SCIP stage does not get changed
919  *
920  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
921  */
922 SCIP_EXPORT
923 int SCIPgetSubscipDepth(
924  SCIP* scip /**< SCIP data structure */
925  );
926 
927 /** sets depth of scip instance
928  *
929  * @pre This method can be called if SCIP is in one of the following stages:
930  * - \ref SCIP_STAGE_PROBLEM
931  *
932  * @note SCIP stage does not get changed
933  *
934  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
935  */
936 SCIP_EXPORT
937 void SCIPsetSubscipDepth(
938  SCIP* scip, /**< SCIP data structure */
939  int newdepth /**< new subscip depth */
940  );
941 
942 /** copies source SCIP to target SCIP; the copying process is done in the following order:
943  * 1) copy the plugins
944  * 2) copy the settings
945  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
946  * 4) copy all active variables except those are marked as relaxation-only
947  * 5) copy all constraints
948  *
949  * The source problem depends on the stage of the \p sourcescip - In SCIP_STAGE_PROBLEM, the original problem is copied,
950  * otherwise, the transformed problem is copied. For an explicit copy of the original problem, use SCIPcopyOrig().
951  *
952  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
953  *
954  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
955  * Also, 'passmessagehdlr' should be set to FALSE.
956  * @note the 'threadsafe' parameter should only be set to TRUE if you are absolutely certain that the source and target
957  * SCIP instances will be solved in parallel. The usual case is to set this to FALSE, since thread safety
958  * typically incurs a performance cost.
959  * @note Do not change the source SCIP environment during the copying process
960  *
961  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
962  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
963  *
964  * @pre This method can be called if sourcescip is in one of the following stages:
965  * - \ref SCIP_STAGE_PROBLEM
966  * - \ref SCIP_STAGE_TRANSFORMED
967  * - \ref SCIP_STAGE_INITPRESOLVE
968  * - \ref SCIP_STAGE_PRESOLVING
969  * - \ref SCIP_STAGE_EXITPRESOLVE
970  * - \ref SCIP_STAGE_PRESOLVED
971  * - \ref SCIP_STAGE_INITSOLVE
972  * - \ref SCIP_STAGE_SOLVING
973  * - \ref SCIP_STAGE_SOLVED
974  *
975  * @pre This method can be called if targetscip is in one of the following stages:
976  * - \ref SCIP_STAGE_INIT
977  * - \ref SCIP_STAGE_FREE
978  *
979  * @note sourcescip stage does not get changed
980  *
981  * @note targetscip stage does not get changed
982  *
983  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
984  */
985 SCIP_EXPORT
986 SCIP_RETCODE SCIPcopy(
987  SCIP* sourcescip, /**< source SCIP data structure */
988  SCIP* targetscip, /**< target SCIP data structure */
989  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
990  * target variables, or NULL */
991  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
992  * target constraints, or NULL */
993  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
994  SCIP_Bool global, /**< create a global or a local copy? */
995  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
996  * plugins will be copied and activated, and the modifiable flag of
997  * constraints will be respected. If FALSE, valid will be set to FALSE, when
998  * there are pricers present */
999  SCIP_Bool threadsafe, /**< FALSE, if data can be safely shared between the source and target
1000  SCIP, otherwise TRUE. This is usually set to FALSE */
1001  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1002  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1003  );
1004 
1005 /** copies source SCIP to target SCIP but compresses constraints
1006  *
1007  * constraint compression is performed by removing fixed variables immediately
1008  * during constraint creation if the involved constraint handlers support
1009  * compression
1010  *
1011  * the copying process is done in the following order:
1012  * 1) copy the plugins
1013  * 2) copy the settings
1014  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1015  * 4) copy all active variables except those are marked as relaxation-only
1016  * a) fix all variable copies specified by \p fixedvars, \p fixedvals, and \p nfixedvars
1017  * b) enable constraint compression
1018  * 5) copy all constraints
1019  *
1020  * The source problem depends on the stage of the \p sourcescip - In SCIP_STAGE_PROBLEM, the original problem is copied,
1021  * otherwise, the transformed problem is copied. For an explicit copy of the original problem, use SCIPcopyOrigConsCompression().
1022  *
1023  * @note: in case that a combination of local bounds and explicit fixing values should be used,
1024  * the fixing value of a variable is preferred if local bounds and fixing value disagree.
1025  *
1026  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1027  *
1028  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1029  * Also, 'passmessagehdlr' should be set to FALSE.
1030  * @note the 'threadsafe' parameter should only be set to TRUE if you are absolutely certain that the source and target
1031  * SCIP instances will be solved in parallel. The usual case is to set this to FALSE, since thread safety
1032  * typically incurs a performance cost.
1033  * @note Do not change the source SCIP environment during the copying process
1034  *
1035  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1036  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1037  *
1038  * @pre This method can be called if sourcescip is in one of the following stages:
1039  * - \ref SCIP_STAGE_PROBLEM
1040  * - \ref SCIP_STAGE_TRANSFORMED
1041  * - \ref SCIP_STAGE_INITPRESOLVE
1042  * - \ref SCIP_STAGE_PRESOLVING
1043  * - \ref SCIP_STAGE_EXITPRESOLVE
1044  * - \ref SCIP_STAGE_PRESOLVED
1045  * - \ref SCIP_STAGE_INITSOLVE
1046  * - \ref SCIP_STAGE_SOLVING
1047  * - \ref SCIP_STAGE_SOLVED
1048  *
1049  * @pre This method can be called if targetscip is in one of the following stages:
1050  * - \ref SCIP_STAGE_INIT
1051  * - \ref SCIP_STAGE_FREE
1052  *
1053  * @note sourcescip stage does not get changed
1054  *
1055  * @note targetscip stage does not get changed
1056  *
1057  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1058  */
1059 SCIP_EXPORT
1060 SCIP_RETCODE SCIPcopyConsCompression(
1061  SCIP* sourcescip, /**< source SCIP data structure */
1062  SCIP* targetscip, /**< target SCIP data structure */
1063  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1064  * target variables, or NULL */
1065  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1066  * target constraints, or NULL */
1067  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1068  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
1069  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
1070  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
1071  SCIP_Bool global, /**< create a global or a local copy? */
1072  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1073  * plugins will be copied and activated, and the modifiable flag of
1074  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1075  * there are pricers present */
1076  SCIP_Bool threadsafe, /**< FALSE, if data can be safely shared between the source and target
1077  SCIP, otherwise TRUE. This is usually set to FALSE */
1078  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1079  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1080  );
1081 
1082 /** copies source SCIP original problem to target SCIP; the copying process is done in the following order:
1083  * 1) copy the plugins
1084  * 2) copy the settings
1085  * 3) create problem data in target-SCIP and copy the original problem data of the source-SCIP
1086  * 4) copy all original variables
1087  * 5) copy all original constraints
1088  *
1089  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1090  *
1091  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1092  * Also, 'passmessagehdlr' should be set to FALSE.
1093  * @note the 'threadsafe' parameter should only be set to TRUE if you are absolutely certain that the source and target
1094  * SCIP instances will be solved in parallel. The usual case is to set this to FALSE, since thread safety
1095  * typically incurs a performance cost.
1096  * @note Do not change the source SCIP environment during the copying process
1097  *
1098  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1099  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1100  *
1101  * @pre This method can be called if sourcescip is in one of the following stages:
1102  * - \ref SCIP_STAGE_PROBLEM
1103  * - \ref SCIP_STAGE_TRANSFORMED
1104  * - \ref SCIP_STAGE_INITPRESOLVE
1105  * - \ref SCIP_STAGE_PRESOLVING
1106  * - \ref SCIP_STAGE_EXITPRESOLVE
1107  * - \ref SCIP_STAGE_PRESOLVED
1108  * - \ref SCIP_STAGE_INITSOLVE
1109  * - \ref SCIP_STAGE_SOLVING
1110  * - \ref SCIP_STAGE_SOLVED
1111  *
1112  * @pre This method can be called if targetscip is in one of the following stages:
1113  * - \ref SCIP_STAGE_INIT
1114  * - \ref SCIP_STAGE_FREE
1115  *
1116  * @note sourcescip stage does not get changed
1117  *
1118  * @note targetscip stage does not get changed
1119  *
1120  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1121  */
1122 SCIP_EXPORT
1123 SCIP_RETCODE SCIPcopyOrig(
1124  SCIP* sourcescip, /**< source SCIP data structure */
1125  SCIP* targetscip, /**< target SCIP data structure */
1126  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1127  * target variables, or NULL */
1128  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1129  * target constraints, or NULL */
1130  const char* suffix, /**< suffix which will be added to the names of the target SCIP, might be empty */
1131  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1132  * plugins will be copied and activated, and the modifiable flag of
1133  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1134  * there are pricers present */
1135  SCIP_Bool threadsafe, /**< FALSE, if data can be safely shared between the source and target
1136  SCIP, otherwise TRUE. This is usually set to FALSE */
1137  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1138  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1139  );
1140 
1141 /** copies source SCIP original problem to target SCIP but compresses constraints
1142  *
1143  * constraint compression is performed by removing fixed variables immediately
1144  * during constraint creation if the involved constraint handlers support
1145  * compression
1146  *
1147  * the copying process is done in the following order:
1148  * 1) copy the plugins
1149  * 2) copy the settings
1150  * 3) create problem data in target-SCIP and copy the problem data of the source-SCIP
1151  * 4) copy all original variables
1152  * a) fix all variable copies specified by \p fixedvars, \p fixedvals, and \p nfixedvars
1153  * b) enable constraint compression
1154  * 5) copy all constraints
1155  *
1156  * @note all variables and constraints which are created in the target-SCIP are not (user) captured
1157  *
1158  * @note In a multi thread case, you need to lock the copying procedure from outside with a mutex.
1159  * Also, 'passmessagehdlr' should be set to FALSE.
1160  * @note the 'threadsafe' parameter should only be set to TRUE if you are absolutely certain that the source and target
1161  * SCIP instances will be solved in parallel. The usual case is to set this to FALSE, since thread safety
1162  * typically incurs a performance cost.
1163  * @note Do not change the source SCIP environment during the copying process
1164  *
1165  * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1166  * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1167  *
1168  * @pre This method can be called if sourcescip is in one of the following stages:
1169  * - \ref SCIP_STAGE_PROBLEM
1170  * - \ref SCIP_STAGE_TRANSFORMED
1171  * - \ref SCIP_STAGE_INITPRESOLVE
1172  * - \ref SCIP_STAGE_PRESOLVING
1173  * - \ref SCIP_STAGE_EXITPRESOLVE
1174  * - \ref SCIP_STAGE_PRESOLVED
1175  * - \ref SCIP_STAGE_INITSOLVE
1176  * - \ref SCIP_STAGE_SOLVING
1177  * - \ref SCIP_STAGE_SOLVED
1178  *
1179  * @pre This method can be called if targetscip is in one of the following stages:
1180  * - \ref SCIP_STAGE_INIT
1181  * - \ref SCIP_STAGE_FREE
1182  *
1183  * @note sourcescip stage does not get changed
1184  *
1185  * @note targetscip stage does not get changed
1186  *
1187  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1188  */
1189 SCIP_EXPORT
1190 SCIP_RETCODE SCIPcopyOrigConsCompression(
1191  SCIP* sourcescip, /**< source SCIP data structure */
1192  SCIP* targetscip, /**< target SCIP data structure */
1193  SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
1194  * target variables, or NULL */
1195  SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
1196  * target constraints, or NULL */
1197  const char* suffix, /**< optional suffix for problem name inside the target SCIP */
1198  SCIP_VAR** fixedvars, /**< source variables whose copies should be fixed in the target SCIP environment, or NULL */
1199  SCIP_Real* fixedvals, /**< array of fixing values for target SCIP variables, or NULL */
1200  int nfixedvars, /**< number of source variables whose copies should be fixed in the target SCIP environment, or NULL */
1201  SCIP_Bool enablepricing, /**< should pricing be enabled in copied SCIP instance? If TRUE, pricer
1202  * plugins will be copied and activated, and the modifiable flag of
1203  * constraints will be respected. If FALSE, valid will be set to FALSE, when
1204  * there are pricers present */
1205  SCIP_Bool threadsafe, /**< FALSE, if data can be safely shared between the source and target
1206  SCIP, otherwise TRUE. This is usually set to FALSE */
1207  SCIP_Bool passmessagehdlr, /**< should the message handler be passed */
1208  SCIP_Bool* valid /**< pointer to store whether the copying was valid, or NULL */
1209  );
1210 
1211 /** checks if there is enough time and memory left for copying the sourcescip into a sub-SCIP and solve the sub-SCIP
1212  *
1213  * This is the case if the time and memory limit that would be passed to the sub-SCIP are larger than 0.0
1214  *
1215  * @pre This method can be called if sourcescip is in one of the following stages:
1216  * - \ref SCIP_STAGE_PROBLEM
1217  * - \ref SCIP_STAGE_TRANSFORMED
1218  * - \ref SCIP_STAGE_INITPRESOLVE
1219  * - \ref SCIP_STAGE_PRESOLVING
1220  * - \ref SCIP_STAGE_EXITPRESOLVE
1221  * - \ref SCIP_STAGE_PRESOLVED
1222  * - \ref SCIP_STAGE_INITSOLVE
1223  * - \ref SCIP_STAGE_SOLVING
1224  * - \ref SCIP_STAGE_SOLVED
1225  *
1226  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1227  */
1228 SCIP_EXPORT
1229 SCIP_RETCODE SCIPcheckCopyLimits(
1230  SCIP* sourcescip, /**< source SCIP data structure */
1231  SCIP_Bool* success /**< pointer to store whether there is time and memory left to copy the
1232  * problem and run the sub-SCIP */
1233  );
1234 
1235 /** copies limits from source SCIP to target SCIP
1236  *
1237  * @note time and memory limit are reduced by the amount already spent in the source SCIP before installing the limit
1238  * in the target SCIP
1239  * @note all other limits are disabled and need to be enabled afterwards, if needed
1240  *
1241  * @see SCIPsetCommonSubscipParams() to set further working limits and other parameters commonly used for auxiliary problems
1242  *
1243  * @pre This method can be called if sourcescip is in one of the following stages:
1244  * - \ref SCIP_STAGE_PROBLEM
1245  * - \ref SCIP_STAGE_TRANSFORMED
1246  * - \ref SCIP_STAGE_INITPRESOLVE
1247  * - \ref SCIP_STAGE_PRESOLVING
1248  * - \ref SCIP_STAGE_EXITPRESOLVE
1249  * - \ref SCIP_STAGE_PRESOLVED
1250  * - \ref SCIP_STAGE_INITSOLVE
1251  * - \ref SCIP_STAGE_SOLVING
1252  * - \ref SCIP_STAGE_SOLVED
1253  *
1254  * See \ref SCIP_Stage "SCIP_STAGE" for a complete list of all possible solving stages.
1255  */
1256 SCIP_EXPORT
1257 SCIP_RETCODE SCIPcopyLimits(
1258  SCIP* sourcescip, /**< source SCIP data structure */
1259  SCIP* targetscip /**< target SCIP data structure */
1260  );
1261 
1262 
1263 /** sets the working limits as well as common search parameters for the auxiliary problem
1264  *
1265  * @note memory and time limits are not affected, and must be set using SCIPcopyLimits() instead
1266  */
1267 SCIP_EXPORT
1268 SCIP_RETCODE SCIPsetCommonSubscipParams(
1269  SCIP* sourcescip, /**< source SCIP data structure */
1270  SCIP* subscip, /**< target SCIP data structure, often a copy of \p sourcescip */
1271  SCIP_Longint nsubnodes, /**< nodelimit for subscip, or -1 for no limit */
1272  SCIP_Longint nstallnodes, /**< stall node limit for subscip, or -1 for no limit */
1273  int bestsollimit /**< the limit on the number of best solutions found, or -1 for no limit */
1274  );
1275 
1276 
1277 /**@} */
1278 
1279 #ifdef __cplusplus
1280 }
1281 #endif
1282 
1283 #endif
SCIPcopyOrigProb
SCIP_RETCODE SCIPcopyOrigProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name)
Definition: scip_copy.c:571
type_misc.h
type definitions for miscellaneous datastructures
SCIPcopy
SCIP_RETCODE SCIPcopy(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip_copy.c:2857
SCIP_Var
Definition: struct_var.h:198
SCIPconvertCutsToConss
SCIP_RETCODE SCIPconvertCutsToConss(SCIP *scip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
Definition: scip_copy.c:2054
SCIPsetSubscipDepth
void SCIPsetSubscipDepth(SCIP *scip, int newdepth)
Definition: scip_copy.c:2612
SCIPcopyLimits
SCIP_RETCODE SCIPcopyLimits(SCIP *sourcescip, SCIP *targetscip)
Definition: scip_copy.c:3278
SCIPcopyOrig
SCIP_RETCODE SCIPcopyOrig(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip_copy.c:3032
SCIPgetSubscipDepth
int SCIPgetSubscipDepth(SCIP *scip)
Definition: scip_copy.c:2591
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIPtranslateSubSol
SCIP_RETCODE SCIPtranslateSubSol(SCIP *scip, SCIP *subscip, SCIP_SOL *subsol, SCIP_HEUR *heur, SCIP_VAR **subvars, SCIP_SOL **newsol)
Definition: scip_copy.c:1399
SCIPtranslateSubSols
SCIP_RETCODE SCIPtranslateSubSols(SCIP *scip, SCIP *subscip, SCIP_HEUR *heur, SCIP_VAR **subvars, SCIP_Bool *success, int *solindex)
Definition: scip_copy.c:1439
type_retcode.h
type definitions for return codes for SCIP methods
SCIPcopyPlugins
SCIP_RETCODE SCIPcopyPlugins(SCIP *sourcescip, SCIP *targetscip, SCIP_Bool copyreaders, SCIP_Bool copypricers, SCIP_Bool copyconshdlrs, SCIP_Bool copyconflicthdlrs, SCIP_Bool copypresolvers, SCIP_Bool copyrelaxators, SCIP_Bool copyseparators, SCIP_Bool copycutselectors, SCIP_Bool copypropagators, SCIP_Bool copyheuristics, SCIP_Bool copyeventhdlrs, SCIP_Bool copynodeselectors, SCIP_Bool copybranchrules, SCIP_Bool copydisplays, SCIP_Bool copydialogs, SCIP_Bool copytables, SCIP_Bool copyexprhdlrs, SCIP_Bool copynlpis, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip_copy.c:266
SCIPcopyParamSettings
SCIP_RETCODE SCIPcopyParamSettings(SCIP *sourcescip, SCIP *targetscip)
Definition: scip_copy.c:2550
SCIPcopyBenders
SCIP_RETCODE SCIPcopyBenders(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_Bool threadsafe, SCIP_Bool *valid)
Definition: scip_copy.c:348
SCIP_Sol
Definition: struct_sol.h:64
SCIPcopyOrigConss
SCIP_RETCODE SCIPcopyOrigConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool enablepricing, SCIP_Bool *valid)
Definition: scip_copy.c:1921
SCIPenableConsCompression
SCIP_RETCODE SCIPenableConsCompression(SCIP *scip)
Definition: scip_copy.c:612
SCIP_HashMap
Definition: struct_misc.h:128
SCIP_Cons
Definition: struct_cons.h:37
SCIP_Conshdlr
Definition: struct_cons.h:117
type_scip.h
type definitions for SCIP&#39;s main datastructure
SCIPcopyVars
SCIP_RETCODE SCIPcopyVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool global)
Definition: scip_copy.c:1169
SCIPcopyCuts
SCIP_RETCODE SCIPcopyCuts(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, int *ncutsadded)
Definition: scip_copy.c:2116
SCIPmergeVariableStatistics
SCIP_RETCODE SCIPmergeVariableStatistics(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR **sourcevars, SCIP_VAR **targetvars, int nvars)
Definition: scip_copy.c:1256
SCIPcopyOrigVars
SCIP_RETCODE SCIPcopyOrigVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars)
Definition: scip_copy.c:1226
type_var.h
type definitions for problem variables
SCIPcopyImplicationsCliques
SCIP_RETCODE SCIPcopyImplicationsCliques(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *infeasible, int *nbdchgs, int *ncopied)
Definition: scip_copy.c:2366
SCIP_Heur
Definition: struct_heur.h:88
SCIPsetCommonSubscipParams
SCIP_RETCODE SCIPsetCommonSubscipParams(SCIP *sourcescip, SCIP *subscip, SCIP_Longint nsubnodes, SCIP_Longint nstallnodes, int bestsollimit)
Definition: scip_copy.c:3319
SCIPcopyConflicts
SCIP_RETCODE SCIPcopyConflicts(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool *valid)
Definition: scip_copy.c:2208
SCIPgetConsCopy
SCIP_RETCODE SCIPgetConsCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_CONS *sourcecons, SCIP_CONS **targetcons, SCIP_CONSHDLR *sourceconshdlr, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *name, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode, SCIP_Bool global, SCIP_Bool *valid)
Definition: scip_copy.c:1577
SCIPcopyConsCompression
SCIP_RETCODE SCIPcopyConsCompression(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip_copy.c:2951
SCIP_Bool
#define SCIP_Bool
Definition: def.h:84
SCIPcopyConss
SCIP_RETCODE SCIPcopyConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool *valid)
Definition: scip_copy.c:1716
SCIPcopyProb
SCIP_RETCODE SCIPcopyProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, const char *name)
Definition: scip_copy.c:518
SCIPcopyOrigConsCompression
SCIP_RETCODE SCIPcopyOrigConsCompression(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, const char *suffix, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool enablepricing, SCIP_Bool threadsafe, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip_copy.c:3119
SCIPgetVarCopy
SCIP_RETCODE SCIPgetVarCopy(SCIP *sourcescip, SCIP *targetscip, SCIP_VAR *sourcevar, SCIP_VAR **targetvar, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool *success)
Definition: scip_copy.c:702
SCIPisConsCompressionEnabled
SCIP_Bool SCIPisConsCompressionEnabled(SCIP *scip)
Definition: scip_copy.c:651
SCIP_Real
#define SCIP_Real
Definition: def.h:177
SCIP_Longint
#define SCIP_Longint
Definition: def.h:162
SCIPcheckCopyLimits
SCIP_RETCODE SCIPcheckCopyLimits(SCIP *sourcescip, SCIP_Bool *success)
Definition: scip_copy.c:3235
subsol
static DPSUBSOL ** subsol
Definition: dptermsinterns.h:148
SCIPmergeNLPIStatistics
void SCIPmergeNLPIStatistics(SCIP *sourcescip, SCIP *targetscip, SCIP_Bool reset)
Definition: scip_copy.c:1321
def.h
common defines and data types used in all packages of SCIP
type_cons.h
type definitions for constraints and constraint handlers