Scippy

SCIP

Solving Constraint Integer Programs

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{
91 assert(sepadata != NULL);
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
113 SCIPfreeBlockMemory(scip, sepadata);
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;
131 SCIP_Real obj;
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,
143 SCIPvarMarkRelaxationOnly(sepadata->objvar);
144 SCIP_CALL( SCIPaddVar(scip, sepadata->objvar) );
145 SCIP_CALL( SCIPaddVarLocksType(scip, sepadata->objvar, SCIP_LOCKTYPE_MODEL, +1, +1) );
146 }
147 else
148 attendobjvarbound = TRUE;
149
150 /* get problem variables */
151 vars = SCIPgetVars(scip);
152 nvars = SCIPgetNVars(scip);
153
154 /* create objective value inequality */
155 if( attendobjvarbound )
156 intobjval = SCIPceil(scip, SCIPgetLowerbound(scip)) - SCIPvarGetLbGlobal(sepadata->objvar);
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
163 SCIP_CALL( SCIPcacheRowExtensions(scip, sepadata->objrow) );
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) );
173 SCIP_CALL( SCIPflushRowExtensions(scip, sepadata->objrow) );
174
175 SCIPdebugMsg(scip, "created objective value row: ");
176 SCIPdebug( SCIP_CALL( SCIPprintRow(scip, sepadata->objrow, NULL) ) );
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{
191 SCIP_SEPADATA* sepadata;
192 SCIP_Real objval;
193 SCIP_Real intbound;
194 SCIP_Bool infeasible;
195 SCIP_Bool tightened;
196
197 assert(result != NULL);
198 assert(*result == SCIP_DIDNOTRUN);
199
200 /* if the objective value may be fractional, we cannot do anything */
201 if( !SCIPisObjIntegral(scip) )
202 return SCIP_OKAY;
203
204 *result = SCIP_DIDNOTFIND;
205
206 /* if the current objective value is integral, there is no integral objective value cut */
207 if( sol == NULL )
208 objval = SCIPgetLPObjval(scip);
209 else
210 objval = SCIPgetSolTransObj(scip, sol);
211 if( SCIPisFeasIntegral(scip, objval) )
212 return SCIP_OKAY;
213
214 sepadata = SCIPsepaGetData(sepa);
215 assert(sepadata != NULL);
216
217 /* the objective value is fractional: create the objective value inequality, if not yet existing */
218 SCIP_CALL( createObjRow(scip, sepa, sepadata) );
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",
224 SCIPvarGetName(sepadata->objvar), SCIPvarGetLbLocal(sepadata->objvar), SCIPvarGetUbLocal(sepadata->objvar));
225
226 /* add the objective value inequality as a cut to the LP */
227 if( infeasible )
228 *result = SCIP_CUTOFF;
229 else
230 {
231 if( !SCIProwIsInLP(sepadata->objrow) )
232 {
233 SCIP_CALL( SCIPaddRow(scip, sepadata->objrow, FALSE, &infeasible) );
234 }
235 if ( infeasible )
236 *result = SCIP_CUTOFF;
237 else if ( tightened )
238 *result = SCIP_REDUCEDDOM;
239 else
240 *result = SCIP_SEPARATED;
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}*/
269 SCIP_SEPADATA* sepadata;
270
271 /* free separator data */
272 sepadata = SCIPsepaGetData(sepa);
273 assert(sepadata != NULL);
274
275 SCIP_CALL( sepadataFree(scip, &sepadata) );
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}*/
287 SCIP_SEPADATA* sepadata;
288
289 sepadata = SCIPsepaGetData(sepa);
290 assert(sepadata != NULL);
291
292 /* release objective row */
293 if( sepadata->objrow != NULL )
294 {
295 SCIP_CALL( SCIPreleaseRow(scip, &sepadata->objrow) );
296 }
297
298 /* release objective variable */
299 if( sepadata->objvar != NULL )
300 {
301 /* remove locks in createObjRow() */
302 SCIP_CALL( SCIPaddVarLocksType(scip, sepadata->objvar, SCIP_LOCKTYPE_MODEL, -1, -1) );
303 SCIP_CALL( SCIPreleaseVar(scip, &sepadata->objvar) );
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}*/
314 *result = SCIP_DIDNOTRUN;
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
328 SCIP_CALL( separateCuts(scip, sepa, NULL, result) );
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}*/
338 *result = SCIP_DIDNOTRUN;
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
348 SCIP_CALL( separateCuts(scip, sepa, sol, result) );
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;
383 SCIP_SEPADATA* sepadata;
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 {
404 SCIP_CALL( SCIPaddVarToRow(scip, sepadata->objrow, var, SCIPvarGetObj(var)) );
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{
432 SCIP_SEPADATA* sepadata;
433 SCIP_EVENTHDLRDATA* eventhdlrdata;
434 SCIP_SEPA* sepa;
435 SCIP_EVENTHDLR* eventhdlr;
436
437 /* create intobj separator data */
438 SCIP_CALL( sepadataCreate(scip, &sepadata) );
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 NULL
Definition: def.h:267
#define SCIP_Bool
Definition: def.h:91
#define SCIP_Real
Definition: def.h:173
#define TRUE
Definition: def.h:93
#define FALSE
Definition: def.h:94
#define SCIP_CALL(x)
Definition: def.h:374
SCIP_Bool SCIPisStopped(SCIP *scip)
Definition: scip_general.c:724
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:3585
#define SCIPdebugMsg
Definition: scip_message.h:78
int SCIPgetNLPBranchCands(SCIP *scip)
Definition: scip_branch.c:428
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_EVENTHDLRDATA * SCIPeventhdlrGetData(SCIP_EVENTHDLR *eventhdlr)
Definition: event.c:334
SCIP_RETCODE SCIPsetEventhdlrExit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTEXIT((*eventexit)))
Definition: scip_event.c:178
SCIP_RETCODE SCIPsetEventhdlrInit(SCIP *scip, SCIP_EVENTHDLR *eventhdlr, SCIP_DECL_EVENTINIT((*eventinit)))
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
const char * SCIPsepaGetName(SCIP_SEPA *sepa)
Definition: sepa.c:743
SCIP_RETCODE SCIPsetSepaFree(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAFREE((*sepafree)))
Definition: scip_sepa.c:167
SCIP_RETCODE SCIPsetSepaExitsol(SCIP *scip, SCIP_SEPA *sepa, SCIP_DECL_SEPAEXITSOL((*sepaexitsol)))
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, SCIP_DECL_SEPACOPY((*sepacopy)))
Definition: scip_sepa.c:151
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip_sol.c:1347
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:5203
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
Definition: var.c:18144
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
Definition: var.c:17926
void SCIPvarMarkRelaxationOnly(SCIP_VAR *var)
Definition: var.c:17724
SCIP_RETCODE SCIPaddVarLocksType(SCIP *scip, SCIP_VAR *var, SCIP_LOCKTYPE locktype, int nlocksdown, int nlocksup)
Definition: scip_var.c:4259
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:17419
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition: scip_var.c:1248
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
Definition: var.c:18134
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:18078
SCIP_RETCODE SCIPincludeSepaIntobj(SCIP *scip)
Definition: sepa_intobj.c:428
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
Definition: sepa_intobj.c:57
static SCIP_RETCODE sepadataCreate(SCIP *scip, SCIP_SEPADATA **sepadata)
Definition: sepa_intobj.c:86
#define SEPA_DELAY
Definition: sepa_intobj.c:61
#define SEPA_DESC
Definition: sepa_intobj.c:56
#define SEPA_USESSUBSCIP
Definition: sepa_intobj.c:60
static SCIP_DECL_SEPACOPY(sepaCopyIntobj)
Definition: sepa_intobj.c:253
static SCIP_DECL_SEPAFREE(sepaFreeIntobj)
Definition: sepa_intobj.c:267
static SCIP_DECL_EVENTEXIT(eventExitIntobj)
Definition: sepa_intobj.c:370
static SCIP_DECL_SEPAEXECSOL(sepaExecsolIntobj)
Definition: sepa_intobj.c:336
static SCIP_RETCODE separateCuts(SCIP *scip, SCIP_SEPA *sepa, SCIP_SOL *sol, SCIP_RESULT *result)
Definition: sepa_intobj.c:184
static SCIP_RETCODE sepadataFree(SCIP *scip, SCIP_SEPADATA **sepadata)
Definition: sepa_intobj.c:103
#define SEPA_MAXBOUNDDIST
Definition: sepa_intobj.c:59
#define SEPA_FREQ
Definition: sepa_intobj.c:58
static SCIP_DECL_SEPAEXECLP(sepaExeclpIntobj)
Definition: sepa_intobj.c:312
#define SEPA_NAME
Definition: sepa_intobj.c:55
#define EVENTHDLR_DESC
Definition: sepa_intobj.c:64
static SCIP_RETCODE createObjRow(SCIP *scip, SCIP_SEPA *sepa, SCIP_SEPADATA *sepadata)
Definition: sepa_intobj.c:120
static SCIP_DECL_EVENTEXEC(eventExecIntobj)
Definition: sepa_intobj.c:380
static SCIP_DECL_SEPAEXITSOL(sepaExitsolIntobj)
Definition: sepa_intobj.c:285
static SCIP_DECL_EVENTINIT(eventInitIntobj)
Definition: sepa_intobj.c:361
#define EVENTHDLR_NAME
Definition: sepa_intobj.c:63
integer objective value separator
#define SCIP_EVENTTYPE_OBJCHANGED
Definition: type_event.h:74
struct SCIP_EventhdlrData SCIP_EVENTHDLRDATA
Definition: type_event.h:155
#define SCIP_EVENTTYPE_FORMAT
Definition: type_event.h:152
#define SCIP_EVENTTYPE_VARADDED
Definition: type_event.h:70
@ 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
Definition: type_retcode.h:52
@ SCIP_OKAY
Definition: type_retcode.h:42
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
struct SCIP_SepaData SCIP_SEPADATA
Definition: type_sepa.h:52
@ SCIP_VARTYPE_IMPLINT
Definition: type_var.h:64
@ SCIP_LOCKTYPE_MODEL
Definition: type_var.h:97