Scippy

SCIP

Solving Constraint Integer Programs

heur_subnlp.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-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 heur_subnlp.c
26 * @ingroup DEFPLUGINS_HEUR
27 * @brief NLP local search primal heuristic using sub-SCIPs
28 * @author Stefan Vigerske
29 *
30 * @todo reconstruct sub-SCIP if problem has changed
31 */
32
33/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
34
35#include "blockmemshell/memory.h"
36#include "scip/nlpi_ipopt.h"
37#include "scip/cons_bounddisjunction.h"
38#include "scip/cons_setppc.h"
39#include "scip/heur_subnlp.h"
40#include "scip/pub_event.h"
41#include "scip/pub_heur.h"
42#include "scip/pub_message.h"
43#include "scip/pub_misc.h"
44#include "scip/pub_sol.h"
45#include "scip/pub_var.h"
46#include "scip/scip_branch.h"
47#include "scip/scip_cons.h"
48#include "scip/scip_copy.h"
49#include "scip/scip_event.h"
50#include "scip/scip_general.h"
51#include "scip/scip_heur.h"
52#include "scip/scip_lp.h"
53#include "scip/scip_mem.h"
54#include "scip/scip_message.h"
55#include "scip/scip_nlp.h"
56#include "scip/scip_nlpi.h"
57#include "scip/scip_numerics.h"
58#include "scip/scip_param.h"
59#include "scip/scip_presol.h"
60#include "scip/scip_pricer.h"
61#include "scip/scip_prob.h"
62#include "scip/scip_sol.h"
63#include "scip/scip_solve.h"
64#include "scip/scip_solvingstats.h"
65#include "scip/scip_timing.h"
66#include "scip/scip_var.h"
67#include <string.h>
68
69#define HEUR_NAME "subnlp"
70#define HEUR_DESC "primal heuristic that performs a local search in an NLP after fixing integer variables and presolving"
71#define HEUR_DISPCHAR SCIP_HEURDISPCHAR_LNS
72#define HEUR_PRIORITY -2000010
73#define HEUR_FREQ 1
74#define HEUR_FREQOFS 0
75#define HEUR_MAXDEPTH -1
76#define HEUR_TIMING SCIP_HEURTIMING_AFTERNODE
77#define HEUR_USESSUBSCIP FALSE /**< does the heuristic use a secondary SCIP instance? we set this to FALSE because we want this heuristic to also run within other heuristics */
78
79/*
80 * Data structures
81 */
82
83/** primal heuristic data */
84struct SCIP_HeurData
85{
86 SCIP* subscip; /**< copy of CIP where presolving and NLP solving is done */
87 SCIP_Bool triedsetupsubscip; /**< whether we have tried to setup a sub-SCIP */
88 SCIP_Bool subscipisvalid; /**< whether all constraints have been copied */
89 SCIP_Bool continuous; /**< whether problem was continuous when sub-SCIP was created */
90 int nseriousnlpierror; /**< number of consecutive serious NLP solver failures (memout, ...) */
91 SCIP_EVENTHDLR* eventhdlr; /**< event handler for global bound change events */
92
93 int nvars; /**< number of active transformed variables in SCIP */
94 int nsubvars; /**< number of original variables in sub-SCIP */
95 SCIP_VAR** var_subscip2scip; /**< mapping variables in sub-SCIP to SCIP variables */
96 SCIP_VAR** var_scip2subscip; /**< mapping variables in SCIP to sub-SCIP variables */
97
98 SCIP_SOL* startcand; /**< candidate for start point for heuristic */
99 SCIP_Real startcandviol; /**< violation of start point candidate w.r.t. constraint that reported this candidate */
100 SCIP_SOL* lastsol; /**< pointer to last found solution (or NULL if none), not captured, thus may be dangling */
101
102 int nlpverblevel; /**< verbosity level of NLP solver */
103 SCIP_Real opttol; /**< optimality tolerance to use for NLP solves */
104 SCIP_Real feastolfactor; /**< factor on SCIP feasibility tolerance for NLP solves if resolving when NLP solution not feasible in CIP */
105 SCIP_Real feastol; /**< feasibility tolerance for NLP solves */
106 SCIP_Bool tighterfeastolfailed;/**< whether we tried to use a tighter feasibility tolerance but the NLP solution was still not accepted */
107 int maxpresolverounds; /**< limit on number of presolve rounds in sub-SCIP */
108 int presolveemphasis; /**< presolve emphasis in sub-SCIP */
109 SCIP_Bool setcutoff; /**< whether to set cutoff in sub-SCIP to current primal bound */
110 SCIP_Bool forbidfixings; /**< whether to add constraints that forbid specific fixations that turned out to be infeasible */
111 SCIP_Bool keepcopy; /**< whether to keep SCIP copy or to create new copy each time heuristic is applied */
112 SCIP_Real expectinfeas; /**< when to tell NLP solver that an infeasible NLP is not unexpected */
113
114 SCIP_Longint iterused; /**< number of iterations used so far (+ number of heuristic runs + number of presolve runs in subscip) */
115 SCIP_Longint iterusedokay; /**< number of iterations used so far when NLP stopped with status okay */
116 SCIP_Longint iterusediterlim; /**< maximal number of iterations used when NLP stopped due to iteration limit */
117 int nnlpsolves; /**< number of NLP solves */
118 int nnlpsolvesokay; /**< number of NLP solves with status okay */
119 int nnlpsolvesiterlim; /**< number of NLP solves that hit an iteration limit */
120 int nnlpsolvesinfeas; /**< number of NLP solves with status okay and infeasible */
121 int nodesoffset; /**< number of nodes added to the actual number of nodes when computing itercontingent */
122 SCIP_Real nodesfactor; /**< factor to apply to number of nodes in SCIP to compute initial itercontingent */
123 SCIP_Real successrateexp; /**< exponent for power of success rate to be multiplied with itercontingent */
124 int iterinit; /**< number of iterations used for initial NLP solves */
125 int ninitsolves; /**< number of successful NLP solves until switching to iterlimit guess and using success rate */
126 int itermin; /**< minimal number of iterations for NLP solves */
127 SCIP_HEURTIMING inittiming; /**< initial heuristic timing */
128};
129
130
131/*
132 * Local methods
133 */
134
135/** free sub-SCIP data structure */
136static
137SCIP_RETCODE freeSubSCIP(
138 SCIP* scip, /**< SCIP data structure */
139 SCIP_HEURDATA* heurdata /**< heuristic data structure */
140 )
141{
142 SCIP_VAR** subvars;
143 int nsubvars;
144 int i;
145 SCIP_VAR* var;
146 SCIP_VAR* subvar;
147
148 assert(scip != NULL);
149 assert(heurdata != NULL);
150
151 assert(heurdata->subscip != NULL);
152
153 SCIP_CALL( SCIPgetOrigVarsData(heurdata->subscip, &subvars, &nsubvars, NULL, NULL, NULL, NULL) );
154 assert(nsubvars == heurdata->nsubvars);
155
156 /* drop global bound change events
157 * release variables in SCIP and sub-SCIP
158 */
159 for( i = 0; i < heurdata->nsubvars; ++i )
160 {
161 subvar = subvars[i];
162 assert(subvar != NULL);
163 assert(SCIPvarGetProbindex(subvar) == i);
164
165 var = heurdata->var_subscip2scip[SCIPvarGetProbindex(subvar)];
166 assert(var != NULL);
167 assert(SCIPvarGetProbindex(var) <= heurdata->nvars);
168 assert(!SCIPvarIsActive(var) || heurdata->var_scip2subscip[SCIPvarGetProbindex(var)] == subvar);
169
170 SCIP_CALL( SCIPdropVarEvent(scip, var, SCIP_EVENTTYPE_GBDCHANGED, heurdata->eventhdlr, (SCIP_EVENTDATA*)heurdata, -1) );
171
172 SCIP_CALL( SCIPreleaseVar(heurdata->subscip, &subvar) );
173 SCIP_CALL( SCIPreleaseVar(scip, &var) );
174 }
175
176 /* free variable mappings subscip -> scip and scip -> subscip */
177 SCIPfreeBlockMemoryArray(scip, &heurdata->var_subscip2scip, heurdata->nsubvars);
178 SCIPfreeBlockMemoryArray(scip, &heurdata->var_scip2subscip, heurdata->nvars);
179 heurdata->nsubvars = 0;
180 heurdata->nvars = 0;
181
182 /* free sub-SCIP */
183 SCIP_CALL( SCIPfree(&heurdata->subscip) );
184
185 return SCIP_OKAY;
186}
187
188/** creates copy of CIP from problem in SCIP */
189static
190SCIP_RETCODE createSubSCIP(
191 SCIP* scip, /**< SCIP data structure */
192 SCIP_HEURDATA* heurdata /**< heuristic data structure */
193 )
194{
195 int nvars;
196 SCIP_VAR** vars;
197 SCIP_VAR** subvars;
198 SCIP_VAR* var;
199 SCIP_VAR* subvar;
200 SCIP_Bool success;
201 char probname[SCIP_MAXSTRLEN];
202 int i;
203 SCIP_HASHMAP* varsmap;
204 SCIP_HASHMAP* conssmap;
205
206 assert(heurdata != NULL);
207 assert(heurdata->subscip == NULL);
208
209 heurdata->triedsetupsubscip = TRUE;
210
211 /* initializing the subproblem */
212 SCIP_CALL( SCIPcreate(&heurdata->subscip) );
213
214 /* create sub-SCIP copy of CIP */
215
216 /* copy interesting plugins */
217 success = TRUE;
218 SCIP_CALL( SCIPcopyPlugins(scip, heurdata->subscip,
219 FALSE, /* readers */
220 FALSE, /* pricers */
221 TRUE, /* conshdlrs */
222 FALSE, /* conflicthdlrs */
223 TRUE, /* presolvers */
224 FALSE, /* relaxators */
225 FALSE, /* separators */
226 FALSE, /* cutselectors */
227 TRUE, /* propagators */
228 FALSE, /* heuristics */
229 TRUE, /* eventhandler */
230 TRUE, /* nodeselectors (SCIP gives an error if there is none) */
231 FALSE, /* branchrules */
232 FALSE, /* iis */
233 TRUE, /* displays */
234 FALSE, /* tables */
235 FALSE, /* dialogs */
236 TRUE, /* expression handlers */
237 TRUE, /* nlpis */
238 TRUE, /* message handler */
239 &success) );
240 if( !success )
241 {
242 SCIPdebugMsg(scip, "failed to copy some plugins to sub-SCIP, continue anyway\n");
243 }
244
245 /* check if we still have NLPI's in subscip */
246 if( SCIPgetNNlpis(heurdata->subscip) <= 0 )
247 {
248 SCIPdebugMsg(scip, "none of the NLPIs from main SCIP copied into sub-SCIP, give up heuristic.\n");
249 SCIP_CALL( SCIPfree(&heurdata->subscip) );
250
251 return SCIP_OKAY;
252 }
253
254 /* copy parameter settings */
255 SCIP_CALL( SCIPcopyParamSettings(scip, heurdata->subscip) );
256
257 /* create problem in sub-SCIP */
258 /* get name of the original problem and add "subnlp" */
259 (void) SCIPsnprintf(probname, SCIP_MAXSTRLEN, "%s_subnlp", SCIPgetProbName(scip));
260 SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
261 SCIP_CALL( SCIPhashmapCreate(&varsmap, SCIPblkmem(scip), nvars) );
262 SCIP_CALL( SCIPhashmapCreate(&conssmap, SCIPblkmem(scip), SCIPgetNConss(scip)) );
263 SCIP_CALL( SCIPcopyProb(scip, heurdata->subscip, varsmap, conssmap, TRUE, probname) );
264
265 /* copy all variables */
266 SCIP_CALL( SCIPcopyVars(scip, heurdata->subscip, varsmap, conssmap, NULL, NULL, 0, TRUE) );
267
268 /* copy as many constraints as possible */
269 SCIP_CALL( SCIPcopyConss(scip, heurdata->subscip, varsmap, conssmap, TRUE, FALSE, &heurdata->subscipisvalid) );
270 SCIPhashmapFree(&conssmap);
271 if( !heurdata->subscipisvalid )
272 {
273 SCIPdebugMsg(scip, "failed to copy some constraints to sub-SCIP, continue anyway\n");
274 }
275
276 /* create arrays translating scip transformed vars to subscip original vars, and vice versa
277 * capture variables in SCIP and sub-SCIP
278 * catch global bound change events
279 */
280
281 SCIP_CALL( SCIPgetVarsData(heurdata->subscip, &subvars, &heurdata->nsubvars, NULL, NULL, NULL, NULL) );
282
283 SCIP_CALL( SCIPallocClearBlockMemoryArray(scip, &heurdata->var_subscip2scip, heurdata->nsubvars) );
284
285 heurdata->nvars = nvars;
286 SCIP_CALL( SCIPallocClearBlockMemoryArray(scip, &heurdata->var_scip2subscip, heurdata->nvars) );
287
288 /* we need to get all subscip variables, also those which are copies of fixed variables from the main scip
289 * therefore we iterate over the hashmap
290 */
291 for( i = 0; i < SCIPhashmapGetNEntries(varsmap); ++i )
292 {
293 SCIP_HASHMAPENTRY* entry;
294 entry = SCIPhashmapGetEntry(varsmap, i);
295 if( entry != NULL )
296 {
297 var = (SCIP_VAR*) SCIPhashmapEntryGetOrigin(entry);
298 subvar = (SCIP_VAR*) SCIPhashmapEntryGetImage(entry);
299 assert(subvar != NULL);
300 assert(SCIPvarGetProbindex(subvar) >= 0);
301 assert(SCIPvarGetProbindex(subvar) <= heurdata->nsubvars);
302
303 if( SCIPvarIsActive(var) )
304 {
305 assert(SCIPvarGetProbindex(var) <= heurdata->nvars);
306 assert(heurdata->var_scip2subscip[SCIPvarGetProbindex(var)] == NULL); /* assert that we have no mapping for this var yet */
307 heurdata->var_scip2subscip[SCIPvarGetProbindex(var)] = subvar;
308 }
309
310 assert(heurdata->var_subscip2scip[SCIPvarGetProbindex(subvar)] == NULL); /* assert that we have no mapping for this subvar yet */
311 heurdata->var_subscip2scip[SCIPvarGetProbindex(subvar)] = var;
312 }
313 }
314
315 for( i = 0; i < heurdata->nsubvars; ++i )
316 {
317 subvar = SCIPgetVars(heurdata->subscip)[i];
318 assert(SCIPvarGetProbindex(subvar) == i);
319 var = heurdata->var_subscip2scip[i];
320
321 SCIP_CALL( SCIPcaptureVar(scip, var) );
322 SCIP_CALL( SCIPcaptureVar(heurdata->subscip, subvar) );
323
324 assert(SCIPisFeasEQ(scip, SCIPvarGetLbGlobal(var), SCIPvarGetLbGlobal(subvar)));
325 assert(SCIPisFeasEQ(scip, SCIPvarGetUbGlobal(var), SCIPvarGetUbGlobal(subvar)));
326
327 SCIP_CALL( SCIPcatchVarEvent(scip, var, SCIP_EVENTTYPE_GBDCHANGED, heurdata->eventhdlr, (SCIP_EVENTDATA*)heurdata, NULL) );
328 }
329
330#ifndef NDEBUG
331 for( i = 0; i < heurdata->nvars; ++i )
332 {
333 assert(heurdata->var_scip2subscip[i] == NULL || (SCIP_VAR*)SCIPhashmapGetImage(varsmap, (void*)vars[i]) == heurdata->var_scip2subscip[i]);
334 }
335 for( i = 0; i < heurdata->nsubvars; ++i )
336 {
337 assert(heurdata->var_subscip2scip[i] != NULL);
338 assert((SCIP_VAR*)SCIPhashmapGetImage(varsmap, (void*)heurdata->var_subscip2scip[i]) == subvars[i]);
339 }
340#endif
341
342 /* do not need hashmap anymore */
343 SCIPhashmapFree(&varsmap);
344
345 /* do not abort subproblem on CTRL-C */
346 SCIP_CALL( SCIPsetBoolParam(heurdata->subscip, "misc/catchctrlc", FALSE) );
347
348 /* disable keeping solutions from one subscip solve for next solve (with usually different fixings) */
349 SCIP_CALL( SCIPsetIntParam(heurdata->subscip, "limits/maxorigsol", 0) );
350
351#ifdef SCIP_DEBUG
352 /* for debugging, enable SCIP output */
353 SCIP_CALL( SCIPsetIntParam(heurdata->subscip, "display/verblevel", 5) );
354#else
355 /* disable output to console */
356 SCIP_CALL( SCIPsetIntParam(heurdata->subscip, "display/verblevel", 0) );
357#endif
358
359 /* reset some limits to default values, in case users changed them in main scip (SCIPcopy copies parameter values :-() */
360 SCIP_CALL( SCIPresetParam(heurdata->subscip, "limits/absgap") );
361 SCIP_CALL( SCIPresetParam(heurdata->subscip, "limits/bestsol") );
362 SCIP_CALL( SCIPresetParam(heurdata->subscip, "limits/gap") );
363 SCIP_CALL( SCIPresetParam(heurdata->subscip, "limits/restarts") );
364 SCIP_CALL( SCIPresetParam(heurdata->subscip, "limits/solutions") );
365 SCIP_CALL( SCIPresetParam(heurdata->subscip, "limits/time") );
366 SCIP_CALL( SCIPresetParam(heurdata->subscip, "limits/totalnodes") );
367 SCIP_CALL( SCIPresetParam(heurdata->subscip, "limits/primal") );
368 SCIP_CALL( SCIPresetParam(heurdata->subscip, "limits/dual") );
369
370 /* we remember here which way (continuous or not) we went, in case all binary and integer vars get fixed in root */
371 heurdata->continuous = (SCIPgetNContVars(heurdata->subscip) + SCIPgetNContImplVars(heurdata->subscip)
372 == SCIPgetNVars(heurdata->subscip));
373 if( !heurdata->continuous )
374 {
375 /* set presolve maxrounds and emphasis; always disable components presolver
376 * heuristics and separators were not copied into subscip, so should not need to switch off
377 */
378 if( !SCIPisParamFixed(heurdata->subscip, "presolving/maxrounds") )
379 {
380 SCIP_CALL( SCIPsetIntParam(heurdata->subscip, "presolving/maxrounds", heurdata->maxpresolverounds) );
381 }
382 SCIP_CALL( SCIPsetPresolving(heurdata->subscip, (SCIP_PARAMSETTING)heurdata->presolveemphasis, TRUE) );
383 if( !SCIPisParamFixed(heurdata->subscip, "constraints/components/maxprerounds") )
384 {
385 SCIP_CALL( SCIPsetIntParam(heurdata->subscip, "constraints/components/maxprerounds", 0) );
386 }
387 }
388 else
389 {
390 /* for continuous problems, disable presolve and move subscip into a stage where it has a NLP
391 * the only reason why we don't solve the NLP in the main SCIP is that we want global variable bounds for the NLP
392 */
393 SCIP_RETCODE retcode;
394
395 SCIP_CALL( SCIPtransformProb(heurdata->subscip) );
396
397 SCIP_CALL( SCIPsetPresolving(heurdata->subscip, SCIP_PARAMSETTING_OFF, TRUE) );
398 SCIP_CALL( SCIPpresolve(heurdata->subscip) );
399
400 if( SCIPgetStage(heurdata->subscip) != SCIP_STAGE_PRESOLVED || SCIPgetNVars(heurdata->subscip) == 0 )
401 {
402 /* presolve found problem infeasible, solved it, or stopped due to some limit
403 * all a bit strange, since problem should be the same as original, presolve was disabled, and we didn't set any limits
404 * we will give up and not run the heuristic
405 */
406 SCIP_CALL( freeSubSCIP(scip, heurdata) );
407 return SCIP_OKAY;
408 }
409
410 /* do initial solve, i.e., "solve" root node with node limit 0 (should do scip.c::initSolve and then stop immediately in solve.c::SCIPsolveCIP) */
411 SCIP_CALL( SCIPsetLongintParam(heurdata->subscip, "limits/nodes", 0LL) );
412 retcode = SCIPsolve(heurdata->subscip);
413
414 /* errors in solving the subproblem should not kill the overall solving process
415 * hence, the return code is caught and a warning is printed
416 */
417 if( retcode != SCIP_OKAY )
418 {
419 SCIPwarningMessage(scip, "Error while initializing subproblem in subnlp heuristic; sub-SCIP terminated with code <%d>\n", retcode);
420 SCIP_CALL( freeSubSCIP(scip, heurdata) );
421 return SCIP_OKAY;
422 }
423
424 /* If we are in stage "solved" (strange) or have no NLP (also strange), then do not run heuristic, too */
425 if( SCIPgetStage(heurdata->subscip) == SCIP_STAGE_SOLVED || !SCIPisNLPConstructed(heurdata->subscip) )
426 {
427 SCIP_CALL( freeSubSCIP(scip, heurdata) );
428 return SCIP_OKAY;
429 }
430
431 assert(SCIPgetStage(heurdata->subscip) == SCIP_STAGE_SOLVING);
432 assert(SCIPgetStatus(heurdata->subscip) == SCIP_STATUS_NODELIMIT);
433 assert(SCIPisNLPConstructed(heurdata->subscip));
434 }
435
436 return SCIP_OKAY;
437}
438
439/** process variable global bound change event */
440static
441SCIP_DECL_EVENTEXEC(processVarEvent)
442{
443 SCIP_HEURDATA* heurdata;
444 SCIP_VAR* var;
445 SCIP_VAR* subvar;
446 int idx;
447
448 assert(scip != NULL);
449 assert(event != NULL);
450 assert(eventdata != NULL);
451 assert(eventhdlr != NULL);
452
453 heurdata = (SCIP_HEURDATA*)eventdata;
454 assert(heurdata != NULL);
455
456 var = SCIPeventGetVar(event);
457 assert(var != NULL);
458
459 idx = SCIPvarGetProbindex(var);
460 /* if event corresponds to an active variable, we can easily look up the corresponding subvar
461 * if it is an inactive variable that has been copied to the subproblem,
462 * then we need to check the subscip2scip mapping
463 * @todo we could do this faster if we keep the variables mapping from SCIPcopy around
464 */
465 if( idx >= 0 )
466 {
467 assert(idx < heurdata->nvars);
468
469 subvar = heurdata->var_scip2subscip[idx];
470 }
471 else
472 {
473 for( idx = 0; idx < heurdata->nsubvars; ++idx )
474 {
475 if( heurdata->var_subscip2scip[idx] == var )
476 break;
477 }
478 assert(idx < heurdata->nsubvars);
479 subvar = SCIPgetVars(heurdata->subscip)[idx];
480 }
481 assert(subvar != NULL);
482
483 if( SCIPeventGetType(event) & SCIP_EVENTTYPE_GLBCHANGED )
484 {
485 SCIP_CALL( SCIPchgVarLbGlobal(heurdata->subscip, subvar, SCIPeventGetNewbound(event)) );
486 }
487
488 if( SCIPeventGetType(event) & SCIP_EVENTTYPE_GUBCHANGED )
489 {
490 SCIP_CALL( SCIPchgVarUbGlobal(heurdata->subscip, subvar, SCIPeventGetNewbound(event)) );
491 }
492
493 return SCIP_OKAY;
494}
495
496/* creates a SCIP_SOL in our SCIP space out of the solution from NLP solver in sub-SCIP */
497static
498SCIP_RETCODE createSolFromNLP(
499 SCIP* scip, /**< SCIP data structure */
500 SCIP_HEUR* heur, /**< heuristic data structure */
501 SCIP_SOL** sol, /**< buffer to store solution value; if pointing to NULL, then a new solution is created, otherwise values in the given one are overwritten */
502 SCIP_HEUR* authorheur /**< the heuristic which should be registered as author of the solution */
503 )
504{
505 SCIP_HEURDATA* heurdata;
506 SCIP_VAR** vars;
507 int nvars;
508 SCIP_VAR* var;
509 SCIP_VAR* subvar;
510 SCIP_Real solval;
511 int i;
512
513 assert(scip != NULL);
514 assert(heur != NULL);
515 assert(sol != NULL);
516
517 heurdata = SCIPheurGetData(heur);
518 assert(heurdata != NULL);
519 assert(SCIPhasNLPSolution(heurdata->subscip));
520
521 if( *sol == NULL )
522 {
523 SCIP_CALL( SCIPcreateSol(scip, sol, authorheur) );
524 }
525 else
526 {
527 SCIPsolSetHeur(*sol, authorheur);
528 }
529
530 SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
531
532 assert(nvars >= heurdata->nvars);
533 for( i = 0; i < heurdata->nvars; ++i )
534 {
535 var = vars[i];
536 assert(var != NULL);
537 assert(SCIPvarIsActive(var)); /* SCIPgetVarsData should have given us only active vars */
538
539 subvar = heurdata->var_scip2subscip[i];
540 if( subvar == NULL )
541 solval = MIN(MAX(0.0, SCIPvarGetLbLocal(var)), SCIPvarGetUbLocal(var)); /*lint !e666*/
542 else
543 solval = SCIPvarGetNLPSol(subvar);
544
545 assert(solval != SCIP_INVALID); /*lint !e777*/
546 SCIP_CALL( SCIPsetSolVal(scip, *sol, var, solval) );
547 }
548
549 for( ; i < nvars; ++i )
550 {
551 var = vars[i];
552 assert(var != NULL);
553 assert(SCIPvarIsActive(var)); /* SCIPgetVarsData should have given us only active vars */
554
555 solval = MIN(MAX(0.0, SCIPvarGetLbLocal(var)), SCIPvarGetUbLocal(var)); /*lint !e666*/
556 SCIP_CALL( SCIPsetSolVal(scip, *sol, var, solval) );
557 }
558
559 return SCIP_OKAY;
560}
561
562/** creates SCIP solution from NLP and tries adding to SCIP or only checks feasibility */
563static
564SCIP_RETCODE processNLPSol(
565 SCIP* scip, /**< original SCIP data structure */
566 SCIP_HEUR* heur, /**< heuristic data structure */
567 SCIP_HEUR* authorheur, /**< the heuristic that should be the author of solution, if any */
568 SCIP_RESULT* result, /**< buffer to store result FOUNDSOL if a solution has been found and accepted */
569 SCIP_SOL* resultsol /**< a solution where to store found solution values, if any, or NULL if to try adding to SCIP */
570 )
571{
572 SCIP_HEURDATA* heurdata;
573
574 assert(scip != NULL);
575 assert(heur != NULL);
576 assert(result != NULL);
577
578 heurdata = SCIPheurGetData(heur);
579 assert(heurdata != NULL);
580
581 assert(SCIPhasNLPSolution(heurdata->subscip));
582
583 if( resultsol == NULL )
584 {
585 /* resultsol NULL means we should try adding the sol to SCIP */
586 if( SCIPisLE(scip, SCIPgetNLPObjval(heurdata->subscip), SCIPgetUpperbound(scip)) )
587 {
588 /* solution is feasible and should improve upper bound, so try adding it to SCIP */
589 SCIP_SOL* sol;
590 SCIP_Bool stored;
591
592 sol = NULL;
593 SCIP_CALL( createSolFromNLP(scip, heur, &sol, authorheur) );
594
595 heurdata->lastsol = sol; /* remember just the pointer so we might recognize if this solution comes back as startingpoint */
596#ifdef SCIP_DEBUG
597 /* print the infeasibilities to stdout */
598 SCIP_CALL( SCIPtrySolFree(scip, &sol, TRUE, TRUE, TRUE, FALSE, TRUE, &stored) );
599#else
600 SCIP_CALL( SCIPtrySolFree(scip, &sol, FALSE, FALSE, TRUE, FALSE, TRUE, &stored) );
601#endif
602
603 if( stored )
604 {
605 /* SCIP stored solution (yippi!), so we are done */
606 if( heurdata->nlpverblevel >= 1 )
607 {
608 SCIPinfoMessage(scip, NULL, "SCIP stored solution from NLP solve\n");
609 }
610 else
611 {
612 SCIPdebugMsg(scip, "SCIP stored solution from NLP solve\n");
613 }
614
615 *result = SCIP_FOUNDSOL;
616 }
617 else
618 {
619 if( heurdata->nlpverblevel >= 1 )
620 {
621 SCIPinfoMessage(scip, NULL, "solution reported by NLP solver not stored by SCIP\n");
622 }
623 else
624 {
625 SCIPdebugMsg(scip, "solution reported by NLP solver not stored by SCIP\n");
626 }
627 }
628 }
629 else if( heurdata->nlpverblevel >= 1 )
630 {
631 SCIPinfoMessage(scip, NULL, "subnlp solution objval %e is above the primal bound %e\n",
632 SCIPgetNLPObjval(heurdata->subscip), SCIPgetUpperbound(scip));
633 }
634 }
635 else
636 {
637 /* only create a solution and pass it back in resultsol, do not add to SCIP */
638 SCIP_Bool feasible;
639
640 SCIP_CALL( createSolFromNLP(scip, heur, &resultsol, authorheur) );
641
642 heurdata->lastsol = resultsol;
643#ifdef SCIP_DEBUG
644 /* print the infeasibilities to stdout */
645 SCIP_CALL( SCIPcheckSol(scip, resultsol, TRUE, TRUE, TRUE, FALSE, TRUE, &feasible) );
646#else
647 SCIP_CALL( SCIPcheckSol(scip, resultsol, FALSE, FALSE, TRUE, FALSE, TRUE, &feasible) );
648#endif
649 if( feasible )
650 {
651 /* SCIP find solution feasible, so we are done */
652 if( heurdata->nlpverblevel >= 1 )
653 {
654 SCIPinfoMessage(scip, NULL, "solution reported by NLP solver feasible for SCIP\n");
655 }
656 else
657 {
658 SCIPdebugMsg(scip, "solution reported by NLP solver feasible for SCIP\n");
659 }
660 *result = SCIP_FOUNDSOL;
661 }
662 else
663 {
664 if( heurdata->nlpverblevel >= 1 )
665 {
666 SCIPinfoMessage(scip, NULL, "solution reported by NLP solver not feasible for SCIP\n");
667 }
668 else
669 {
670 SCIPdebugMsg(scip, "solution reported by NLP solver not feasible for SCIP\n");
671 }
672 }
673 }
674
675 return SCIP_OKAY;
676}
677
678/* creates a SCIP_SOL in our SCIP space out of the SCIP_SOL from a sub-SCIP */
679static
680SCIP_RETCODE createSolFromSubScipSol(
681 SCIP* scip, /**< SCIP data structure */
682 SCIP_HEUR* heur, /**< heuristic data structure */
683 SCIP_SOL** sol, /**< buffer to store solution value; if pointing to NULL, then a new solution is created, otherwise values in the given one are overwritten */
684 SCIP_SOL* subsol, /**< solution of sub-SCIP */
685 SCIP_HEUR* authorheur /**< the heuristic which should be registered as author of the solution */
686 )
687{
688 SCIP_HEURDATA* heurdata;
689 SCIP_VAR** vars;
690 int nvars;
691 SCIP_VAR* var;
692 SCIP_VAR* subvar;
693 SCIP_Real solval;
694 int i;
695
696 assert(scip != NULL);
697 assert(heur != NULL);
698 assert(sol != NULL);
699 assert(subsol != NULL);
700
701 heurdata = SCIPheurGetData(heur);
702 assert(heurdata != NULL);
703
704 if( *sol == NULL )
705 {
706 SCIP_CALL( SCIPcreateSol(scip, sol, authorheur) );
707 }
708 else
709 {
710 SCIPsolSetHeur(*sol, authorheur);
711 }
712
713 SCIP_CALL( SCIPgetVarsData(scip, &vars, &nvars, NULL, NULL, NULL, NULL) );
714
715 assert(nvars >= heurdata->nvars);
716 for( i = 0; i < heurdata->nvars; ++i )
717 {
718 var = vars[i];
719 assert(var != NULL);
720 assert(SCIPvarIsActive(var));
721
722 subvar = heurdata->var_scip2subscip[i];
723 if( subvar == NULL )
724 solval = MIN(MAX(0.0, SCIPvarGetLbLocal(var)), SCIPvarGetUbLocal(var)); /*lint !e666*/
725 else
726 solval = SCIPgetSolVal(heurdata->subscip, subsol, subvar);
727
728 assert(solval != SCIP_INVALID); /*lint !e777*/
729 SCIP_CALL( SCIPsetSolVal(scip, *sol, var, solval) );
730 }
731
732 for( ; i < nvars; ++i )
733 {
734 var = vars[i];
735 assert(var != NULL);
736 assert(SCIPvarIsActive(var));
737
738 solval = MIN(MAX(0.0, SCIPvarGetLbLocal(var)), SCIPvarGetUbLocal(var)); /*lint !e666*/
739 SCIP_CALL( SCIPsetSolVal(scip, *sol, var, solval) );
740 }
741
742 return SCIP_OKAY;
743}
744
745/** finds an iteration limit */ /*lint --e{715}*/
746static
747int calcIterLimit(
748 SCIP* scip, /**< original SCIP data structure */
749 SCIP_HEURDATA* heurdata /**< heuristic data */
750 )
751{
752 /* if we hit more often an iterlimit than we were successful (termstatus=okay), then allow for more iterations:
753 * take twice the maximal iterusage on solves that hit the iterlimit
754 */
755 if( heurdata->nnlpsolvesiterlim > heurdata->nnlpsolvesokay )
756 return MAX(heurdata->itermin, 2 * heurdata->iterusediterlim); /*lint !e712*/
757
758 /* if we had sufficiently many successful solves, then take twice the average of previous iterusages on successful solves */
759 if( heurdata->nnlpsolvesokay >= heurdata->ninitsolves )
760 return MAX(heurdata->itermin, 2 * heurdata->iterusedokay / heurdata->nnlpsolvesokay); /*lint !e712*/
761
762 /* if we had too few successful solves, then still ensure that we allow for at least iterinit iterations */
763 if( heurdata->nnlpsolvesokay > 0 )
764 return MAX3(heurdata->itermin, heurdata->iterinit, 2 * heurdata->iterusedokay / heurdata->nnlpsolvesokay); /*lint !e712*/
765
766 /* if we had no successful solve so far and none that hit an iterlimit, e.g., we are at the first NLP solve, then use iterinit */
767 return MAX(heurdata->itermin, heurdata->iterinit);
768}
769
770/** solves the subNLP specified in subscip */
771static
772SCIP_RETCODE solveSubNLP(
773 SCIP* scip, /**< original SCIP data structure */
774 SCIP_HEUR* heur, /**< heuristic data structure */
775 SCIP_RESULT* result, /**< buffer to store result, DIDNOTFIND, FOUNDSOL, or CUTOFF */
776 SCIP_SOL* refpoint, /**< point to take fixation of discrete variables from, and startpoint for NLP solver; if NULL, then LP solution is used */
777 SCIP_SOL* resultsol /**< a solution where to store found solution values, if any, or NULL if to try adding to SCIP */
778 )
779{
780 SCIP_HEURDATA* heurdata = SCIPheurGetData(heur);
781 SCIP_RETCODE retcode;
782 SCIP_Real* startpoint;
783 SCIP_VAR* var;
784 SCIP_VAR* subvar;
785 int i;
786 SCIP_HEUR* authorheur; /* the heuristic which will be the author of a solution, if found */
787 SCIP_Real timelimit;
788 SCIP_Bool expectinfeas;
789 SCIP_NLPSTATISTICS nlpstatistics;
790
791 assert(scip != NULL);
792 assert(heur != NULL);
793 assert(heurdata != NULL);
794 assert(result != NULL);
795 assert(SCIPisTransformed(heurdata->subscip));
796
797 /* get remaining SCIP solve time; if no time left, then stop */
798 SCIP_CALL( SCIPgetRealParam(scip, "limits/time", &timelimit) );
799 if( !SCIPisInfinity(scip, timelimit) )
800 {
801 timelimit -= SCIPgetSolvingTime(scip);
802 if( timelimit <= 0.0 )
803 return SCIP_OKAY;
804 }
805 /* set timelimit for NLP solve and in case presolve is unexpectedly expensive */
806 SCIP_CALL( SCIPsetRealParam(heurdata->subscip, "limits/time", timelimit) );
807
808 /* if the refpoint comes from a heuristic, then make it the author of a found solution,
809 * otherwise let the subNLP heuristic claim authorship
810 * TODO: I doubt that this has much effect; for the statistics, the number of solutions found by a heuristic
811 * seems to be computed as the increase in number of solutions before and after a heuristic is run
812 * check this and maybe change
813 */
814 if( refpoint == NULL || SCIPsolGetHeur(refpoint) == NULL )
815 authorheur = heur;
816 else
817 authorheur = SCIPsolGetHeur(refpoint);
818
819 if( !heurdata->continuous )
820 {
821 /* presolve sub-SCIP
822 * set node limit to 1 so that presolve can go
823 */
824 SCIP_CALL( SCIPsetLongintParam(heurdata->subscip, "limits/nodes", 1LL) );
825 SCIP_CALL( SCIPpresolve(heurdata->subscip) );
826
827 /* count one presolve round as on NLP iteration for now
828 * plus one extra for all the setup cost
829 * this is mainly to avoid that the primal heuristics runs all the time on instances that are solved in the subscip-presolve
830 */
831 heurdata->iterused += 1 + SCIPgetNPresolRounds(scip); /*lint !e776*/
832
833 if( SCIPgetStage(heurdata->subscip) == SCIP_STAGE_SOLVED )
834 {
835 /* presolve probably found the subproblem infeasible */
836 SCIPdebugMsg(scip, "SCIP returned from presolve in stage solved with status %d and %d sols\n", SCIPgetStatus(heurdata->subscip), SCIPgetNSols(heurdata->subscip));
837 /* if presolve found subproblem infeasible, report this to caller by setting *result to cutoff */
838 if( SCIPgetStatus(heurdata->subscip) == SCIP_STATUS_INFEASIBLE )
839 *result = SCIP_CUTOFF;
840 }
841 else if( SCIPgetStage(heurdata->subscip) == SCIP_STAGE_PRESOLVING )
842 {
843 /* presolve was stopped because some still existing limit was hit (e.g., memory) */
844 SCIPdebugMsg(scip, "SCIP returned from presolve in stage presolving with status %d and %d sols\n", SCIPgetStatus(heurdata->subscip), SCIPgetNSols(heurdata->subscip));
845 /* if presolve found subproblem infeasible, report this to caller by setting *result to cutoff */
846 if( SCIPgetStatus(heurdata->subscip) == SCIP_STATUS_INFEASIBLE )
847 *result = SCIP_CUTOFF;
848 }
849 else
850 {
851 assert(SCIPgetStage(heurdata->subscip) == SCIP_STAGE_PRESOLVED);
852
853 if( SCIPgetNVars(heurdata->subscip) > 0 )
854 {
855 /* do initial solve, i.e., "solve" root node with node limit 0 (should do scip.c::initSolve and then stop immediately in solve.c::SCIPsolveCIP) */
856 SCIP_CALL( SCIPsetLongintParam(heurdata->subscip, "limits/nodes", 0LL) );
857 retcode = SCIPsolve(heurdata->subscip);
858
859 /* If no NLP was constructed, then there were no nonlinearities after presolve.
860 * So we increase the nodelimit to 1 and hope that SCIP will find some solution to this probably linear subproblem.
861 */
862 if( retcode == SCIP_OKAY && SCIPgetStage(heurdata->subscip) != SCIP_STAGE_SOLVED && !SCIPisNLPConstructed(heurdata->subscip) )
863 {
864 SCIP_CALL( SCIPsetLongintParam(heurdata->subscip, "limits/nodes", 1LL) );
865 retcode = SCIPsolve(heurdata->subscip);
866 }
867 }
868 else
869 {
870 /* If all variables were removed by presolve, but presolve did not end with status SOLVED,
871 * then we run solve, still with nodelimit=1, and hope to find some (maybe trivial) solution.
872 */
873 retcode = SCIPsolve(heurdata->subscip);
874 }
875
876 /* errors in solving the subproblem should not kill the overall solving process
877 * hence, the return code is caught and a warning is printed
878 */
879 if( retcode != SCIP_OKAY )
880 {
881 SCIPwarningMessage(scip, "Error while solving subproblem in subnlp heuristic; sub-SCIP terminated with code <%d>\n", retcode);
882 return SCIP_OKAY;
883 }
884 }
885
886 /* we should either have variables, or the problem was trivial, in which case it should have been presolved or solved */
887 assert(SCIPgetNVars(heurdata->subscip) > 0 || SCIPgetStage(heurdata->subscip) == SCIP_STAGE_PRESOLVING || SCIPgetStage(heurdata->subscip) == SCIP_STAGE_SOLVED);
888
889 SCIPdebug( SCIP_CALL( SCIPprintStatistics(heurdata->subscip, NULL) ); )
890
891 /* if sub-SCIP found solutions already, then pass them to main scip */
892 for( i = 0; i < SCIPgetNSols(heurdata->subscip); ++i )
893 {
894 if( resultsol == NULL )
895 {
896 SCIP_Bool stored;
897 SCIP_SOL* sol;
898
899 sol = NULL;
900 SCIP_CALL( createSolFromSubScipSol(scip, heur, &sol, SCIPgetSols(heurdata->subscip)[i], authorheur) );
901
902 heurdata->lastsol = sol; /* remember just the pointer so we might recognize if this solution comes back as startingpoint */
903 SCIP_CALL( SCIPtrySolFree(scip, &sol, FALSE, FALSE, TRUE, FALSE, TRUE, &stored) );
904 if( stored )
905 {
906 if( heurdata->nlpverblevel >= 1 )
907 {
908 SCIPinfoMessage(scip, NULL, "SCIP stored solution from sub-SCIP root node\n");
909 }
910 else
911 {
912 SCIPdebugMsg(scip, "SCIP stored solution from sub-SCIP root node\n");
913 }
914 *result = SCIP_FOUNDSOL;
915 break;
916 }
917 else
918 {
919 if( heurdata->nlpverblevel >= 1 )
920 {
921 SCIPinfoMessage(scip, NULL, "SCIP did not store sub-SCIP optimal solution\n");
922 }
923 else
924 {
925 SCIPdebugMsg(scip, "SCIP did not store sub-SCIP optimal solution\n");
926 }
927 }
928 }
929 else
930 {
931 SCIP_Bool feasible;
932
933 SCIP_CALL( createSolFromSubScipSol(scip, heur, &resultsol, SCIPgetSols(heurdata->subscip)[i], authorheur) );
934
935 heurdata->lastsol = resultsol;
936 SCIP_CALL( SCIPcheckSol(scip, resultsol, FALSE, FALSE, TRUE, FALSE, TRUE, &feasible) );
937 if( feasible )
938 {
939 if( heurdata->nlpverblevel >= 1 )
940 {
941 SCIPinfoMessage(scip, NULL, "SCIP solution from sub-SCIP root node is feasible\n");
942 }
943 else
944 {
945 SCIPdebugMsg(scip, "SCIP solution from sub-SCIP root node is feasible\n");
946 }
947 *result = SCIP_FOUNDSOL;
948 break;
949 }
950 else
951 {
952 if( heurdata->nlpverblevel >= 1 )
953 {
954 SCIPinfoMessage(scip, NULL, "SCIP solution from sub-SCIP root node is not feasible\n");
955 }
956 else
957 {
958 SCIPdebugMsg(scip, "SCIP solution from sub-SCIP root node is not feasible\n");
959 }
960 }
961 }
962 }
963
964 /* if subscip is infeasible here, we signal this to the caller */
965 if( SCIPgetStatus(heurdata->subscip) == SCIP_STATUS_INFEASIBLE )
966 {
967 if( heurdata->nlpverblevel >= 1 )
968 {
969 SCIPinfoMessage(scip, NULL, "sub-SCIP detected infeasibility\n");
970 }
971 else
972 {
973 SCIPdebugMsg(scip, "sub-SCIP detected infeasibility\n");
974 }
975
976 assert(SCIPgetStage(heurdata->subscip) == SCIP_STAGE_SOLVED);
977 *result = SCIP_CUTOFF;
978 return SCIP_OKAY;
979 }
980
981 /* if we stopped for some other reason, or there is no NLP, we also stop */
982 if( SCIPgetStage(heurdata->subscip) <= SCIP_STAGE_PRESOLVED || SCIPgetStage(heurdata->subscip) == SCIP_STAGE_SOLVED || !SCIPisNLPConstructed(heurdata->subscip) )
983 return SCIP_OKAY;
984
985 /* in most cases, the status should be nodelimit
986 * in some cases, if the sub-SCIP is very easy, it may report optimal, so we do not need invoke an NLP solver
987 * if the presolve found the problem infeasible, then there is no use in solving an NLP
988 * if the user interrupted or a timelimit was reached, then we should also stop here
989 * unbounded is very unlikely to happen, in most cases, it should have been concluded in the main scip already
990 */
991 switch( SCIPgetStatus(heurdata->subscip) )
992 {
993 case SCIP_STATUS_NODELIMIT:
994 break; /* this is the status that is most likely happening */
995 case SCIP_STATUS_TOTALNODELIMIT:
996 case SCIP_STATUS_STALLNODELIMIT:
997 case SCIP_STATUS_GAPLIMIT:
998 case SCIP_STATUS_SOLLIMIT:
999 case SCIP_STATUS_BESTSOLLIMIT:
1000 /* these should not happen, but if one does, it's safe to return */
1001 SCIPABORT(); /*lint -fallthrough*/
1002 case SCIP_STATUS_OPTIMAL:
1003 case SCIP_STATUS_INFEASIBLE:
1004 case SCIP_STATUS_USERINTERRUPT:
1005 case SCIP_STATUS_TIMELIMIT:
1006 case SCIP_STATUS_MEMLIMIT:
1007 case SCIP_STATUS_UNBOUNDED:
1008 case SCIP_STATUS_INFORUNBD:
1009 return SCIP_OKAY;
1010 default:
1011 SCIPerrorMessage("unexpected status of sub-SCIP: <%d>\n", SCIPgetStatus(heurdata->subscip));
1012 return SCIP_ERROR;
1013 } /*lint !e788*/
1014 }
1015 else
1016 {
1017 /* for continuous problem, createSubSCIP() should have put us into a state where we can invoke the NLP solver */
1018 assert(SCIPisNLPConstructed(heurdata->subscip));
1019 assert(SCIPgetStage(heurdata->subscip) == SCIP_STAGE_SOLVING);
1020 assert(SCIPgetStatus(heurdata->subscip) == SCIP_STATUS_NODELIMIT);
1021 }
1022
1023 /* set starting values (=refpoint, if not NULL; otherwise LP solution (or pseudo solution)) */
1024 SCIP_CALL( SCIPallocBufferArray(scip, &startpoint, SCIPgetNNLPVars(heurdata->subscip)) );
1025
1026 if( heurdata->nlpverblevel >= 3 )
1027 {
1028 SCIPinfoMessage(scip, NULL, "set NLP starting point\n");
1029 }
1030
1031 for( i = 0; i < SCIPgetNNLPVars(heurdata->subscip); ++i )
1032 {
1033 SCIP_Real scalar;
1034 SCIP_Real constant;
1035
1036 subvar = SCIPgetNLPVars(heurdata->subscip)[i];
1037
1038 /* gets corresponding original variable */
1039 scalar = 1.0;
1040 constant = 0.0;
1041 SCIP_CALL( SCIPvarGetOrigvarSum(&subvar, &scalar, &constant) );
1042 if( subvar == NULL )
1043 {
1044 startpoint[i] = constant;
1045
1046 if( heurdata->nlpverblevel >= 3 && !SCIPisZero(heurdata->subscip, startpoint[i]) )
1047 {
1048 SCIPinfoMessage(scip, NULL, "%s = %e\n", SCIPvarGetName(SCIPgetNLPVars(heurdata->subscip)[i]), startpoint[i]);
1049 }
1050
1051 continue;
1052 }
1053
1054 assert(SCIPvarGetProbindex(subvar) >= 0);
1055 assert(SCIPvarGetProbindex(subvar) < heurdata->nsubvars);
1056 var = heurdata->var_subscip2scip[SCIPvarGetProbindex(subvar)];
1057 if( var == NULL || REALABS(SCIPgetSolVal(scip, refpoint, var)) > 1.0e+12 )
1058 startpoint[i] = MIN(MAX(0.0, SCIPvarGetLbGlobal(subvar)), SCIPvarGetUbGlobal(subvar)); /*lint !e666*/
1059 else
1060 /* scalar*subvar+constant corresponds to nlpvar[i], so nlpvar[i] gets value scalar*varval+constant */
1061 startpoint[i] = scalar * SCIPgetSolVal(scip, refpoint, var) + constant;
1062
1063 if( heurdata->nlpverblevel >= 3 && !SCIPisZero(heurdata->subscip, startpoint[i]) )
1064 {
1065 SCIPinfoMessage(scip, NULL, "%s = %e\n", SCIPvarGetName(SCIPgetNLPVars(heurdata->subscip)[i]), startpoint[i]);
1066 }
1067 }
1068 SCIP_CALL( SCIPsetNLPInitialGuess(heurdata->subscip, startpoint) );
1069
1070 SCIPfreeBufferArray(scip, &startpoint);
1071
1072 *result = SCIP_DIDNOTFIND;
1073
1074 /* if we had many (fraction > expectinfeas) infeasible NLPs, then tell NLP solver to expect an infeasible problem */
1075 expectinfeas = FALSE; /* cppcheck-suppress unreadVariable */
1076 if( heurdata->expectinfeas == 0.0 ) /* to keep original behavior on default settings */
1077 expectinfeas = TRUE; /* cppcheck-suppress unreadVariable */
1078 else if( heurdata->nnlpsolvesokay > heurdata->ninitsolves && heurdata->nnlpsolvesinfeas > heurdata->expectinfeas * heurdata->nnlpsolvesokay )
1079 expectinfeas = TRUE; /* cppcheck-suppress unreadVariable */
1080
1081 /* let the NLP solver do its magic */
1082 SCIPdebugMsg(scip, "start NLP solve with iteration limit %d\n", calcIterLimit(scip, heurdata));
1083 SCIP_CALL( SCIPsolveNLP(heurdata->subscip,
1084 .iterlimit = calcIterLimit(scip, heurdata),
1085 .opttol = heurdata->opttol,
1086 .feastol = heurdata->feastol,
1087 .verblevel = (unsigned short)heurdata->nlpverblevel,
1088 .expectinfeas = expectinfeas
1089 ) ); /*lint !e666*/
1090
1091 SCIPdebugMsg(scip, "NLP solver returned with termination status %d and solution status %d, objective value is %g\n",
1092 SCIPgetNLPTermstat(heurdata->subscip), SCIPgetNLPSolstat(heurdata->subscip), SCIPgetNLPObjval(heurdata->subscip));
1093
1094 /* add NLP solve statistics from subscip to main SCIP, so they show up in final statistics
1095 * for continuous problems, we also ask to reset statistics, since we do not retransform subSCIP in the next run (which would reset all stats)
1096 * (merging statistics once in exitsol is too late, since they may be printed before)
1097 */
1098 SCIPmergeNLPIStatistics(heurdata->subscip, scip, heurdata->continuous);
1099
1100 if( SCIPgetNLPTermstat(heurdata->subscip) >= SCIP_NLPTERMSTAT_OUTOFMEMORY )
1101 {
1102 /* oops, something did not go well at all */
1103 if( heurdata->nlpverblevel >= 1 )
1104 {
1105 SCIPinfoMessage(scip, NULL, "NLP solver in subNLP heuristic for problem <%s> returned with bad termination status %d.\n",
1106 SCIPgetProbName(scip), SCIPgetNLPTermstat(heurdata->subscip));
1107 }
1108
1109 ++(heurdata->nseriousnlpierror);
1110 SCIPverbMessage(scip, SCIP_VERBLEVEL_MINIMAL, NULL,
1111 "NLP solver in subNLP heuristic for problem <%s> returned with bad termination status %d. This was the %d%s successive time.\n",
1112 SCIPgetProbName(scip), SCIPgetNLPTermstat(heurdata->subscip), heurdata->nseriousnlpierror,
1113 heurdata->nseriousnlpierror == 1 ? "st" : heurdata->nseriousnlpierror == 2 ? "nd" : heurdata->nseriousnlpierror == 3 ? "rd" : "th");
1114 if( heurdata->nseriousnlpierror >= 5 )
1115 {
1116 SCIPverbMessage(scip, SCIP_VERBLEVEL_MINIMAL, NULL, "Will not run subNLP heuristic again for this run.\n");
1117 SCIP_CALL( freeSubSCIP(scip, heurdata) );
1118 }
1119 return SCIP_OKAY;
1120 }
1121 heurdata->nseriousnlpierror = 0;
1122
1123 SCIP_CALL( SCIPgetNLPStatistics(heurdata->subscip, &nlpstatistics) );
1124
1125 SCIPdebugMsg(scip, "NLP solver used %d iterations and %g seconds; violation cons %g, bounds %g\n",
1126 nlpstatistics.niterations, nlpstatistics.totaltime, nlpstatistics.consviol, nlpstatistics.boundviol);
1127
1128 heurdata->iterused += nlpstatistics.niterations;
1129 ++heurdata->nnlpsolves;
1130 if( SCIPgetNLPTermstat(heurdata->subscip) == SCIP_NLPTERMSTAT_OKAY )
1131 {
1132 ++heurdata->nnlpsolvesokay;
1133 heurdata->iterusedokay += nlpstatistics.niterations;
1134
1135 if( (SCIPgetNLPSolstat(heurdata->subscip) == SCIP_NLPSOLSTAT_GLOBINFEASIBLE) || (SCIPgetNLPSolstat(heurdata->subscip) == SCIP_NLPSOLSTAT_LOCINFEASIBLE) )
1136 ++heurdata->nnlpsolvesinfeas;
1137 }
1138 else if( SCIPgetNLPTermstat(heurdata->subscip) == SCIP_NLPTERMSTAT_ITERLIMIT )
1139 {
1140 ++heurdata->nnlpsolvesiterlim;
1141 heurdata->iterusediterlim = MAX(heurdata->iterusediterlim, nlpstatistics.niterations);
1142 }
1143
1144 if( SCIPgetNLPSolstat(heurdata->subscip) > SCIP_NLPSOLSTAT_FEASIBLE )
1145 return SCIP_OKAY;
1146
1147 /* create SCIP solution, check whether feasible, and try adding to SCIP (if resultsol==NULL) */
1148 SCIP_CALL( processNLPSol(scip, heur, authorheur, result, resultsol) );
1149
1150 if( *result == SCIP_FOUNDSOL || !SCIPisLE(scip, SCIPgetNLPObjval(heurdata->subscip), SCIPgetUpperbound(scip)) )
1151 return SCIP_OKAY;
1152
1153 /* if solution was not added to SCIP, then either
1154 * - the objective function value was not good enough,
1155 * - the NLP was missing some constraints of the original CIP, or
1156 * - the solution is feasible for the presolved CIP, but slightly infeasible for the unpresolved problem
1157 *
1158 * The first case we can check easily (see if() above).
1159 * For the last case, we try whether tightening the feasibility tolerance for the NLP solve may help.
1160 * If that doesn't help, we guess that we are in the second case and will not try a tighter feastol anymore.
1161 */
1162
1163 /* if we tried with a tighter feastol before, but solution was still not accepted, then don't try again */
1164 if( heurdata->tighterfeastolfailed )
1165 return SCIP_OKAY;
1166
1167 /* if resolve with tighter feastol is disabled, then don't do anything */
1168 if( heurdata->feastolfactor == 1.0 )
1169 return SCIP_OKAY;
1170
1171 /* if we have already used a tighter feastol, then give up */
1172 if( heurdata->feastol < SCIPfeastol(scip) )
1173 return SCIP_OKAY;
1174
1175 /* if original CIP is continuous, then we have not done any presolve, so it shouldn't have caused problems */
1176 if( heurdata->continuous )
1177 return SCIP_OKAY;
1178
1179 /* if solution is NLP-feasible for a tightened tolerance already, then there is no use in resolving with that tighter feastol */
1180 if( MAX(nlpstatistics.consviol, nlpstatistics.boundviol) <= heurdata->feastolfactor * heurdata->feastol )
1181 return SCIP_OKAY;
1182
1183 /* let the NLP solver redo its magic
1184 * as iterlimit, we use the number of iterations it took for the first solve, or itermin
1185 */
1186 SCIPdebugMsg(scip, "start NLP solve with iteration limit %d\n", calcIterLimit(scip, heurdata));
1187 SCIP_CALL( SCIPsolveNLP(heurdata->subscip,
1188 .iterlimit = MAX(heurdata->itermin, nlpstatistics.niterations),
1189 .opttol = heurdata->opttol,
1190 .feastol = heurdata->feastolfactor * heurdata->feastol,
1191 .verblevel = (unsigned short)heurdata->nlpverblevel,
1192 .warmstart = TRUE
1193 ) ); /*lint !e666*/
1194
1195 SCIPdebugMsg(scip, "NLP solver returned with termination status %d and solution status %d, objective value is %g\n",
1196 SCIPgetNLPTermstat(heurdata->subscip), SCIPgetNLPSolstat(heurdata->subscip), SCIPgetNLPObjval(heurdata->subscip));
1197
1198 /* add NLP solve statistics from subscip to main SCIP again, so they show up in final statistics */
1199 SCIPmergeNLPIStatistics(heurdata->subscip, scip, heurdata->continuous);
1200
1201 /* some serious problem: just pretend it didn't happen */
1202 if( SCIPgetNLPTermstat(heurdata->subscip) >= SCIP_NLPTERMSTAT_OUTOFMEMORY )
1203 return SCIP_OKAY;
1204
1205 SCIP_CALL( SCIPgetNLPStatistics(heurdata->subscip, &nlpstatistics) );
1206 SCIPdebugMsg(scip, "NLP solver used %d iterations and %g seconds; violation cons %g, bounds %g\n",
1207 nlpstatistics.niterations, nlpstatistics.totaltime, nlpstatistics.consviol, nlpstatistics.boundviol);
1208
1209 /* we account only the extra iterations for this unusual NLP solve, but don't add anything else to our statistics (nnlpsolved, etc) */
1210 heurdata->iterused += nlpstatistics.niterations;
1211
1212 /* if failed to get a feasible NLP solution now, then nothing to do */
1213 if( SCIPgetNLPSolstat(heurdata->subscip) > SCIP_NLPSOLSTAT_FEASIBLE )
1214 return SCIP_OKAY;
1215
1216 SCIP_CALL( processNLPSol(scip, heur, authorheur, result, resultsol) );
1217
1218 /* if successful, then use tighter feastol for all NLP solves from now on
1219 * if still not accepted, then don't try this again
1220 * (maybe the NLP is incomplete; we could give up on running this heur completely, but for now let the successrate factor in heurExec take care of running it less often)
1221 */
1222 if( *result == SCIP_FOUNDSOL )
1223 heurdata->feastol *= heurdata->feastolfactor;
1224 else
1225 heurdata->tighterfeastolfailed = TRUE;
1226
1227 return SCIP_OKAY;
1228}
1229
1230
1231/** adds a set covering or bound disjunction constraint to the original problem */
1232static
1233SCIP_RETCODE forbidFixation(
1234 SCIP* scip, /**< SCIP data structure */
1235 SCIP_HEURDATA* heurdata /**< heuristic data */
1236 )
1237{
1238 SCIP_VAR** subvars;
1239 int nsubvars;
1240 int nsubbinvars;
1241 int nsubintvars;
1242 SCIP_VAR* var;
1243 SCIP_VAR* subvar;
1244 SCIP_CONS* cons;
1245 SCIP_VAR** consvars;
1246 int nconsvars;
1247 char name[SCIP_MAXSTRLEN];
1248 int i;
1249 SCIP_Real fixval;
1250
1251 assert(scip != NULL);
1252
1253 SCIP_CALL( SCIPgetOrigVarsData(heurdata->subscip, &subvars, &nsubvars, &nsubbinvars, &nsubintvars, NULL, NULL) );
1254 assert(nsubvars == heurdata->nsubvars);
1255
1256 if( nsubbinvars == 0 && nsubintvars == 0 )
1257 {
1258 /* If we did not fix any discrete variables but found the "sub"CIP infeasible, then also the CIP is infeasible. */
1259 SCIPdebugMsg(scip, "heur_subnlp found subCIP infeasible after fixing no variables, something is strange here...\n");
1260 return SCIP_OKAY;
1261 }
1262
1263 /* initialize */
1264 cons = NULL;
1265 consvars = NULL;
1266
1267 /* create constraint name */
1268 (void) SCIPsnprintf(name, SCIP_MAXSTRLEN, "subnlp_cutoff");
1269
1270 /* if all discrete variables in the CIP are binary, then we create a set covering constraint
1271 * sum_{x_i fixed at 0} x_i + sum_{x_i fixed at 1} ~x_i >= 1
1272 */
1273 if( nsubintvars == 0 )
1274 {
1275 /* allocate memory for constraint variables */
1276 SCIP_CALL( SCIPallocBufferArray(scip, &consvars, nsubbinvars) );
1277
1278 /* get fixations of discrete variables
1279 * to be sure, we take the values that were put into the subCIP before
1280 */
1281 nconsvars = 0;
1282 for( i = nsubbinvars - 1; i >= 0; --i )
1283 {
1284 subvar = subvars[i];
1285 assert(SCIPvarGetProbindex(subvar) == i);
1286
1287 var = heurdata->var_subscip2scip[i];
1288 assert(var != NULL || SCIPisEQ(scip, SCIPvarGetLbGlobal(subvar), SCIPvarGetUbGlobal(subvar))); /* otherwise we should have exited in the variable fixation loop */
1289 if( var == NULL )
1290 continue;
1291
1292 fixval = SCIPvarGetLbGlobal(subvar);
1293 assert(fixval == SCIPvarGetUbGlobal(subvar)); /* variable should be fixed in sub-SCIP */ /*lint !e777*/
1294 assert(fixval == 0.0 || fixval == 1.0); /* we have rounded values before fixing */
1295
1296 if( fixval == 0.0 )
1297 {
1298 /* variable fixed at lower bound */
1299 consvars[nconsvars] = var;
1300 }
1301 else
1302 {
1303 SCIP_CALL( SCIPgetNegatedVar(scip, var, &consvars[nconsvars]) );
1304 }
1305
1306 ++nconsvars;
1307 }
1308
1309 /* create conflict constraint
1310 * In undercover, ConsLogicor is used, since then the inequality is not added to the LP.
1311 * However, I may want to use Setcover to avoid that the same fixing is computed by some LP based heuristic again.
1312 */
1313 SCIP_CALL( SCIPcreateConsSetcover(scip, &cons, name, nconsvars, consvars,
1314 FALSE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE) );
1315 }
1316 else
1317 {
1318 /* if there are also integer variable, then create a bound disjunction constraint
1319 * x_1 >= fixval_1 + 1 || x_1 <= fixval_1 - 1 || x_2 >= fixval_2 + 1 || x_2 <= fixval_2 - 1 || ...
1320 */
1321 SCIP_BOUNDTYPE* boundtypes;
1322 SCIP_Real* bounds;
1323
1324 /* allocate memory for constraint variables, boundtypes, and bounds
1325 * (there should be at most two literals for each integer variable)
1326 */
1327 SCIP_CALL( SCIPallocBufferArray(scip, &consvars, nsubbinvars + 2*nsubintvars) );
1328 SCIP_CALL( SCIPallocBufferArray(scip, &boundtypes, nsubbinvars + 2*nsubintvars) );
1329 SCIP_CALL( SCIPallocBufferArray(scip, &bounds, nsubbinvars + 2*nsubintvars) );
1330
1331 /* get fixations of discrete variables
1332 * to be sure, we take the values that were put into the subCIP before
1333 */
1334 nconsvars = 0;
1335 for( i = nsubbinvars + nsubintvars - 1; i >= 0; --i )
1336 {
1337 subvar = subvars[i];
1338 assert(SCIPvarGetProbindex(subvar) == i);
1339
1340 var = heurdata->var_subscip2scip[i];
1341 assert(var != NULL || SCIPisEQ(scip, SCIPvarGetLbGlobal(subvar), SCIPvarGetUbGlobal(subvar))); /* otherwise we should have exited in the variable fixation loop */
1342
1343 if( var == NULL )
1344 continue;
1345
1346 fixval = SCIPvarGetLbGlobal(subvar);
1347 assert(fixval == SCIPvarGetUbGlobal(subvar)); /* variable should be fixed in sub-SCIP */ /*lint !e777*/
1348 assert(SCIPceil(scip, fixval - 0.5) == fixval); /* we have rounded values before fixing */ /*lint !e777*/
1349 assert(SCIPvarGetType(var) != SCIP_VARTYPE_BINARY || SCIPvarIsImpliedIntegral(var)
1350 || SCIPvarGetLbGlobal(var) == fixval || SCIPvarGetUbGlobal(var) == fixval); /* for binaries, the fixval should be either 0.0 or 1.0 */ /*lint !e777*/
1351
1352 if( SCIPvarGetLbGlobal(var) < fixval )
1353 {
1354 assert(nconsvars < nsubbinvars + 2*nsubintvars);
1355
1356 /* literal x_i <= fixval-1 */
1357 boundtypes[nconsvars] = SCIP_BOUNDTYPE_UPPER;
1358 bounds[nconsvars] = fixval - 1.0;
1359 consvars[nconsvars] = var;
1360 ++nconsvars;
1361 }
1362
1363 if( SCIPvarGetUbGlobal(var) > fixval )
1364 {
1365 assert(nconsvars < nsubbinvars + 2*nsubintvars);
1366
1367 /* literal x_i >= fixval+1 */
1368 boundtypes[nconsvars] = SCIP_BOUNDTYPE_LOWER;
1369 bounds[nconsvars] = fixval + 1.0;
1370 consvars[nconsvars] = var;
1371 ++nconsvars;
1372 }
1373 }
1374
1375 /* create conflict constraint */
1376 SCIP_CALL( SCIPcreateConsBounddisjunction(scip, &cons, name, nconsvars, consvars, boundtypes, bounds,
1377 FALSE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE) );
1378
1379 SCIPfreeBufferArray(scip, &bounds);
1380 SCIPfreeBufferArray(scip, &boundtypes);
1381 SCIPfreeBufferArray(scip, &consvars);
1382 }
1383
1384 /* add and release constraint if created successfully */
1385 if( cons != NULL )
1386 {
1387 SCIPdebugMsg(scip, "adding constraint to forbid fixation in main problem\n");
1388 /* SCIPdebugPrintCons(scip, cons, NULL); */
1389 SCIP_CALL( SCIPaddCons(scip, cons) );
1390 SCIP_CALL( SCIPreleaseCons(scip, &cons) );
1391 }
1392
1393 /* free memory */
1394 SCIPfreeBufferArrayNull(scip, &consvars);
1395
1396 return SCIP_OKAY;
1397}
1398
1399
1400/*
1401 * Callback methods of primal heuristic
1402 */
1403
1404/** copy method for primal heuristic plugins (called when SCIP copies plugins) */
1405static
1406SCIP_DECL_HEURCOPY(heurCopySubNlp)
1407{ /*lint --e{715}*/
1408 assert(scip != NULL);
1409 assert(heur != NULL);
1410 assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
1411
1412 /* call inclusion method of primal heuristic */
1413 SCIP_CALL( SCIPincludeHeurSubNlp(scip) );
1414
1415 return SCIP_OKAY;
1416}
1417
1418/** destructor of primal heuristic to free user data (called when SCIP is exiting) */
1419static
1420SCIP_DECL_HEURFREE(heurFreeSubNlp)
1421{
1422 SCIP_HEURDATA* heurdata;
1423 assert(scip != NULL);
1424 assert(heur != NULL);
1425
1426 heurdata = SCIPheurGetData(heur);
1427 assert(heurdata != NULL);
1428 assert(heurdata->subscip == NULL);
1429 assert(heurdata->var_subscip2scip == NULL);
1430 assert(heurdata->var_scip2subscip == NULL);
1431 assert(heurdata->startcand == NULL);
1432
1433 SCIPfreeBlockMemory(scip, &heurdata);
1434
1435 return SCIP_OKAY;
1436}
1437
1438/** initialization method of primal heuristic (called after problem was transformed) */
1439static
1440SCIP_DECL_HEURINIT(heurInitSubNlp)
1441{ /*lint --e{715}*/
1442 SCIP_HEURDATA* heurdata;
1443
1444 assert(scip != NULL);
1445 assert(heur != NULL);
1446
1447 heurdata = SCIPheurGetData(heur);
1448 assert(heurdata != NULL);
1449 assert(heurdata->subscip == NULL);
1450
1451 /* reset or initialize some flags and counters */
1452 heurdata->feastol = SCIPfeastol(scip);
1453 heurdata->tighterfeastolfailed = FALSE;
1454 heurdata->triedsetupsubscip = FALSE;
1455 heurdata->nseriousnlpierror = 0;
1456 heurdata->iterused = 0;
1457 heurdata->iterusedokay = 0;
1458 heurdata->iterusediterlim = 0;
1459 heurdata->nnlpsolves = 0;
1460 heurdata->nnlpsolvesokay = 0;
1461 heurdata->nnlpsolvesiterlim = 0;
1462 heurdata->nnlpsolvesinfeas = 0;
1463
1464 return SCIP_OKAY;
1465}
1466
1467/** solving process initialization method of primal heuristic (called when branch and bound process is about to begin) */
1468static
1469SCIP_DECL_HEURINITSOL(heurInitsolSubNlp)
1470{
1471 SCIP_HEURDATA* heurdata;
1472
1473 assert(scip != NULL);
1474 assert(heur != NULL);
1475
1476 /* get heuristic data */
1477 heurdata = SCIPheurGetData(heur);
1478 assert(heurdata != NULL);
1479
1480 /* store subnlp timing */
1481 heurdata->inittiming = SCIPheurGetTimingmask(heur);
1482
1483 /* disable subnlp heuristic */
1484 if( !SCIPisNLPConstructed(scip) || SCIPgetNNlpis(scip) == 0 )
1485 SCIPheurSetTimingmask(heur, SCIP_HEURTIMING_NONE);
1486 /* if the heuristic is called at the root node, we want to be called directly after the initial root LP solve */
1487 else if( SCIPheurGetFreqofs(heur) == 0 )
1488 SCIPheurSetTimingmask(heur, heurdata->inittiming | SCIP_HEURTIMING_DURINGLPLOOP);
1489
1490 return SCIP_OKAY;
1491}
1492
1493/** solving process deinitialization method of primal heuristic (called before branch and bound process data is freed) */
1494static
1495SCIP_DECL_HEUREXITSOL(heurExitsolSubNlp)
1496{
1497 SCIP_HEURDATA* heurdata;
1498
1499 assert(scip != NULL);
1500 assert(heur != NULL);
1501
1502 /* get heuristic data */
1503 heurdata = SCIPheurGetData(heur);
1504 assert(heurdata != NULL);
1505
1506 if( heurdata->subscip != NULL )
1507 {
1508 SCIP_CALL( freeSubSCIP(scip, heurdata) );
1509 heurdata->triedsetupsubscip = FALSE;
1510 }
1511
1512 /* free start candidate */
1513 if( heurdata->startcand != NULL )
1514 {
1515 SCIP_CALL( SCIPfreeSol(scip, &heurdata->startcand) );
1516 }
1517
1518 /* reset subnlp timing */
1519 SCIPheurSetTimingmask(heur, heurdata->inittiming);
1520
1521 return SCIP_OKAY;
1522}
1523
1524
1525/** execution method of primal heuristic */
1526static
1527SCIP_DECL_HEUREXEC(heurExecSubNlp)
1528{ /*lint --e{666,715}*/
1529 SCIP_HEURDATA* heurdata;
1530 SCIP_Bool runheur;
1531 SCIP_Real itercontingent;
1532
1533 assert(scip != NULL);
1534 assert(heur != NULL);
1535 assert(SCIPisNLPConstructed(scip));
1536 assert(SCIPgetNNlpis(scip) >= 1);
1537
1538 /* obviously, we did not do anything yet */
1539 *result = SCIP_DIDNOTRUN;
1540
1541 /* before we run the heuristic for the first time, check whether we want to run the heuristic at all */
1542 if( SCIPheurGetNCalls(heur) == 0 )
1543 {
1544 SCIP_CALL( SCIPhasNLPContinuousNonlinearity(scip, &runheur) );
1545 if( !runheur )
1546 {
1547 SCIPheurSetTimingmask(heur, SCIP_HEURTIMING_NONE);
1548 return SCIP_OKAY;
1549 }
1550 }
1551
1552 /* get heuristic's data */
1553 heurdata = SCIPheurGetData(heur);
1554 assert(heurdata != NULL);
1555
1556 /* if triedsetupsubscip and keepcopy and subscip == NULL, then we tried to setup a subSCIP before, but failed due to some serious error
1557 * thus, we should do not need to try again
1558 *
1559 * otherwise, we continue and let SCIPapplyHeurSubNlp try to create subscip
1560 */
1561 if( heurdata->subscip == NULL && heurdata->keepcopy && heurdata->triedsetupsubscip )
1562 return SCIP_OKAY;
1563
1564 if( heurdata->startcand == NULL )
1565 {
1566 /* if no start candidate is given, we consider the LP solution of the current node */
1567
1568 /* however, if the node was already detected to be infeasible, then there is no point to look at its LP solution */
1569 if( nodeinfeasible )
1570 return SCIP_OKAY;
1571
1572 /* at least if we are not called the first time, we call the heuristic only if an optimal LP solution is available
1573 * if we are called the first time and the LP is unbounded, then we are quite desperate and still give the NLP a try
1574 */
1575 if( SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
1576 {
1577 if( SCIPgetNNodes(scip) > 1 || SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_UNBOUNDEDRAY )
1578 {
1579 *result = SCIP_DELAYED;
1580 SCIPdebugMsg(scip, "NLP heuristic delayed because no start candidate given and no LP solution available; LP status = %d\n", SCIPgetLPSolstat(scip));
1581 return SCIP_OKAY;
1582 }
1583 else
1584 {
1585 SCIPdebugMsg(scip, "LP is unbounded in root node, so we are quite desperate; run NLP heuristic and pray\n");
1586 }
1587 }
1588 else if( SCIPgetNLPBranchCands(scip) > 0 )
1589 {
1590 /* only call heuristic, if there are no fractional variables */
1591 *result = SCIP_DELAYED;
1592 SCIPdebugMsg(scip, "NLP heuristic delayed because no start candidate given and current LP solution is fractional\n");
1593 return SCIP_OKAY;
1594 }
1595 else if( !SCIPisInfinity(scip, SCIPgetPrimalbound(scip)) && SCIPisEQ(scip, SCIPgetLocalDualbound(scip), SCIPgetPrimalbound(scip)) )
1596 {
1597 /* only call heuristic, if there is still room for improvement in the current node */
1598 SCIPdebugMsg(scip, "NLP heuristic delayed because lower and upper bound coincide in current node\n");
1599 return SCIP_OKAY;
1600 }
1601 SCIPdebugMsg(scip, "using current LP solution as startcand\n");
1602 }
1603 else
1604 {
1605 SCIPdebugMsg(scip, "have startcand from heur %s\n", SCIPsolGetHeur(heurdata->startcand) ? SCIPheurGetName(SCIPsolGetHeur(heurdata->startcand)) : "NULL");
1606 }
1607
1608 /* check if enough nodes have been processed so that we want to run the heuristic again */
1609
1610 /* compute the contingent on number of iterations that the NLP solver is allowed to use
1611 * we make it depending on the current number of processed nodes
1612 */
1613 itercontingent = heurdata->nodesfactor * (SCIPgetNNodes(scip) + heurdata->nodesoffset);
1614 /* weight by previous success of heuristic if we have been running already
1615 * require at least ninitsolves many runs that didn't run into the NLP iterlimit
1616 * (so if we are still in the phase of finding a good iterlimit, do not consider success rate so far)
1617 */
1618 if( heurdata->successrateexp > 0.0 && SCIPheurGetNCalls(heur) - heurdata->nnlpsolvesiterlim >= heurdata->ninitsolves )
1619 itercontingent *= pow((SCIPheurGetNSolsFound(heur) + 1.0) / (SCIPheurGetNCalls(heur) + 1.0), heurdata->successrateexp);
1620 /* subtract the number of iterations used for all NLP solves so far */
1621 itercontingent -= heurdata->iterused;
1622
1623 /* check whether the itercontingent is sufficient for the iteration limit we would use */
1624 if( itercontingent < calcIterLimit(scip, heurdata) )
1625 {
1626 /* not enough iterations left to start NLP solver */
1627 SCIPdebugMsg(scip, "skip NLP heuristic; contingent=%f; iterlimit=%d; success ratio=%g\n",
1628 itercontingent, calcIterLimit(scip, heurdata), pow((SCIPheurGetNSolsFound(heur) + 1.0) / (SCIPheurGetNCalls(heur) + 1.0), heurdata->successrateexp));
1629 return SCIP_OKAY;
1630 }
1631
1632 /* so far we have not found any solution, but now we are willing to search for one */
1633 *result = SCIP_DIDNOTFIND;
1634
1635 if( heurdata->nlpverblevel >= 1 )
1636 {
1637 SCIPinfoMessage(scip, NULL, "calling subnlp heuristic\n");
1638 }
1639
1640 SCIP_CALL( SCIPapplyHeurSubNlp(scip, heur, result, heurdata->startcand, NULL) );
1641
1642 /* SCIP does not like cutoff as return, so we say didnotfind, since we did not find a solution */
1643 if( *result == SCIP_CUTOFF )
1644 *result = SCIP_DIDNOTFIND;
1645
1646 /* forget startcand */
1647 if( heurdata->startcand != NULL )
1648 {
1649 SCIP_CALL( SCIPfreeSol(scip, &heurdata->startcand) );
1650 }
1651
1652 /* reset timing, if it was changed temporary (at the root node) */
1653 if( heurtiming != HEUR_TIMING )
1654 SCIPheurSetTimingmask(heur, HEUR_TIMING);
1655
1656 return SCIP_OKAY;
1657}
1658
1659
1660/*
1661 * primal heuristic specific interface methods
1662 */
1663
1664/** creates the NLP local search primal heuristic and includes it in SCIP */
1665SCIP_RETCODE SCIPincludeHeurSubNlp(
1666 SCIP* scip /**< SCIP data structure */
1667 )
1668{
1669 SCIP_HEURDATA* heurdata;
1670 SCIP_HEUR* heur;
1671
1672 /* create Nlp primal heuristic data */
1673 SCIP_CALL( SCIPallocBlockMemory(scip, &heurdata) );
1674 BMSclearMemory(heurdata);
1675 heurdata->inittiming = HEUR_TIMING;
1676
1677 /* include variable event handler */
1678 heurdata->eventhdlr = NULL;
1679 SCIP_CALL( SCIPincludeEventhdlrBasic(scip, &heurdata->eventhdlr, HEUR_NAME, "propagates a global bound change to the sub-SCIP",
1680 processVarEvent, NULL) );
1681 assert(heurdata->eventhdlr != NULL);
1682
1683 /* include primal heuristic */
1684 SCIP_CALL( SCIPincludeHeurBasic(scip, &heur,
1685 HEUR_NAME, HEUR_DESC, HEUR_DISPCHAR, HEUR_PRIORITY, HEUR_FREQ, HEUR_FREQOFS,
1686 HEUR_MAXDEPTH, HEUR_TIMING, HEUR_USESSUBSCIP, heurExecSubNlp, heurdata) );
1687
1688 assert(heur != NULL);
1689
1690 /* set non-NULL pointers to callback methods */
1691 SCIP_CALL( SCIPsetHeurCopy(scip, heur, heurCopySubNlp) );
1692 SCIP_CALL( SCIPsetHeurFree(scip, heur, heurFreeSubNlp) );
1693 SCIP_CALL( SCIPsetHeurInit(scip, heur, heurInitSubNlp) );
1694 SCIP_CALL( SCIPsetHeurInitsol(scip, heur, heurInitsolSubNlp) );
1695 SCIP_CALL( SCIPsetHeurExitsol(scip, heur, heurExitsolSubNlp) );
1696
1697 /* add Nlp primal heuristic parameters */
1698 SCIP_CALL( SCIPaddIntParam (scip, "heuristics/" HEUR_NAME "/nlpverblevel",
1699 "verbosity level of NLP solver",
1700 &heurdata->nlpverblevel, FALSE, 0, 0, USHRT_MAX, NULL, NULL) );
1701
1702 SCIP_CALL( SCIPaddIntParam (scip, "heuristics/" HEUR_NAME "/nodesoffset",
1703 "number of nodes added to the current number of nodes when computing itercontingent (higher value runs heuristic more often in early search)",
1704 &heurdata->nodesoffset, FALSE, 1600, 0, INT_MAX, NULL, NULL) );
1705
1706 SCIP_CALL( SCIPaddRealParam(scip, "heuristics/" HEUR_NAME "/nodesfactor",
1707 "factor on number of nodes in SCIP (plus nodesoffset) to compute itercontingent (higher value runs heuristics more frequently)",
1708 &heurdata->nodesfactor, FALSE, 0.3, 0.0, SCIPinfinity(scip), NULL, NULL) );
1709
1710 SCIP_CALL( SCIPaddRealParam(scip, "heuristics/" HEUR_NAME "/successrateexp",
1711 "exponent for power of success rate to be multiplied with itercontingent (lower value decreases impact of success rate)",
1712 &heurdata->successrateexp, FALSE, 1.0, 0.0, DBL_MAX, NULL, NULL) );
1713
1714 SCIP_CALL( SCIPaddIntParam (scip, "heuristics/" HEUR_NAME "/iterinit",
1715 "number of iterations used for initial NLP solves",
1716 &heurdata->iterinit, FALSE, 300, 0, INT_MAX, NULL, NULL) );
1717
1718 SCIP_CALL( SCIPaddIntParam (scip, "heuristics/" HEUR_NAME "/ninitsolves",
1719 "number of successful NLP solves until switching to iterlimit guess and using success rate",
1720 &heurdata->ninitsolves, FALSE, 2, 0, INT_MAX, NULL, NULL) );
1721
1722 SCIP_CALL( SCIPaddIntParam (scip, "heuristics/" HEUR_NAME "/itermin",
1723 "minimal number of iterations for NLP solves",
1724 &heurdata->itermin, FALSE, 20, 0, INT_MAX, NULL, NULL) );
1725
1726 SCIP_CALL( SCIPaddRealParam(scip, "heuristics/" HEUR_NAME "/opttol",
1727 "absolute optimality tolerance to use for NLP solves",
1728 &heurdata->opttol, TRUE, SCIPdualfeastol(scip), 0.0, 1.0, NULL, NULL) );
1729
1730 SCIP_CALL( SCIPaddRealParam(scip, "heuristics/" HEUR_NAME "/feastolfactor",
1731 "factor on SCIP feasibility tolerance for NLP solves if resolving when NLP solution not feasible in CIP",
1732 &heurdata->feastolfactor, FALSE, 0.1, 0.0, 1.0, NULL, NULL) );
1733
1734 SCIP_CALL( SCIPaddIntParam(scip, "heuristics/" HEUR_NAME "/maxpresolverounds",
1735 "limit on number of presolve rounds in sub-SCIP (-1 for unlimited, 0 for no presolve)",
1736 &heurdata->maxpresolverounds, FALSE, -1, -1, INT_MAX, NULL, NULL) );
1737
1738 SCIP_CALL( SCIPaddIntParam(scip, "heuristics/" HEUR_NAME "/presolveemphasis",
1739 "presolve emphasis in sub-SCIP (0: default, 1: aggressive, 2: fast, 3: off)",
1740 &heurdata->presolveemphasis, FALSE, (int)SCIP_PARAMSETTING_FAST, (int)SCIP_PARAMSETTING_DEFAULT, (int)SCIP_PARAMSETTING_OFF, NULL, NULL) );
1741
1742 SCIP_CALL( SCIPaddBoolParam (scip, "heuristics/" HEUR_NAME "/setcutoff",
1743 "whether to set cutoff in sub-SCIP to current primal bound",
1744 &heurdata->setcutoff, FALSE, TRUE, NULL, NULL) );
1745
1746 SCIP_CALL( SCIPaddBoolParam (scip, "heuristics/" HEUR_NAME "/forbidfixings",
1747 "whether to add constraints that forbid specific fixings that turned out to be infeasible",
1748 &heurdata->forbidfixings, FALSE, FALSE, NULL, NULL) );
1749
1750 SCIP_CALL( SCIPaddBoolParam (scip, "heuristics/" HEUR_NAME "/keepcopy",
1751 "whether to keep SCIP copy or to create new copy each time heuristic is applied",
1752 &heurdata->keepcopy, TRUE, TRUE, NULL, NULL) );
1753
1754 SCIP_CALL( SCIPaddRealParam(scip, "heuristics/" HEUR_NAME "/expectinfeas",
1755 "percentage of NLP solves with infeasible status required to tell NLP solver to expect an infeasible NLP",
1756 &heurdata->expectinfeas, FALSE, 0.0, 0.0, 1.0, NULL, NULL) );
1757
1758 return SCIP_OKAY;
1759}
1760
1761/** main procedure of the subNLP heuristic */
1762SCIP_RETCODE SCIPapplyHeurSubNlp(
1763 SCIP* scip, /**< original SCIP data structure */
1764 SCIP_HEUR* heur, /**< heuristic data structure */
1765 SCIP_RESULT* result, /**< pointer to store result of: did not run, solution found, no solution found, or fixing is infeasible (cutoff) */
1766 SCIP_SOL* refpoint, /**< point to take fixation of discrete variables from, and startpoint for NLP solver; if NULL, then LP solution is used */
1767 SCIP_SOL* resultsol /**< a solution where to store found solution values, if any, or NULL if to try adding to SCIP */
1768 )
1769{
1770 SCIP_HEURDATA* heurdata;
1771 SCIP_VAR* var;
1772 SCIP_VAR* subvar;
1773 int i;
1774 SCIP_Real cutoff = SCIPinfinity(scip);
1775
1776 assert(scip != NULL);
1777 assert(heur != NULL);
1778
1779 /* get heuristic's data */
1780 heurdata = SCIPheurGetData(heur);
1781 assert(heurdata != NULL);
1782
1783 /* try to setup NLP if not tried before */
1784 if( heurdata->subscip == NULL && !heurdata->triedsetupsubscip )
1785 {
1786 SCIP_CALL( createSubSCIP(scip, heurdata) );
1787 }
1788
1789 *result = SCIP_DIDNOTRUN;
1790
1791 /* if subSCIP could not be created, then do not run */
1792 if( heurdata->subscip == NULL )
1793 return SCIP_OKAY;
1794
1795 assert(heurdata->nsubvars > 0);
1796 assert(heurdata->var_subscip2scip != NULL);
1797
1798 /* fix discrete variables in sub-SCIP */
1799 if( !heurdata->continuous )
1800 {
1801 SCIP_Real fixval;
1802 SCIP_VAR** subvars;
1803 int nsubvars;
1804 int nsubbinvars;
1805 int nsubintvars;
1806 SCIP_Bool infeas;
1807 SCIP_Bool tightened;
1808
1809 /* transform sub-SCIP, so variable fixing are easily undone by free-transform */
1810 assert(!SCIPisTransformed(heurdata->subscip));
1811 SCIP_CALL( SCIPtransformProb(heurdata->subscip) );
1812
1813 SCIP_CALL( SCIPgetOrigVarsData(heurdata->subscip, &subvars, &nsubvars, &nsubbinvars, &nsubintvars, NULL, NULL) );
1814 assert(nsubvars == heurdata->nsubvars);
1815
1816 /* fix discrete variables to values in startpoint */
1817 for( i = nsubbinvars + nsubintvars - 1; i >= 0; --i )
1818 {
1819 subvar = subvars[i];
1820 assert(SCIPvarGetProbindex(subvar) == i);
1821
1822 var = heurdata->var_subscip2scip[i];
1823 assert(var != NULL);
1824
1825 /* at this point, variables in subscip and in our scip should have same bounds */
1826 assert(SCIPisEQ(scip, SCIPvarGetLbGlobal(subvar), SCIPvarGetLbGlobal(var)));
1827 assert(SCIPisEQ(scip, SCIPvarGetUbGlobal(subvar), SCIPvarGetUbGlobal(var)));
1828
1829 fixval = SCIPgetSolVal(scip, refpoint, var);
1830
1831 /* only run heuristic on integer feasible points (unless we are on an unbounded LP) */
1832 if( !SCIPisFeasIntegral(scip, fixval) )
1833 {
1834 if( refpoint != NULL || SCIPgetLPSolstat(scip) == SCIP_LPSOLSTAT_OPTIMAL )
1835 {
1836 SCIPdebugMsg(scip, "skip NLP heuristic because start candidate not integer feasible: var <%s> has value %g\n", SCIPvarGetName(var), fixval);
1837 goto CLEANUP;
1838 }
1839 }
1840 /* if we do not really have a startpoint, then we should take care that we do not fix variables to very large values
1841 * thus, we set to 0.0 here and project on bounds below
1842 */
1843 if( REALABS(fixval) > 1E+10 && refpoint == NULL && SCIPgetLPSolstat(scip) != SCIP_LPSOLSTAT_OPTIMAL )
1844 fixval = 0.0;
1845
1846 /* fixing variables to infinity causes problems, we should not have been passed such a solution as refpoint */
1847 assert(!SCIPisInfinity(scip, REALABS(fixval)));
1848
1849 /* round fractional variables to the nearest integer */
1850 fixval = SCIPround(scip, fixval);
1851
1852 /* adjust value to the global bounds of the corresponding SCIP variable */
1853 fixval = MAX(fixval, SCIPvarGetLbGlobal(var)); /*lint !e666*/
1854 fixval = MIN(fixval, SCIPvarGetUbGlobal(var)); /*lint !e666*/
1855
1856 /* SCIPdebugMsg(scip, "fix variable <%s> to %g\n", SCIPvarGetName(var), fixval); */
1857 SCIP_CALL( SCIPtightenVarLb(heurdata->subscip, subvar, fixval, TRUE, &infeas, &tightened) );
1858 if( !infeas )
1859 {
1860 SCIP_CALL( SCIPtightenVarUb(heurdata->subscip, subvar, fixval, TRUE, &infeas, &tightened) );
1861 }
1862 if( infeas )
1863 {
1864 SCIPdebugMsg(scip, "skip NLP heuristic because start candidate not feasible: fixing var <%s> to value %g is infeasible\n", SCIPvarGetName(var), fixval);
1865 goto CLEANUP;
1866 }
1867 }
1868
1869 /* if there is already a solution, possibly add an objective cutoff in sub-SCIP
1870 * we do this here only for problems with discrete variables, since the cutoff may be useful when presolving the subscip
1871 * for the NLP solver, a cutoff is useless at best
1872 */
1873 if( SCIPgetNSols(scip) > 0 && heurdata->setcutoff )
1874 {
1875 cutoff = SCIPgetUpperbound(scip);
1876 assert( !SCIPisInfinity(scip, cutoff) );
1877
1878 SCIP_CALL( SCIPsetObjlimit(heurdata->subscip, cutoff) );
1879 SCIPdebugMsg(scip, "set objective limit %g\n", cutoff);
1880 }
1881 }
1882 else
1883 {
1884 /* for continuous problems, we should already be in the transformed stage */
1885 assert(SCIPisTransformed(heurdata->subscip));
1886 }
1887
1888 /* solve the subNLP and try to add solution to SCIP */
1889 SCIP_CALL( solveSubNLP(scip, heur, result, refpoint, resultsol) );
1890
1891 if( heurdata->subscip == NULL )
1892 {
1893 /* something horrible must have happened that we decided to give up completely on this heuristic */
1894 *result = SCIP_DIDNOTFIND;
1895 return SCIP_OKAY;
1896 }
1897
1898 if( *result == SCIP_CUTOFF )
1899 {
1900 if( heurdata->subscipisvalid && SCIPgetNActivePricers(scip) == 0 )
1901 {
1902 /* if the subNLP is valid and turned out to be globally infeasible (i.e., proven by SCIP), then we forbid this fixation in the main problem */
1903 if( SCIPisInfinity(scip, cutoff) && heurdata->forbidfixings )
1904 {
1905 SCIP_CALL( forbidFixation(scip, heurdata) );
1906 }
1907 }
1908 else
1909 {
1910 /* if the subNLP turned out to be globally infeasible but we are not sure that we have a valid copy, we change to DIDNOTFIND */
1911 *result = SCIP_DIDNOTFIND;
1912 }
1913 }
1914
1915 CLEANUP:
1916 if( !heurdata->continuous )
1917 {
1918 SCIP_CALL( SCIPfreeTransform(heurdata->subscip) );
1919 }
1920
1921 /* if the heuristic was applied before solving has started, then destroy subSCIP, since EXITSOL may not be called
1922 * also if keepcopy is disabled, then destroy subSCIP
1923 */
1924 if( SCIPgetStage(scip) < SCIP_STAGE_SOLVING || !heurdata->keepcopy )
1925 {
1926 SCIP_CALL( freeSubSCIP(scip, heurdata) );
1927 heurdata->triedsetupsubscip = FALSE;
1928 }
1929
1930 return SCIP_OKAY;
1931}
1932
1933/** updates the starting point for the NLP heuristic
1934 *
1935 * Is called by a constraint handler that handles nonlinear constraints when a check on feasibility of a solution fails.
1936 */
1937SCIP_RETCODE SCIPupdateStartpointHeurSubNlp(
1938 SCIP* scip, /**< SCIP data structure */
1939 SCIP_HEUR* heur, /**< NLP heuristic */
1940 SCIP_SOL* solcand, /**< solution candidate */
1941 SCIP_Real violation /**< constraint violation of solution candidate */
1942 )
1943{
1944 SCIP_HEURDATA* heurdata;
1945
1946 assert(scip != NULL);
1947 assert(heur != NULL);
1948 assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
1949 assert(solcand != NULL);
1950 assert(SCIPisPositive(scip, violation));
1951
1952 /* too early or the game is over already: no more interest in starting points */
1953 if( SCIPgetStage(scip) != SCIP_STAGE_SOLVING )
1954 return SCIP_OKAY;
1955
1956 /* only update starting point if an NLP relaxation has been constructed */
1957 if( !SCIPisNLPConstructed(scip) || SCIPgetNNlpis(scip) == 0 )
1958 return SCIP_OKAY;
1959
1960 heurdata = SCIPheurGetData(heur);
1961 assert(heurdata != NULL);
1962
1963 if( heurdata->subscip == NULL )
1964 {
1965 /* if we do not have a sub-SCIP, but tried to set one up before or will never create a subSCIP, then do not need a starting point */
1966 SCIP_Bool runheur;
1967 if( heurdata->triedsetupsubscip )
1968 return SCIP_OKAY;
1969 if( SCIPheurGetFreq(heur) < 0 )
1970 return SCIP_OKAY;
1971 SCIP_CALL( SCIPhasNLPContinuousNonlinearity(scip, &runheur) );
1972 if( !runheur )
1973 return SCIP_OKAY;
1974 }
1975
1976 /* if the solution is the one we created (last), then it is useless to use it as starting point again
1977 * (we cannot check SCIPsolGetHeur()==heur, as subnlp may not be registered as author of the solution)
1978 */
1979 if( heurdata->lastsol == solcand )
1980 return SCIP_OKAY;
1981
1982 SCIPdebugMsg(scip, "consider solution candidate with violation %g and objective %g from %s\n",
1983 violation, SCIPgetSolTransObj(scip, solcand), SCIPsolGetHeur(solcand) ? SCIPheurGetName(SCIPsolGetHeur(solcand)) : "tree");
1984
1985 /* if we have no point yet, or the new point has a lower constraint violation, or it has a better objective function value, then take the new point */
1986 if( heurdata->startcand == NULL || violation < heurdata->startcandviol ||
1987 SCIPisRelGT(scip, SCIPgetSolTransObj(scip, heurdata->startcand), SCIPgetSolTransObj(scip, solcand)) )
1988 {
1989 if( heurdata->startcand != NULL )
1990 {
1991 SCIP_CALL( SCIPfreeSol(scip, &heurdata->startcand) );
1992 }
1993 SCIP_CALL( SCIPcreateSolCopy(scip, &heurdata->startcand, solcand) );
1994 SCIP_CALL( SCIPunlinkSol(scip, heurdata->startcand) );
1995 heurdata->startcandviol = violation;
1996
1997 /* remember which heuristic proposed the candidate */
1998 SCIPsolSetHeur(heurdata->startcand, SCIPgetSolHeur(scip, solcand));
1999 }
2000
2001 return SCIP_OKAY;
2002}
2003
2004/** gets startpoint candidate to be used in next call to NLP heuristic, or NULL if none */
2005SCIP_SOL* SCIPgetStartCandidateHeurSubNlp(
2006 SCIP* scip, /**< original SCIP data structure */
2007 SCIP_HEUR* heur /**< heuristic data structure */
2008 )
2009{
2010 SCIP_HEURDATA* heurdata;
2011
2012 assert(scip != NULL);
2013 assert(heur != NULL);
2014 assert(strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0);
2015
2016 heurdata = SCIPheurGetData(heur);
2017 assert(heurdata != NULL);
2018
2019 return heurdata->startcand;
2020}
cons_bounddisjunction.h
constraint handler for bound disjunction constraints
cons_setppc.h
Constraint handler for the set partitioning / packing / covering constraints .
NULL
#define NULL
Definition: def.h:248
SCIP_MAXSTRLEN
#define SCIP_MAXSTRLEN
Definition: def.h:269
SCIP_Longint
#define SCIP_Longint
Definition: def.h:141
SCIP_INVALID
#define SCIP_INVALID
Definition: def.h:178
SCIP_Bool
#define SCIP_Bool
Definition: def.h:91
MIN
#define MIN(x, y)
Definition: def.h:224
MAX3
#define MAX3(x, y, z)
Definition: def.h:228
SCIP_Real
#define SCIP_Real
Definition: def.h:156
TRUE
#define TRUE
Definition: def.h:93
FALSE
#define FALSE
Definition: def.h:94
MAX
#define MAX(x, y)
Definition: def.h:220
SCIPABORT
#define SCIPABORT()
Definition: def.h:327
REALABS
#define REALABS(x)
Definition: def.h:182
SCIP_CALL
#define SCIP_CALL(x)
Definition: def.h:355
SCIPcreateConsBounddisjunction
SCIP_RETCODE SCIPcreateConsBounddisjunction(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
Definition: cons_bounddisjunction.c:3316
SCIPcreateConsSetcover
SCIP_RETCODE SCIPcreateConsSetcover(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Bool initial, SCIP_Bool separate, SCIP_Bool enforce, SCIP_Bool check, SCIP_Bool propagate, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool dynamic, SCIP_Bool removable, SCIP_Bool stickingatnode)
Definition: cons_setppc.c:9518
SCIPcopyPlugins
SCIP_RETCODE SCIPcopyPlugins(SCIP *sourcescip, SCIP *targetscip, SCIP_Bool copyreaders, SCIP_Bool copypricers, SCIP_Bool copyconshdlrs, SCIP_Bool copyconflicthdlrs, SCIP_Bool copypresolvers, SCIP_Bool copyrelaxators, SCIP_Bool copyseparators, SCIP_Bool copycutselectors, SCIP_Bool copypropagators, SCIP_Bool copyheuristics, SCIP_Bool copyeventhdlrs, SCIP_Bool copynodeselectors, SCIP_Bool copybranchrules, SCIP_Bool copyiisfinders, SCIP_Bool copydisplays, SCIP_Bool copydialogs, SCIP_Bool copytables, SCIP_Bool copyexprhdlrs, SCIP_Bool copynlpis, SCIP_Bool passmessagehdlr, SCIP_Bool *valid)
Definition: scip_copy.c:276
SCIPmergeNLPIStatistics
void SCIPmergeNLPIStatistics(SCIP *sourcescip, SCIP *targetscip, SCIP_Bool reset)
Definition: scip_copy.c:1319
SCIPcopyVars
SCIP_RETCODE SCIPcopyVars(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_VAR **fixedvars, SCIP_Real *fixedvals, int nfixedvars, SCIP_Bool global)
Definition: scip_copy.c:1167
SCIPcopyProb
SCIP_RETCODE SCIPcopyProb(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, const char *name)
Definition: scip_copy.c:529
SCIPcopyConss
SCIP_RETCODE SCIPcopyConss(SCIP *sourcescip, SCIP *targetscip, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global, SCIP_Bool enablepricing, SCIP_Bool *valid)
Definition: scip_copy.c:1716
SCIPcopyParamSettings
SCIP_RETCODE SCIPcopyParamSettings(SCIP *sourcescip, SCIP *targetscip)
Definition: scip_copy.c:2547
SCIPisTransformed
SCIP_Bool SCIPisTransformed(SCIP *scip)
Definition: scip_general.c:647
SCIPfree
SCIP_RETCODE SCIPfree(SCIP **scip)
Definition: scip_general.c:402
SCIPcreate
SCIP_RETCODE SCIPcreate(SCIP **scip)
Definition: scip_general.c:370
SCIPgetStatus
SCIP_STATUS SCIPgetStatus(SCIP *scip)
Definition: scip_general.c:562
SCIPgetStage
SCIP_STAGE SCIPgetStage(SCIP *scip)
Definition: scip_general.c:444
SCIPgetOrigVarsData
SCIP_RETCODE SCIPgetOrigVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip_prob.c:2753
SCIPgetProbName
const char * SCIPgetProbName(SCIP *scip)
Definition: scip_prob.c:1242
SCIPgetNContVars
int SCIPgetNContVars(SCIP *scip)
Definition: scip_prob.c:2569
SCIPsetObjlimit
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
Definition: scip_prob.c:1661
SCIPgetVarsData
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
Definition: scip_prob.c:2115
SCIPgetNVars
int SCIPgetNVars(SCIP *scip)
Definition: scip_prob.c:2246
SCIPaddCons
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
Definition: scip_prob.c:3274
SCIPgetNConss
int SCIPgetNConss(SCIP *scip)
Definition: scip_prob.c:3620
SCIPgetVars
SCIP_VAR ** SCIPgetVars(SCIP *scip)
Definition: scip_prob.c:2201
SCIPgetNContImplVars
int SCIPgetNContImplVars(SCIP *scip)
Definition: scip_prob.c:2522
SCIPhashmapFree
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
Definition: misc.c:3095
SCIPhashmapEntryGetImage
void * SCIPhashmapEntryGetImage(SCIP_HASHMAPENTRY *entry)
Definition: misc.c:3613
SCIPhashmapGetImage
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
Definition: misc.c:3284
SCIPhashmapGetNEntries
int SCIPhashmapGetNEntries(SCIP_HASHMAP *hashmap)
Definition: misc.c:3584
SCIPhashmapGetEntry
SCIP_HASHMAPENTRY * SCIPhashmapGetEntry(SCIP_HASHMAP *hashmap, int entryidx)
Definition: misc.c:3592
SCIPhashmapCreate
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
Definition: misc.c:3061
SCIPhashmapEntryGetOrigin
void * SCIPhashmapEntryGetOrigin(SCIP_HASHMAPENTRY *entry)
Definition: misc.c:3603
SCIPgetLocalDualbound
SCIP_Real SCIPgetLocalDualbound(SCIP *scip)
Definition: scip_prob.c:4159
SCIPinfoMessage
void SCIPinfoMessage(SCIP *scip, FILE *file, const char *formatstr,...)
Definition: scip_message.c:208
SCIPverbMessage
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
Definition: scip_message.c:225
SCIPdebugMsg
#define SCIPdebugMsg
Definition: scip_message.h:78
SCIPwarningMessage
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
Definition: scip_message.c:120
SCIPgetStartCandidateHeurSubNlp
SCIP_SOL * SCIPgetStartCandidateHeurSubNlp(SCIP *scip, SCIP_HEUR *heur)
Definition: heur_subnlp.c:2005
SCIPapplyHeurSubNlp
SCIP_RETCODE SCIPapplyHeurSubNlp(SCIP *scip, SCIP_HEUR *heur, SCIP_RESULT *result, SCIP_SOL *refpoint, SCIP_SOL *resultsol)
Definition: heur_subnlp.c:1762
SCIPupdateStartpointHeurSubNlp
SCIP_RETCODE SCIPupdateStartpointHeurSubNlp(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL *solcand, SCIP_Real violation)
Definition: heur_subnlp.c:1937
SCIPisParamFixed
SCIP_Bool SCIPisParamFixed(SCIP *scip, const char *name)
Definition: scip_param.c:219
SCIPaddIntParam
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:83
SCIPsetLongintParam
SCIP_RETCODE SCIPsetLongintParam(SCIP *scip, const char *name, SCIP_Longint value)
Definition: scip_param.c:545
SCIPaddRealParam
SCIP_RETCODE SCIPaddRealParam(SCIP *scip, const char *name, const char *desc, SCIP_Real *valueptr, SCIP_Bool isadvanced, SCIP_Real defaultvalue, SCIP_Real minvalue, SCIP_Real maxvalue, SCIP_DECL_PARAMCHGD((*paramchgd)), SCIP_PARAMDATA *paramdata)
Definition: scip_param.c:139
SCIPsetIntParam
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
Definition: scip_param.c:487
SCIPgetRealParam
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
Definition: scip_param.c:307
SCIPresetParam
SCIP_RETCODE SCIPresetParam(SCIP *scip, const char *name)
Definition: scip_param.c:835
SCIPsetPresolving
SCIP_RETCODE SCIPsetPresolving(SCIP *scip, SCIP_PARAMSETTING paramsetting, SCIP_Bool quiet)
Definition: scip_param.c:956
SCIPaddBoolParam
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:57
SCIPsetBoolParam
SCIP_RETCODE SCIPsetBoolParam(SCIP *scip, const char *name, SCIP_Bool value)
Definition: scip_param.c:429
SCIPsetRealParam
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
Definition: scip_param.c:603
SCIPincludeHeurSubNlp
SCIP_RETCODE SCIPincludeHeurSubNlp(SCIP *scip)
Definition: heur_subnlp.c:1665
SCIPgetNLPBranchCands
int SCIPgetNLPBranchCands(SCIP *scip)
Definition: scip_branch.c:436
SCIPreleaseCons
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
Definition: scip_cons.c:1173
SCIPincludeEventhdlrBasic
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:111
SCIPeventGetType
SCIP_EVENTTYPE SCIPeventGetType(SCIP_EVENT *event)
Definition: event.c:1194
SCIPcatchVarEvent
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
Definition: scip_event.c:367
SCIPdropVarEvent
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
Definition: scip_event.c:413
SCIPeventGetVar
SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)
Definition: event.c:1217
SCIPeventGetNewbound
SCIP_Real SCIPeventGetNewbound(SCIP_EVENT *event)
Definition: event.c:1415
SCIPsetHeurExitsol
SCIP_RETCODE SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEUREXITSOL((*heurexitsol)))
Definition: scip_heur.c:247
SCIPsetHeurCopy
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURCOPY((*heurcopy)))
Definition: scip_heur.c:167
SCIPheurGetData
SCIP_HEURDATA * SCIPheurGetData(SCIP_HEUR *heur)
Definition: heur.c:1368
SCIPincludeHeurBasic
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:122
SCIPsetHeurFree
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURFREE((*heurfree)))
Definition: scip_heur.c:183
SCIPheurGetTimingmask
SCIP_HEURTIMING SCIPheurGetTimingmask(SCIP_HEUR *heur)
Definition: heur.c:1497
SCIPheurGetNSolsFound
SCIP_Longint SCIPheurGetNSolsFound(SCIP_HEUR *heur)
Definition: heur.c:1603
SCIPheurSetTimingmask
void SCIPheurSetTimingmask(SCIP_HEUR *heur, SCIP_HEURTIMING timingmask)
Definition: heur.c:1507
SCIPheurGetNCalls
SCIP_Longint SCIPheurGetNCalls(SCIP_HEUR *heur)
Definition: heur.c:1593
SCIPsetHeurInitsol
SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINITSOL((*heurinitsol)))
Definition: scip_heur.c:231
SCIPheurGetFreqofs
int SCIPheurGetFreqofs(SCIP_HEUR *heur)
Definition: heur.c:1573
SCIPsetHeurInit
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur, SCIP_DECL_HEURINIT((*heurinit)))
Definition: scip_heur.c:199
SCIPheurGetFreq
int SCIPheurGetFreq(SCIP_HEUR *heur)
Definition: heur.c:1552
SCIPheurGetName
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition: heur.c:1467
SCIPgetLPSolstat
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition: scip_lp.c:174
SCIPfreeBlockMemoryArray
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
Definition: scip_mem.h:110
SCIPblkmem
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
Definition: scip_mem.c:57
SCIPallocClearBlockMemoryArray
#define SCIPallocClearBlockMemoryArray(scip, ptr, num)
Definition: scip_mem.h:97
SCIPallocBufferArray
#define SCIPallocBufferArray(scip, ptr, num)
Definition: scip_mem.h:124
SCIPfreeBufferArray
#define SCIPfreeBufferArray(scip, ptr)
Definition: scip_mem.h:136
SCIPfreeBlockMemory
#define SCIPfreeBlockMemory(scip, ptr)
Definition: scip_mem.h:108
SCIPfreeBufferArrayNull
#define SCIPfreeBufferArrayNull(scip, ptr)
Definition: scip_mem.h:137
SCIPallocBlockMemory
#define SCIPallocBlockMemory(scip, ptr)
Definition: scip_mem.h:89
SCIPgetNNlpis
int SCIPgetNNlpis(SCIP *scip)
Definition: scip_nlpi.c:205
SCIPhasNLPContinuousNonlinearity
SCIP_RETCODE SCIPhasNLPContinuousNonlinearity(SCIP *scip, SCIP_Bool *result)
Definition: scip_nlp.c:125
SCIPisNLPConstructed
SCIP_Bool SCIPisNLPConstructed(SCIP *scip)
Definition: scip_nlp.c:110
SCIPgetNLPSolstat
SCIP_NLPSOLSTAT SCIPgetNLPSolstat(SCIP *scip)
Definition: scip_nlp.c:574
SCIPsolveNLP
#define SCIPsolveNLP(...)
Definition: scip_nlp.h:361
SCIPsetNLPInitialGuess
SCIP_RETCODE SCIPsetNLPInitialGuess(SCIP *scip, SCIP_Real *initialguess)
Definition: scip_nlp.c:474
SCIPgetNLPObjval
SCIP_Real SCIPgetNLPObjval(SCIP *scip)
Definition: scip_nlp.c:645
SCIPgetNNLPVars
int SCIPgetNNLPVars(SCIP *scip)
Definition: scip_nlp.c:201
SCIPgetNLPVars
SCIP_VAR ** SCIPgetNLPVars(SCIP *scip)
Definition: scip_nlp.c:179
SCIPhasNLPSolution
SCIP_Bool SCIPhasNLPSolution(SCIP *scip)
Definition: scip_nlp.c:671
SCIPgetNLPTermstat
SCIP_NLPTERMSTAT SCIPgetNLPTermstat(SCIP *scip)
Definition: scip_nlp.c:596
SCIPgetNLPStatistics
SCIP_RETCODE SCIPgetNLPStatistics(SCIP *scip, SCIP_NLPSTATISTICS *statistics)
Definition: scip_nlp.c:621
SCIPgetNPresolRounds
int SCIPgetNPresolRounds(SCIP *scip)
Definition: scip_presol.c:296
SCIPgetNActivePricers
int SCIPgetNActivePricers(SCIP *scip)
Definition: scip_pricer.c:348
SCIPcreateSol
SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
Definition: scip_sol.c:516
SCIPcreateSolCopy
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
Definition: scip_sol.c:884
SCIPfreeSol
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
Definition: scip_sol.c:1252
SCIPgetSolHeur
SCIP_HEUR * SCIPgetSolHeur(SCIP *scip, SCIP_SOL *sol)
Definition: scip_sol.c:2249
SCIPgetNSols
int SCIPgetNSols(SCIP *scip)
Definition: scip_sol.c:2882
SCIPsolGetHeur
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
Definition: sol.c:4259
SCIPunlinkSol
SCIP_RETCODE SCIPunlinkSol(SCIP *scip, SCIP_SOL *sol)
Definition: scip_sol.c:1506
SCIPgetSols
SCIP_SOL ** SCIPgetSols(SCIP *scip)
Definition: scip_sol.c:2931
SCIPcheckSol
SCIP_RETCODE SCIPcheckSol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *feasible)
Definition: scip_sol.c:4312
SCIPtrySolFree
SCIP_RETCODE SCIPtrySolFree(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:4109
SCIPsetSolVal
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
Definition: scip_sol.c:1571
SCIPgetSolVal
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
Definition: scip_sol.c:1765
SCIPgetSolTransObj
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
Definition: scip_sol.c:2005
SCIPsolSetHeur
void SCIPsolSetHeur(SCIP_SOL *sol, SCIP_HEUR *heur)
Definition: sol.c:4304
SCIPtransformProb
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
Definition: scip_solve.c:232
SCIPpresolve
SCIP_RETCODE SCIPpresolve(SCIP *scip)
Definition: scip_solve.c:2449
SCIPfreeTransform
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
Definition: scip_solve.c:3462
SCIPsolve
SCIP_RETCODE SCIPsolve(SCIP *scip)
Definition: scip_solve.c:2635
SCIPgetPrimalbound
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
Definition: scip_solvingstats.c:1687
SCIPgetUpperbound
SCIP_Real SCIPgetUpperbound(SCIP *scip)
Definition: scip_solvingstats.c:1734
SCIPgetNNodes
SCIP_Longint SCIPgetNNodes(SCIP *scip)
Definition: scip_solvingstats.c:214
SCIPprintStatistics
SCIP_RETCODE SCIPprintStatistics(SCIP *scip, FILE *file)
Definition: scip_solvingstats.c:5927
SCIPgetSolvingTime
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
Definition: scip_timing.c:378
SCIPinfinity
SCIP_Real SCIPinfinity(SCIP *scip)
Definition: scip_numerics.c:501
SCIPisRelGT
SCIP_Bool SCIPisRelGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:1186
SCIPisFeasEQ
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:771
SCIPisPositive
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:561
SCIPisLE
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:462
SCIPisInfinity
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:512
SCIPround
SCIP_Real SCIPround(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:646
SCIPisFeasIntegral
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:872
SCIPfeastol
SCIP_Real SCIPfeastol(SCIP *scip)
Definition: scip_numerics.c:168
SCIPdualfeastol
SCIP_Real SCIPdualfeastol(SCIP *scip)
Definition: scip_numerics.c:182
SCIPceil
SCIP_Real SCIPceil(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:634
SCIPisEQ
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
Definition: scip_numerics.c:436
SCIPisZero
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
Definition: scip_numerics.c:549
SCIPtightenVarLb
SCIP_RETCODE SCIPtightenVarLb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6401
SCIPvarGetOrigvarSum
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
Definition: var.c:18320
SCIPvarIsActive
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
Definition: var.c:23642
SCIPvarIsImpliedIntegral
SCIP_Bool SCIPvarIsImpliedIntegral(SCIP_VAR *var)
Definition: var.c:23498
SCIPvarGetUbLocal
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
Definition: var.c:24268
SCIPtightenVarUb
SCIP_RETCODE SCIPtightenVarUb(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound, SCIP_Bool force, SCIP_Bool *infeasible, SCIP_Bool *tightened)
Definition: scip_var.c:6651
SCIPvarGetType
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
Definition: var.c:23453
SCIPvarGetUbGlobal
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
Definition: var.c:24142
SCIPvarGetProbindex
int SCIPvarGetProbindex(SCIP_VAR *var)
Definition: var.c:23662
SCIPvarGetName
const char * SCIPvarGetName(SCIP_VAR *var)
Definition: var.c:23267
SCIPreleaseVar
SCIP_RETCODE SCIPreleaseVar(SCIP *scip, SCIP_VAR **var)
Definition: scip_var.c:1887
SCIPchgVarLbGlobal
SCIP_RETCODE SCIPchgVarLbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:6141
SCIPgetNegatedVar
SCIP_RETCODE SCIPgetNegatedVar(SCIP *scip, SCIP_VAR *var, SCIP_VAR **negvar)
Definition: scip_var.c:2166
SCIPvarGetLbLocal
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
Definition: var.c:24234
SCIPchgVarUbGlobal
SCIP_RETCODE SCIPchgVarUbGlobal(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
Definition: scip_var.c:6230
SCIPvarGetLbGlobal
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
Definition: var.c:24120
SCIPvarGetNLPSol
SCIP_Real SCIPvarGetNLPSol(SCIP_VAR *var)
Definition: var.c:24691
SCIPcaptureVar
SCIP_RETCODE SCIPcaptureVar(SCIP *scip, SCIP_VAR *var)
Definition: scip_var.c:1853
SCIPsnprintf
int SCIPsnprintf(char *t, int len, const char *s,...)
Definition: misc.c:10827
processNLPSol
static SCIP_RETCODE processNLPSol(SCIP *scip, SCIP_HEUR *heur, SCIP_HEUR *authorheur, SCIP_RESULT *result, SCIP_SOL *resultsol)
Definition: heur_subnlp.c:564
SCIP_DECL_HEURINITSOL
static SCIP_DECL_HEURINITSOL(heurInitsolSubNlp)
Definition: heur_subnlp.c:1469
HEUR_TIMING
#define HEUR_TIMING
Definition: heur_subnlp.c:76
SCIP_DECL_HEUREXITSOL
static SCIP_DECL_HEUREXITSOL(heurExitsolSubNlp)
Definition: heur_subnlp.c:1495
HEUR_FREQOFS
#define HEUR_FREQOFS
Definition: heur_subnlp.c:74
HEUR_DESC
#define HEUR_DESC
Definition: heur_subnlp.c:70
createSolFromNLP
static SCIP_RETCODE createSolFromNLP(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL **sol, SCIP_HEUR *authorheur)
Definition: heur_subnlp.c:498
forbidFixation
static SCIP_RETCODE forbidFixation(SCIP *scip, SCIP_HEURDATA *heurdata)
Definition: heur_subnlp.c:1233
createSolFromSubScipSol
static SCIP_RETCODE createSolFromSubScipSol(SCIP *scip, SCIP_HEUR *heur, SCIP_SOL **sol, SCIP_SOL *subsol, SCIP_HEUR *authorheur)
Definition: heur_subnlp.c:680
SCIP_DECL_EVENTEXEC
static SCIP_DECL_EVENTEXEC(processVarEvent)
Definition: heur_subnlp.c:441
SCIP_DECL_HEURFREE
static SCIP_DECL_HEURFREE(heurFreeSubNlp)
Definition: heur_subnlp.c:1420
HEUR_DISPCHAR
#define HEUR_DISPCHAR
Definition: heur_subnlp.c:71
HEUR_MAXDEPTH
#define HEUR_MAXDEPTH
Definition: heur_subnlp.c:75
HEUR_PRIORITY
#define HEUR_PRIORITY
Definition: heur_subnlp.c:72
HEUR_NAME
#define HEUR_NAME
Definition: heur_subnlp.c:69
calcIterLimit
static int calcIterLimit(SCIP *scip, SCIP_HEURDATA *heurdata)
Definition: heur_subnlp.c:747
SCIP_DECL_HEURCOPY
static SCIP_DECL_HEURCOPY(heurCopySubNlp)
Definition: heur_subnlp.c:1406
solveSubNLP
static SCIP_RETCODE solveSubNLP(SCIP *scip, SCIP_HEUR *heur, SCIP_RESULT *result, SCIP_SOL *refpoint, SCIP_SOL *resultsol)
Definition: heur_subnlp.c:772
createSubSCIP
static SCIP_RETCODE createSubSCIP(SCIP *scip, SCIP_HEURDATA *heurdata)
Definition: heur_subnlp.c:190
SCIP_DECL_HEUREXEC
static SCIP_DECL_HEUREXEC(heurExecSubNlp)
Definition: heur_subnlp.c:1527
freeSubSCIP
static SCIP_RETCODE freeSubSCIP(SCIP *scip, SCIP_HEURDATA *heurdata)
Definition: heur_subnlp.c:137
HEUR_FREQ
#define HEUR_FREQ
Definition: heur_subnlp.c:73
SCIP_DECL_HEURINIT
static SCIP_DECL_HEURINIT(heurInitSubNlp)
Definition: heur_subnlp.c:1440
HEUR_USESSUBSCIP
#define HEUR_USESSUBSCIP
Definition: heur_subnlp.c:77
heur_subnlp.h
NLP local search primal heuristic using sub-SCIPs.
memory.h
memory allocation routines
BMSclearMemory
#define BMSclearMemory(ptr)
Definition: memory.h:129
nlpi_ipopt.h
Ipopt NLP interface.
pub_event.h
public methods for managing events
pub_heur.h
public methods for primal heuristics
pub_message.h
public methods for message output
SCIPerrorMessage
#define SCIPerrorMessage
Definition: pub_message.h:64
SCIPdebug
#define SCIPdebug(x)
Definition: pub_message.h:93
pub_misc.h
public data structures and miscellaneous methods
pub_sol.h
public methods for primal CIP solutions
pub_var.h
public methods for problem variables
scip_branch.h
public methods for branching rule plugins and branching
scip_cons.h
public methods for constraint handler plugins and constraints
scip_copy.h
public methods for problem copies
scip_event.h
public methods for event handler plugins and event handlers
scip_general.h
general public methods
scip_heur.h
public methods for primal heuristic plugins and divesets
scip_lp.h
public methods for the LP relaxation, rows and columns
scip_mem.h
public methods for memory management
scip_message.h
public methods for message handling
scip_nlp.h
public methods for nonlinear relaxation
scip_nlpi.h
public methods for NLPI solver interfaces
scip_numerics.h
public methods for numerical tolerances
scip_param.h
public methods for SCIP parameter handling
scip_presol.h
public methods for presolving plugins
scip_pricer.h
public methods for variable pricer plugins
scip_prob.h
public methods for global and local (sub)problems
scip_sol.h
public methods for solutions
scip_solve.h
public solving methods
scip_solvingstats.h
public methods for querying solving statistics
scip_timing.h
public methods for timing
scip_var.h
public methods for SCIP variables
SCIP_Cons
Definition: struct_cons.h:47
SCIP_Eventhdlr
Definition: struct_event.h:218
SCIP_HashMapEntry
Definition: struct_misc.h:132
SCIP_HashMap
Definition: struct_misc.h:139
SCIP_Heur
Definition: struct_heur.h:98
SCIP_NlpStatistics
Definition: type_nlpi.h:188
SCIP_NlpStatistics::totaltime
SCIP_Real totaltime
Definition: type_nlpi.h:190
SCIP_NlpStatistics::boundviol
SCIP_Real boundviol
Definition: type_nlpi.h:194
SCIP_NlpStatistics::niterations
int niterations
Definition: type_nlpi.h:189
SCIP_NlpStatistics::consviol
SCIP_Real consviol
Definition: type_nlpi.h:193
SCIP_Sol
Definition: struct_sol.h:74
SCIP_Var
Definition: struct_var.h:262
SCIP_EVENTTYPE_GUBCHANGED
#define SCIP_EVENTTYPE_GUBCHANGED
Definition: type_event.h:76
SCIP_EVENTTYPE_GBDCHANGED
#define SCIP_EVENTTYPE_GBDCHANGED
Definition: type_event.h:122
SCIP_EVENTDATA
struct SCIP_EventData SCIP_EVENTDATA
Definition: type_event.h:179
SCIP_EVENTTYPE_GLBCHANGED
#define SCIP_EVENTTYPE_GLBCHANGED
Definition: type_event.h:75
SCIP_HEURDATA
struct SCIP_HeurData SCIP_HEURDATA
Definition: type_heur.h:77
SCIP_BOUNDTYPE_UPPER
@ SCIP_BOUNDTYPE_UPPER
Definition: type_lp.h:58
SCIP_BOUNDTYPE_LOWER
@ SCIP_BOUNDTYPE_LOWER
Definition: type_lp.h:57
SCIP_BOUNDTYPE
enum SCIP_BoundType SCIP_BOUNDTYPE
Definition: type_lp.h:60
SCIP_LPSOLSTAT_OPTIMAL
@ SCIP_LPSOLSTAT_OPTIMAL
Definition: type_lp.h:44
SCIP_LPSOLSTAT_UNBOUNDEDRAY
@ SCIP_LPSOLSTAT_UNBOUNDEDRAY
Definition: type_lp.h:46
SCIP_VERBLEVEL_MINIMAL
@ SCIP_VERBLEVEL_MINIMAL
Definition: type_message.h:59
SCIP_NLPTERMSTAT_OKAY
@ SCIP_NLPTERMSTAT_OKAY
Definition: type_nlpi.h:173
SCIP_NLPTERMSTAT_ITERLIMIT
@ SCIP_NLPTERMSTAT_ITERLIMIT
Definition: type_nlpi.h:175
SCIP_NLPTERMSTAT_OUTOFMEMORY
@ SCIP_NLPTERMSTAT_OUTOFMEMORY
Definition: type_nlpi.h:180
SCIP_NLPSOLSTAT_GLOBINFEASIBLE
@ SCIP_NLPSOLSTAT_GLOBINFEASIBLE
Definition: type_nlpi.h:164
SCIP_NLPSOLSTAT_LOCINFEASIBLE
@ SCIP_NLPSOLSTAT_LOCINFEASIBLE
Definition: type_nlpi.h:163
SCIP_NLPSOLSTAT_FEASIBLE
@ SCIP_NLPSOLSTAT_FEASIBLE
Definition: type_nlpi.h:162
SCIP_PARAMSETTING_OFF
@ SCIP_PARAMSETTING_OFF
Definition: type_paramset.h:63
SCIP_PARAMSETTING_DEFAULT
@ SCIP_PARAMSETTING_DEFAULT
Definition: type_paramset.h:59
SCIP_PARAMSETTING_FAST
@ SCIP_PARAMSETTING_FAST
Definition: type_paramset.h:62
SCIP_PARAMSETTING
enum SCIP_ParamSetting SCIP_PARAMSETTING
Definition: type_paramset.h:65
SCIP_DIDNOTRUN
@ SCIP_DIDNOTRUN
Definition: type_result.h:42
SCIP_CUTOFF
@ SCIP_CUTOFF
Definition: type_result.h:48
SCIP_DELAYED
@ SCIP_DELAYED
Definition: type_result.h:43
SCIP_DIDNOTFIND
@ SCIP_DIDNOTFIND
Definition: type_result.h:44
SCIP_FOUNDSOL
@ SCIP_FOUNDSOL
Definition: type_result.h:56
SCIP_RESULT
enum SCIP_Result SCIP_RESULT
Definition: type_result.h:61
SCIP_OKAY
@ SCIP_OKAY
Definition: type_retcode.h:42
SCIP_ERROR
@ SCIP_ERROR
Definition: type_retcode.h:43
SCIP_RETCODE
enum SCIP_Retcode SCIP_RETCODE
Definition: type_retcode.h:63
SCIP_STAGE_SOLVED
@ SCIP_STAGE_SOLVED
Definition: type_set.h:54
SCIP_STAGE_PRESOLVING
@ SCIP_STAGE_PRESOLVING
Definition: type_set.h:49
SCIP_STAGE_SOLVING
@ SCIP_STAGE_SOLVING
Definition: type_set.h:53
SCIP_STAGE_PRESOLVED
@ SCIP_STAGE_PRESOLVED
Definition: type_set.h:51
SCIP_STATUS_OPTIMAL
@ SCIP_STATUS_OPTIMAL
Definition: type_stat.h:43
SCIP_STATUS_TOTALNODELIMIT
@ SCIP_STATUS_TOTALNODELIMIT
Definition: type_stat.h:50
SCIP_STATUS_BESTSOLLIMIT
@ SCIP_STATUS_BESTSOLLIMIT
Definition: type_stat.h:60
SCIP_STATUS_SOLLIMIT
@ SCIP_STATUS_SOLLIMIT
Definition: type_stat.h:59
SCIP_STATUS_UNBOUNDED
@ SCIP_STATUS_UNBOUNDED
Definition: type_stat.h:45
SCIP_STATUS_GAPLIMIT
@ SCIP_STATUS_GAPLIMIT
Definition: type_stat.h:56
SCIP_STATUS_USERINTERRUPT
@ SCIP_STATUS_USERINTERRUPT
Definition: type_stat.h:47
SCIP_STATUS_INFORUNBD
@ SCIP_STATUS_INFORUNBD
Definition: type_stat.h:46
SCIP_STATUS_STALLNODELIMIT
@ SCIP_STATUS_STALLNODELIMIT
Definition: type_stat.h:52
SCIP_STATUS_TIMELIMIT
@ SCIP_STATUS_TIMELIMIT
Definition: type_stat.h:54
SCIP_STATUS_INFEASIBLE
@ SCIP_STATUS_INFEASIBLE
Definition: type_stat.h:44
SCIP_STATUS_NODELIMIT
@ SCIP_STATUS_NODELIMIT
Definition: type_stat.h:49
SCIP_STATUS_MEMLIMIT
@ SCIP_STATUS_MEMLIMIT
Definition: type_stat.h:55
SCIP_HEURTIMING
unsigned int SCIP_HEURTIMING
Definition: type_timing.h:103
SCIP_HEURTIMING_DURINGLPLOOP
#define SCIP_HEURTIMING_DURINGLPLOOP
Definition: type_timing.h:81
SCIP_HEURTIMING_NONE
#define SCIP_HEURTIMING_NONE
Definition: type_timing.h:79
SCIP_VARTYPE_BINARY
@ SCIP_VARTYPE_BINARY
Definition: type_var.h:64