Scippy

SCIP

Solving Constraint Integer Programs

heur_bound.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-2020 Konrad-Zuse-Zentrum */
7 /* fuer Informationstechnik Berlin */
8 /* */
9 /* SCIP is distributed under the terms of the ZIB Academic License. */
10 /* */
11 /* You should have received a copy of the ZIB Academic License */
12 /* along with SCIP; see the file COPYING. If not visit scipopt.org. */
13 /* */
14 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
15 
16 /**@file heur_bound.c
17  * @ingroup DEFPLUGINS_HEUR
18  * @brief heuristic which fixes all integer variables to a bound (lower/upper) and solves the remaining LP
19  * @author Gerald Gamrath
20  *
21  */
22 
23 /*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
24 
25 #include "scip/heur_bound.h"
26 #include "scip/pub_heur.h"
27 #include "scip/pub_message.h"
28 #include "scip/pub_tree.h"
29 #include "scip/pub_var.h"
30 #include "scip/scip_branch.h"
31 #include "scip/scip_general.h"
32 #include "scip/scip_heur.h"
33 #include "scip/scip_lp.h"
34 #include "scip/scip_mem.h"
35 #include "scip/scip_message.h"
36 #include "scip/scip_numerics.h"
37 #include "scip/scip_param.h"
38 #include "scip/scip_prob.h"
39 #include "scip/scip_probing.h"
40 #include "scip/scip_sol.h"
41 #include "scip/scip_solvingstats.h"
42 #include "scip/scip_timing.h"
43 #include "scip/scip_tree.h"
44 #include <string.h>
45 
46 #ifdef SCIP_STATISTIC
47 #include "scip/clock.h"
48 #endif
49 
50 #define HEUR_NAME "bound"
51 #define HEUR_DESC "heuristic which fixes all integer variables to a bound and solves the remaining LP"
52 #define HEUR_DISPCHAR SCIP_HEURDISPCHAR_PROP
53 #define HEUR_PRIORITY -1107000
54 #define HEUR_FREQ -1
55 #define HEUR_FREQOFS 0
56 #define HEUR_MAXDEPTH -1
57 #define HEUR_TIMING SCIP_HEURTIMING_BEFORENODE
58 #define HEUR_USESSUBSCIP FALSE /**< does the heuristic use a secondary SCIP instance? */
59 
60 #define DEFAULT_ONLYWITHOUTSOL TRUE /**< Should heuristic only be executed if no primal solution was found, yet? */
61 #define DEFAULT_MAXPROPROUNDS 0 /* maximum number of propagation rounds during probing */
62 #define DEFAULT_BOUND 'l' /**< to which bound should integer variables be fixed? */
63 
64 
65 /*
66  * Data structures
67  */
68 
69 /** primal heuristic data */
70 struct SCIP_HeurData
71 {
72  SCIP_Bool onlywithoutsol; /**< Should heuristic only be executed if no primal solution was found, yet? */
73  int maxproprounds; /**< maximum number of propagation rounds during probing */
74  char bound; /**< to which bound should integer variables be fixed? */
75 };
76 
77 /*
78  * Local methods
79  */
80 
81 /** main procedure of the bound heuristic */
82 static
84  SCIP* scip, /**< original SCIP data structure */
85  SCIP_HEUR* heur, /**< heuristic */
86  SCIP_HEURDATA* heurdata, /**< heuristic data structure */
87  SCIP_Bool lower, /**< should integer variables be fixed to their lower bound? */
88  SCIP_RESULT* result /**< pointer to store the result */
89  )
90 {
91  SCIP_VAR** vars;
92  SCIP_VAR* var;
93  SCIP_Bool infeasible = FALSE;
94  int maxproprounds;
95  int nbinvars;
96  int nintvars;
97  int nvars;
98  int v;
99 
100  /* get variable data of original problem */
101  SCIP_CALL( SCIPgetVarsData(scip, &vars, NULL, &nbinvars, &nintvars, NULL, NULL) );
102 
103  maxproprounds = heurdata->maxproprounds;
104  if( maxproprounds == -2 )
105  maxproprounds = 0;
106 
107  /* only look at binary and integer variables */
108  nvars = nbinvars + nintvars;
109 
110  /* stop if we would have infinite fixings */
111  if( lower )
112  {
113  for( v = 0; v < nvars; ++v )
114  {
115  if( SCIPisInfinity(scip, -SCIPvarGetLbLocal(vars[v])) )
116  return SCIP_OKAY;
117  }
118  }
119  else
120  {
121  for( v = 0; v < nvars; ++v )
122  {
123  if( SCIPisInfinity(scip, SCIPvarGetUbLocal(vars[v])) )
124  return SCIP_OKAY;
125  }
126  }
127 
128  /* start probing */
129  SCIP_CALL( SCIPstartProbing(scip) );
130 
131  for( v = 0; v < nvars; ++v )
132  {
133  var = vars[v];
134 
135  assert(SCIPvarGetType(var) < SCIP_VARTYPE_IMPLINT);
136 
137  /* skip variables which are already fixed */
138  if( SCIPvarGetLbLocal(var) + 0.5 > SCIPvarGetUbLocal(var) )
139  continue;
140 
141  /* fix variable to lower bound */
142  if( lower )
143  {
144  SCIP_CALL( SCIPfixVarProbing(scip, var, SCIPvarGetLbLocal(var)) );
145  SCIPdebugMsg(scip, "fixing %d: variable <%s> to lower bound <%g> (%d pseudo cands)\n",
147  }
148  /* fix variable to upper bound */
149  else
150  {
151  SCIP_CALL( SCIPfixVarProbing(scip, var, SCIPvarGetUbLocal(var)) );
152  SCIPdebugMsg(scip, "fixing %d: variable <%s> to upper bound <%g> (%d pseudo cands)\n",
154  }
155 
156  /* propagate fixings */
157  if( heurdata->maxproprounds != 0 )
158  {
159  SCIP_CALL( SCIPpropagateProbing(scip, maxproprounds, &infeasible, NULL) );
160  }
161 
162  /* try to repair probing */
163  if( infeasible )
164  {
165 #if 0
167 
168  /* fix the last variable, which was fixed the reverse bound */
169  SCIP_CALL( SCIPfixVarProbing(scip, var, SCIPvarGetUbLocal(var)) );
170 
171  /* propagate fixings */
172  SCIP_CALL( SCIPpropagateProbing(scip, maxproprounds, &infeasible, NULL) );
173 
174  SCIPdebugMsg(scip, "backtracking ended with %sfeasible problem\n", (infeasible ? "in" : ""));
175 
176  if( infeasible )
177 #endif
178  break;
179  }
180  }
181 
182  SCIPdebugMsg(scip, "probing ended with %sfeasible problem\n", infeasible ? "in" : "");
183 
184  /*************************** Probing LP Solving ***************************/
185 
186  /* solve lp only if the problem is still feasible */
187  if( !infeasible )
188  {
189  char strbuf[SCIP_MAXSTRLEN];
190  SCIP_LPSOLSTAT lpstatus;
191  SCIP_Bool lperror;
192 
193  SCIPdebugMsg(scip, "starting solving bound-heur LP at time %g, LP iterations: %" SCIP_LONGINT_FORMAT "\n",
195 
196  /* print probing stats before LP */
197  SCIPverbMessage(scip, SCIP_VERBLEVEL_FULL, NULL, "Heuristic " HEUR_NAME " probing LP: %s\n",
199 
200  /* solve LP; errors in the LP solver should not kill the overall solving process, if the LP is just needed for a
201  * heuristic. hence in optimized mode, the return code is caught and a warning is printed, only in debug mode,
202  * SCIP will stop.
203  */
204 #ifdef NDEBUG
205  {
206  SCIP_Bool retstat;
207  retstat = SCIPsolveProbingLP(scip, -1, &lperror, NULL);
208  if( retstat != SCIP_OKAY )
209  {
210  SCIPwarningMessage(scip, "Error while solving LP in bound heuristic; LP solve terminated with code <%d>\n",
211  retstat);
212  }
213  }
214 #else
215  SCIP_CALL( SCIPsolveProbingLP(scip, -1, &lperror, NULL) );
216 #endif
217  SCIPdebugMsg(scip, "ending solving bound-heur LP at time %g\n", SCIPgetSolvingTime(scip));
218 
219  lpstatus = SCIPgetLPSolstat(scip);
220 
221  SCIPdebugMsg(scip, " -> new LP iterations: %" SCIP_LONGINT_FORMAT "\n", SCIPgetNLPIterations(scip));
222  SCIPdebugMsg(scip, " -> error=%u, status=%d\n", lperror, lpstatus);
223 
224  /* check if this is a feasible solution */
225  if( lpstatus == SCIP_LPSOLSTAT_OPTIMAL && !lperror )
226  {
227  SCIP_SOL* newsol;
228  SCIP_Bool stored;
229  SCIP_Bool success;
230 
231  /* create temporary solution */
232  SCIP_CALL( SCIPcreateSol(scip, &newsol, heur) );
233 
234  /* copy the current LP solution to the working solution */
235  SCIP_CALL( SCIPlinkLPSol(scip, newsol) );
236 
237  SCIP_CALL( SCIProundSol(scip, newsol, &success) );
238 
239  if( success )
240  {
241  SCIPdebugMsg(scip, "bound heuristic found roundable primal solution: obj=%g\n",
242  SCIPgetSolOrigObj(scip, newsol));
243 
244  /* check solution for feasibility, and add it to solution store if possible.
245  * Neither integrality nor feasibility of LP rows have to be checked, because they
246  * are guaranteed by the heuristic at this stage.
247  */
248 #ifdef SCIP_DEBUG
249  SCIP_CALL( SCIPtrySol(scip, newsol, TRUE, TRUE, TRUE, TRUE, TRUE, &stored) );
250 #else
251  SCIP_CALL( SCIPtrySol(scip, newsol, FALSE, FALSE, TRUE, FALSE, FALSE, &stored) );
252 #endif
253 
254  if( stored )
255  {
256  SCIPdebugMsg(scip, "found feasible solution:\n");
257  *result = SCIP_FOUNDSOL;
258  }
259  }
260 
261  /* free solution */
262  SCIP_CALL( SCIPfreeSol(scip, &newsol) );
263  }
264  }
265 
266  /* exit probing mode */
267  SCIP_CALL( SCIPendProbing(scip) );
268 
269  return SCIP_OKAY;
270 }
271 
272 
273 /*
274  * Callback methods of primal heuristic
275  */
276 
277 /** copy method for primal heuristic plugins (called when SCIP copies plugins) */
278 static
279 SCIP_DECL_HEURCOPY(heurCopyBound)
280 { /*lint --e{715}*/
281  assert(scip != NULL);
282  assert(heur != NULL);
283  assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
284 
285  /* call inclusion method of heuristic */
287 
288  return SCIP_OKAY;
289 }
290 
291 /** destructor of primal heuristic to free user data (called when SCIP is exiting) */
292 static
293 SCIP_DECL_HEURFREE(heurFreeBound)
294 { /*lint --e{715}*/
295  SCIP_HEURDATA* heurdata;
296 
297  /* free heuristic data */
298  heurdata = SCIPheurGetData(heur);
299 
300  SCIPfreeBlockMemory(scip, &heurdata);
301  SCIPheurSetData(heur, NULL);
302 
303  return SCIP_OKAY;
304 }
305 
306 /** execution method of primal heuristic */
307 static
308 SCIP_DECL_HEUREXEC(heurExecBound)
309 { /*lint --e{715}*/
310  SCIP_HEURDATA* heurdata;
311 
312  assert(heur != NULL);
313  assert(scip != NULL);
314  assert(result != NULL);
315 
316  *result = SCIP_DIDNOTRUN;
317 
318  if( SCIPgetNPseudoBranchCands(scip) == 0 )
319  return SCIP_OKAY;
320 
321  if( !SCIPhasCurrentNodeLP(scip) )
322  return SCIP_OKAY;
323 
324  heurdata = SCIPheurGetData(heur);
325  assert(heurdata != NULL);
326 
327  *result = SCIP_DIDNOTFIND;
328 
329  if( SCIPisStopped(scip) )
330  return SCIP_OKAY;
331 
332  /* stop execution method if there is already a primal feasible solution at hand */
333  if( SCIPgetBestSol(scip) != NULL && heurdata->onlywithoutsol )
334  return SCIP_OKAY;
335 
336  SCIPdebugMsg(scip, "apply bound heuristic at node %lld\n",
338 
339  if( !SCIPisLPConstructed(scip) )
340  {
341  SCIP_Bool cutoff;
342 
343  SCIP_CALL( SCIPconstructLP(scip, &cutoff) );
344 
345  /* manually cut off the node if the LP construction detected infeasibility (heuristics cannot return such a result) */
346  if( cutoff )
347  {
349  return SCIP_OKAY;
350  }
351 
353  }
354 
355  if( heurdata->bound == 'l' || heurdata->bound == 'b' )
356  {
357  SCIP_CALL(applyBoundHeur(scip, heur, heurdata, TRUE, result) );
358  }
359  if( heurdata->bound == 'u' || heurdata->bound == 'b' )
360  {
361  SCIP_CALL(applyBoundHeur(scip, heur, heurdata, FALSE, result) );
362  }
363 
364  return SCIP_OKAY;
365 }
366 
367 /*
368  * primal heuristic specific interface methods
369  */
370 
371 /** creates the bound primal heuristic and includes it in SCIP */
373  SCIP* scip /**< SCIP data structure */
374  )
375 {
376  SCIP_HEURDATA* heurdata;
377  SCIP_HEUR* heur;
378 
379  /* create bound primal heuristic data */
380  SCIP_CALL( SCIPallocBlockMemory(scip, &heurdata) );
381 
382  /* include primal heuristic */
383  SCIP_CALL( SCIPincludeHeurBasic(scip, &heur,
385  HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP, heurExecBound, heurdata) );
386 
387  assert(heur != NULL);
388 
389  /* set non-NULL pointers to callback methods */
390  SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopyBound) );
391  SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeBound) );
392 
393  /* add bound heuristic parameters */
394 
395  SCIP_CALL( SCIPaddBoolParam(scip, "heuristics/" HEUR_NAME "/onlywithoutsol",
396  "Should heuristic only be executed if no primal solution was found, yet?",
397  &heurdata->onlywithoutsol, TRUE, DEFAULT_ONLYWITHOUTSOL, NULL, NULL) );
398 
399  SCIP_CALL( SCIPaddIntParam(scip, "heuristics/" HEUR_NAME "/maxproprounds",
400  "maximum number of propagation rounds during probing (-1 infinity, -2 parameter settings)",
401  &heurdata->maxproprounds, TRUE, DEFAULT_MAXPROPROUNDS, -1, INT_MAX/4, NULL, NULL) );
402 
403  SCIP_CALL( SCIPaddCharParam(scip, "heuristics/" HEUR_NAME "/bound",
404  "to which bound should integer variables be fixed? ('l'ower, 'u'pper, or 'b'oth)",
405  &heurdata->bound, FALSE, DEFAULT_BOUND, "lub", NULL, NULL) );
406 
407  return SCIP_OKAY;
408 }
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:52
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
Definition: scip_sol.c:977
SCIP_RETCODE SCIProundSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *success)
Definition: scip_sol.c:2447
SCIP_Bool SCIPisStopped(SCIP *scip)
Definition: scip_general.c:687
#define HEUR_PRIORITY
Definition: heur_bound.c:53
static SCIP_DECL_HEURCOPY(heurCopyBound)
Definition: heur_bound.c:279
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:1429
public methods for SCIP parameter handling
public methods for branch and bound tree
SCIP_RETCODE SCIPfixVarProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval)
Definition: scip_probing.c:409
static SCIP_DECL_HEUREXEC(heurExecBound)
Definition: heur_bound.c:308
public methods for memory management
SCIP_HEURDATA * SCIPheurGetData(SCIP_HEUR *heur)
Definition: heur.c:1340
#define DEFAULT_MAXPROPROUNDS
Definition: heur_bound.c:61
#define SCIP_MAXSTRLEN
Definition: def.h:273
#define HEUR_DESC
Definition: heur_bound.c:51
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
Definition: scip_message.c:123
internal methods for clocks and timing issues
static long bound
#define HEUR_FREQ
Definition: heur_bound.c:54
SCIP_EXPORT SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
Definition: tree.c:7429
public methods for timing
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
Definition: scip_tree.c:81
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip_timing.c:360
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
Definition: scip_message.c:216
#define FALSE
Definition: def.h:73
char * SCIPsnprintfProbingStats(SCIP *scip, char *strbuf, int len)
SCIP_EXPORT SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
Definition: var.c:17182
#define TRUE
Definition: def.h:72
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:54
SCIP_RETCODE SCIPlinkLPSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip_sol.c:1018
SCIP_Bool SCIPisLPConstructed(SCIP *scip)
Definition: scip_lp.c:92
SCIP_RETCODE SCIPcutoffNode(SCIP *scip, SCIP_NODE *node)
Definition: scip_tree.c:424
struct SCIP_HeurData SCIP_HEURDATA
Definition: type_heur.h:67
public methods for problem variables
SCIP_RETCODE SCIPaddBoolParam(SCIP *scip, const char *name, const char *desc, SCIP_Bool *valueptr, SCIP_Bool isadvanced, SCIP_Bool defaultvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:48
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:95
#define HEUR_FREQOFS
Definition: heur_bound.c:55
enum SCIP_LPSolStat SCIP_LPSOLSTAT
Definition: type_lp.h:42
#define SCIPallocBlockMemory(scip, ptr)
Definition: scip_mem.h:78
SCIP_RETCODE SCIPtrySol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
Definition: scip_sol.c:3126
#define SCIPdebugMsg
Definition: scip_message.h:69
#define HEUR_DISPCHAR
Definition: heur_bound.c:52
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip_lp.c:159
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
Definition: scip_lp.c:74
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
public methods for numerical tolerances
SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip_sol.c:320
public methods for querying solving statistics
SCIP_RETCODE SCIPincludeHeurBasic(SCIP *scip, SCIP_HEUR **heur, const char *name, const char *desc, char dispchar, int priority, int freq, int freqofs, int maxdepth, SCIP_HEURTIMING timingmask, SCIP_Bool usessubscip, SCIP_DECL_HEUREXEC((*heurexec)), SCIP_HEURDATA *heurdata)
Definition: scip_heur.c:108
public methods for the branch-and-bound tree
int SCIPgetNPseudoBranchCands(SCIP *scip)
Definition: scip_branch.c:749
static SCIP_RETCODE applyBoundHeur(SCIP *scip, SCIP_HEUR *heur, SCIP_HEURDATA *heurdata, SCIP_Bool lower, SCIP_RESULT *result)
Definition: heur_bound.c:83
#define DEFAULT_BOUND
Definition: heur_bound.c:62
SCIP_EXPORT const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:17017
int SCIPgetProbingDepth(SCIP *scip)
Definition: scip_probing.c:189
void SCIPheurSetData(SCIP_HEUR *heur, SCIP_HEURDATA *heurdata)
Definition: heur.c:1350
#define NULL
Definition: lpi_spx1.cpp:155
SCIP_RETCODE SCIPendProbing(SCIP *scip)
Definition: scip_probing.c:251
#define HEUR_MAXDEPTH
Definition: heur_bound.c:56
#define SCIP_CALL(x)
Definition: def.h:364
static SCIP_DECL_HEURFREE(heurFreeBound)
Definition: heur_bound.c:293
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
Definition: scip_probing.c:216
#define DEFAULT_ONLYWITHOUTSOL
Definition: heur_bound.c:60
#define HEUR_USESSUBSCIP
Definition: heur_bound.c:58
public methods for primal heuristic plugins and divesets
#define HEUR_NAME
Definition: heur_bound.c:50
#define SCIP_Bool
Definition: def.h:70
SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)
Definition: scip_lp.c:115
SCIP_RETCODE SCIPincludeHeurBound(SCIP *scip)
Definition: heur_bound.c:372
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
Definition: scip_probing.c:571
SCIP_RETCODE SCIPflushLP(SCIP *scip)
Definition: scip_lp.c:139
SCIP_EXPORT SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
Definition: var.c:17723
public methods for the LP relaxation, rows and columns
SCIP_EXPORT SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
Definition: var.c:17733
public methods for branching rule plugins and branching
general public methods
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
public methods for solutions
public methods for the probing mode
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
Definition: scip_heur.c:153
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
Definition: scip_probing.c:110
public methods for message output
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip_prob.c:1860
SCIP_RETCODE SCIPaddIntParam(SCIP *scip, const char *name, const char *desc, int *valueptr, SCIP_Bool isadvanced, int defaultvalue, int minvalue, int maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:74
public methods for message handling
#define HEUR_TIMING
Definition: heur_bound.c:57
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
Definition: scip_heur.c:169
public methods for primal heuristics
public methods for global and local (sub)problems
SCIP_RETCODE SCIPaddCharParam(SCIP *scip, const char *name, const char *desc, char *valueptr, SCIP_Bool isadvanced, char defaultvalue, const char *allowedvalues, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:158
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
Definition: scip_sol.c:2305
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
Definition: scip_probing.c:810
heuristic which fixes all integer variables to a bound (lower/upper) and solves the remaining LP ...
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip_sol.c:1436