SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
sepa_intobj.c
Go to the documentation of this file.
1/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2/* */
3/* This file is part of the program and library */
4/* SCIP --- Solving Constraint Integer Programs */
5/* */
6/* Copyright (c) 2002-2024 Zuse Institute Berlin (ZIB) */
7/* */
8/* Licensed under the Apache License, Version 2.0 (the "License"); */
9/* you may not use this file except in compliance with the License. */
10/* You may obtain a copy of the License at */
11/* */
12/* http://www.apache.org/licenses/LICENSE-2.0 */
13/* */
14/* Unless required by applicable law or agreed to in writing, software */
15/* distributed under the License is distributed on an "AS IS" BASIS, */
16/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
17/* See the License for the specific language governing permissions and */
18/* limitations under the License. */
19/* */
20/* You should have received a copy of the Apache-2.0 license */
21/* along with SCIP; see the file LICENSE. If not visit scipopt.org. */
22/* */
23/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
24
25/**@file sepa_intobj.c
26 * @ingroup DEFPLUGINS_SEPA
27 * @brief integer objective value separator
28 * @author Tobias Achterberg
29 * @author Timo Berthold
30 */
31/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
32
33#include "scip/pub_event.h"
34#include "scip/pub_lp.h"
35#include "scip/pub_message.h"
36#include "scip/pub_sepa.h"
37#include "scip/pub_var.h"
38#include "scip/scip_branch.h"
39#include "scip/scip_cut.h"
40#include "scip/scip_event.h"
41#include "scip/scip_general.h"
42#include "scip/scip_lp.h"
43#include "scip/scip_message.h"
44#include "scip/scip_mem.h"
45#include "scip/scip_numerics.h"
46#include "scip/scip_prob.h"
47#include "scip/scip_sepa.h"
48#include "scip/scip_sol.h"
50#include "scip/scip_var.h"
51#include "scip/sepa_intobj.h"
52#include <string.h>
53
54
55#define SEPA_NAME "intobj"
56#define SEPA_DESC "integer objective value separator"
57#define SEPA_PRIORITY -100
58#define SEPA_FREQ -1
59#define SEPA_MAXBOUNDDIST 0.0
60#define SEPA_USESSUBSCIP FALSE /**< does the separator use a secondary SCIP instance? */
61#define SEPA_DELAY FALSE /**< should separation method be delayed, if other separators found cuts? */
62
63#define EVENTHDLR_NAME "intobj"
64#define EVENTHDLR_DESC "objective change event handler for integer objective value separator"
65
66
67/*
68 * Data structures
69 */
70
71/** separator data */
72struct SCIP_SepaData
73{
74 SCIP_ROW* objrow; /**< objective value inequality */
75 SCIP_VAR* objvar; /**< objective value variable */
76 SCIP_Real setoff; /**< setoff of the inequality */
77};
78
79
80/*
81 * Local methods
82 */
83
84/** creates separator data */
85static
87 SCIP* scip, /**< SCIP data structure */
88 SCIP_SEPADATA** sepadata /**< pointer to store separator data */
89 )
90{
92
94 (*sepadata)->objrow = NULL;
95 (*sepadata)->objvar = NULL;
96 (*sepadata)->setoff = 0.0;
97
98 return SCIP_OKAY;
99}
100
101/** frees separator data */
102static
104 SCIP* scip, /**< SCIP data structure */
105 SCIP_SEPADATA** sepadata /**< pointer to separator data */
106 )
107{
108 assert(sepadata != NULL);
109 assert(*sepadata != NULL);
110 assert((*sepadata)->objrow == NULL);
111 assert((*sepadata)->objvar == NULL);
112
114
115 return SCIP_OKAY;
116}
117
118/** creates the objective value inequality and the objective value variable, if not yet existing */
119static
121 SCIP* scip, /**< SCIP data structure */
122 SCIP_SEPA* sepa, /**< separator */
123 SCIP_SEPADATA* sepadata /**< separator data */
124 )
125{
126 assert(sepadata != NULL);
127
128 if( sepadata->objrow == NULL )
129 {
130 SCIP_VAR** vars;
132 SCIP_Real intobjval;
133 int nvars;
134 int v;
135 SCIP_Bool attendobjvarbound;
136
137 attendobjvarbound = FALSE;
138 /* create and add objective value variable */
139 if( sepadata->objvar == NULL )
140 {
141 SCIP_CALL( SCIPcreateVar(scip, &sepadata->objvar, "objvar", -SCIPinfinity(scip), SCIPinfinity(scip), 0.0,
144 SCIP_CALL( SCIPaddVar(scip, sepadata->objvar) );
146 }
147 else
148 attendobjvarbound = TRUE;
149
150 /* get problem variables */
153
154 /* create objective value inequality */
155 if( attendobjvarbound )
157 else
158 intobjval = SCIPceil(scip, SCIPgetLowerbound(scip));
159 SCIP_CALL( SCIPcreateEmptyRowSepa(scip, &sepadata->objrow, sepa, "objrow", intobjval, SCIPinfinity(scip),
161 sepadata->setoff = intobjval;
162
164 for( v = 0; v < nvars; ++v )
165 {
166 obj = SCIPvarGetObj(vars[v]);
167 if( !SCIPisZero(scip, obj) )
168 {
169 SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, vars[v], obj) );
170 }
171 }
172 SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, sepadata->objvar, -1.0) );
174
175 SCIPdebugMsg(scip, "created objective value row: ");
177 }
178
179 return SCIP_OKAY;
180}
181
182/** searches and adds integral objective cuts that separate the given primal solution */
183static
185 SCIP* scip, /**< SCIP data structure */
186 SCIP_SEPA* sepa, /**< the intobj separator */
187 SCIP_SOL* sol, /**< the solution that should be separated, or NULL for LP solution */
188 SCIP_RESULT* result /**< pointer to store the result */
189 )
190{
193 SCIP_Real intbound;
194 SCIP_Bool infeasible;
195 SCIP_Bool tightened;
196
197 assert(result != NULL);
199
200 /* if the objective value may be fractional, we cannot do anything */
201 if( !SCIPisObjIntegral(scip) )
202 return SCIP_OKAY;
203
205
206 /* if the current objective value is integral, there is no integral objective value cut */
207 if( sol == NULL )
209 else
212 return SCIP_OKAY;
213
215 assert(sepadata != NULL);
216
217 /* the objective value is fractional: create the objective value inequality, if not yet existing */
219
220 /* adjust the bounds of the objective value variable */
221 intbound = SCIPceil(scip, objval) - sepadata->setoff;
222 SCIP_CALL( SCIPtightenVarLb(scip, sepadata->objvar, intbound, FALSE, &infeasible, &tightened) );
223 SCIPdebugMsg(scip, "new objective variable lower bound: <%s>[%g,%g]\n",
225
226 /* add the objective value inequality as a cut to the LP */
227 if( infeasible )
229 else
230 {
231 if( !SCIProwIsInLP(sepadata->objrow) )
232 {
233 SCIP_CALL( SCIPaddRow(scip, sepadata->objrow, FALSE, &infeasible) );
234 }
235 if ( infeasible )
237 else if ( tightened )
239 else
241 }
242
243 return SCIP_OKAY;
244}
245
246
247/*
248 * Callback methods of separator
249 */
250
251/** copy method for separator plugins (called when SCIP copies plugins) */
252static
253SCIP_DECL_SEPACOPY(sepaCopyIntobj)
254{ /*lint --e{715}*/
255 assert(scip != NULL);
256 assert(sepa != NULL);
257 assert(strcmp(SCIPsepaGetName(sepa), SEPA_NAME) == 0);
258
259 /* call inclusion method of constraint handler */
261
262 return SCIP_OKAY;
263}
264
265/** destructor of separator to free user data (called when SCIP is exiting) */
266static
267SCIP_DECL_SEPAFREE(sepaFreeIntobj)
268{ /*lint --e{715}*/
270
271 /* free separator data */
273 assert(sepadata != NULL);
274
276
277 SCIPsepaSetData(sepa, NULL);
278
279 return SCIP_OKAY;
280}
281
282
283/** solving process deinitialization method of separator (called before branch and bound process data is freed) */
284static
285SCIP_DECL_SEPAEXITSOL(sepaExitsolIntobj)
286{ /*lint --e{715}*/
288
290 assert(sepadata != NULL);
291
292 /* release objective row */
293 if( sepadata->objrow != NULL )
294 {
296 }
297
298 /* release objective variable */
299 if( sepadata->objvar != NULL )
300 {
301 /* remove locks in createObjRow() */
304 }
305
306 return SCIP_OKAY;
307}
308
309
310/** LP solution separation method of separator */
311static
312SCIP_DECL_SEPAEXECLP(sepaExeclpIntobj)
313{ /*lint --e{715}*/
315
316 /* only call separator, if we are not close to terminating */
317 if( SCIPisStopped(scip) )
318 return SCIP_OKAY;
319
320 /* only call separator, if an optimal LP solution is at hand */
322 return SCIP_OKAY;
323
324 /* only call separator, if there are fractional variables */
325 if( SCIPgetNLPBranchCands(scip) == 0 )
326 return SCIP_OKAY;
327
329
330 return SCIP_OKAY;
331}
332
333
334/** arbitrary primal solution separation method of separator */
335static
336SCIP_DECL_SEPAEXECSOL(sepaExecsolIntobj)
337{ /*lint --e{715}*/
339
340 /* only call separator, if we are not close to terminating */
341 if( SCIPisStopped(scip) )
342 return SCIP_OKAY;
343
344 /* only call separator, if there can be no feasible integral objective value at least as good */
346 return SCIP_OKAY;
347
349
350 return SCIP_OKAY;
351}
352
353
354/*
355 * event handler for objective changes
356 */
357
358
359/** initialization method of event handler (called after problem was transformed) */
360static
361SCIP_DECL_EVENTINIT(eventInitIntobj)
362{ /*lint --e{715}*/
364
365 return SCIP_OKAY;
366}
367
368/** deinitialization method of event handler (called before transformed problem is freed) */
369static
370SCIP_DECL_EVENTEXIT(eventExitIntobj)
371{ /*lint --e{715}*/
373
374 return SCIP_OKAY;
375}
376
377
378/** execution method of objective change event handler */
379static
380SCIP_DECL_EVENTEXEC(eventExecIntobj)
381{ /*lint --e{715}*/
382 SCIP_EVENTHDLRDATA* eventhdlrdata;
384 SCIP_VAR* var;
385 SCIP_Real objdelta;
386
387 eventhdlrdata = SCIPeventhdlrGetData(eventhdlr);
388 sepadata = (SCIP_SEPADATA*)eventhdlrdata;
389 assert(sepadata != NULL);
390
391 /* we don't have anything to do, if the objective value inequality doesn't yet exist */
392 if( sepadata->objrow == NULL )
393 return SCIP_OKAY;
394
395 var = SCIPeventGetVar(event);
396
397 switch( SCIPeventGetType(event) )
398 {
400 SCIPdebugMsg(scip, "variable <%s> with obj=%g was added to the problem\n", SCIPvarGetName(var), SCIPvarGetObj(var));
401 objdelta = SCIPvarGetObj(var);
402 if( !SCIPisZero(scip, objdelta) )
403 {
405 }
406 break;
407
409 SCIPdebugMsg(scip, "variable <%s> changed objective value from %g to %g\n", SCIPvarGetName(var), SCIPeventGetOldobj(event), SCIPeventGetNewobj(event));
410 objdelta = SCIPeventGetNewobj(event) - SCIPeventGetOldobj(event);
411 SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, var, objdelta) );
412 break;
413
414 default:
415 SCIPerrorMessage("invalid event type %" SCIP_EVENTTYPE_FORMAT "\n", SCIPeventGetType(event));
416 return SCIP_INVALIDDATA;
417 }
418
419 return SCIP_OKAY;
420}
421
422
423/*
424 * separator specific interface methods
425 */
426
427/** creates the integer objective value separator and includes it in SCIP */
429 SCIP* scip /**< SCIP data structure */
430 )
431{
433 SCIP_EVENTHDLRDATA* eventhdlrdata;
434 SCIP_SEPA* sepa;
435 SCIP_EVENTHDLR* eventhdlr;
436
437 /* create intobj separator data */
439
440 /* include separator */
443 sepaExeclpIntobj, sepaExecsolIntobj,
444 sepadata) );
445
446 assert(sepa != NULL);
447
448 /* set non-NULL pointers to callback methods */
449 SCIP_CALL( SCIPsetSepaCopy(scip, sepa, sepaCopyIntobj) );
450 SCIP_CALL( SCIPsetSepaFree(scip, sepa, sepaFreeIntobj) );
451 SCIP_CALL( SCIPsetSepaExitsol(scip, sepa, sepaExitsolIntobj) );
452
453 /* include event handler for objective change events */
454 eventhdlr = NULL;
455 eventhdlrdata = (SCIP_EVENTHDLRDATA*)sepadata;
457 eventExecIntobj, eventhdlrdata) );
458 assert(eventhdlr != NULL);
459
460 SCIP_CALL( SCIPsetEventhdlrInit(scip, eventhdlr, eventInitIntobj) );
461 SCIP_CALL( SCIPsetEventhdlrExit(scip, eventhdlr, eventExitIntobj) );
462
463 return SCIP_OKAY;
464}
#define EVENTHDLR_NAME
#define EVENTHDLR_DESC
#define NULL
Definition def.h:266
#define SCIP_Bool
Definition def.h:91
#define SCIP_Real
Definition def.h:172
#define TRUE
Definition def.h:93
#define FALSE
Definition def.h:94
#define SCIP_CALL(x)
Definition def.h:373
SCIP_Bool SCIPisStopped(SCIP *scip)
SCIP_RETCODE SCIPaddVar(SCIP *scip, SCIP_VAR *var)
Definition scip_prob.c:1668
int SCIPgetNVars(SCIP *scip)
Definition scip_prob.c:1992
SCIP_VAR ** SCIPgetVars(SCIP *scip)
Definition scip_prob.c:1947
SCIP_Bool SCIPallVarsInProb(SCIP *scip)
Definition scip_prob.c:2743
SCIP_Bool SCIPisObjIntegral(SCIP *scip)
Definition scip_prob.c:1562
SCIP_Real SCIPgetLocalLowerbound(SCIP *scip)
Definition scip_prob.c:3586
#define SCIPdebugMsg
int SCIPgetNLPBranchCands(SCIP *scip)
SCIP_RETCODE SCIPaddRow(SCIP *scip, SCIP_ROW *row, SCIP_Bool forcecut, SCIP_Bool *infeasible)
Definition scip_cut.c:250
SCIP_RETCODE SCIPincludeEventhdlrBasic(SCIP *scip, SCIP_EVENTHDLR **eventhdlrptr, const char *name, const char *desc, SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
Definition scip_event.c:104
SCIP_RETCODE SCIPsetEventhdlrExit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr,)
Definition scip_event.c:178
SCIP_EVENTHDLRDATA * SCIPeventhdlrGetData(SCIP_EVENTHDLR *eventhdlr)
Definition event.c:334
SCIP_RETCODE SCIPsetEventhdlrInit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr,)
Definition scip_event.c:164
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
Definition event.c:1030
SCIP_Real SCIPeventGetOldobj(SCIP_EVENT *event)
Definition event.c:1184
SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)
Definition event.c:1053
SCIP_Real SCIPeventGetNewobj(SCIP_EVENT *event)
Definition event.c:1201
SCIP_RETCODE SCIPcatchEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition scip_event.c:286
SCIP_RETCODE SCIPdropEvent(SCIP *scip, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition scip_event.c:320
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition scip_lp.c:168
SCIP_Real SCIPgetLPObjval(SCIP *scip)
Definition scip_lp.c:247
#define SCIPfreeBlockMemory(scip, ptr)
Definition scip_mem.h:108
#define SCIPallocBlockMemory(scip, ptr)
Definition scip_mem.h:89
SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition scip_lp.c:1635
SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)
Definition scip_lp.c:1658
SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)
Definition scip_lp.c:1701
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
Definition scip_lp.c:2212
SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)
Definition scip_lp.c:1562
SCIP_RETCODE SCIPcreateEmptyRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
Definition scip_lp.c:1453
SCIP_Bool SCIProwIsInLP(SCIP_ROW *row)
Definition lp.c:17523
SCIP_RETCODE SCIPincludeSepaBasic(SCIP *scip, SCIP_SEPA **sepa, const char *name, const char *desc, int priority, int freq, SCIP_Real maxbounddist, SCIP_Bool usessubscip, SCIP_Bool delay, SCIP_DECL_SEPAEXECLP((*sepaexeclp)), SCIP_DECL_SEPAEXECSOL((*sepaexecsol)), SCIP_SEPADATA *sepadata)
Definition scip_sepa.c:109
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa,)
Definition scip_sepa.c:167
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition sepa.c:743
SCIP_RETCODE SCIPsetSepaExitsol(SCIP *scip, SCIP_SEPA *sepa,)
Definition scip_sepa.c:231
SCIP_SEPADATA * SCIPsepaGetData(SCIP_SEPA *sepa)
Definition sepa.c:633
void SCIPsepaSetData(SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata)
Definition sepa.c:643
SCIP_RETCODE SCIPsetSepaCopy(SCIP *scip, SCIP_SEPA *sepa,)
Definition scip_sepa.c:151
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
Definition scip_sol.c:1343
SCIP_Real SCIPgetLowerbound(SCIP *scip)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Real SCIPfloor(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition scip_var.c:5326
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
Definition var.c:18143
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
Definition var.c:17925
void SCIPvarMarkRelaxationOnly(SCIP_VAR *var)
Definition var.c:17723
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
Definition scip_var.c:4382
const char * SCIPvarGetName(SCIP_VAR *var)
Definition var.c:17418
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition scip_var.c:1248
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
Definition var.c:18133
SCIP_RETCODE SCIPcreateVar(SCIP *scip, SCIP_VAR **var, const char *name, SCIP_Real lb, SCIP_Real ub, SCIP_Real obj, SCIP_VARTYPE vartype, SCIP_Bool initial, SCIP_Bool removable, SCIP_DECL_VARDELORIG((*vardelorig)), SCIP_DECL_VARTRANS((*vartrans)), SCIP_DECL_VARDELTRANS((*vardeltrans)), SCIP_DECL_VARCOPY((*varcopy)), SCIP_VARDATA *vardata)
Definition scip_var.c:114
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
Definition var.c:18077
SCIP_RETCODE SCIPincludeSepaIntobj(SCIP *scip)
return SCIP_OKAY
SCIP_Real objval
static SCIP_SOL * sol
SCIP_Real obj
assert(minobj< SCIPgetCutoffbound(scip))
int nvars
SCIP_VAR * var
static SCIP_VAR ** vars
public methods for managing events
public methods for LP management
public methods for message output
#define SCIPerrorMessage
Definition pub_message.h:64
#define SCIPdebug(x)
Definition pub_message.h:93
public methods for separators
public methods for problem variables
public methods for branching rule plugins and branching
public methods for cuts and aggregation rows
public methods for event handler plugins and event handlers
general public methods
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for numerical tolerances
public methods for global and local (sub)problems
public methods for separator plugins
public methods for solutions
public methods for querying solving statistics
public methods for SCIP variables
#define SEPA_PRIORITY
#define SEPA_DELAY
#define SEPA_DESC
#define SEPA_USESSUBSCIP
#define SEPA_MAXBOUNDDIST
#define SEPA_FREQ
#define SEPA_NAME
static SCIP_RETCODE sepadataCreate(SCIP *scip, SCIP_SEPADATA **sepadata)
Definition sepa_intobj.c:86
static SCIP_RETCODE separateCuts(SCIP *scip, SCIP_SEPA *sepa, SCIP_SOL *sol, SCIP_RESULT *result)
static SCIP_RETCODE sepadataFree(SCIP *scip, SCIP_SEPADATA **sepadata)
static SCIP_RETCODE createObjRow(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata)
integer objective value separator
struct SCIP_Eventhdlr SCIP_EVENTHDLR
Definition type_event.h:154
#define SCIP_DECL_EVENTEXIT(x)
Definition type_event.h:207
#define SCIP_EVENTTYPE_OBJCHANGED
Definition type_event.h:74
struct SCIP_EventhdlrData SCIP_EVENTHDLRDATA
Definition type_event.h:155
#define SCIP_DECL_EVENTEXEC(x)
Definition type_event.h:253
#define SCIP_DECL_EVENTINIT(x)
Definition type_event.h:199
#define SCIP_EVENTTYPE_FORMAT
Definition type_event.h:152
#define SCIP_EVENTTYPE_VARADDED
Definition type_event.h:70
struct SCIP_Row SCIP_ROW
Definition type_lp.h:104
@ SCIP_LPSOLSTAT_OPTIMAL
Definition type_lp.h:43
@ SCIP_DIDNOTRUN
Definition type_result.h:42
@ SCIP_CUTOFF
Definition type_result.h:48
@ SCIP_REDUCEDDOM
Definition type_result.h:51
@ SCIP_DIDNOTFIND
Definition type_result.h:44
@ SCIP_SEPARATED
Definition type_result.h:49
enum SCIP_Result SCIP_RESULT
Definition type_result.h:61
@ SCIP_INVALIDDATA
enum SCIP_Retcode SCIP_RETCODE
struct Scip SCIP
Definition type_scip.h:39
struct SCIP_SepaData SCIP_SEPADATA
Definition type_sepa.h:52
#define SCIP_DECL_SEPAEXECSOL(x)
Definition type_sepa.h:166
#define SCIP_DECL_SEPAEXECLP(x)
Definition type_sepa.h:136
#define SCIP_DECL_SEPAFREE(x)
Definition type_sepa.h:69
#define SCIP_DECL_SEPAEXITSOL(x)
Definition type_sepa.h:107
struct SCIP_Sepa SCIP_SEPA
Definition type_sepa.h:51
#define SCIP_DECL_SEPACOPY(x)
Definition type_sepa.h:61
struct SCIP_Sol SCIP_SOL
Definition type_sol.h:57
struct SCIP_Var SCIP_VAR
Definition type_var.h:119
@ SCIP_VARTYPE_IMPLINT
Definition type_var.h:64
@ SCIP_LOCKTYPE_MODEL
Definition type_var.h:97