Scippy

SCIP

Solving Constraint Integer Programs

scip_prob.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_prob.h
26 * @ingroup PUBLICCOREAPI
27 * @brief public methods for global and local (sub)problems
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_PROB_H__
41#define __SCIP_SCIP_PROB_H__
42
43
44#include "scip/def.h"
45#include "scip/type_conflict.h"
46#include "scip/type_cons.h"
47#include "scip/type_event.h"
48#include "scip/type_misc.h"
49#include "scip/type_prob.h"
50#include "scip/type_rational.h"
51#include "scip/type_result.h"
52#include "scip/type_retcode.h"
53#include "scip/type_scip.h"
54#include "scip/type_sol.h"
55#include "scip/type_tree.h"
56#include "scip/type_var.h"
57
58#ifdef __cplusplus
59extern "C" {
60#endif
61
62/**@addtogroup GlobalProblemMethods
63 *
64 * @{
65 */
66
67/** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
68 * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
69 * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
70 *
71 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
72 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
73 *
74 * @pre This method can be called if @p scip is in one of the following stages:
75 * - \ref SCIP_STAGE_INIT
76 * - \ref SCIP_STAGE_PROBLEM
77 * - \ref SCIP_STAGE_TRANSFORMED
78 * - \ref SCIP_STAGE_PRESOLVING
79 * - \ref SCIP_STAGE_PRESOLVED
80 * - \ref SCIP_STAGE_SOLVING
81 * - \ref SCIP_STAGE_SOLVED
82 * - \ref SCIP_STAGE_FREE
83 *
84 * @post After calling this method, \SCIP reaches the following stage:
85 * - \ref SCIP_STAGE_PROBLEM
86 */
87SCIP_EXPORT
88SCIP_RETCODE SCIPcreateProb(
89 SCIP* scip, /**< SCIP data structure */
90 const char* name, /**< problem name */
91 SCIP_DECL_PROBDELORIG ((*probdelorig)), /**< frees user data of original problem */
92 SCIP_DECL_PROBTRANS ((*probtrans)), /**< creates user data of transformed problem by transforming original user data */
93 SCIP_DECL_PROBDELTRANS((*probdeltrans)), /**< frees user data of transformed problem */
94 SCIP_DECL_PROBINITSOL ((*probinitsol)), /**< solving process initialization method of transformed data */
95 SCIP_DECL_PROBEXITSOL ((*probexitsol)), /**< solving process deinitialization method of transformed data */
96 SCIP_DECL_PROBCOPY ((*probcopy)), /**< copies user data if you want to copy it to a subscip, or NULL */
97 SCIP_PROBDATA* probdata /**< user problem data set by the reader */
98 );
99
100/** creates empty problem and initializes all solving data structures (the objective sense is set to MINIMIZE)
101 * all callback methods will be set to NULL and can be set afterwards, if needed, via SCIPsetProbDelorig(),
102 * SCIPsetProbTrans(), SCIPsetProbDeltrans(), SCIPsetProbInitsol(), SCIPsetProbExitsol(), and
103 * SCIPsetProbCopy()
104 * If the problem type requires the use of variable pricers, these pricers should be added to the problem with calls
105 * to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
106 *
107 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
108 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
109 *
110 * @pre This method can be called if @p scip is in one of the following stages:
111 * - \ref SCIP_STAGE_INIT
112 * - \ref SCIP_STAGE_PROBLEM
113 * - \ref SCIP_STAGE_TRANSFORMED
114 * - \ref SCIP_STAGE_PRESOLVING
115 * - \ref SCIP_STAGE_PRESOLVED
116 * - \ref SCIP_STAGE_SOLVING
117 * - \ref SCIP_STAGE_SOLVED
118 * - \ref SCIP_STAGE_FREE
119 *
120 * @post After calling this method, \SCIP reaches the following stage:
121 * - \ref SCIP_STAGE_PROBLEM
122 */
123SCIP_EXPORT
124SCIP_RETCODE SCIPcreateProbBasic(
125 SCIP* scip, /**< SCIP data structure */
126 const char* name /**< problem name */
127 );
128
129/** sets callback to free user data of original problem
130 *
131 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
132 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
133 *
134 * @pre This method can be called if @p scip is in one of the following stages:
135 * - \ref SCIP_STAGE_PROBLEM
136 */
137SCIP_EXPORT
138SCIP_RETCODE SCIPsetProbDelorig(
139 SCIP* scip, /**< SCIP data structure */
140 SCIP_DECL_PROBDELORIG ((*probdelorig)) /**< frees user data of original problem */
141 );
142
143/** sets callback to create user data of transformed problem by transforming original user data
144 *
145 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
146 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
147 *
148 * @pre This method can be called if @p scip is in one of the following stages:
149 * - \ref SCIP_STAGE_PROBLEM
150 */
151SCIP_EXPORT
152SCIP_RETCODE SCIPsetProbTrans(
153 SCIP* scip, /**< SCIP data structure */
154 SCIP_DECL_PROBTRANS ((*probtrans)) /**< creates user data of transformed problem by transforming original user data */
155 );
156
157/** sets callback to free user data of transformed problem
158 *
159 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
160 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
161 *
162 * @pre This method can be called if @p scip is in one of the following stages:
163 * - \ref SCIP_STAGE_PROBLEM
164 */
165SCIP_EXPORT
166SCIP_RETCODE SCIPsetProbDeltrans(
167 SCIP* scip, /**< SCIP data structure */
168 SCIP_DECL_PROBDELTRANS((*probdeltrans)) /**< frees user data of transformed problem */
169 );
170
171/** sets solving process initialization callback of transformed data
172 *
173 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
174 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
175 *
176 * @pre This method can be called if @p scip is in one of the following stages:
177 * - \ref SCIP_STAGE_PROBLEM
178 */
179SCIP_EXPORT
180SCIP_RETCODE SCIPsetProbInitsol(
181 SCIP* scip, /**< SCIP data structure */
182 SCIP_DECL_PROBINITSOL ((*probinitsol)) /**< solving process initialization method of transformed data */
183 );
184
185/** sets solving process deinitialization callback of transformed data
186 *
187 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
188 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
189 *
190 * @pre This method can be called if @p scip is in one of the following stages:
191 * - \ref SCIP_STAGE_PROBLEM
192 */
193SCIP_EXPORT
194SCIP_RETCODE SCIPsetProbExitsol(
195 SCIP* scip, /**< SCIP data structure */
196 SCIP_DECL_PROBEXITSOL ((*probexitsol)) /**< solving process deinitialization method of transformed data */
197 );
198
199/** sets callback to copy user data to a subscip
200 *
201 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
202 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
203 *
204 * @pre This method can be called if @p scip is in one of the following stages:
205 * - \ref SCIP_STAGE_PROBLEM
206 */
207SCIP_EXPORT
208SCIP_RETCODE SCIPsetProbCopy(
209 SCIP* scip, /**< SCIP data structure */
210 SCIP_DECL_PROBCOPY ((*probcopy)) /**< copies user data if you want to copy it to a subscip, or NULL */
211 );
212
213/** reads problem from file and initializes all solving data structures
214 *
215 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
216 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
217 *
218 * @pre This method can be called if @p scip is in one of the following stages:
219 * - \ref SCIP_STAGE_INIT
220 * - \ref SCIP_STAGE_PROBLEM
221 * - \ref SCIP_STAGE_TRANSFORMED
222 * - \ref SCIP_STAGE_INITPRESOLVE
223 * - \ref SCIP_STAGE_PRESOLVING
224 * - \ref SCIP_STAGE_EXITPRESOLVE
225 * - \ref SCIP_STAGE_PRESOLVED
226 * - \ref SCIP_STAGE_SOLVING
227 * - \ref SCIP_STAGE_EXITSOLVE
228 *
229 * @post After the method was called, \SCIP is in one of the following stages:
230 * - \ref SCIP_STAGE_INIT if reading failed (usually, when a SCIP_READERROR occurs)
231 * - \ref SCIP_STAGE_PROBLEM if the problem file was successfully read
232 */
233SCIP_EXPORT
234SCIP_RETCODE SCIPreadProb(
235 SCIP* scip, /**< SCIP data structure */
236 const char* filename, /**< problem file name */
237 const char* extension /**< extension of the desired file reader,
238 * or NULL if file extension should be used */
239 );
240
241/** outputs original problem to file stream
242 *
243 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
244 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
245 *
246 * @pre This method can be called if SCIP is in one of the following stages:
247 * - \ref SCIP_STAGE_PROBLEM
248 * - \ref SCIP_STAGE_TRANSFORMING
249 * - \ref SCIP_STAGE_TRANSFORMED
250 * - \ref SCIP_STAGE_INITPRESOLVE
251 * - \ref SCIP_STAGE_PRESOLVING
252 * - \ref SCIP_STAGE_EXITPRESOLVE
253 * - \ref SCIP_STAGE_PRESOLVED
254 * - \ref SCIP_STAGE_INITSOLVE
255 * - \ref SCIP_STAGE_SOLVING
256 * - \ref SCIP_STAGE_SOLVED
257 * - \ref SCIP_STAGE_EXITSOLVE
258 * - \ref SCIP_STAGE_FREETRANS
259 */
260SCIP_EXPORT
261SCIP_RETCODE SCIPprintOrigProblem(
262 SCIP* scip, /**< SCIP data structure */
263 FILE* file, /**< output file (or NULL for standard output) */
264 const char* extension, /**< file format (or NULL for default CIP format)*/
265 SCIP_Bool genericnames /**< using generic variable and constraint names? */
266 );
267
268/** outputs transformed problem of the current node to file stream
269 *
270 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
271 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
272 *
273 * @pre This method can be called if SCIP is in one of the following stages:
274 * - \ref SCIP_STAGE_TRANSFORMED
275 * - \ref SCIP_STAGE_INITPRESOLVE
276 * - \ref SCIP_STAGE_PRESOLVING
277 * - \ref SCIP_STAGE_EXITPRESOLVE
278 * - \ref SCIP_STAGE_PRESOLVED
279 * - \ref SCIP_STAGE_INITSOLVE
280 * - \ref SCIP_STAGE_SOLVING
281 * - \ref SCIP_STAGE_SOLVED
282 * - \ref SCIP_STAGE_EXITSOLVE
283 * - \ref SCIP_STAGE_FREETRANS
284 */
285SCIP_EXPORT
286SCIP_RETCODE SCIPprintTransProblem(
287 SCIP* scip, /**< SCIP data structure */
288 FILE* file, /**< output file (or NULL for standard output) */
289 const char* extension, /**< file format (or NULL for default CIP format)*/
290 SCIP_Bool genericnames /**< using generic variable and constraint names? */
291 );
292
293/** writes original problem to file
294 *
295 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
296 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
297 *
298 * @pre This method can be called if @p scip is in one of the following stages:
299 * - \ref SCIP_STAGE_PROBLEM
300 * - \ref SCIP_STAGE_TRANSFORMING
301 * - \ref SCIP_STAGE_TRANSFORMED
302 * - \ref SCIP_STAGE_INITPRESOLVE
303 * - \ref SCIP_STAGE_PRESOLVING
304 * - \ref SCIP_STAGE_EXITPRESOLVE
305 * - \ref SCIP_STAGE_PRESOLVED
306 * - \ref SCIP_STAGE_INITSOLVE
307 * - \ref SCIP_STAGE_SOLVING
308 * - \ref SCIP_STAGE_SOLVED
309 * - \ref SCIP_STAGE_EXITSOLVE
310 * - \ref SCIP_STAGE_FREETRANS
311 */
312SCIP_EXPORT
313SCIP_RETCODE SCIPwriteOrigProblem(
314 SCIP* scip, /**< SCIP data structure */
315 const char* filename, /**< output file (or NULL for standard output) */
316 const char* extension, /**< extension of the desired file reader,
317 * or NULL if file extension should be used */
318 SCIP_Bool genericnames /**< use generic variable and constraint names? */
319 );
320
321/** writes transformed problem which are valid in the current node to file
322 *
323 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
324 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
325 *
326 * @pre This method can be called if @p scip is in one of the following stages:
327 * - \ref SCIP_STAGE_TRANSFORMED
328 * - \ref SCIP_STAGE_INITPRESOLVE
329 * - \ref SCIP_STAGE_PRESOLVING
330 * - \ref SCIP_STAGE_EXITPRESOLVE
331 * - \ref SCIP_STAGE_PRESOLVED
332 * - \ref SCIP_STAGE_INITSOLVE
333 * - \ref SCIP_STAGE_SOLVING
334 * - \ref SCIP_STAGE_SOLVED
335 * - \ref SCIP_STAGE_EXITSOLVE
336 *
337 * @note If you want the write all constraints (including the once which are redundant for example), you need to set
338 * the parameter <write/allconss> to TRUE
339 */
340SCIP_EXPORT
341SCIP_RETCODE SCIPwriteTransProblem(
342 SCIP* scip, /**< SCIP data structure */
343 const char* filename, /**< output file (or NULL for standard output) */
344 const char* extension, /**< extension of the desired file reader,
345 * or NULL if file extension should be used */
346 SCIP_Bool genericnames /**< using generic variable and constraint names? */
347 );
348
349/** frees problem and solution process data
350 *
351 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
352 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
353 *
354 * @pre This method can be called if @p scip is in one of the following stages:
355 * - \ref SCIP_STAGE_INIT
356 * - \ref SCIP_STAGE_PROBLEM
357 * - \ref SCIP_STAGE_TRANSFORMED
358 * - \ref SCIP_STAGE_PRESOLVING
359 * - \ref SCIP_STAGE_PRESOLVED
360 * - \ref SCIP_STAGE_SOLVING
361 * - \ref SCIP_STAGE_SOLVED
362 * - \ref SCIP_STAGE_FREE
363 *
364 * @post After this method was called, SCIP is in the following stage:
365 * - \ref SCIP_STAGE_INIT
366 */
367SCIP_EXPORT
368SCIP_RETCODE SCIPfreeProb(
369 SCIP* scip /**< SCIP data structure */
370 );
371
372/** permutes parts of the problem data structure
373 *
374 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
375 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
376 *
377 * @pre This method can be called if @p scip is in one of the following stages:
378 * - \ref SCIP_STAGE_PROBLEM
379 * - \ref SCIP_STAGE_TRANSFORMED
380 *
381 * @todo This need to be changed to use the new random number generator implemented in random.c
382 */
383SCIP_EXPORT
384SCIP_RETCODE SCIPpermuteProb(
385 SCIP* scip, /**< SCIP data structure */
386 unsigned int randseed, /**< seed value for random generator */
387 SCIP_Bool permuteconss, /**< should the list of constraints in each constraint handler be permuted? */
388 SCIP_Bool permutebinvars, /**< should the list of binary variables be permuted? */
389 SCIP_Bool permuteintvars, /**< should the list of integer variables be permuted? */
390 SCIP_Bool permutebinimplvars, /**< should the list of binary implied integral vars be permuted? */
391 SCIP_Bool permuteintimplvars, /**< should the list of integer implied integral vars be permuted? */
392 SCIP_Bool permutecontimplvars, /**< should the list of continuous implied integral vars be permuted? */
393 SCIP_Bool permutecontvars /**< should the list of continuous variables be permuted? */
394 );
395
396/** gets user problem data
397 *
398 * @return a SCIP_PROBDATA pointer, or NULL if no problem data was allocated
399 *
400 * @pre This method can be called if @p scip is in one of the following stages:
401 * - \ref SCIP_STAGE_PROBLEM
402 * - \ref SCIP_STAGE_TRANSFORMING
403 * - \ref SCIP_STAGE_TRANSFORMED
404 * - \ref SCIP_STAGE_INITPRESOLVE
405 * - \ref SCIP_STAGE_PRESOLVING
406 * - \ref SCIP_STAGE_EXITPRESOLVE
407 * - \ref SCIP_STAGE_PRESOLVED
408 * - \ref SCIP_STAGE_INITSOLVE
409 * - \ref SCIP_STAGE_SOLVING
410 * - \ref SCIP_STAGE_SOLVED
411 * - \ref SCIP_STAGE_EXITSOLVE
412 * - \ref SCIP_STAGE_FREETRANS
413 */
414SCIP_EXPORT
415SCIP_PROBDATA* SCIPgetProbData(
416 SCIP* scip /**< SCIP data structure */
417 );
418
419/** sets user problem data
420 *
421 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
422 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
423 *
424 * @pre This method can be called if @p scip is in one of the following stages:
425 * - \ref SCIP_STAGE_PROBLEM
426 * - \ref SCIP_STAGE_TRANSFORMING
427 * - \ref SCIP_STAGE_TRANSFORMED
428 * - \ref SCIP_STAGE_INITPRESOLVE
429 * - \ref SCIP_STAGE_PRESOLVING
430 * - \ref SCIP_STAGE_EXITPRESOLVE
431 * - \ref SCIP_STAGE_PRESOLVED
432 * - \ref SCIP_STAGE_INITSOLVE
433 * - \ref SCIP_STAGE_SOLVING
434 * - \ref SCIP_STAGE_SOLVED
435 * - \ref SCIP_STAGE_EXITSOLVE
436 * - \ref SCIP_STAGE_FREETRANS
437 */
438SCIP_EXPORT
439SCIP_RETCODE SCIPsetProbData(
440 SCIP* scip, /**< SCIP data structure */
441 SCIP_PROBDATA* probdata /**< user problem data to use */
442 );
443
444/** returns name of the current problem instance
445 *
446 * @return name of the current problem instance
447 *
448 * @pre This method can be called if @p scip is in one of the following stages:
449 * - \ref SCIP_STAGE_PROBLEM
450 * - \ref SCIP_STAGE_TRANSFORMING
451 * - \ref SCIP_STAGE_TRANSFORMED
452 * - \ref SCIP_STAGE_INITPRESOLVE
453 * - \ref SCIP_STAGE_PRESOLVING
454 * - \ref SCIP_STAGE_EXITPRESOLVE
455 * - \ref SCIP_STAGE_PRESOLVED
456 * - \ref SCIP_STAGE_INITSOLVE
457 * - \ref SCIP_STAGE_SOLVING
458 * - \ref SCIP_STAGE_SOLVED
459 * - \ref SCIP_STAGE_EXITSOLVE
460 * - \ref SCIP_STAGE_FREETRANS
461 */
462SCIP_EXPORT
463const char* SCIPgetProbName(
464 SCIP* scip /**< SCIP data structure */
465 );
466
467/** sets name of the current problem instance
468 *
469 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
470 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
471 *
472 * @pre This method can be called if @p scip is in one of the following stages:
473 * - \ref SCIP_STAGE_PROBLEM
474 * - \ref SCIP_STAGE_TRANSFORMING
475 * - \ref SCIP_STAGE_TRANSFORMED
476 * - \ref SCIP_STAGE_INITPRESOLVE
477 * - \ref SCIP_STAGE_PRESOLVING
478 * - \ref SCIP_STAGE_EXITPRESOLVE
479 * - \ref SCIP_STAGE_PRESOLVED
480 * - \ref SCIP_STAGE_INITSOLVE
481 * - \ref SCIP_STAGE_SOLVING
482 * - \ref SCIP_STAGE_SOLVED
483 * - \ref SCIP_STAGE_EXITSOLVE
484 * - \ref SCIP_STAGE_FREETRANS
485 */
486SCIP_EXPORT
487SCIP_RETCODE SCIPsetProbName(
488 SCIP* scip, /**< SCIP data structure */
489 const char* name /**< name to be set */
490 );
491
492/** changes the objective function of the original problem.
493 *
494 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
495 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
496 *
497 * @pre This method can be called if @p scip is in one of the following stages:
498 * - \ref SCIP_STAGE_PROBLEM
499 * - \ref SCIP_STAGE_PRESOLVED
500 *
501 * @note This method should be only used to change the objective function during two reoptimization runs and is only
502 * recommended to an experienced user.
503 *
504 * @note All variables not given in \p vars array are assumed to have an objective coefficient of zero.
505 */
506SCIP_EXPORT
507SCIP_RETCODE SCIPchgReoptObjective(
508 SCIP* scip, /**< SCIP data structure */
509 SCIP_OBJSENSE objsense, /**< new objective function */
510 SCIP_VAR** vars, /**< problem variables */
511 SCIP_Real* coefs, /**< objective coefficients */
512 int nvars /**< variables in vars array */
513 );
514
515/** returns objective sense of original problem
516 *
517 * @return objective sense of original problem
518 *
519 * @pre This method can be called if @p scip is in one of the following stages:
520 * - \ref SCIP_STAGE_PROBLEM
521 * - \ref SCIP_STAGE_TRANSFORMING
522 * - \ref SCIP_STAGE_TRANSFORMED
523 * - \ref SCIP_STAGE_INITPRESOLVE
524 * - \ref SCIP_STAGE_PRESOLVING
525 * - \ref SCIP_STAGE_EXITPRESOLVE
526 * - \ref SCIP_STAGE_PRESOLVED
527 * - \ref SCIP_STAGE_INITSOLVE
528 * - \ref SCIP_STAGE_SOLVING
529 * - \ref SCIP_STAGE_SOLVED
530 * - \ref SCIP_STAGE_EXITSOLVE
531 * - \ref SCIP_STAGE_FREETRANS
532 */
533SCIP_EXPORT
534SCIP_OBJSENSE SCIPgetObjsense(
535 SCIP* scip /**< SCIP data structure */
536 );
537
538/** sets objective sense of problem
539 *
540 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
541 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
542 *
543 * @pre This method can be called if @p scip is in one of the following stages:
544 * - \ref SCIP_STAGE_PROBLEM
545 */
546SCIP_EXPORT
547SCIP_RETCODE SCIPsetObjsense(
548 SCIP* scip, /**< SCIP data structure */
549 SCIP_OBJSENSE objsense /**< new objective sense */
550 );
551
552/** adds offset of objective function
553 *
554 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
555 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
556 *
557 * @pre This method can be called if @p scip is in one of the following stages:
558 * - \ref SCIP_STAGE_PRESOLVING
559 */
560SCIP_EXPORT
561SCIP_RETCODE SCIPaddObjoffset(
562 SCIP* scip, /**< SCIP data structure */
563 SCIP_Real addval /**< value to add to objective offset */
564 );
565
566/** adds offset of objective function to original problem and to all existing solution in original space
567 *
568 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
569 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
570 *
571 * @pre This method can be called if @p scip is in one of the following stages:
572 * - \ref SCIP_STAGE_PROBLEM
573 */
574SCIP_EXPORT
575SCIP_RETCODE SCIPaddOrigObjoffsetExact(
576 SCIP* scip, /**< SCIP data structure */
577 SCIP_RATIONAL* addval /**< value to add to objective offset */
578 );
579
580/** adds offset of objective function to original problem and to all existing solution in original space
581 *
582 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
583 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
584 *
585 * @pre This method can be called if @p scip is in one of the following stages:
586 * - \ref SCIP_STAGE_PROBLEM
587 */
588SCIP_EXPORT
589SCIP_RETCODE SCIPaddOrigObjoffset(
590 SCIP* scip, /**< SCIP data structure */
591 SCIP_Real addval /**< value to add to objective offset */
592 );
593
594/** returns the objective offset of the original problem
595 *
596 * @return the objective offset of the original problem
597 *
598 * @pre This method can be called if @p scip is in one of the following stages:
599 * - \ref SCIP_STAGE_PROBLEM
600 * - \ref SCIP_STAGE_TRANSFORMING
601 * - \ref SCIP_STAGE_TRANSFORMED
602 * - \ref SCIP_STAGE_INITPRESOLVE
603 * - \ref SCIP_STAGE_PRESOLVING
604 * - \ref SCIP_STAGE_EXITPRESOLVE
605 * - \ref SCIP_STAGE_PRESOLVED
606 * - \ref SCIP_STAGE_INITSOLVE
607 * - \ref SCIP_STAGE_SOLVING
608 * - \ref SCIP_STAGE_SOLVED
609 */
610SCIP_EXPORT
611SCIP_Real SCIPgetOrigObjoffset(
612 SCIP* scip /**< SCIP data structure */
613 );
614
615/** returns the exact objective offset of the original problem
616 *
617 * DO NOT MODIFY THE POINTER RETURNED BY THIS METHOD
618 *
619 * @return the exact objective offset of the original problem
620 *
621 * @pre This method can be called if @p scip is in one of the following stages:
622 * - \ref SCIP_STAGE_PROBLEM
623 * - \ref SCIP_STAGE_TRANSFORMING
624 * - \ref SCIP_STAGE_TRANSFORMED
625 * - \ref SCIP_STAGE_INITPRESOLVE
626 * - \ref SCIP_STAGE_PRESOLVING
627 * - \ref SCIP_STAGE_EXITPRESOLVE
628 * - \ref SCIP_STAGE_PRESOLVED
629 * - \ref SCIP_STAGE_INITSOLVE
630 * - \ref SCIP_STAGE_SOLVING
631 * - \ref SCIP_STAGE_SOLVED
632 */
633SCIP_EXPORT
634SCIP_RATIONAL* SCIPgetOrigObjoffsetExact(
635 SCIP* scip /**< SCIP data structure */
636 );
637
638/** returns the objective scale of the original problem
639 *
640 * @return the objective scale of the original problem
641 *
642 * @pre This method can be called if @p scip is in one of the following stages:
643 * - \ref SCIP_STAGE_PROBLEM
644 * - \ref SCIP_STAGE_TRANSFORMING
645 * - \ref SCIP_STAGE_TRANSFORMED
646 * - \ref SCIP_STAGE_INITPRESOLVE
647 * - \ref SCIP_STAGE_PRESOLVING
648 * - \ref SCIP_STAGE_EXITPRESOLVE
649 * - \ref SCIP_STAGE_PRESOLVED
650 * - \ref SCIP_STAGE_INITSOLVE
651 * - \ref SCIP_STAGE_SOLVING
652 * - \ref SCIP_STAGE_SOLVED
653 */
654SCIP_EXPORT
655SCIP_Real SCIPgetOrigObjscale(
656 SCIP* scip /**< SCIP data structure */
657 );
658
659/** returns the objective offset of the transformed problem
660 *
661 * @return the objective offset of the transformed problem
662 *
663 * @pre This method can be called if @p scip is in one of the following stages:
664 * - \ref SCIP_STAGE_TRANSFORMED
665 * - \ref SCIP_STAGE_INITPRESOLVE
666 * - \ref SCIP_STAGE_PRESOLVING
667 * - \ref SCIP_STAGE_EXITPRESOLVE
668 * - \ref SCIP_STAGE_PRESOLVED
669 * - \ref SCIP_STAGE_INITSOLVE
670 * - \ref SCIP_STAGE_SOLVING
671 * - \ref SCIP_STAGE_SOLVED
672 */
673SCIP_EXPORT
674SCIP_Real SCIPgetTransObjoffset(
675 SCIP* scip /**< SCIP data structure */
676 );
677
678/** returns the objective scale of the transformed problem
679 *
680 * @return the objective scale of the transformed problem
681 *
682 * @pre This method can be called if @p scip is in one of the following stages:
683 * - \ref SCIP_STAGE_TRANSFORMED
684 * - \ref SCIP_STAGE_INITPRESOLVE
685 * - \ref SCIP_STAGE_PRESOLVING
686 * - \ref SCIP_STAGE_EXITPRESOLVE
687 * - \ref SCIP_STAGE_PRESOLVED
688 * - \ref SCIP_STAGE_INITSOLVE
689 * - \ref SCIP_STAGE_SOLVING
690 * - \ref SCIP_STAGE_SOLVED
691 */
692SCIP_EXPORT
693SCIP_Real SCIPgetTransObjscale(
694 SCIP* scip /**< SCIP data structure */
695 );
696
697/** sets limit on objective function, such that only solutions better than this limit are accepted
698 *
699 * @note SCIP will only look for solutions with a strictly better objective value, thus, e.g., prune
700 * all branch-and-bound nodes with dual bound equal or worse to the objective limit.
701 * However, SCIP will also collect solutions with objective value worse than the objective limit and
702 * use them to run improvement heuristics on them.
703 * @note If SCIP can prove that there exists no solution with a strictly better objective value, the solving status
704 * will normally be infeasible (the objective limit is interpreted as part of the problem).
705 * The only exception is that by chance, SCIP found a solution with the same objective value and thus
706 * proved the optimality of this solution, resulting in solution status optimal.
707 *
708 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
709 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
710 *
711 * @pre This method can be called if @p scip is in one of the following stages:
712 * - \ref SCIP_STAGE_PROBLEM
713 * - \ref SCIP_STAGE_TRANSFORMED
714 * - \ref SCIP_STAGE_INITPRESOLVE
715 * - \ref SCIP_STAGE_PRESOLVING
716 * - \ref SCIP_STAGE_EXITPRESOLVE
717 * - \ref SCIP_STAGE_PRESOLVED
718 * - \ref SCIP_STAGE_SOLVING
719 */
720SCIP_EXPORT
721SCIP_RETCODE SCIPsetObjlimit(
722 SCIP* scip, /**< SCIP data structure */
723 SCIP_Real objlimit /**< new primal objective limit */
724 );
725
726/** returns current limit on objective function
727 *
728 * @return the current objective limit of the original problem
729 *
730 * @pre This method can be called if @p scip is in one of the following stages:
731 * - \ref SCIP_STAGE_PROBLEM
732 * - \ref SCIP_STAGE_TRANSFORMING
733 * - \ref SCIP_STAGE_TRANSFORMED
734 * - \ref SCIP_STAGE_INITPRESOLVE
735 * - \ref SCIP_STAGE_PRESOLVING
736 * - \ref SCIP_STAGE_EXITPRESOLVE
737 * - \ref SCIP_STAGE_PRESOLVED
738 * - \ref SCIP_STAGE_INITSOLVE
739 * - \ref SCIP_STAGE_SOLVING
740 * - \ref SCIP_STAGE_SOLVED
741 */
742SCIP_EXPORT
743SCIP_Real SCIPgetObjlimit(
744 SCIP* scip /**< SCIP data structure */
745 );
746
747/** informs SCIP, that the objective value is always integral in every feasible solution
748 *
749 * @return \ref SCIP_OKAY is returned if everything worked. otherwise a suitable error code is passed. see \ref
750 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
751 *
752 * @pre This method can be called if @p scip is in one of the following stages:
753 * - \ref SCIP_STAGE_PROBLEM
754 * - \ref SCIP_STAGE_TRANSFORMING
755 * - \ref SCIP_STAGE_INITPRESOLVE
756 * - \ref SCIP_STAGE_EXITPRESOLVE
757 * - \ref SCIP_STAGE_SOLVING
758 *
759 * @note This function should be used to inform SCIP that the objective function is integral, helping to improve the
760 * performance. This is useful when using column generation. If no column generation (pricing) is used, SCIP
761 * automatically detects whether the objective function is integral or can be scaled to be integral. However, in
762 * any case, the user has to make sure that no variable is added during the solving process that destroys this
763 * property.
764 */
765SCIP_EXPORT
766SCIP_RETCODE SCIPsetObjIntegral(
767 SCIP* scip /**< SCIP data structure */
768 );
769
770/** returns whether the objective value is known to be integral in every feasible solution
771 *
772 * @return TRUE, if objective value is known to be always integral, otherwise FALSE
773 *
774 * @pre This method can be called if @p scip is in one of the following stages:
775 * - \ref SCIP_STAGE_PROBLEM
776 * - \ref SCIP_STAGE_TRANSFORMING
777 * - \ref SCIP_STAGE_INITPRESOLVE
778 * - \ref SCIP_STAGE_PRESOLVING
779 * - \ref SCIP_STAGE_EXITPRESOLVE
780 * - \ref SCIP_STAGE_PRESOLVED
781 * - \ref SCIP_STAGE_SOLVING
782 *
783 * @note If no pricing is performed, SCIP automatically detects whether the objective function is integral or can be
784 * scaled to be integral, helping to improve performance. This function returns the result. Otherwise
785 * SCIPsetObjIntegral() can be used to inform SCIP. However, in any case, the user has to make sure that no
786 * variable is added during the solving process that destroys this property.
787 */
788SCIP_EXPORT
789SCIP_Bool SCIPisObjIntegral(
790 SCIP* scip /**< SCIP data structure */
791 );
792
793/** returns the Euclidean norm of the objective function vector (available only for transformed problem)
794 *
795 * @return the Euclidean norm of the transformed objective function vector
796 *
797 * @pre This method can be called if @p scip is in one of the following stages:
798 * - \ref SCIP_STAGE_TRANSFORMED
799 * - \ref SCIP_STAGE_INITPRESOLVE
800 * - \ref SCIP_STAGE_PRESOLVING
801 * - \ref SCIP_STAGE_EXITPRESOLVE
802 * - \ref SCIP_STAGE_PRESOLVED
803 * - \ref SCIP_STAGE_INITSOLVE
804 * - \ref SCIP_STAGE_SOLVING
805 * - \ref SCIP_STAGE_SOLVED
806 * - \ref SCIP_STAGE_EXITSOLVE
807 */
808SCIP_EXPORT
809SCIP_Real SCIPgetObjNorm(
810 SCIP* scip /**< SCIP data structure */
811 );
812
813/** adds variable to the problem
814 *
815 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
816 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
817 *
818 * @pre This method can be called if @p scip is in one of the following stages:
819 * - \ref SCIP_STAGE_PROBLEM
820 * - \ref SCIP_STAGE_TRANSFORMING
821 * - \ref SCIP_STAGE_INITPRESOLVE
822 * - \ref SCIP_STAGE_PRESOLVING
823 * - \ref SCIP_STAGE_EXITPRESOLVE
824 * - \ref SCIP_STAGE_PRESOLVED
825 * - \ref SCIP_STAGE_SOLVING
826 */
827SCIP_EXPORT
828SCIP_RETCODE SCIPaddVar(
829 SCIP* scip, /**< SCIP data structure */
830 SCIP_VAR* var /**< variable to add */
831 );
832
833/** adds variable to the problem and uses it as pricing candidate to enter the LP
834 *
835 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
836 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
837 *
838 * @pre This method can only be called if @p scip is in stage \ref SCIP_STAGE_SOLVING
839 */
840SCIP_EXPORT
841SCIP_RETCODE SCIPaddPricedVar(
842 SCIP* scip, /**< SCIP data structure */
843 SCIP_VAR* var, /**< variable to add */
844 SCIP_Real score /**< pricing score of variable (the larger, the better the variable) */
845 );
846
847/** removes variable from the problem
848 *
849 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
850 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
851 *
852 * @warning The variable is not deleted from the constraints when in SCIP_STAGE_PROBLEM. In this stage, it is the
853 * user's responsibility to ensure the variable has been removed from all constraints or the constraints
854 * deleted.
855 *
856 * @pre This method can be called if @p scip is in one of the following stages:
857 * - \ref SCIP_STAGE_PROBLEM
858 * - \ref SCIP_STAGE_TRANSFORMING
859 * - \ref SCIP_STAGE_TRANSFORMED
860 * - \ref SCIP_STAGE_PRESOLVING
861 * - \ref SCIP_STAGE_FREETRANS
862 *
863 * @warning The variable is not deleted from the constraints when in SCIP_STAGE_PROBLEM. In this stage, it is the
864 * user's responsibility to ensure the variable has been removed from all constraints or the constraints
865 * deleted.
866 */
867SCIP_EXPORT
868SCIP_RETCODE SCIPdelVar(
869 SCIP* scip, /**< SCIP data structure */
870 SCIP_VAR* var, /**< variable to delete */
871 SCIP_Bool* deleted /**< pointer to store whether marking variable to be deleted was successful */
872 );
873
874/** gets variables of the problem along with the numbers of different variable types; data may become invalid after
875 * calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
876 *
877 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
878 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
879 *
880 * @pre This method can be called if @p scip is in one of the following stages:
881 * - \ref SCIP_STAGE_PROBLEM
882 * - \ref SCIP_STAGE_TRANSFORMED
883 * - \ref SCIP_STAGE_INITPRESOLVE
884 * - \ref SCIP_STAGE_PRESOLVING
885 * - \ref SCIP_STAGE_EXITPRESOLVE
886 * - \ref SCIP_STAGE_PRESOLVED
887 * - \ref SCIP_STAGE_INITSOLVE
888 * - \ref SCIP_STAGE_SOLVING
889 * - \ref SCIP_STAGE_SOLVED
890 * - \ref SCIP_STAGE_EXITSOLVE
891 */
892SCIP_EXPORT
893SCIP_RETCODE SCIPgetVarsData(
894 SCIP* scip, /**< SCIP data structure */
895 SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
896 int* nvars, /**< pointer to store number of variables or NULL if not needed */
897 int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
898 int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
899 int* nimplvars, /**< pointer to store number of implied integral vars or NULL if not needed */
900 int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
901 );
902
903/** gets array with active problem variables
904 *
905 * @return array with active problem variables
906 *
907 * @note Variables in the array are grouped in following order:
908 * - binaries
909 * - integers
910 * - implied integral binaries
911 * - implied integral integers
912 * - implied integral continuous
913 * - continuous
914 *
915 * @warning Modifying a variable status (e.g. with SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar())
916 * or a variable type (e.g. with SCIPchgVarType() and SCIPchgVarImplType())
917 * may invalidate or resort the data array.
918 *
919 * @pre This method can be called if @p scip is in one of the following stages:
920 * - \ref SCIP_STAGE_PROBLEM
921 * - \ref SCIP_STAGE_TRANSFORMED
922 * - \ref SCIP_STAGE_INITPRESOLVE
923 * - \ref SCIP_STAGE_PRESOLVING
924 * - \ref SCIP_STAGE_EXITPRESOLVE
925 * - \ref SCIP_STAGE_PRESOLVED
926 * - \ref SCIP_STAGE_INITSOLVE
927 * - \ref SCIP_STAGE_SOLVING
928 * - \ref SCIP_STAGE_SOLVED
929 * - \ref SCIP_STAGE_EXITSOLVE
930 */
931SCIP_EXPORT
932SCIP_VAR** SCIPgetVars(
933 SCIP* scip /**< SCIP data structure */
934 );
935
936/** gets number of active problem variables
937 *
938 * @return the number of active problem variables
939 *
940 * @pre This method can be called if @p scip is in one of the following stages:
941 * - \ref SCIP_STAGE_PROBLEM
942 * - \ref SCIP_STAGE_TRANSFORMED
943 * - \ref SCIP_STAGE_INITPRESOLVE
944 * - \ref SCIP_STAGE_PRESOLVING
945 * - \ref SCIP_STAGE_EXITPRESOLVE
946 * - \ref SCIP_STAGE_PRESOLVED
947 * - \ref SCIP_STAGE_INITSOLVE
948 * - \ref SCIP_STAGE_SOLVING
949 * - \ref SCIP_STAGE_SOLVED
950 * - \ref SCIP_STAGE_EXITSOLVE
951 */
952SCIP_EXPORT
953int SCIPgetNVars(
954 SCIP* scip /**< SCIP data structure */
955 );
956
957/** gets number of binary active problem variables
958 *
959 * @return the number of binary active problem variables
960 *
961 * @note This function does not count binary variables which are implied integral.
962 *
963 * @pre This method can be called if @p scip is in one of the following stages:
964 * - \ref SCIP_STAGE_PROBLEM
965 * - \ref SCIP_STAGE_TRANSFORMED
966 * - \ref SCIP_STAGE_INITPRESOLVE
967 * - \ref SCIP_STAGE_PRESOLVING
968 * - \ref SCIP_STAGE_EXITPRESOLVE
969 * - \ref SCIP_STAGE_PRESOLVED
970 * - \ref SCIP_STAGE_INITSOLVE
971 * - \ref SCIP_STAGE_SOLVING
972 * - \ref SCIP_STAGE_SOLVED
973 * - \ref SCIP_STAGE_EXITSOLVE
974 */
975SCIP_EXPORT
976int SCIPgetNBinVars(
977 SCIP* scip /**< SCIP data structure */
978 );
979
980/** gets number of integer active problem variables
981 *
982 * @return the number of integer active problem variables
983 *
984 * @note This function does not count integer variables which are implied integral.
985 *
986 * @pre This method can be called if @p scip is in one of the following stages:
987 * - \ref SCIP_STAGE_PROBLEM
988 * - \ref SCIP_STAGE_TRANSFORMED
989 * - \ref SCIP_STAGE_INITPRESOLVE
990 * - \ref SCIP_STAGE_PRESOLVING
991 * - \ref SCIP_STAGE_EXITPRESOLVE
992 * - \ref SCIP_STAGE_PRESOLVED
993 * - \ref SCIP_STAGE_INITSOLVE
994 * - \ref SCIP_STAGE_SOLVING
995 * - \ref SCIP_STAGE_SOLVED
996 * - \ref SCIP_STAGE_EXITSOLVE
997 */
998SCIP_EXPORT
999int SCIPgetNIntVars(
1000 SCIP* scip /**< SCIP data structure */
1001 );
1002
1003/** gets number of implied integral active problem variables
1004 *
1005 * @return the number of implied integral active problem variables
1006 *
1007 * @note This function counts binary, integer, and continuous variables which are implied integral.
1008 *
1009 * @pre This method can be called if @p scip is in one of the following stages:
1010 * - \ref SCIP_STAGE_PROBLEM
1011 * - \ref SCIP_STAGE_TRANSFORMED
1012 * - \ref SCIP_STAGE_INITPRESOLVE
1013 * - \ref SCIP_STAGE_PRESOLVING
1014 * - \ref SCIP_STAGE_EXITPRESOLVE
1015 * - \ref SCIP_STAGE_PRESOLVED
1016 * - \ref SCIP_STAGE_INITSOLVE
1017 * - \ref SCIP_STAGE_SOLVING
1018 * - \ref SCIP_STAGE_SOLVED
1019 * - \ref SCIP_STAGE_EXITSOLVE
1020 */
1021SCIP_EXPORT
1022int SCIPgetNImplVars(
1023 SCIP* scip /**< SCIP data structure */
1024 );
1025
1026/** gets number of binary implied integral active problem variables
1027 *
1028 * @return the number of binary implied integral active problem variables
1029 *
1030 * @pre This method can be called if @p scip is in one of the following stages:
1031 * - \ref SCIP_STAGE_PROBLEM
1032 * - \ref SCIP_STAGE_TRANSFORMED
1033 * - \ref SCIP_STAGE_INITPRESOLVE
1034 * - \ref SCIP_STAGE_PRESOLVING
1035 * - \ref SCIP_STAGE_EXITPRESOLVE
1036 * - \ref SCIP_STAGE_PRESOLVED
1037 * - \ref SCIP_STAGE_INITSOLVE
1038 * - \ref SCIP_STAGE_SOLVING
1039 * - \ref SCIP_STAGE_SOLVED
1040 * - \ref SCIP_STAGE_EXITSOLVE
1041 */
1042SCIP_EXPORT
1043int SCIPgetNBinImplVars(
1044 SCIP* scip /**< SCIP data structure */
1045 );
1046
1047/** gets number of integer implied integral active problem variables
1048 *
1049 * @return the number of integer implied integral active problem variables
1050 *
1051 * @pre This method can be called if @p scip is in one of the following stages:
1052 * - \ref SCIP_STAGE_PROBLEM
1053 * - \ref SCIP_STAGE_TRANSFORMED
1054 * - \ref SCIP_STAGE_INITPRESOLVE
1055 * - \ref SCIP_STAGE_PRESOLVING
1056 * - \ref SCIP_STAGE_EXITPRESOLVE
1057 * - \ref SCIP_STAGE_PRESOLVED
1058 * - \ref SCIP_STAGE_INITSOLVE
1059 * - \ref SCIP_STAGE_SOLVING
1060 * - \ref SCIP_STAGE_SOLVED
1061 * - \ref SCIP_STAGE_EXITSOLVE
1062 */
1063SCIP_EXPORT
1064int SCIPgetNIntImplVars(
1065 SCIP* scip /**< SCIP data structure */
1066 );
1067
1068/** gets number of continuous implied integral active problem variables
1069 *
1070 * @return the number of continuous implied integral active problem variables
1071 *
1072 * @pre This method can be called if @p scip is in one of the following stages:
1073 * - \ref SCIP_STAGE_PROBLEM
1074 * - \ref SCIP_STAGE_TRANSFORMED
1075 * - \ref SCIP_STAGE_INITPRESOLVE
1076 * - \ref SCIP_STAGE_PRESOLVING
1077 * - \ref SCIP_STAGE_EXITPRESOLVE
1078 * - \ref SCIP_STAGE_PRESOLVED
1079 * - \ref SCIP_STAGE_INITSOLVE
1080 * - \ref SCIP_STAGE_SOLVING
1081 * - \ref SCIP_STAGE_SOLVED
1082 * - \ref SCIP_STAGE_EXITSOLVE
1083 */
1084SCIP_EXPORT
1085int SCIPgetNContImplVars(
1086 SCIP* scip /**< SCIP data structure */
1087 );
1088
1089/** gets number of continuous active problem variables
1090 *
1091 * @return the number of continuous active problem variables
1092 *
1093 * @note This function does not count continuous variables which are implied integral.
1094 *
1095 * @pre This method can be called if @p scip is in one of the following stages:
1096 * - \ref SCIP_STAGE_PROBLEM
1097 * - \ref SCIP_STAGE_TRANSFORMED
1098 * - \ref SCIP_STAGE_INITPRESOLVE
1099 * - \ref SCIP_STAGE_PRESOLVING
1100 * - \ref SCIP_STAGE_EXITPRESOLVE
1101 * - \ref SCIP_STAGE_PRESOLVED
1102 * - \ref SCIP_STAGE_INITSOLVE
1103 * - \ref SCIP_STAGE_SOLVING
1104 * - \ref SCIP_STAGE_SOLVED
1105 * - \ref SCIP_STAGE_EXITSOLVE
1106 */
1107SCIP_EXPORT
1108int SCIPgetNContVars(
1109 SCIP* scip /**< SCIP data structure */
1110 );
1111
1112/** gets number of active problem variables with a non-zero objective coefficient
1113 *
1114 * @note In case of the original problem the number of variables is counted. In case of the transformed problem the
1115 * number of variables is just returned since it is stored internally
1116 *
1117 * @return the number of active problem variables with a non-zero objective coefficient
1118 *
1119 * @pre This method can be called if @p scip is in one of the following stages:
1120 * - \ref SCIP_STAGE_PROBLEM
1121 * - \ref SCIP_STAGE_TRANSFORMED
1122 * - \ref SCIP_STAGE_INITPRESOLVE
1123 * - \ref SCIP_STAGE_PRESOLVING
1124 * - \ref SCIP_STAGE_EXITPRESOLVE
1125 * - \ref SCIP_STAGE_PRESOLVED
1126 * - \ref SCIP_STAGE_INITSOLVE
1127 * - \ref SCIP_STAGE_SOLVING
1128 * - \ref SCIP_STAGE_SOLVED
1129 */
1130SCIP_EXPORT
1131int SCIPgetNObjVars(
1132 SCIP* scip /**< SCIP data structure */
1133 );
1134
1135/** gets array with fixed and aggregated problem variables; data may become invalid after
1136 * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
1137 *
1138 * @return an array with fixed and aggregated problem variables; data may become invalid after
1139 * calls to SCIPfixVar(), SCIPaggregateVars(), and SCIPmultiaggregateVar()
1140 *
1141 * @pre This method can be called if @p scip is in one of the following stages:
1142 * - \ref SCIP_STAGE_PROBLEM
1143 * - \ref SCIP_STAGE_TRANSFORMED
1144 * - \ref SCIP_STAGE_INITPRESOLVE
1145 * - \ref SCIP_STAGE_PRESOLVING
1146 * - \ref SCIP_STAGE_EXITPRESOLVE
1147 * - \ref SCIP_STAGE_PRESOLVED
1148 * - \ref SCIP_STAGE_INITSOLVE
1149 * - \ref SCIP_STAGE_SOLVING
1150 * - \ref SCIP_STAGE_SOLVED
1151 */
1152SCIP_EXPORT
1153SCIP_VAR** SCIPgetFixedVars(
1154 SCIP* scip /**< SCIP data structure */
1155 );
1156
1157/** gets number of fixed or aggregated problem variables
1158 *
1159 * @return the number of fixed or aggregated problem variables
1160 *
1161 * @pre This method can be called if @p scip is in one of the following stages:
1162 * - \ref SCIP_STAGE_PROBLEM
1163 * - \ref SCIP_STAGE_TRANSFORMED
1164 * - \ref SCIP_STAGE_INITPRESOLVE
1165 * - \ref SCIP_STAGE_PRESOLVING
1166 * - \ref SCIP_STAGE_EXITPRESOLVE
1167 * - \ref SCIP_STAGE_PRESOLVED
1168 * - \ref SCIP_STAGE_INITSOLVE
1169 * - \ref SCIP_STAGE_SOLVING
1170 * - \ref SCIP_STAGE_SOLVED
1171 */
1172SCIP_EXPORT
1173int SCIPgetNFixedVars(
1174 SCIP* scip /**< SCIP data structure */
1175 );
1176
1177/** gets variables of the original problem along with the numbers of different variable types; data may become invalid
1178 * after a call to SCIPchgVarType()
1179 *
1180 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1181 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1182 *
1183 * @pre This method can be called if @p scip is in one of the following stages:
1184 * - \ref SCIP_STAGE_PROBLEM
1185 * - \ref SCIP_STAGE_TRANSFORMING
1186 * - \ref SCIP_STAGE_TRANSFORMED
1187 * - \ref SCIP_STAGE_INITPRESOLVE
1188 * - \ref SCIP_STAGE_PRESOLVING
1189 * - \ref SCIP_STAGE_EXITPRESOLVE
1190 * - \ref SCIP_STAGE_PRESOLVED
1191 * - \ref SCIP_STAGE_INITSOLVE
1192 * - \ref SCIP_STAGE_SOLVING
1193 * - \ref SCIP_STAGE_SOLVED
1194 * - \ref SCIP_STAGE_EXITSOLVE
1195 * - \ref SCIP_STAGE_FREETRANS
1196 */
1197SCIP_EXPORT
1198SCIP_RETCODE SCIPgetOrigVarsData(
1199 SCIP* scip, /**< SCIP data structure */
1200 SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
1201 int* nvars, /**< pointer to store number of variables or NULL if not needed */
1202 int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
1203 int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
1204 int* nimplvars, /**< pointer to store number of implied integral vars or NULL if not needed */
1205 int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
1206 );
1207
1208/** gets array with original problem variables
1209 *
1210 * @return array with original problem variables
1211 *
1212 * @note Variables in the array are grouped in following order:
1213 * - binaries
1214 * - integers
1215 * - implied integral binaries
1216 * - implied integral integers
1217 * - implied integral continuous
1218 * - continuous
1219 *
1220 * @warning Modifying the variable number (e.g. with SCIPaddVar() and SCIPdelVar())
1221 * or a variable type (e.g. with SCIPchgVarType() and SCIPchgVarImplType())
1222 * may invalidate or resort the data array.
1223 *
1224 * @pre This method can be called if @p scip is in one of the following stages:
1225 * - \ref SCIP_STAGE_PROBLEM
1226 * - \ref SCIP_STAGE_TRANSFORMING
1227 * - \ref SCIP_STAGE_TRANSFORMED
1228 * - \ref SCIP_STAGE_INITPRESOLVE
1229 * - \ref SCIP_STAGE_PRESOLVING
1230 * - \ref SCIP_STAGE_EXITPRESOLVE
1231 * - \ref SCIP_STAGE_PRESOLVED
1232 * - \ref SCIP_STAGE_INITSOLVE
1233 * - \ref SCIP_STAGE_SOLVING
1234 * - \ref SCIP_STAGE_SOLVED
1235 * - \ref SCIP_STAGE_EXITSOLVE
1236 * - \ref SCIP_STAGE_FREETRANS
1237 */
1238SCIP_EXPORT
1239SCIP_VAR** SCIPgetOrigVars(
1240 SCIP* scip /**< SCIP data structure */
1241 );
1242
1243/** gets number of original problem variables
1244 *
1245 * @return the number of original problem variables
1246 *
1247 * @pre This method can be called if @p scip is in one of the following stages:
1248 * - \ref SCIP_STAGE_PROBLEM
1249 * - \ref SCIP_STAGE_TRANSFORMING
1250 * - \ref SCIP_STAGE_TRANSFORMED
1251 * - \ref SCIP_STAGE_INITPRESOLVE
1252 * - \ref SCIP_STAGE_PRESOLVING
1253 * - \ref SCIP_STAGE_EXITPRESOLVE
1254 * - \ref SCIP_STAGE_PRESOLVED
1255 * - \ref SCIP_STAGE_INITSOLVE
1256 * - \ref SCIP_STAGE_SOLVING
1257 * - \ref SCIP_STAGE_SOLVED
1258 * - \ref SCIP_STAGE_EXITSOLVE
1259 * - \ref SCIP_STAGE_FREETRANS
1260 */
1261SCIP_EXPORT
1262int SCIPgetNOrigVars(
1263 SCIP* scip /**< SCIP data structure */
1264 );
1265
1266/** gets number of binary variables in the original problem
1267 *
1268 * @return the number of binary variables in the original problem
1269 *
1270 * @note This function does not count binary variables which are implied integral.
1271 *
1272 * @pre This method can be called if @p scip is in one of the following stages:
1273 * - \ref SCIP_STAGE_PROBLEM
1274 * - \ref SCIP_STAGE_TRANSFORMING
1275 * - \ref SCIP_STAGE_TRANSFORMED
1276 * - \ref SCIP_STAGE_INITPRESOLVE
1277 * - \ref SCIP_STAGE_PRESOLVING
1278 * - \ref SCIP_STAGE_EXITPRESOLVE
1279 * - \ref SCIP_STAGE_PRESOLVED
1280 * - \ref SCIP_STAGE_INITSOLVE
1281 * - \ref SCIP_STAGE_SOLVING
1282 * - \ref SCIP_STAGE_SOLVED
1283 * - \ref SCIP_STAGE_EXITSOLVE
1284 * - \ref SCIP_STAGE_FREETRANS
1285 */
1286SCIP_EXPORT
1287int SCIPgetNOrigBinVars(
1288 SCIP* scip /**< SCIP data structure */
1289 );
1290
1291/** gets the number of integer variables in the original problem
1292 *
1293 * @return the number of integer variables in the original problem
1294 *
1295 * @note This function does not count integer variables which are implied integral.
1296 *
1297 * @pre This method can be called if @p scip is in one of the following stages:
1298 * - \ref SCIP_STAGE_PROBLEM
1299 * - \ref SCIP_STAGE_TRANSFORMING
1300 * - \ref SCIP_STAGE_TRANSFORMED
1301 * - \ref SCIP_STAGE_INITPRESOLVE
1302 * - \ref SCIP_STAGE_PRESOLVING
1303 * - \ref SCIP_STAGE_EXITPRESOLVE
1304 * - \ref SCIP_STAGE_PRESOLVED
1305 * - \ref SCIP_STAGE_INITSOLVE
1306 * - \ref SCIP_STAGE_SOLVING
1307 * - \ref SCIP_STAGE_SOLVED
1308 * - \ref SCIP_STAGE_EXITSOLVE
1309 * - \ref SCIP_STAGE_FREETRANS
1310 */
1311SCIP_EXPORT
1312int SCIPgetNOrigIntVars(
1313 SCIP* scip /**< SCIP data structure */
1314 );
1315
1316/** gets number of implied integral variables in the original problem
1317 *
1318 * @return the number of implied integral variables in the original problem
1319 *
1320 * @note This function counts binary, integer, and continuous variables which are implied integral.
1321 *
1322 * @pre This method can be called if @p scip is in one of the following stages:
1323 * - \ref SCIP_STAGE_PROBLEM
1324 * - \ref SCIP_STAGE_TRANSFORMING
1325 * - \ref SCIP_STAGE_TRANSFORMED
1326 * - \ref SCIP_STAGE_INITPRESOLVE
1327 * - \ref SCIP_STAGE_PRESOLVING
1328 * - \ref SCIP_STAGE_EXITPRESOLVE
1329 * - \ref SCIP_STAGE_PRESOLVED
1330 * - \ref SCIP_STAGE_INITSOLVE
1331 * - \ref SCIP_STAGE_SOLVING
1332 * - \ref SCIP_STAGE_SOLVED
1333 * - \ref SCIP_STAGE_EXITSOLVE
1334 * - \ref SCIP_STAGE_FREETRANS
1335 */
1336SCIP_EXPORT
1337int SCIPgetNOrigImplVars(
1338 SCIP* scip /**< SCIP data structure */
1339 );
1340
1341/** gets number of binary implied integral variables in the original problem
1342 *
1343 * @return the number of binary implied integral variables in the original problem
1344 *
1345 * @pre This method can be called if @p scip is in one of the following stages:
1346 * - \ref SCIP_STAGE_PROBLEM
1347 * - \ref SCIP_STAGE_TRANSFORMING
1348 * - \ref SCIP_STAGE_TRANSFORMED
1349 * - \ref SCIP_STAGE_INITPRESOLVE
1350 * - \ref SCIP_STAGE_PRESOLVING
1351 * - \ref SCIP_STAGE_EXITPRESOLVE
1352 * - \ref SCIP_STAGE_PRESOLVED
1353 * - \ref SCIP_STAGE_INITSOLVE
1354 * - \ref SCIP_STAGE_SOLVING
1355 * - \ref SCIP_STAGE_SOLVED
1356 * - \ref SCIP_STAGE_EXITSOLVE
1357 * - \ref SCIP_STAGE_FREETRANS
1358 */
1359SCIP_EXPORT
1360int SCIPgetNOrigBinImplVars(
1361 SCIP* scip /**< SCIP data structure */
1362 );
1363
1364/** gets number of integer implied integral variables in the original problem
1365 *
1366 * @return the number of integer implied integral variables in the original problem
1367 *
1368 * @pre This method can be called if @p scip is in one of the following stages:
1369 * - \ref SCIP_STAGE_PROBLEM
1370 * - \ref SCIP_STAGE_TRANSFORMING
1371 * - \ref SCIP_STAGE_TRANSFORMED
1372 * - \ref SCIP_STAGE_INITPRESOLVE
1373 * - \ref SCIP_STAGE_PRESOLVING
1374 * - \ref SCIP_STAGE_EXITPRESOLVE
1375 * - \ref SCIP_STAGE_PRESOLVED
1376 * - \ref SCIP_STAGE_INITSOLVE
1377 * - \ref SCIP_STAGE_SOLVING
1378 * - \ref SCIP_STAGE_SOLVED
1379 * - \ref SCIP_STAGE_EXITSOLVE
1380 * - \ref SCIP_STAGE_FREETRANS
1381 */
1382SCIP_EXPORT
1383int SCIPgetNOrigIntImplVars(
1384 SCIP* scip /**< SCIP data structure */
1385 );
1386
1387/** gets number of continuous implied integral variables in the original problem
1388 *
1389 * @return the number of continuous implied integral variables in the original problem
1390 *
1391 * @pre This method can be called if @p scip is in one of the following stages:
1392 * - \ref SCIP_STAGE_PROBLEM
1393 * - \ref SCIP_STAGE_TRANSFORMING
1394 * - \ref SCIP_STAGE_TRANSFORMED
1395 * - \ref SCIP_STAGE_INITPRESOLVE
1396 * - \ref SCIP_STAGE_PRESOLVING
1397 * - \ref SCIP_STAGE_EXITPRESOLVE
1398 * - \ref SCIP_STAGE_PRESOLVED
1399 * - \ref SCIP_STAGE_INITSOLVE
1400 * - \ref SCIP_STAGE_SOLVING
1401 * - \ref SCIP_STAGE_SOLVED
1402 * - \ref SCIP_STAGE_EXITSOLVE
1403 * - \ref SCIP_STAGE_FREETRANS
1404 */
1405SCIP_EXPORT
1406int SCIPgetNOrigContImplVars(
1407 SCIP* scip /**< SCIP data structure */
1408 );
1409
1410/** gets number of continuous variables in the original problem
1411 *
1412 * @return the number of continuous variables in the original problem
1413 *
1414 * @note This function does not count continuous variables which are implied integral.
1415 *
1416 * @pre This method can be called if @p scip is in one of the following stages:
1417 * - \ref SCIP_STAGE_PROBLEM
1418 * - \ref SCIP_STAGE_TRANSFORMING
1419 * - \ref SCIP_STAGE_TRANSFORMED
1420 * - \ref SCIP_STAGE_INITPRESOLVE
1421 * - \ref SCIP_STAGE_PRESOLVING
1422 * - \ref SCIP_STAGE_EXITPRESOLVE
1423 * - \ref SCIP_STAGE_PRESOLVED
1424 * - \ref SCIP_STAGE_INITSOLVE
1425 * - \ref SCIP_STAGE_SOLVING
1426 * - \ref SCIP_STAGE_SOLVED
1427 * - \ref SCIP_STAGE_EXITSOLVE
1428 * - \ref SCIP_STAGE_FREETRANS
1429 */
1430SCIP_EXPORT
1431int SCIPgetNOrigContVars(
1432 SCIP* scip /**< SCIP data structure */
1433 );
1434
1435/** gets number of all problem variables created during creation and solving of problem;
1436 * this includes also variables that were deleted in the meantime
1437 *
1438 * @return the number of all problem variables created during creation and solving of problem;
1439 * this includes also variables that were deleted in the meantime
1440 *
1441 * @pre This method can be called if @p scip is in one of the following stages:
1442 * - \ref SCIP_STAGE_PROBLEM
1443 * - \ref SCIP_STAGE_TRANSFORMING
1444 * - \ref SCIP_STAGE_TRANSFORMED
1445 * - \ref SCIP_STAGE_INITPRESOLVE
1446 * - \ref SCIP_STAGE_PRESOLVING
1447 * - \ref SCIP_STAGE_EXITPRESOLVE
1448 * - \ref SCIP_STAGE_PRESOLVED
1449 * - \ref SCIP_STAGE_INITSOLVE
1450 * - \ref SCIP_STAGE_SOLVING
1451 * - \ref SCIP_STAGE_SOLVED
1452 * - \ref SCIP_STAGE_EXITSOLVE
1453 * - \ref SCIP_STAGE_FREETRANS
1454 */
1455SCIP_EXPORT
1456int SCIPgetNTotalVars(
1457 SCIP* scip /**< SCIP data structure */
1458 );
1459
1460/** gets variables of the original or transformed problem along with the numbers of different variable types;
1461 * the returned problem space (original or transformed) corresponds to the given solution;
1462 * data may become invalid after calls to SCIPchgVarType(), SCIPfixVar(), SCIPaggregateVars(), and
1463 * SCIPmultiaggregateVar()
1464 *
1465 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1466 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1467 *
1468 * @pre This method can be called if @p scip is in one of the following stages:
1469 * - \ref SCIP_STAGE_PROBLEM
1470 * - \ref SCIP_STAGE_TRANSFORMED
1471 * - \ref SCIP_STAGE_INITPRESOLVE
1472 * - \ref SCIP_STAGE_PRESOLVING
1473 * - \ref SCIP_STAGE_EXITPRESOLVE
1474 * - \ref SCIP_STAGE_PRESOLVED
1475 * - \ref SCIP_STAGE_INITSOLVE
1476 * - \ref SCIP_STAGE_SOLVING
1477 * - \ref SCIP_STAGE_SOLVED
1478 */
1479SCIP_EXPORT
1480SCIP_RETCODE SCIPgetSolVarsData(
1481 SCIP* scip, /**< SCIP data structure */
1482 SCIP_SOL* sol, /**< primal solution that selects the problem space, NULL for current solution */
1483 SCIP_VAR*** vars, /**< pointer to store variables array or NULL if not needed */
1484 int* nvars, /**< pointer to store number of variables or NULL if not needed */
1485 int* nbinvars, /**< pointer to store number of binary variables or NULL if not needed */
1486 int* nintvars, /**< pointer to store number of integer variables or NULL if not needed */
1487 int* nbinimplvars, /**< pointer to store number of binary implied integral vars or NULL if not needed */
1488 int* nintimplvars, /**< pointer to store number of integer implied integral vars or NULL if not needed */
1489 int* ncontimplvars, /**< pointer to store number of continuous implied integral vars or NULL if not needed */
1490 int* ncontvars /**< pointer to store number of continuous variables or NULL if not needed */
1491 );
1492
1493/** returns variable of given name in the problem, or NULL if not existing
1494 *
1495 * @return variable of given name in the problem, or NULL if not existing
1496 *
1497 * @pre This method can be called if @p scip is in one of the following stages:
1498 * - \ref SCIP_STAGE_PROBLEM
1499 * - \ref SCIP_STAGE_TRANSFORMING
1500 * - \ref SCIP_STAGE_TRANSFORMED
1501 * - \ref SCIP_STAGE_INITPRESOLVE
1502 * - \ref SCIP_STAGE_PRESOLVING
1503 * - \ref SCIP_STAGE_EXITPRESOLVE
1504 * - \ref SCIP_STAGE_PRESOLVED
1505 * - \ref SCIP_STAGE_INITSOLVE
1506 * - \ref SCIP_STAGE_SOLVING
1507 * - \ref SCIP_STAGE_SOLVED
1508 * - \ref SCIP_STAGE_EXITSOLVE
1509 * - \ref SCIP_STAGE_FREETRANS
1510 */
1511SCIP_EXPORT
1512SCIP_VAR* SCIPfindVar(
1513 SCIP* scip, /**< SCIP data structure */
1514 const char* name /**< name of variable to find */
1515 );
1516
1517/** returns TRUE iff all potential variables exist in the problem, and FALSE, if there may be additional variables,
1518 * that will be added in pricing and improve the objective value
1519 *
1520 * @return TRUE, if all potential variables exist in the problem; FALSE, otherwise
1521 *
1522 * @pre This method can be called if @p scip is in one of the following stages:
1523 * - \ref SCIP_STAGE_TRANSFORMING
1524 * - \ref SCIP_STAGE_TRANSFORMED
1525 * - \ref SCIP_STAGE_INITPRESOLVE
1526 * - \ref SCIP_STAGE_PRESOLVING
1527 * - \ref SCIP_STAGE_EXITPRESOLVE
1528 * - \ref SCIP_STAGE_PRESOLVED
1529 * - \ref SCIP_STAGE_INITSOLVE
1530 * - \ref SCIP_STAGE_SOLVING
1531 * - \ref SCIP_STAGE_SOLVED
1532 * - \ref SCIP_STAGE_EXITSOLVE
1533 * - \ref SCIP_STAGE_FREETRANS
1534 */
1535SCIP_EXPORT
1536SCIP_Bool SCIPallVarsInProb(
1537 SCIP* scip /**< SCIP data structure */
1538 );
1539
1540/** adds constraint to the problem; if constraint is only valid locally, it is added to the local subproblem of the
1541 * current node (and all of its subnodes); otherwise it is added to the global problem;
1542 * if a local constraint is added at the root node, it is automatically upgraded into a global constraint
1543 *
1544 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1545 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1546 *
1547 * @pre This method can be called if @p scip is in one of the following stages:
1548 * - \ref SCIP_STAGE_PROBLEM
1549 * - \ref SCIP_STAGE_TRANSFORMED
1550 * - \ref SCIP_STAGE_INITPRESOLVE
1551 * - \ref SCIP_STAGE_PRESOLVING
1552 * - \ref SCIP_STAGE_EXITPRESOLVE
1553 * - \ref SCIP_STAGE_PRESOLVED
1554 * - \ref SCIP_STAGE_INITSOLVE
1555 * - \ref SCIP_STAGE_SOLVING
1556 * - \ref SCIP_STAGE_EXITSOLVE
1557 */
1558SCIP_EXPORT
1559SCIP_RETCODE SCIPaddCons(
1560 SCIP* scip, /**< SCIP data structure */
1561 SCIP_CONS* cons /**< constraint to add */
1562 );
1563
1564/** adds constraint to the problem and upgrades conflict in the conflict store; if oldcons is valid globally, newcons
1565 * is added to the global problem; otherwise it is added to the local subproblem of the current node
1566 *
1567 * @note must only be called once for both constraints
1568 *
1569 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1570 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1571 *
1572 * @pre this method can be called if @p scip is in one of the following stages:
1573 * - \ref SCIP_STAGE_PROBLEM
1574 * - \ref SCIP_STAGE_TRANSFORMED
1575 * - \ref SCIP_STAGE_INITPRESOLVE
1576 * - \ref SCIP_STAGE_PRESOLVING
1577 * - \ref SCIP_STAGE_EXITPRESOLVE
1578 * - \ref SCIP_STAGE_PRESOLVED
1579 * - \ref SCIP_STAGE_INITSOLVE
1580 * - \ref SCIP_STAGE_SOLVING
1581 * - \ref SCIP_STAGE_EXITSOLVE
1582 *
1583 * @note this method will release the upgraded constraint
1584 */
1585SCIP_EXPORT
1586SCIP_RETCODE SCIPaddConsUpgrade(
1587 SCIP* scip, /**< SCIP data structure */
1588 SCIP_CONS* oldcons, /**< underlying constraint to upgrade */
1589 SCIP_CONS** newcons /**< upgraded constraint to add */
1590 );
1591
1592/** globally removes constraint from all subproblems; removes constraint from the constraint set change data of the
1593 * node, where it was added, or from the problem, if it was a problem constraint
1594 *
1595 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1596 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1597 *
1598 * @pre This method can be called if @p scip is in one of the following stages:
1599 * - \ref SCIP_STAGE_PROBLEM
1600 * - \ref SCIP_STAGE_INITPRESOLVE
1601 * - \ref SCIP_STAGE_PRESOLVING
1602 * - \ref SCIP_STAGE_EXITPRESOLVE
1603 * - \ref SCIP_STAGE_INITSOLVE
1604 * - \ref SCIP_STAGE_SOLVING
1605 * - \ref SCIP_STAGE_EXITSOLVE
1606 */
1607SCIP_EXPORT
1608SCIP_RETCODE SCIPdelCons(
1609 SCIP* scip, /**< SCIP data structure */
1610 SCIP_CONS* cons /**< constraint to delete */
1611 );
1612
1613/** returns original constraint of given name in the problem, or NULL if not existing
1614 *
1615 * @return original constraint of given name in the problem, or NULL if not existing
1616 *
1617 * @pre This method can be called if @p scip is in one of the following stages:
1618 * - \ref SCIP_STAGE_PROBLEM
1619 * - \ref SCIP_STAGE_TRANSFORMING
1620 * - \ref SCIP_STAGE_TRANSFORMED
1621 * - \ref SCIP_STAGE_INITPRESOLVE
1622 * - \ref SCIP_STAGE_PRESOLVING
1623 * - \ref SCIP_STAGE_EXITPRESOLVE
1624 * - \ref SCIP_STAGE_PRESOLVED
1625 * - \ref SCIP_STAGE_INITSOLVE
1626 * - \ref SCIP_STAGE_SOLVING
1627 * - \ref SCIP_STAGE_SOLVED
1628 * - \ref SCIP_STAGE_EXITSOLVE
1629 * - \ref SCIP_STAGE_FREETRANS
1630 */
1631SCIP_EXPORT
1632SCIP_CONS* SCIPfindOrigCons(
1633 SCIP* scip, /**< SCIP data structure */
1634 const char* name /**< name of constraint to find */
1635 );
1636
1637/** returns constraint of given name in the problem, or NULL if not existing
1638 *
1639 * @return constraint of given name in the problem, or NULL if not existing
1640 *
1641 * @pre This method can be called if @p scip is in one of the following stages:
1642 * - \ref SCIP_STAGE_PROBLEM
1643 * - \ref SCIP_STAGE_TRANSFORMING
1644 * - \ref SCIP_STAGE_TRANSFORMED
1645 * - \ref SCIP_STAGE_INITPRESOLVE
1646 * - \ref SCIP_STAGE_PRESOLVING
1647 * - \ref SCIP_STAGE_EXITPRESOLVE
1648 * - \ref SCIP_STAGE_PRESOLVED
1649 * - \ref SCIP_STAGE_INITSOLVE
1650 * - \ref SCIP_STAGE_SOLVING
1651 * - \ref SCIP_STAGE_SOLVED
1652 * - \ref SCIP_STAGE_EXITSOLVE
1653 * - \ref SCIP_STAGE_FREETRANS
1654 */
1655SCIP_EXPORT
1656SCIP_CONS* SCIPfindCons(
1657 SCIP* scip, /**< SCIP data structure */
1658 const char* name /**< name of constraint to find */
1659 );
1660
1661/** gets number of upgraded constraints
1662 *
1663 * @return number of upgraded constraints
1664 *
1665 * @pre This method can be called if @p scip is in one of the following stages:
1666 * - \ref SCIP_STAGE_PROBLEM
1667 * - \ref SCIP_STAGE_TRANSFORMED
1668 * - \ref SCIP_STAGE_INITPRESOLVE
1669 * - \ref SCIP_STAGE_PRESOLVING
1670 * - \ref SCIP_STAGE_PRESOLVED
1671 * - \ref SCIP_STAGE_EXITPRESOLVE
1672 * - \ref SCIP_STAGE_SOLVING
1673 * - \ref SCIP_STAGE_SOLVED
1674 */
1675SCIP_EXPORT
1676int SCIPgetNUpgrConss(
1677 SCIP* scip /**< SCIP data structure */
1678 );
1679
1680/** gets total number of globally valid constraints currently in the problem
1681 *
1682 * @return total number of globally valid constraints currently in the problem
1683 *
1684 * @pre This method can be called if @p scip is in one of the following stages:
1685 * - \ref SCIP_STAGE_PROBLEM
1686 * - \ref SCIP_STAGE_TRANSFORMED
1687 * - \ref SCIP_STAGE_INITPRESOLVE
1688 * - \ref SCIP_STAGE_PRESOLVING
1689 * - \ref SCIP_STAGE_EXITPRESOLVE
1690 * - \ref SCIP_STAGE_PRESOLVED
1691 * - \ref SCIP_STAGE_INITSOLVE
1692 * - \ref SCIP_STAGE_SOLVING
1693 * - \ref SCIP_STAGE_SOLVED
1694 */
1695SCIP_EXPORT
1696int SCIPgetNConss(
1697 SCIP* scip /**< SCIP data structure */
1698 );
1699
1700/** gets array of globally valid constraints currently in the problem
1701 *
1702 * @return array of globally valid constraints currently in the problem
1703 *
1704 * @pre This method can be called if @p scip is in one of the following stages:
1705 * - \ref SCIP_STAGE_PROBLEM
1706 * - \ref SCIP_STAGE_TRANSFORMED
1707 * - \ref SCIP_STAGE_INITPRESOLVE
1708 * - \ref SCIP_STAGE_PRESOLVING
1709 * - \ref SCIP_STAGE_EXITPRESOLVE
1710 * - \ref SCIP_STAGE_PRESOLVED
1711 * - \ref SCIP_STAGE_INITSOLVE
1712 * - \ref SCIP_STAGE_SOLVING
1713 * - \ref SCIP_STAGE_SOLVED
1714 *
1715 * @warning If your are using the method SCIPaddCons(), it can happen that the internal constraint array (which is
1716 * accessed via this method) gets resized. This can invalid the pointer which is returned by this method.
1717 */
1718SCIP_EXPORT
1719SCIP_CONS** SCIPgetConss(
1720 SCIP* scip /**< SCIP data structure */
1721 );
1722
1723/** gets total number of constraints in the original problem
1724 *
1725 * @return total number of constraints in the original problem
1726 *
1727 * @pre This method can be called if @p scip is in one of the following stages:
1728 * - \ref SCIP_STAGE_PROBLEM
1729 * - \ref SCIP_STAGE_TRANSFORMING
1730 * - \ref SCIP_STAGE_TRANSFORMED
1731 * - \ref SCIP_STAGE_INITPRESOLVE
1732 * - \ref SCIP_STAGE_PRESOLVING
1733 * - \ref SCIP_STAGE_EXITPRESOLVE
1734 * - \ref SCIP_STAGE_PRESOLVED
1735 * - \ref SCIP_STAGE_INITSOLVE
1736 * - \ref SCIP_STAGE_SOLVING
1737 * - \ref SCIP_STAGE_SOLVED
1738 * - \ref SCIP_STAGE_EXITSOLVE
1739 * - \ref SCIP_STAGE_FREETRANS
1740 */
1741SCIP_EXPORT
1742int SCIPgetNOrigConss(
1743 SCIP* scip /**< SCIP data structure */
1744 );
1745
1746/** gets array of constraints in the original problem
1747 *
1748 * @return array of constraints in the original problem
1749 *
1750 * @pre This method can be called if @p scip is in one of the following stages:
1751 * - \ref SCIP_STAGE_PROBLEM
1752 * - \ref SCIP_STAGE_TRANSFORMING
1753 * - \ref SCIP_STAGE_TRANSFORMED
1754 * - \ref SCIP_STAGE_INITPRESOLVE
1755 * - \ref SCIP_STAGE_PRESOLVING
1756 * - \ref SCIP_STAGE_EXITPRESOLVE
1757 * - \ref SCIP_STAGE_PRESOLVED
1758 * - \ref SCIP_STAGE_INITSOLVE
1759 * - \ref SCIP_STAGE_SOLVING
1760 * - \ref SCIP_STAGE_SOLVED
1761 * - \ref SCIP_STAGE_EXITSOLVE
1762 * - \ref SCIP_STAGE_FREETRANS
1763 */
1764SCIP_EXPORT
1765SCIP_CONS** SCIPgetOrigConss(
1766 SCIP* scip /**< SCIP data structure */
1767 );
1768
1769/** computes the number of check constraint in the current node (loop over all constraint handler and cumulates the
1770 * number of check constraints)
1771 *
1772 * @return returns the number of check constraints
1773 *
1774 * @pre This method can be called if @p scip is in one of the following stages:
1775 * - \ref SCIP_STAGE_TRANSFORMED
1776 * - \ref SCIP_STAGE_INITPRESOLVE
1777 * - \ref SCIP_STAGE_PRESOLVING
1778 * - \ref SCIP_STAGE_EXITPRESOLVE
1779 * - \ref SCIP_STAGE_PRESOLVED
1780 * - \ref SCIP_STAGE_INITSOLVE
1781 * - \ref SCIP_STAGE_SOLVING
1782 */
1783SCIP_EXPORT
1784int SCIPgetNCheckConss(
1785 SCIP* scip /**< SCIP data structure */
1786 );
1787
1788/**@} */
1789
1790/**@addtogroup LocalSubproblemMethods
1791 *
1792 * @{
1793 */
1794
1795/** adds a conflict to a given node or globally to the problem if @p node == NULL.
1796 *
1797 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1798 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1799 *
1800 * @pre this method can be called in one of the following stages of the SCIP solving process:
1801 * - \ref SCIP_STAGE_INITPRESOLVE
1802 * - \ref SCIP_STAGE_PRESOLVING
1803 * - \ref SCIP_STAGE_EXITPRESOLVE
1804 * - \ref SCIP_STAGE_SOLVING
1805 *
1806 * @note this method will release the constraint
1807 */
1808SCIP_EXPORT
1809SCIP_RETCODE SCIPaddConflict(
1810 SCIP* scip, /**< SCIP data structure */
1811 SCIP_NODE* node, /**< node to add conflict (or NULL if global) */
1812 SCIP_CONS** cons, /**< constraint representing the conflict */
1813 SCIP_NODE* validnode, /**< node at which the constraint is valid (or NULL) */
1814 SCIP_CONFTYPE conftype, /**< type of the conflict */
1815 SCIP_Bool iscutoffinvolved /**< is a cutoff bound involved in this conflict */
1816 );
1817
1818/** tries to remove conflicts depending on an old cutoff bound if the improvement of the new incumbent is good enough
1819 *
1820 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1821 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1822 *
1823 * @pre this method can be called in one of the following stages of the SCIP solving process:
1824 * - \ref SCIP_STAGE_PRESOLVING
1825 * - \ref SCIP_STAGE_SOLVING
1826 */
1827SCIP_EXPORT
1828SCIP_RETCODE SCIPclearConflictStore(
1829 SCIP* scip, /**< SCIP data structure */
1830 SCIP_EVENT* event /**< event data */
1831 );
1832
1833/** adds constraint to the given node (and all of its subnodes), even if it is a global constraint;
1834 * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
1835 * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
1836 * only active in a small part of the tree although it is valid in a larger part.
1837 * In this case, one should pass the more global node where the constraint is valid as "validnode".
1838 * Note that the same constraint cannot be added twice to the branching tree with different "validnode" parameters.
1839 * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
1840 * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
1841 * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
1842 *
1843 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1844 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1845 *
1846 * @pre this method can be called in one of the following stages of the SCIP solving process:
1847 * - \ref SCIP_STAGE_INITPRESOLVE
1848 * - \ref SCIP_STAGE_PRESOLVING
1849 * - \ref SCIP_STAGE_EXITPRESOLVE
1850 * - \ref SCIP_STAGE_SOLVING
1851 */
1852SCIP_EXPORT
1853SCIP_RETCODE SCIPaddConsNode(
1854 SCIP* scip, /**< SCIP data structure */
1855 SCIP_NODE* node, /**< node to add constraint to */
1856 SCIP_CONS* cons, /**< constraint to add */
1857 SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
1858 );
1859
1860/** adds constraint locally to the current node (and all of its subnodes), even if it is a global constraint;
1861 * It is sometimes desirable to add the constraint to a more local node (i.e., a node of larger depth) even if
1862 * the constraint is also valid higher in the tree, for example, if one wants to produce a constraint which is
1863 * only active in a small part of the tree although it is valid in a larger part.
1864 *
1865 * If the constraint is valid at the same node as it is inserted (the usual case), one should pass NULL as "validnode".
1866 * If the "validnode" is the root node, it is automatically upgraded into a global constraint, but still only added to
1867 * the given node. If a local constraint is added to the root node, it is added to the global problem instead.
1868 *
1869 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1870 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1871 *
1872 * @pre this method can be called in one of the following stages of the SCIP solving process:
1873 * - \ref SCIP_STAGE_INITPRESOLVE
1874 * - \ref SCIP_STAGE_PRESOLVING
1875 * - \ref SCIP_STAGE_EXITPRESOLVE
1876 * - \ref SCIP_STAGE_SOLVING
1877 *
1878 * @note The same constraint cannot be added twice to the branching tree with different "validnode" parameters. This is
1879 * the case due to internal data structures and performance issues. In such a case you should try to realize your
1880 * issue using the method SCIPdisableCons() and SCIPenableCons() and control these via the event system of SCIP.
1881 */
1882SCIP_EXPORT
1883SCIP_RETCODE SCIPaddConsLocal(
1884 SCIP* scip, /**< SCIP data structure */
1885 SCIP_CONS* cons, /**< constraint to add */
1886 SCIP_NODE* validnode /**< node at which the constraint is valid, or NULL */
1887 );
1888
1889/** disables constraint's separation, enforcing, and propagation capabilities at the given node (and all subnodes);
1890 * if the method is called at the root node, the constraint is globally deleted from the problem;
1891 * the constraint deletion is being remembered at the given node, s.t. after leaving the node's subtree, the constraint
1892 * is automatically enabled again, and after entering the node's subtree, it is automatically disabled;
1893 * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
1894 * alternatively, use SCIPdisableCons()
1895 *
1896 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1897 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1898 *
1899 * @pre this method can be called in one of the following stages of the SCIP solving process:
1900 * - \ref SCIP_STAGE_INITPRESOLVE
1901 * - \ref SCIP_STAGE_PRESOLVING
1902 * - \ref SCIP_STAGE_EXITPRESOLVE
1903 * - \ref SCIP_STAGE_SOLVING
1904 */
1905SCIP_EXPORT
1906SCIP_RETCODE SCIPdelConsNode(
1907 SCIP* scip, /**< SCIP data structure */
1908 SCIP_NODE* node, /**< node to disable constraint in */
1909 SCIP_CONS* cons /**< constraint to locally delete */
1910 );
1911
1912/** disables constraint's separation, enforcing, and propagation capabilities at the current node (and all subnodes);
1913 * if the method is called during problem modification or at the root node, the constraint is globally deleted from
1914 * the problem;
1915 * the constraint deletion is being remembered at the current node, s.t. after leaving the current subtree, the
1916 * constraint is automatically enabled again, and after reentering the current node's subtree, it is automatically
1917 * disabled again;
1918 * this may improve performance because redundant checks on this constraint are avoided, but it consumes memory;
1919 * alternatively, use SCIPdisableCons()
1920 *
1921 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
1922 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
1923 *
1924 * @pre this method can be called in one of the following stages of the SCIP solving process:
1925 * - \ref SCIP_STAGE_PROBLEM
1926 * - \ref SCIP_STAGE_INITPRESOLVE
1927 * - \ref SCIP_STAGE_PRESOLVING
1928 * - \ref SCIP_STAGE_EXITPRESOLVE
1929 * - \ref SCIP_STAGE_SOLVING
1930 *
1931 * @note SCIP stage does not get changed
1932 *
1933 */
1934SCIP_EXPORT
1935SCIP_RETCODE SCIPdelConsLocal(
1936 SCIP* scip, /**< SCIP data structure */
1937 SCIP_CONS* cons /**< constraint to locally delete */
1938 );
1939
1940/** gets estimate of best primal solution w.r.t. original problem contained in current subtree
1941 *
1942 * @return estimate of best primal solution w.r.t. original problem contained in current subtree
1943 *
1944 * @pre this method can be called in one of the following stages of the SCIP solving process:
1945 * - \ref SCIP_STAGE_SOLVING
1946 */
1947SCIP_EXPORT
1948SCIP_Real SCIPgetLocalOrigEstimate(
1949 SCIP* scip /**< SCIP data structure */
1950 );
1951
1952/** gets estimate of best primal solution w.r.t. transformed problem contained in current subtree
1953 *
1954 * @return estimate of best primal solution w.r.t. transformed problem contained in current subtree
1955 *
1956 * @pre this method can be called in one of the following stages of the SCIP solving process:
1957 * - \ref SCIP_STAGE_SOLVING
1958 */
1959SCIP_EXPORT
1960SCIP_Real SCIPgetLocalTransEstimate(
1961 SCIP* scip /**< SCIP data structure */
1962 );
1963
1964/** gets dual bound of current node
1965 *
1966 * @return dual bound of current node
1967 *
1968 * @pre this method can be called in one of the following stages of the SCIP solving process:
1969 * - \ref SCIP_STAGE_SOLVING
1970 */
1971SCIP_EXPORT
1972SCIP_Real SCIPgetLocalDualbound(
1973 SCIP* scip /**< SCIP data structure */
1974 );
1975
1976/** gets lower bound of current node in transformed problem
1977 *
1978 * @return lower bound of current node in transformed problem
1979 *
1980 * @pre this method can be called in one of the following stages of the SCIP solving process:
1981 * - \ref SCIP_STAGE_SOLVING
1982 */
1983SCIP_EXPORT
1984SCIP_Real SCIPgetLocalLowerbound(
1985 SCIP* scip /**< SCIP data structure */
1986 );
1987
1988/** gets dual bound of given node
1989 *
1990 * @return dual bound of a given node
1991 *
1992 * @pre this method can be called in one of the following stages of the SCIP solving process:
1993 * - \ref SCIP_STAGE_SOLVING
1994 */
1995SCIP_EXPORT
1996SCIP_Real SCIPgetNodeDualbound(
1997 SCIP* scip, /**< SCIP data structure */
1998 SCIP_NODE* node /**< node to get dual bound for */
1999 );
2000
2001/** gets lower bound of given node in transformed problem
2002 *
2003 * @return lower bound of given node in transformed problem
2004 *
2005 * @pre this method can be called in one of the following stages of the SCIP solving process:
2006 * - \ref SCIP_STAGE_SOLVING
2007 */
2008SCIP_EXPORT
2009SCIP_Real SCIPgetNodeLowerbound(
2010 SCIP* scip, /**< SCIP data structure */
2011 SCIP_NODE* node /**< node to get dual bound for */
2012 );
2013
2014/** if given value is tighter (larger for minimization, smaller for maximization) than the current node's dual bound (in
2015 * original problem space), sets the current node's dual bound to the new value
2016 *
2017 * @note the given new bound has to be a dual bound, i.e., it has to be valid for the original problem.
2018 *
2019 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2020 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2021 *
2022 * @pre this method can be called in one of the following stages of the SCIP solving process:
2023 * - \ref SCIP_STAGE_PROBLEM
2024 * - \ref SCIP_STAGE_PRESOLVING
2025 * - \ref SCIP_STAGE_PRESOLVED
2026 * - \ref SCIP_STAGE_SOLVING
2027 */
2028SCIP_EXPORT
2029SCIP_RETCODE SCIPupdateLocalDualbound(
2030 SCIP* scip, /**< SCIP data structure */
2031 SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
2032 );
2033
2034/** if given value is larger than the current node's lower bound (in transformed problem), sets the current node's
2035 * lower bound to the new value
2036 *
2037 * @note the given new bound has to be a lower bound, i.e., it has to be valid for the transformed problem.
2038 *
2039 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2040 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2041 *
2042 * @pre this method can be called in one of the following stages of the SCIP solving process:
2043 * - \ref SCIP_STAGE_PRESOLVING
2044 * - \ref SCIP_STAGE_PRESOLVED
2045 * - \ref SCIP_STAGE_SOLVING
2046 */
2047SCIP_EXPORT
2048SCIP_RETCODE SCIPupdateLocalLowerbound(
2049 SCIP* scip, /**< SCIP data structure */
2050 SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
2051 );
2052
2053/** if given value is tighter (higher for minimization, lower for maximization) than the node's dual bound, sets the
2054 * node's dual bound to the new value.
2055 *
2056 * @note must not be used on a leaf because the node priority queue remains untouched
2057 *
2058 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2059 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2060 *
2061 * @pre this method can be called in one of the following stages of the SCIP solving process:
2062 * - \ref SCIP_STAGE_SOLVING
2063 */
2064SCIP_EXPORT
2065SCIP_RETCODE SCIPupdateNodeDualbound(
2066 SCIP* scip, /**< SCIP data structure */
2067 SCIP_NODE* node, /**< node to update dual bound for */
2068 SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
2069 );
2070
2071/** if given value is higher than the node's lower bound (in transformed problem), sets the node's lower bound to the
2072 * new value.
2073 *
2074 * @note must not be used on a leaf because the node priority queue remains untouched
2075 *
2076 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2077 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2078 *
2079 * @pre this method can be called in one of the following stages of the SCIP solving process:
2080 * - \ref SCIP_STAGE_SOLVING
2081 */
2082SCIP_EXPORT
2083SCIP_RETCODE SCIPupdateNodeLowerbound(
2084 SCIP* scip, /**< SCIP data structure */
2085 SCIP_NODE* node, /**< node to update lower bound for */
2086 SCIP_Real newbound /**< new lower bound for the node (if it's larger than the old one) */
2087 );
2088
2089/** change the node selection priority of the given child
2090 *
2091 * @return \ref SCIP_OKAY is returned if everything worked. Otherwise a suitable error code is passed. See \ref
2092 * SCIP_Retcode "SCIP_RETCODE" for a complete list of error codes.
2093 *
2094 * @pre this method can be called in one of the following stages of the SCIP solving process:
2095 * - \ref SCIP_STAGE_SOLVING
2096 */
2097SCIP_EXPORT
2098SCIP_RETCODE SCIPchgChildPrio(
2099 SCIP* scip, /**< SCIP data structure */
2100 SCIP_NODE* child, /**< child to update the node selection priority */
2101 SCIP_Real priority /**< node selection priority value */
2102 );
2103
2104/**@} */
2105
2106#ifdef __cplusplus
2107}
2108#endif
2109
2110#endif
def.h
common defines and data types used in all packages of SCIP
SCIP_Bool
#define SCIP_Bool
Definition: def.h:91
SCIP_Real
#define SCIP_Real
Definition: def.h:156
SCIPgetNObjVars
int SCIPgetNObjVars(SCIP *scip)
Definition: scip_prob.c:2616
SCIPaddVar
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_prob.c:1907
SCIPgetNIntVars
int SCIPgetNIntVars(SCIP *scip)
Definition: scip_prob.c:2340
SCIPpermuteProb
SCIP_RETCODE SCIPpermuteProb(SCIP *scip, unsigned int randseed, SCIP_Bool permuteconss, SCIP_Bool permutebinvars, SCIP_Bool permuteintvars, SCIP_Bool permutebinimplvars, SCIP_Bool permuteintimplvars, SCIP_Bool permutecontimplvars, SCIP_Bool permutecontvars)
Definition: scip_prob.c:922
SCIPaddConsUpgrade
SCIP_RETCODE SCIPaddConsUpgrade(SCIP *scip, SCIP_CONS *oldcons, SCIP_CONS **newcons)
Definition: scip_prob.c:3368
SCIPsetObjIntegral
SCIP_RETCODE SCIPsetObjIntegral(SCIP *scip)
Definition: scip_prob.c:1758
SCIPgetOrigVarsData
SCIP_RETCODE SCIPgetOrigVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip_prob.c:2753
SCIPgetNImplVars
int SCIPgetNImplVars(SCIP *scip)
Definition: scip_prob.c:2387
SCIPgetProbName
const char * SCIPgetProbName(SCIP *scip)
Definition: scip_prob.c:1242
SCIPgetNContVars
int SCIPgetNContVars(SCIP *scip)
Definition: scip_prob.c:2569
SCIPgetNCheckConss
int SCIPgetNCheckConss(SCIP *scip)
Definition: scip_prob.c:3762
SCIPaddPricedVar
SCIP_RETCODE SCIPaddPricedVar(SCIP *scip, SCIP_VAR *var, SCIP_Real score)
Definition: scip_prob.c:1984
SCIPgetOrigObjscale
SCIP_Real SCIPgetOrigObjscale(SCIP *scip)
Definition: scip_prob.c:1583
SCIPgetSolVarsData
SCIP_RETCODE SCIPgetSolVarsData(SCIP *scip, SCIP_SOL *sol, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nbinimplvars, int *nintimplvars, int *ncontimplvars, int *ncontvars)
Definition: scip_prob.c:3114
SCIPwriteOrigProblem
SCIP_RETCODE SCIPwriteOrigProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip_prob.c:742
SCIPsetProbName
SCIP_RETCODE SCIPsetProbName(SCIP *scip, const char *name)
Definition: scip_prob.c:1270
SCIPsetObjlimit
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
Definition: scip_prob.c:1661
SCIPsetProbDeltrans
SCIP_RETCODE SCIPsetProbDeltrans(SCIP *scip, SCIP_DECL_PROBDELTRANS((*probdeltrans)))
Definition: scip_prob.c:244
SCIPgetTransObjoffset
SCIP_Real SCIPgetTransObjoffset(SCIP *scip)
Definition: scip_prob.c:1606
SCIPgetNBinImplVars
int SCIPgetNBinImplVars(SCIP *scip)
Definition: scip_prob.c:2432
SCIPgetNOrigBinVars
int SCIPgetNOrigBinVars(SCIP *scip)
Definition: scip_prob.c:2867
SCIPgetVarsData
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip_prob.c:2115
SCIPgetNOrigConss
int SCIPgetNOrigConss(SCIP *scip)
Definition: scip_prob.c:3712
SCIPgetOrigObjoffset
SCIP_Real SCIPgetOrigObjoffset(SCIP *scip)
Definition: scip_prob.c:1529
SCIPgetNOrigContImplVars
int SCIPgetNOrigContImplVars(SCIP *scip)
Definition: scip_prob.c:3006
SCIPgetOrigVars
SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)
Definition: scip_prob.c:2811
SCIPgetNOrigContVars
int SCIPgetNOrigContVars(SCIP *scip)
Definition: scip_prob.c:3035
SCIPsetProbExitsol
SCIP_RETCODE SCIPsetProbExitsol(SCIP *scip, SCIP_DECL_PROBEXITSOL((*probexitsol)))
Definition: scip_prob.c:287
SCIPgetNOrigIntVars
int SCIPgetNOrigIntVars(SCIP *scip)
Definition: scip_prob.c:2896
SCIPgetConss
SCIP_CONS ** SCIPgetConss(SCIP *scip)
Definition: scip_prob.c:3666
SCIPsetProbTrans
SCIP_RETCODE SCIPsetProbTrans(SCIP *scip, SCIP_DECL_PROBTRANS((*probtrans)))
Definition: scip_prob.c:223
SCIPsetProbDelorig
SCIP_RETCODE SCIPsetProbDelorig(SCIP *scip, SCIP_DECL_PROBDELORIG((*probdelorig)))
Definition: scip_prob.c:202
SCIPgetNOrigImplVars
int SCIPgetNOrigImplVars(SCIP *scip)
Definition: scip_prob.c:2925
SCIPgetObjlimit
SCIP_Real SCIPgetObjlimit(SCIP *scip)
Definition: scip_prob.c:1731
SCIPaddObjoffset
SCIP_RETCODE SCIPaddObjoffset(SCIP *scip, SCIP_Real addval)
Definition: scip_prob.c:1443
SCIPgetNUpgrConss
int SCIPgetNUpgrConss(SCIP *scip)
Definition: scip_prob.c:3578
SCIPgetNVars
int SCIPgetNVars(SCIP *scip)
Definition: scip_prob.c:2246
SCIPaddCons
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:3274
SCIPchgReoptObjective
SCIP_RETCODE SCIPchgReoptObjective(SCIP *scip, SCIP_OBJSENSE objsense, SCIP_VAR **vars, SCIP_Real *coefs, int nvars)
Definition: scip_prob.c:1294
SCIPfindOrigCons
SCIP_CONS * SCIPfindOrigCons(SCIP *scip, const char *name)
Definition: scip_prob.c:3476
SCIPdelCons
SCIP_RETCODE SCIPdelCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:3420
SCIPgetNConss
int SCIPgetNConss(SCIP *scip)
Definition: scip_prob.c:3620
SCIPfreeProb
SCIP_RETCODE SCIPfreeProb(SCIP *scip)
Definition: scip_prob.c:835
SCIPgetProbData
SCIP_PROBDATA * SCIPgetProbData(SCIP *scip)
Definition: scip_prob.c:1139
SCIPgetVars
SCIP_VAR ** SCIPgetVars(SCIP *scip)
Definition: scip_prob.c:2201
SCIPgetObjNorm
SCIP_Real SCIPgetObjNorm(SCIP *scip)
Definition: scip_prob.c:1880
SCIPallVarsInProb
SCIP_Bool SCIPallVarsInProb(SCIP *scip)
Definition: scip_prob.c:3247
SCIPgetNOrigVars
int SCIPgetNOrigVars(SCIP *scip)
Definition: scip_prob.c:2838
SCIPprintTransProblem
SCIP_RETCODE SCIPprintTransProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip_prob.c:696
SCIPprintOrigProblem
SCIP_RETCODE SCIPprintOrigProblem(SCIP *scip, FILE *file, const char *extension, SCIP_Bool genericnames)
Definition: scip_prob.c:652
SCIPgetNOrigBinImplVars
int SCIPgetNOrigBinImplVars(SCIP *scip)
Definition: scip_prob.c:2952
SCIPsetProbInitsol
SCIP_RETCODE SCIPsetProbInitsol(SCIP *scip, SCIP_DECL_PROBINITSOL((*probinitsol)))
Definition: scip_prob.c:265
SCIPgetNOrigIntImplVars
int SCIPgetNOrigIntImplVars(SCIP *scip)
Definition: scip_prob.c:2979
SCIPgetNIntImplVars
int SCIPgetNIntImplVars(SCIP *scip)
Definition: scip_prob.c:2477
SCIPgetNContImplVars
int SCIPgetNContImplVars(SCIP *scip)
Definition: scip_prob.c:2522
SCIPdelVar
SCIP_RETCODE SCIPdelVar(SCIP *scip, SCIP_VAR *var, SCIP_Bool *deleted)
Definition: scip_prob.c:2041
SCIPsetObjsense
SCIP_RETCODE SCIPsetObjsense(SCIP *scip, SCIP_OBJSENSE objsense)
Definition: scip_prob.c:1417
SCIPaddOrigObjoffset
SCIP_RETCODE SCIPaddOrigObjoffset(SCIP *scip, SCIP_Real addval)
Definition: scip_prob.c:1486
SCIPcreateProbBasic
SCIP_RETCODE SCIPcreateProbBasic(SCIP *scip, const char *name)
Definition: scip_prob.c:182
SCIPgetOrigConss
SCIP_CONS ** SCIPgetOrigConss(SCIP *scip)
Definition: scip_prob.c:3739
SCIPgetObjsense
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
Definition: scip_prob.c:1400
SCIPwriteTransProblem
SCIP_RETCODE SCIPwriteTransProblem(SCIP *scip, const char *filename, const char *extension, SCIP_Bool genericnames)
Definition: scip_prob.c:789
SCIPgetNFixedVars
int SCIPgetNFixedVars(SCIP *scip)
Definition: scip_prob.c:2705
SCIPcreateProb
SCIP_RETCODE SCIPcreateProb(SCIP *scip, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata)
Definition: scip_prob.c:119
SCIPsetProbData
SCIP_RETCODE SCIPsetProbData(SCIP *scip, SCIP_PROBDATA *probdata)
Definition: scip_prob.c:1189
SCIPgetOrigObjoffsetExact
SCIP_RATIONAL * SCIPgetOrigObjoffsetExact(SCIP *scip)
Definition: scip_prob.c:1556
SCIPgetNBinVars
int SCIPgetNBinVars(SCIP *scip)
Definition: scip_prob.c:2293
SCIPgetFixedVars
SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
Definition: scip_prob.c:2662
SCIPgetNTotalVars
int SCIPgetNTotalVars(SCIP *scip)
Definition: scip_prob.c:3064
SCIPgetTransObjscale
SCIP_Real SCIPgetTransObjscale(SCIP *scip)
Definition: scip_prob.c:1629
SCIPsetProbCopy
SCIP_RETCODE SCIPsetProbCopy(SCIP *scip, SCIP_DECL_PROBCOPY((*probcopy)))
Definition: scip_prob.c:308
SCIPisObjIntegral
SCIP_Bool SCIPisObjIntegral(SCIP *scip)
Definition: scip_prob.c:1801
SCIPfindVar
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
Definition: scip_prob.c:3189
SCIPfindCons
SCIP_CONS * SCIPfindCons(SCIP *scip, const char *name)
Definition: scip_prob.c:3525
SCIPaddOrigObjoffsetExact
SCIP_RETCODE SCIPaddOrigObjoffsetExact(SCIP *scip, SCIP_RATIONAL *addval)
Definition: scip_prob.c:1465
SCIPreadProb
SCIP_RETCODE SCIPreadProb(SCIP *scip, const char *filename, const char *extension)
Definition: scip_prob.c:341
SCIPupdateNodeLowerbound
SCIP_RETCODE SCIPupdateNodeLowerbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition: scip_prob.c:4354
SCIPupdateLocalLowerbound
SCIP_RETCODE SCIPupdateLocalLowerbound(SCIP *scip, SCIP_Real newbound)
Definition: scip_prob.c:4289
SCIPgetNodeDualbound
SCIP_Real SCIPgetNodeDualbound(SCIP *scip, SCIP_NODE *node)
Definition: scip_prob.c:4198
SCIPdelConsNode
SCIP_RETCODE SCIPdelConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons)
Definition: scip_prob.c:4017
SCIPgetLocalOrigEstimate
SCIP_Real SCIPgetLocalOrigEstimate(SCIP *scip)
Definition: scip_prob.c:4120
SCIPdelConsLocal
SCIP_RETCODE SCIPdelConsLocal(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:4067
SCIPaddConsNode
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
Definition: scip_prob.c:3901
SCIPclearConflictStore
SCIP_RETCODE SCIPclearConflictStore(SCIP *scip, SCIP_EVENT *event)
Definition: scip_prob.c:3864
SCIPgetLocalLowerbound
SCIP_Real SCIPgetLocalLowerbound(SCIP *scip)
Definition: scip_prob.c:4178
SCIPupdateLocalDualbound
SCIP_RETCODE SCIPupdateLocalDualbound(SCIP *scip, SCIP_Real newbound)
Definition: scip_prob.c:4239
SCIPaddConflict
SCIP_RETCODE SCIPaddConflict(SCIP *scip, SCIP_NODE *node, SCIP_CONS **cons, SCIP_NODE *validnode, SCIP_CONFTYPE conftype, SCIP_Bool iscutoffinvolved)
Definition: scip_prob.c:3806
SCIPchgChildPrio
SCIP_RETCODE SCIPchgChildPrio(SCIP *scip, SCIP_NODE *child, SCIP_Real priority)
Definition: scip_prob.c:4388
SCIPupdateNodeDualbound
SCIP_RETCODE SCIPupdateNodeDualbound(SCIP *scip, SCIP_NODE *node, SCIP_Real newbound)
Definition: scip_prob.c:4330
SCIPgetLocalDualbound
SCIP_Real SCIPgetLocalDualbound(SCIP *scip)
Definition: scip_prob.c:4159
SCIPaddConsLocal
SCIP_RETCODE SCIPaddConsLocal(SCIP *scip, SCIP_CONS *cons, SCIP_NODE *validnode)
Definition: scip_prob.c:3986
SCIPgetNodeLowerbound
SCIP_Real SCIPgetNodeLowerbound(SCIP *scip, SCIP_NODE *node)
Definition: scip_prob.c:4215
SCIPgetLocalTransEstimate
SCIP_Real SCIPgetLocalTransEstimate(SCIP *scip)
Definition: scip_prob.c:4139
SCIP_Cons
Definition: struct_cons.h:47
SCIP_Event
Definition: struct_event.h:174
SCIP_Node
Definition: struct_tree.h:142
SCIP_Rational
Definition: struct_rational.h:47
SCIP_Sol
Definition: struct_sol.h:74
SCIP_Var
Definition: struct_var.h:262
type_conflict.h
type definitions for conflict analysis
SCIP_CONFTYPE
enum SCIP_ConflictType SCIP_CONFTYPE
Definition: type_conflict.h:68
type_cons.h
type definitions for constraints and constraint handlers
type_event.h
type definitions for managing events
type_misc.h
type definitions for miscellaneous datastructures
type_prob.h
type definitions for storing and manipulating the main problem
SCIP_DECL_PROBCOPY
#define SCIP_DECL_PROBCOPY(x)
Definition: type_prob.h:150
SCIP_DECL_PROBDELTRANS
#define SCIP_DECL_PROBDELTRANS(x)
Definition: type_prob.h:95
SCIP_DECL_PROBEXITSOL
#define SCIP_DECL_PROBEXITSOL(x)
Definition: type_prob.h:119
SCIP_PROBDATA
struct SCIP_ProbData SCIP_PROBDATA
Definition: type_prob.h:53
SCIP_DECL_PROBDELORIG
#define SCIP_DECL_PROBDELORIG(x)
Definition: type_prob.h:64
SCIP_DECL_PROBTRANS
#define SCIP_DECL_PROBTRANS(x)
Definition: type_prob.h:83
SCIP_DECL_PROBINITSOL
#define SCIP_DECL_PROBINITSOL(x)
Definition: type_prob.h:106
SCIP_OBJSENSE
enum SCIP_Objsense SCIP_OBJSENSE
Definition: type_prob.h:50
type_rational.h
type definitions for rational numbers
type_result.h
result codes for SCIP callback methods
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_sol.h
type definitions for storing primal CIP solutions
type_tree.h
type definitions for branch and bound tree
type_var.h
type definitions for problem variables