1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright 2002-2022 Zuse Institute Berlin */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); */
/* you may not use this file except in compliance with the License. */
/* You may obtain a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
/* See the License for the specific language governing permissions and */
/* limitations under the License. */
/* */
/* You should have received a copy of the Apache-2.0 license */
/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**@file prob.h
* @ingroup INTERNALAPI
* @brief internal methods for storing and manipulating the main problem
* @author Tobias Achterberg
*/
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#ifndef __SCIP_PROB_H__
#define __SCIP_PROB_H__
#include "scip/def.h"
#include "blockmemshell/memory.h"
#include "scip/type_retcode.h"
#include "scip/type_set.h"
#include "scip/type_stat.h"
#include "scip/type_event.h"
#include "scip/type_lp.h"
#include "scip/type_var.h"
#include "scip/type_implics.h"
#include "scip/type_prob.h"
#include "scip/type_primal.h"
#include "scip/type_tree.h"
#include "scip/type_reopt.h"
#include "scip/type_branch.h"
#include "scip/type_cons.h"
#include "scip/type_conflictstore.h"
#include "scip/struct_prob.h"
#ifdef __cplusplus
extern "C" {
#endif
/*
* problem creation
*/
/** creates problem data structure by copying the source problem;
* If the problem type requires the use of variable pricers, these pricers should be activated with calls
* to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
*/
SCIP_RETCODE SCIPprobCopy(
SCIP_PROB** prob, /**< pointer to problem data structure */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
const char* name, /**< problem name */
SCIP* sourcescip, /**< source SCIP data structure */
SCIP_PROB* sourceprob, /**< source problem structure */
SCIP_HASHMAP* varmap, /**< a hashmap to store the mapping of source variables corresponding
* target variables, or NULL */
SCIP_HASHMAP* consmap, /**< a hashmap to store the mapping of source constraints to the corresponding
* target constraints, or NULL */
SCIP_Bool global /**< create a global or a local copy? */
);
/** creates problem data structure
* If the problem type requires the use of variable pricers, these pricers should be activated with calls
* to SCIPactivatePricer(). These pricers are automatically deactivated, when the problem is freed.
*/
SCIP_RETCODE SCIPprobCreate(
SCIP_PROB** prob, /**< pointer to problem data structure */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
const char* name, /**< problem name */
SCIP_DECL_PROBDELORIG ((*probdelorig)), /**< frees user data of original problem */
SCIP_DECL_PROBTRANS ((*probtrans)), /**< creates user data of transformed problem by transforming original user data */
SCIP_DECL_PROBDELTRANS((*probdeltrans)), /**< frees user data of transformed problem */
SCIP_DECL_PROBINITSOL ((*probinitsol)), /**< solving process initialization method of transformed data */
SCIP_DECL_PROBEXITSOL ((*probexitsol)), /**< solving process deinitialization method of transformed data */
SCIP_DECL_PROBCOPY ((*probcopy)), /**< copies user data if you want to copy it to a subscip, or NULL */
SCIP_PROBDATA* probdata, /**< user problem data set by the reader */
SCIP_Bool transformed /**< is this the transformed problem? */
);
/** sets callback to free user data of original problem */
void SCIPprobSetDelorig(
SCIP_PROB* prob, /**< problem */
SCIP_DECL_PROBDELORIG ((*probdelorig)) /**< frees user data of original problem */
);
/** sets callback to create user data of transformed problem by transforming original user data */
void SCIPprobSetTrans(
SCIP_PROB* prob, /**< problem */
SCIP_DECL_PROBTRANS ((*probtrans)) /**< creates user data of transformed problem by transforming original user data */
);
/** sets callback to free user data of transformed problem */
void SCIPprobSetDeltrans(
SCIP_PROB* prob, /**< problem */
SCIP_DECL_PROBDELTRANS((*probdeltrans)) /**< frees user data of transformed problem */
);
/** sets solving process initialization callback of transformed data */
void SCIPprobSetInitsol(
SCIP_PROB* prob, /**< problem */
SCIP_DECL_PROBINITSOL ((*probinitsol)) /**< solving process initialization callback of transformed data */
);
/** sets solving process deinitialization callback of transformed data */
void SCIPprobSetExitsol(
SCIP_PROB* prob, /**< problem */
SCIP_DECL_PROBEXITSOL ((*probexitsol)) /**< solving process deinitialization callback of transformed data */
);
/** sets callback to copy user data to copy it to a subscip, or NULL */
void SCIPprobSetCopy(
SCIP_PROB* prob, /**< problem */
SCIP_DECL_PROBCOPY ((*probcopy)) /**< copies user data if you want to copy it to a subscip, or NULL */
);
/** frees problem data structure */
SCIP_RETCODE SCIPprobFree(
SCIP_PROB** prob, /**< pointer to problem data structure */
SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
BMS_BLKMEM* blkmem, /**< block memory buffer */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< dynamic problem statistics */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_LP* lp /**< current LP data (or NULL, if it's the original problem) */
);
/** transform problem data into normalized form */
SCIP_RETCODE SCIPprobTransform(
SCIP_PROB* source, /**< problem to transform */
BMS_BLKMEM* blkmem, /**< block memory buffer */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics */
SCIP_PRIMAL* primal, /**< primal data */
SCIP_TREE* tree, /**< branch and bound tree */
SCIP_REOPT* reopt, /**< reoptimization data structure */
SCIP_LP* lp, /**< current LP data */
SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
SCIP_EVENTFILTER* eventfilter, /**< event filter for global (not variable dependent) events */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_CONFLICTSTORE* conflictstore, /**< conflict store */
SCIP_PROB** target /**< pointer to target problem data structure */
);
/** resets the global and local bounds of original variables in original problem to their original values */
SCIP_RETCODE SCIPprobResetBounds(
SCIP_PROB* prob, /**< original problem data */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat /**< problem statistics */
);
/** (Re)Sort the variables, which appear in the four categories (binary, integer, implicit, continuous) after presolve
* with respect to their original index (within their categories). Adjust the problem index afterwards which is
* supposed to reflect the position in the variable array. This additional (re)sorting is supposed to get more robust
* against the order presolving fixed variables. (We also reobtain a possible block structure induced by the user
* model)
*/
void SCIPprobResortVars(
SCIP_PROB* prob /**< problem data */
);
/*
* problem modification
*/
/** sets user problem data */
void SCIPprobSetData(
SCIP_PROB* prob, /**< problem */
SCIP_PROBDATA* probdata /**< user problem data to use */
);
/** adds variable's name to the namespace */
SCIP_RETCODE SCIPprobAddVarName(
SCIP_PROB* prob, /**< problem data */
SCIP_VAR* var /**< variable */
);
/** removes variable's name from the namespace */
SCIP_RETCODE SCIPprobRemoveVarName(
SCIP_PROB* prob, /**< problem data */
SCIP_VAR* var /**< variable */
);
/** adds variable to the problem and captures it */
SCIP_RETCODE SCIPprobAddVar(
SCIP_PROB* prob, /**< problem data */
BMS_BLKMEM* blkmem, /**< block memory buffers */
SCIP_SET* set, /**< global SCIP settings */
SCIP_LP* lp, /**< current LP data */
SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
SCIP_EVENTFILTER* eventfilter, /**< event filter for global (not variable dependent) events */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_VAR* var /**< variable to add */
);
/** marks variable to be removed from the problem; however, the variable is NOT removed from the constraints */
SCIP_RETCODE SCIPprobDelVar(
SCIP_PROB* prob, /**< problem data */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_VAR* var, /**< problem variable */
SCIP_Bool* deleted /**< pointer to store whether marking variable to be deleted was successful */
);
/** actually removes the deleted variables from the problem and releases them */
SCIP_RETCODE SCIPprobPerformVarDeletions(
SCIP_PROB* prob, /**< problem data */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< dynamic problem statistics */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
SCIP_LP* lp, /**< current LP data (may be NULL) */
SCIP_BRANCHCAND* branchcand /**< branching candidate storage */
);
/** changes the type of a variable in the problem */
SCIP_RETCODE SCIPprobChgVarType(
SCIP_PROB* prob, /**< problem data */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_PRIMAL* primal, /**< primal data */
SCIP_LP* lp, /**< current LP data */
SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
SCIP_VAR* var, /**< variable to add */
SCIP_VARTYPE vartype /**< new type of variable */
);
/** informs problem, that the given loose problem variable changed its status */
SCIP_RETCODE SCIPprobVarChangedStatus(
SCIP_PROB* prob, /**< problem data */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_BRANCHCAND* branchcand, /**< branching candidate storage */
SCIP_CLIQUETABLE* cliquetable, /**< clique table data structure */
SCIP_VAR* var /**< problem variable */
);
/** adds constraint's name to the namespace */
SCIP_RETCODE SCIPprobAddConsName(
SCIP_PROB* prob, /**< problem data */
SCIP_CONS* cons /**< constraint */
);
/** remove constraint's name from the namespace */
SCIP_RETCODE SCIPprobRemoveConsName(
SCIP_PROB* prob, /**< problem data */
SCIP_CONS* cons /**< constraint */
);
/** adds constraint to the problem and captures it;
* a local constraint is automatically upgraded into a global constraint
*/
SCIP_RETCODE SCIPprobAddCons(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< dynamic problem statistics */
SCIP_CONS* cons /**< constraint to add */
);
/** releases and removes constraint from the problem; if the user has not captured the constraint for his own use, the
* constraint may be invalid after the call
*/
SCIP_RETCODE SCIPprobDelCons(
SCIP_PROB* prob, /**< problem data */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< dynamic problem statistics */
SCIP_CONS* cons /**< constraint to remove */
);
/** remembers the current number of constraints in the problem's internal data structure
* - resets maximum number of constraints to current number of constraints
* - remembers current number of constraints as starting number of constraints
*/
void SCIPprobMarkNConss(
SCIP_PROB* prob /**< problem data */
);
/** sets objective sense: minimization or maximization */
void SCIPprobSetObjsense(
SCIP_PROB* prob, /**< problem data */
SCIP_OBJSENSE objsense /**< new objective sense */
);
/** adds value to objective offset */
void SCIPprobAddObjoffset(
SCIP_PROB* prob, /**< problem data */
SCIP_Real addval /**< value to add to objective offset */
);
/** sets the dual bound on objective function */
void SCIPprobSetDualbound(
SCIP_PROB* prob, /**< problem data */
SCIP_Real dualbound /**< external dual bound */
);
/** sets limit on objective function, such that only solutions better than this limit are accepted */
void SCIPprobSetObjlim(
SCIP_PROB* prob, /**< problem data */
SCIP_Real objlim /**< external objective limit */
);
/** informs the problem, that its objective value is always integral in every feasible solution */
void SCIPprobSetObjIntegral(
SCIP_PROB* prob /**< problem data */
);
/** sets integral objective value flag, if all variables with non-zero objective values are integral and have
* integral objective value and also updates the cutoff bound if primal solution is already known
*/
SCIP_RETCODE SCIPprobCheckObjIntegral(
SCIP_PROB* transprob, /**< tranformed problem data */
SCIP_PROB* origprob, /**< original problem data */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics data */
SCIP_PRIMAL* primal, /**< primal data */
SCIP_TREE* tree, /**< branch and bound tree */
SCIP_REOPT* reopt, /**< reoptimization data structure */
SCIP_LP* lp, /**< current LP data */
SCIP_EVENTFILTER* eventfilter, /**< event filter for global (not variable dependent) events */
SCIP_EVENTQUEUE* eventqueue /**< event queue */
);
/** if possible, scales objective function such that it is integral with gcd = 1 */
SCIP_RETCODE SCIPprobScaleObj(
SCIP_PROB* transprob, /**< tranformed problem data */
SCIP_PROB* origprob, /**< original problem data */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics data */
SCIP_PRIMAL* primal, /**< primal data */
SCIP_TREE* tree, /**< branch and bound tree */
SCIP_REOPT* reopt, /**< reoptimization data structure */
SCIP_LP* lp, /**< current LP data */
SCIP_EVENTFILTER* eventfilter, /**< event filter for global (not variable dependent) events */
SCIP_EVENTQUEUE* eventqueue /**< event queue */
);
/** remembers the current solution as root solution in the problem variables */
void SCIPprobStoreRootSol(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< SCIP statistics */
SCIP_LP* lp, /**< current LP data */
SCIP_Bool roothaslp /**< is the root solution from LP? */
);
/** remembers the best solution w.r.t. root reduced cost propagation as root solution in the problem variables */
void SCIPprobUpdateBestRootSol(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set, /**< global SCIP settings */
SCIP_STAT* stat, /**< problem statistics */
SCIP_LP* lp /**< current LP data */
);
/** informs problem, that the presolving process was finished, and updates all internal data structures */
SCIP_RETCODE SCIPprobExitPresolve(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set /**< global SCIP settings */
);
/** initializes problem for branch and bound process */
SCIP_RETCODE SCIPprobInitSolve(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set /**< global SCIP settings */
);
/** deinitializes problem after branch and bound process, and converts all COLUMN variables back into LOOSE variables */
SCIP_RETCODE SCIPprobExitSolve(
SCIP_PROB* prob, /**< problem data */
BMS_BLKMEM* blkmem, /**< block memory */
SCIP_SET* set, /**< global SCIP settings */
SCIP_EVENTQUEUE* eventqueue, /**< event queue */
SCIP_LP* lp, /**< current LP data */
SCIP_Bool restart /**< was this exit solve call triggered by a restart? */
);
/*
* problem information
*/
/** sets problem name */
SCIP_RETCODE SCIPprobSetName(
SCIP_PROB* prob, /**< problem data */
const char* name /**< name to be set */
);
/** returns the number of implicit binary variables, meaning variable of vartype != SCIP_VARTYPE_BINARY and !=
* SCIP_VARTYPE_CONTINUOUS but with global bounds [0,1]
*
* @note this number needs to be computed, because it cannot be update like the othe counters for binary and interger
* variables, each time the variable type changes(, we would need to update this counter each time a global bound
* changes), even at the end of presolving this cannot be computed, because some variable can change to an
* implicit binary status
*/
int SCIPprobGetNImplBinVars(
SCIP_PROB* prob /**< problem data */
);
/** returns the number of variables with non-zero objective coefficient */
int SCIPprobGetNObjVars(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set /**< global SCIP settings */
);
/** returns the minimal absolute non-zero objective coefficient
*
* @note currently, this is only used for statistics and printed after the solving process. if this information is
* needed during the (pre)solving process this should be implemented more efficiently, e.g., updating the minimal
* absolute non-zero coefficient every time an objective coefficient has changed.
*/
SCIP_Real SCIPprobGetAbsMinObjCoef(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set /**< global SCIP settings */
);
/** returns the maximal absolute non-zero objective coefficient
*
* @note currently, this is only used for statistics and printed after the solving process. if this information is
* needed during the (pre)solving process this should be implemented more efficiently, e.g., updating the maximal
* absolute non-zero coefficient every time an objective coefficient has changed.
*/
SCIP_Real SCIPprobGetAbsMaxObjCoef(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set /**< global SCIP settings */
);
/** update the number of variables with non-zero objective coefficient */
void SCIPprobUpdateNObjVars(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set, /**< global SCIP settings */
SCIP_Real oldobj, /**< old objective value for variable */
SCIP_Real newobj /**< new objective value for variable */
);
/** update the dual bound if its better as the current one */
void SCIPprobUpdateDualbound(
SCIP_PROB* prob, /**< problem data */
SCIP_Real newbound /**< new dual bound for the node (if it's tighter than the old one) */
);
/** invalidates the dual bound */
void SCIPprobInvalidateDualbound(
SCIP_PROB* prob /**< problem data */
);
/** returns the external value of the given internal objective value */
SCIP_Real SCIPprobExternObjval(
SCIP_PROB* transprob, /**< tranformed problem data */
SCIP_PROB* origprob, /**< original problem data */
SCIP_SET* set, /**< global SCIP settings */
SCIP_Real objval /**< internal objective value */
);
/** returns the internal value of the given external objective value */
SCIP_Real SCIPprobInternObjval(
SCIP_PROB* transprob, /**< tranformed problem data */
SCIP_PROB* origprob, /**< original problem data */
SCIP_SET* set, /**< global SCIP settings */
SCIP_Real objval /**< external objective value */
);
/** returns variable of the problem with given name */
SCIP_VAR* SCIPprobFindVar(
SCIP_PROB* prob, /**< problem data */
const char* name /**< name of variable to find */
);
/** returns constraint of the problem with given name */
SCIP_CONS* SCIPprobFindCons(
SCIP_PROB* prob, /**< problem data */
const char* name /**< name of variable to find */
);
/** displays current pseudo solution */
void SCIPprobPrintPseudoSol(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr /**< message handler */
);
/** outputs problem statistics */
void SCIPprobPrintStatistics(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set, /**< global SCIP settings */
SCIP_MESSAGEHDLR* messagehdlr, /**< message handler */
FILE* file /**< output file (or NULL for standard output) */
);
#ifndef NDEBUG
/* In debug mode, the following methods are implemented as function calls to ensure
* type validity.
*/
/** is the problem permuted */
SCIP_Bool SCIPprobIsPermuted(
SCIP_PROB* prob
);
/** mark the problem as permuted */
void SCIPprobMarkPermuted(
SCIP_PROB* prob
);
/** is the problem data transformed */
SCIP_Bool SCIPprobIsTransformed(
SCIP_PROB* prob /**< problem data */
);
/** returns whether the objective value is known to be integral in every feasible solution */
SCIP_Bool SCIPprobIsObjIntegral(
SCIP_PROB* prob /**< problem data */
);
/** returns TRUE iff all columns, i.e. every variable with non-empty column w.r.t. all ever created rows, are present
* in the LP, and FALSE, if there are additional already existing columns, that may be added to the LP in pricing
*/
SCIP_Bool SCIPprobAllColsInLP(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set, /**< global SCIP settings */
SCIP_LP* lp /**< current LP data */
);
/** gets limit on objective function in external space */
SCIP_Real SCIPprobGetObjlim(
SCIP_PROB* prob, /**< problem data */
SCIP_SET* set /**< global SCIP settings */
);
/** gets user problem data */
SCIP_PROBDATA* SCIPprobGetData(
SCIP_PROB* prob /**< problem */
);
/** gets problem name */
const char* SCIPprobGetName(
SCIP_PROB* prob /**< problem data */
);
/** gets number of problem variables */
int SCIPprobGetNVars(
SCIP_PROB* prob /**< problem data */
);
/** gets number of binary problem variables */
int SCIPprobGetNBinVars(
SCIP_PROB* prob /**< problem data */
);
/** gets number of integer problem variables */
int SCIPprobGetNIntVars(
SCIP_PROB* prob /**< problem data */
);
/** gets number of implicit integer problem variables */
int SCIPprobGetNImplVars(
SCIP_PROB* prob /**< problem data */
);
/** gets number of continuous problem variables */
int SCIPprobGetNContVars(
SCIP_PROB* prob /**< problem data */
);
/** gets problem variables */
SCIP_VAR** SCIPprobGetVars(
SCIP_PROB* prob /**< problem data */
);
/** gets number of problem constraints */
int SCIPprobGetNConss(
SCIP_PROB* prob /**< problem data */
);
/** gets the objective offset */
SCIP_Real SCIPprobGetObjoffset(
SCIP_PROB* prob /**< problem data */
);
/** gets the objective scalar */
SCIP_Real SCIPprobGetObjscale(
SCIP_PROB* prob /**< problem data */
);
/** is constraint compression enabled for this problem? */
SCIP_Bool SCIPprobIsConsCompressionEnabled(
SCIP_PROB* prob /**< problem data */
);
/** enable problem compression, i.e., constraints can reduce memory size by removing fixed variables during creation */
void SCIPprobEnableConsCompression(
SCIP_PROB* prob /**< problem data */
);
#else
/* In optimized mode, the methods are implemented as defines to reduce the number of function calls and
* speed up the algorithms.
*/
#define SCIPprobIsPermuted(prob) ((prob)->permuted)
#define SCIPprobMarkPermuted(prob) ((prob)->permuted = TRUE)
#define SCIPprobIsTransformed(prob) ((prob)->transformed)
#define SCIPprobIsObjIntegral(prob) ((prob)->objisintegral)
#define SCIPprobAllColsInLP(prob,set,lp) (SCIPlpGetNCols(lp) == (prob)->ncolvars && (set)->nactivepricers == 0)
#define SCIPprobGetObjlim(prob,set) \
((prob)->objlim >= SCIP_INVALID ? (SCIP_Real)((prob)->objsense) * SCIPsetInfinity(set) : (prob)->objlim)
#define SCIPprobGetData(prob) ((prob)->probdata)
#define SCIPprobGetName(prob) ((prob)->name)
#define SCIPprobGetName(prob) ((prob)->name)
#define SCIPprobGetNVars(prob) ((prob)->nvars)
#define SCIPprobGetNBinVars(prob) ((prob)->nbinvars)
#define SCIPprobGetNIntVars(prob) ((prob)->nintvars)
#define SCIPprobGetNImplVars(prob) ((prob)->nimplvars)
#define SCIPprobGetNContVars(prob) ((prob)->ncontvars)
#define SCIPprobGetVars(prob) ((prob)->vars)
#define SCIPprobGetNConss(prob) ((prob)->nconss)
#define SCIPprobGetObjoffset(prob) ((prob)->objoffset)
#define SCIPprobGetObjscale(prob) ((prob)->objscale)
#define SCIPprobIsConsCompressionEnabled(prob) ((prob)->conscompression)
#define SCIPprobEnableConsCompression(prob) ((prob)->conscompression = TRUE)
#endif
#ifdef __cplusplus
}
#endif
#endif