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