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