SCIP Doxygen Documentation
 
Loading...
Searching...
No Matches
heur_indicator.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-2023 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_indicator.c
26 * @ingroup DEFPLUGINS_HEUR
27 * @brief handle partial solutions for linear problems with indicators and otherwise continuous variables
28 * @author Marc Pfetsch
29 *
30 * For linear problems with indicators and otherwise continuous variables, the indicator constraint handler can produce
31 * partial solutions, i.e., values for the indicator variables. This partial solution can be passed to this heuristic,
32 * which then fixes these values and solves an LP. Additionally a local search for a better solution is added.
33 */
34
35/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
36
38#include "scip/cons_indicator.h"
39#include "scip/heur_indicator.h"
40#include "scip/pub_cons.h"
41#include "scip/pub_heur.h"
42#include "scip/pub_message.h"
43#include "scip/pub_sol.h"
44#include "scip/pub_var.h"
45#include "scip/scip_cons.h"
46#include "scip/scip_copy.h"
47#include "scip/scip_general.h"
48#include "scip/scip_heur.h"
49#include "scip/scip_lp.h"
50#include "scip/scip_mem.h"
51#include "scip/scip_message.h"
52#include "scip/scip_numerics.h"
53#include "scip/scip_param.h"
54#include "scip/scip_prob.h"
55#include "scip/scip_probing.h"
56#include "scip/scip_sol.h"
57#include "scip/scip_tree.h"
58#include <string.h>
59
60#define HEUR_NAME "indicator"
61#define HEUR_DESC "indicator heuristic to create feasible solutions from values for indicator variables"
62#define HEUR_DISPCHAR SCIP_HEURDISPCHAR_LNS
63#define HEUR_PRIORITY -20200
64#define HEUR_FREQ 1
65#define HEUR_FREQOFS 0
66#define HEUR_MAXDEPTH -1
67#define HEUR_TIMING SCIP_HEURTIMING_DURINGLPLOOP
68#define HEUR_USESSUBSCIP FALSE /**< does the heuristic use a secondary SCIP instance? */
69
70#define DEFAULT_ONEOPT FALSE /**< whether the one-opt heuristic should be started */
71#define DEFAULT_IMPROVESOLS FALSE /**< Try to improve other solutions by one-opt? */
72
73
74/** primal heuristic data */
75struct SCIP_HeurData
76{
77 int nindconss; /**< number of indicator constraints */
78 SCIP_CONS** indconss; /**< indicator constraints */
79 SCIP_Bool* solcand; /**< bitset of indicator variables in solution candidate */
80 SCIP_Real obj; /**< objective of previously stored solution */
81 SCIP_Bool oneopt; /**< whether the one-opt heuristic should be started */
82 SCIP_CONSHDLR* indicatorconshdlr; /**< indicator constraint handler */
83 SCIP_SOL* lastsol; /**< last solution considered for improvement */
84 SCIP_Bool improvesols; /**< Try to improve other solutions by one-opt? */
85};
86
87/*
88 * Local methods
89 */
90
91/** try one-opt on given solution */
92static
94 SCIP* scip, /**< SCIP data structure */
95 SCIP_HEUR* heur, /**< indicator heuristic */
96 SCIP_HEURDATA* heurdata, /**< heuristic data */
97 int nindconss, /**< number of indicator constraints */
98 SCIP_CONS** indconss, /**< indicator constraints */
99 SCIP_Bool* solcand, /**< values for indicator variables in partial solution */
100 int* nfoundsols /**< number of solutions found */
101 )
102{
103 SCIP_Bool cutoff;
104 SCIP_Bool lperror;
105 SCIP_Bool stored;
106 SCIP_SOL* sol;
107 int cnt = 0;
108 int i;
109 int c;
110
111 assert( scip != NULL );
112 assert( heur != NULL );
113 assert( heurdata != NULL );
114 assert( nindconss == 0 || indconss != NULL );
115 assert( solcand != NULL );
116 assert( nfoundsols != NULL );
117
118 SCIPdebugMsg(scip, "Performing one-opt ...\n");
119 *nfoundsols = 0;
120
122
123 for (i = 0; i < nindconss && ! SCIPisStopped(scip); ++i)
124 {
125 SCIP_VAR* binvar;
126
127 /* skip nonactive constraints */
128 if ( ! SCIPconsIsActive(indconss[i]) )
129 continue;
130
131 binvar = SCIPgetBinaryVarIndicator(indconss[i]);
132 assert( binvar != NULL );
133
134 /* skip constraints with fixed variables */
135 if ( SCIPvarGetUbLocal(binvar) < 0.5 || SCIPvarGetLbLocal(binvar) > 0.5 )
136 continue;
137
138 /* return if the we would exceed the depth limit of the tree */
140 break;
141
142 if ( solcand[i] )
143 continue;
144
145 /* get rid of all bound changes */
147 ++cnt;
148
149 /* fix variables */
150 for (c = 0; c < nindconss; ++c)
151 {
152 SCIP_Bool s;
153
154 /* skip nonactive constraints */
155 if ( ! SCIPconsIsActive(indconss[c]) )
156 continue;
157
158 binvar = SCIPgetBinaryVarIndicator(indconss[c]);
159 assert( binvar != NULL );
160
161 /* fix variables according to solution candidate, except constraint i */
162 if ( c == i )
163 s = ! solcand[c];
164 else
165 s = solcand[c];
166
167 if ( ! s )
168 {
169 if ( SCIPvarGetLbLocal(binvar) < 0.5 && SCIPvarGetUbLocal(binvar) > 0.5 )
170 {
171 SCIP_CALL( SCIPchgVarLbProbing(scip, binvar, 1.0) );
172 }
173 }
174 else
175 {
176 if ( SCIPvarGetUbLocal(binvar) > 0.5 && SCIPvarGetLbLocal(binvar) < 0.5 )
177 {
178 SCIP_CALL( SCIPchgVarUbProbing(scip, binvar, 0.0) );
179 }
180 }
181 }
182
183 /* propagate variables */
185 if ( cutoff )
186 {
188 continue;
189 }
190
191 /* solve LP to move continuous variables */
193
194 /* the LP often reaches the objective limit - we currently do not use such solutions */
196 {
197#ifdef SCIP_DEBUG
198 if ( lperror )
199 SCIPdebugMsg(scip, "An LP error occurred.\n");
200#endif
202 continue;
203 }
204
205 /* create solution */
206 SCIP_CALL( SCIPcreateSol(scip, &sol, heur) );
207
208 /* copy the current LP solution to the working solution */
210
211 /* check solution for feasibility */
212 SCIPdebugMsg(scip, "One-opt found solution candidate with value %g.\n", SCIPgetSolTransObj(scip, sol));
213
214 /* only check integrality, because we solved an LP */
216 if ( stored )
217 ++(*nfoundsols);
219 }
221
222 SCIPdebugMsg(scip, "Finished one-opt (tried variables: %d, found sols: %d).\n", cnt, *nfoundsols);
223
224 return SCIP_OKAY;
225}
226
227
228/** try given solution */
229static
231 SCIP* scip, /**< SCIP data structure */
232 SCIP_HEUR* heur, /**< indicator heuristic */
233 SCIP_HEURDATA* heurdata, /**< heuristic data */
234 int nindconss, /**< number of indicator constraints */
235 SCIP_CONS** indconss, /**< indicator constraints */
236 SCIP_Bool* solcand, /**< values for indicator variables in partial solution */
237 int* nfoundsols /**< number of solutions found */
238 )
239{
240 SCIP_Bool cutoff;
241 SCIP_Bool lperror;
242 SCIP_Bool stored;
243 SCIP_SOL* sol;
244 int c;
245
246 assert( scip != NULL );
247 assert( heur != NULL );
248 assert( heurdata != NULL );
249 assert( nindconss == 0 || indconss != NULL );
250 assert( solcand != NULL );
251 assert( nfoundsols != NULL );
252
253 SCIPdebugMsg(scip, "Trying to generate feasible solution with indicators from solution candidate (obj: %f) ...\n", heurdata->obj);
254 *nfoundsols = 0;
255
257
258 /* we can stop here if we have already reached the maximal depth */
260 {
262 return SCIP_OKAY;
263 }
264
266
267 /* fix variables */
268 for (c = 0; c < nindconss; ++c)
269 {
270 SCIP_VAR* binvar;
271
272 /* skip nonactive constraints */
273 if ( ! SCIPconsIsActive(indconss[c]) )
274 continue;
275
276 binvar = SCIPgetBinaryVarIndicator(indconss[c]);
277 assert( binvar != NULL );
278
279 /* Fix binary variables not in cover to 1 and corresponding slack variables to 0. The other binary variables are fixed to 0. */
280 if ( ! solcand[c] )
281 {
282 /* to be sure, check for non-fixed variables */
283 if ( SCIPvarGetLbLocal(binvar) < 0.5 && SCIPvarGetUbLocal(binvar) > 0.5 )
284 {
285 SCIP_CALL( SCIPchgVarLbProbing(scip, binvar, 1.0) );
286 }
287 }
288 else
289 {
290 if ( SCIPvarGetUbLocal(binvar) > 0.5 && SCIPvarGetLbLocal(binvar) < 0.5 )
291 {
292 SCIP_CALL( SCIPchgVarUbProbing(scip, binvar, 0.0) );
293 }
294 }
295 }
296
297 /* propagate variables */
299 if ( cutoff )
300 {
301 SCIPdebugMsg(scip, "Solution candidate reaches cutoff (in propagation).\n");
303 return SCIP_OKAY;
304 }
305
306 /* solve LP to move continuous variables */
308
309 /* the LP often reaches the objective limit - we currently do not use such solutions */
311 {
312#ifdef SCIP_DEBUG
313 if ( lperror )
314 {
315 SCIPdebugMsg(scip, "An LP error occurred.\n");
316 }
317 else
318 {
319 SCIPdebugMsg(scip, "Solution candidate reaches cutoff (in LP solving).\n");
320 }
321#endif
323 return SCIP_OKAY;
324 }
325
326 /* create solution */
327 SCIP_CALL( SCIPcreateSol(scip, &sol, heur) );
328
329 /* copy the current LP solution to the working solution */
331
332 /* check solution for feasibility */
333#ifdef SCIP_DEBUG
334 SCIPdebugMsg(scip, "Found solution candidate with value %g.\n", SCIPgetSolTransObj(scip, sol));
335#ifdef SCIP_MORE_DEBUG
337#endif
339 if ( stored )
340 {
341 ++(*nfoundsols);
342 SCIPdebugMsg(scip, "Solution is feasible and stored.\n");
343 }
344 else
345 SCIPdebugMsg(scip, "Solution was not stored.\n");
346#else
347 /* only check integrality, because we solved an LP */
349 if ( stored )
350 ++(*nfoundsols);
351#endif
353
354 /* possibly perform one-opt */
355 if ( stored && heurdata->oneopt )
356 {
357 int nfound = 0;
358 assert( *nfoundsols > 0 );
359 SCIP_CALL( tryOneOpt(scip, heur, heurdata, nindconss, indconss, solcand, &nfound) );
360 }
361
362 return SCIP_OKAY;
363}
364
365
366/*
367 * Callback methods of primal heuristic
368 */
369
370/** copy method for primal heuristic plugins (called when SCIP copies plugins) */
371static
373{ /*lint --e{715}*/
374 assert( scip != NULL );
375 assert( heur != NULL );
376 assert( strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0 );
377
378 /* call inclusion method of primal heuristic */
380
381 return SCIP_OKAY;
382}
383
384/** initialization method of primal heuristic (called after problem was transformed) */
385static
387{ /*lint --e{715}*/
389
390 assert( heur != NULL );
391 assert( scip != NULL );
392
393 /* get heuristic data */
395 assert( heurdata != NULL );
396
397 if ( heurdata->indicatorconshdlr == NULL )
398 {
399 heurdata->indicatorconshdlr = SCIPfindConshdlr(scip, "indicator");
400 if ( heurdata->indicatorconshdlr == NULL )
401 {
402 SCIPwarningMessage(scip, "Could not find indicator constraint handler.\n");
403 }
404 }
405
406 return SCIP_OKAY;
407}
408
409/** destructor of primal heuristic to free user data (called when SCIP is exiting) */
410static
412{ /*lint --e{715}*/
414
415 assert( heur != NULL );
416 assert( scip != NULL );
417
418 /* get heuristic data */
420 assert( heurdata != NULL );
421
422 SCIPfreeBlockMemoryArrayNull(scip, &(heurdata->indconss), heurdata->nindconss);
423 SCIPfreeBlockMemoryArrayNull(scip, &(heurdata->solcand), heurdata->nindconss);
424
425 /* free heuristic data */
427 SCIPheurSetData(heur, NULL);
428
429 return SCIP_OKAY;
430}
431
432
433/** execution method of primal heuristic */
434static
436{ /*lint --e{715}*/
438 int nfoundsols = 0;
439
440 assert( heur != NULL );
441 assert( scip != NULL );
442 assert( result != NULL );
443
445
446 if ( SCIPgetSubscipDepth(scip) > 0 )
447 return SCIP_OKAY;
448
449 /* get heuristic's data */
451 assert( heurdata != NULL );
452
453 /* call heuristic, if solution candidate is available */
454 if ( heurdata->solcand != NULL )
455 {
456 assert( heurdata->nindconss > 0 );
457 assert( heurdata->indconss != NULL );
458
459 /* The heuristic will only be successful if there are no integral variables and no binary variables except the
460 * indicator variables. */
461 if ( SCIPgetNIntVars(scip) > 0 || heurdata->nindconss < SCIPgetNBinVars(scip) )
462 return SCIP_OKAY;
463
464 SCIP_CALL( trySolCandidate(scip, heur, heurdata, heurdata->nindconss, heurdata->indconss, heurdata->solcand, &nfoundsols) );
465
466 if ( nfoundsols > 0 )
468 else
470
471 /* free memory */
472 SCIPfreeBlockMemoryArray(scip, &(heurdata->solcand), heurdata->nindconss);
473 SCIPfreeBlockMemoryArray(scip, &(heurdata->indconss), heurdata->nindconss);
474 }
475
476 /* try to improve solutions generated by other heuristics */
477 if ( heurdata->improvesols )
478 {
479 SCIP_CONS** indconss;
480 SCIP_Bool* solcand;
481 SCIP_SOL* bestsol;
482 int nindconss;
483 int i;
484
485 if ( heurdata->indicatorconshdlr == NULL )
486 return SCIP_OKAY;
487
488 /* check whether a new best solution has been found */
489 bestsol = SCIPgetBestSol(scip);
490 if ( bestsol == heurdata->lastsol )
491 return SCIP_OKAY;
492 heurdata->lastsol = bestsol;
493
494 /* avoid solutions produced by this heuristic */
495 if ( SCIPsolGetHeur(bestsol) == heur )
496 return SCIP_OKAY;
497
498 /* The heuristic will only be successful if there are no integral variables and no binary variables except the
499 * indicator variables. */
500 nindconss = SCIPconshdlrGetNConss(heurdata->indicatorconshdlr);
501 if ( SCIPgetNIntVars(scip) > 0 || nindconss < SCIPgetNBinVars(scip) )
502 return SCIP_OKAY;
503
504 if ( nindconss == 0 )
505 return SCIP_OKAY;
506
507 indconss = SCIPconshdlrGetConss(heurdata->indicatorconshdlr);
508 assert( indconss != NULL );
509
510 /* fill solution candidate */
511 SCIP_CALL( SCIPallocBufferArray(scip, &solcand, nindconss) );
512 for (i = 0; i < nindconss; ++i)
513 {
514 SCIP_VAR* binvar;
515 SCIP_Real val;
516
517 solcand[i] = FALSE;
518 if ( SCIPconsIsActive(indconss[i]) )
519 {
520 binvar = SCIPgetBinaryVarIndicator(indconss[i]);
521 assert( binvar != NULL );
522
523 val = SCIPgetSolVal(scip, bestsol, binvar);
525 if ( val > 0.5 )
526 solcand[i] = TRUE;
527 }
528 }
529
530 SCIPdebugMsg(scip, "Trying to improve best solution of value %f.\n", SCIPgetSolOrigObj(scip, bestsol) );
531
532 /* try one-opt heuristic */
533 SCIP_CALL( tryOneOpt(scip, heur, heurdata, nindconss, indconss, solcand, &nfoundsols) );
534
535 if ( nfoundsols > 0 )
537 else
539
540 SCIPfreeBufferArray(scip, &solcand);
541 }
542
543 return SCIP_OKAY;
544}
545
546
547/*
548 * primal heuristic specific interface methods
549 */
550
551/** creates the indicator primal heuristic and includes it in SCIP */
553 SCIP* scip /**< SCIP data structure */
554 )
555{
557 SCIP_HEUR* heur;
558
559 /* create Indicator primal heuristic data */
561 heurdata->nindconss = 0;
562 heurdata->indconss = NULL;
563 heurdata->solcand = NULL;
564 heurdata->lastsol = NULL;
565 heurdata->indicatorconshdlr = NULL;
566 heurdata->obj = SCIPinfinity(scip);
567
568 /* include primal heuristic */
572
573 assert( heur != NULL );
574
575 /* set non-NULL pointers to callback methods */
579
580 /* add parameters */
582 "heuristics/" HEUR_NAME "/oneopt",
583 "whether the one-opt heuristic should be started",
584 &heurdata->oneopt, TRUE, DEFAULT_ONEOPT, NULL, NULL) );
585
587 "heuristics/" HEUR_NAME "/improvesols",
588 "Try to improve other solutions by one-opt?",
589 &heurdata->improvesols, TRUE, DEFAULT_IMPROVESOLS, NULL, NULL) );
590
591 return SCIP_OKAY;
592}
593
594
595/** pass partial solution for indicator variables to heuristic */
597 SCIP* scip, /**< SCIP data structure */
598 SCIP_HEUR* heur, /**< indicator heuristic */
599 int nindconss, /**< number of indicator constraints */
600 SCIP_CONS** indconss, /**< indicator constraints */
601 SCIP_Bool* solcand, /**< values for indicator variables in partial solution */
602 SCIP_Real obj /**< objective of solution */
603 )
604{
606
607 assert( scip != NULL );
608 assert( heur != NULL );
609 assert( strcmp(SCIPheurGetName(heur), HEUR_NAME) == 0 );
610 assert( nindconss > 0 );
611 assert( indconss != NULL );
612 assert( solcand != NULL );
613
614 /* get heuristic's data */
616 assert( heurdata != NULL );
617
618 if ( obj >= heurdata->obj )
619 return SCIP_OKAY;
620
621 /* copy indicator information */
622 if ( heurdata->indconss != NULL )
623 SCIPfreeBlockMemoryArray(scip, &(heurdata->indconss), heurdata->nindconss);
624
625 SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &(heurdata->indconss), indconss, nindconss) );
626 heurdata->nindconss = nindconss;
627
628 /* copy partial solution */
629 if ( heurdata->solcand != NULL )
630 BMScopyMemoryArray(heurdata->solcand, solcand, nindconss);
631 else
632 SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &(heurdata->solcand), solcand, nindconss) );
633 heurdata->obj = obj;
634
635 return SCIP_OKAY;
636}
constraint handler for indicator constraints
#define SCIP_MAXTREEDEPTH
Definition def.h:330
#define TRUE
Definition def.h:95
#define FALSE
Definition def.h:96
#define SCIP_CALL(x)
Definition def.h:388
SCIP_VAR * SCIPgetBinaryVarIndicator(SCIP_CONS *cons)
int SCIPgetSubscipDepth(SCIP *scip)
Definition scip_copy.c:2605
SCIP_Bool SCIPisStopped(SCIP *scip)
int SCIPgetNIntVars(SCIP *scip)
Definition scip_prob.c:2082
int SCIPgetNBinVars(SCIP *scip)
Definition scip_prob.c:2037
#define SCIPdebugMsg
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_RETCODE SCIPheurPassIndicator(SCIP *scip, SCIP_HEUR *heur, int nindconss, SCIP_CONS **indconss, SCIP_Bool *solcand, SCIP_Real obj)
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
SCIP_RETCODE SCIPincludeHeurIndicator(SCIP *scip)
int SCIPconshdlrGetNConss(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4595
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
Definition scip_cons.c:886
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
Definition cons.c:4552
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
Definition cons.c:8149
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur,)
Definition scip_heur.c:178
SCIP_HEURDATA * SCIPheurGetData(SCIP_HEUR *heur)
Definition heur.c:1361
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:117
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur,)
Definition scip_heur.c:162
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur,)
Definition scip_heur.c:194
const char * SCIPheurGetName(SCIP_HEUR *heur)
Definition heur.c:1450
void SCIPheurSetData(SCIP_HEUR *heur, SCIP_HEURDATA *heurdata)
Definition heur.c:1371
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
Definition scip_lp.c:168
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
Definition scip_mem.h:110
#define SCIPallocBufferArray(scip, ptr, num)
Definition scip_mem.h:124
#define SCIPfreeBufferArray(scip, ptr)
Definition scip_mem.h:136
#define SCIPfreeBlockMemory(scip, ptr)
Definition scip_mem.h:108
#define SCIPfreeBlockMemoryArrayNull(scip, ptr, num)
Definition scip_mem.h:111
#define SCIPallocBlockMemory(scip, ptr)
Definition scip_mem.h:89
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
Definition scip_mem.h:105
SCIP_RETCODE SCIPchgVarUbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPchgVarLbProbing(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPpropagateProbing(SCIP *scip, int maxproprounds, SCIP_Bool *cutoff, SCIP_Longint *ndomredsfound)
SCIP_RETCODE SCIPbacktrackProbing(SCIP *scip, int probingdepth)
SCIP_RETCODE SCIPstartProbing(SCIP *scip)
SCIP_RETCODE SCIPnewProbingNode(SCIP *scip)
SCIP_RETCODE SCIPsolveProbingLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
Definition scip_sol.c:2313
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
Definition scip_sol.c:1775
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
Definition sol.c:2638
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:3193
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
Definition scip_sol.c:1444
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
Definition scip_sol.c:1361
SCIP_Real SCIPgetSolTransObj(SCIP *scip, SCIP_SOL *sol)
Definition scip_sol.c:1491
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
int SCIPgetDepth(SCIP *scip)
Definition scip_tree.c:670
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
Definition var.c:17966
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
Definition var.c:17956
return SCIP_OKAY
SCIPcreateSol(scip, &heurdata->sol, heur))
static SCIP_RETCODE tryOneOpt(SCIP *scip, SCIP_HEUR *heur, SCIP_HEURDATA *heurdata, int nindconss, SCIP_CONS **indconss, SCIP_Bool *solcand, int *nfoundsols)
#define DEFAULT_ONEOPT
#define HEUR_TIMING
#define HEUR_FREQOFS
#define HEUR_DESC
static SCIP_RETCODE trySolCandidate(SCIP *scip, SCIP_HEUR *heur, SCIP_HEURDATA *heurdata, int nindconss, SCIP_CONS **indconss, SCIP_Bool *solcand, int *nfoundsols)
#define HEUR_DISPCHAR
#define HEUR_MAXDEPTH
#define HEUR_PRIORITY
#define HEUR_NAME
#define HEUR_FREQ
#define HEUR_USESSUBSCIP
#define DEFAULT_IMPROVESOLS
handle partial solutions for linear problems with indicators and otherwise continuous variables
SCIP_Bool lperror
int c
SCIPendProbing(scip))
SCIP_Bool cutoff
static SCIP_SOL * sol
SCIP_Real obj
assert(minobj< SCIPgetCutoffbound(scip))
SCIPlinkLPSol(scip, sol))
#define NULL
Definition lpi_spx1.cpp:161
memory allocation routines
#define BMScopyMemoryArray(ptr, source, num)
Definition memory.h:136
public methods for managing constraints
public methods for primal heuristics
public methods for message output
public methods for primal CIP solutions
public methods for problem variables
public methods for constraint handler plugins and constraints
public methods for problem copies
general public methods
public methods for primal heuristic plugins and divesets
public methods for the LP relaxation, rows and columns
public methods for memory management
public methods for message handling
public methods for numerical tolerances
public methods for SCIP parameter handling
public methods for global and local (sub)problems
public methods for the probing mode
public methods for solutions
public methods for the branch-and-bound tree
#define SCIP_DECL_HEURCOPY(x)
Definition type_heur.h:96
struct SCIP_HeurData SCIP_HEURDATA
Definition type_heur.h:76
#define SCIP_DECL_HEURINIT(x)
Definition type_heur.h:112
#define SCIP_DECL_HEURFREE(x)
Definition type_heur.h:104
#define SCIP_DECL_HEUREXEC(x)
Definition type_heur.h:162
@ SCIP_LPSOLSTAT_OPTIMAL
Definition type_lp.h:43
@ SCIP_DIDNOTRUN
Definition type_result.h:42
@ SCIP_DIDNOTFIND
Definition type_result.h:44
@ SCIP_FOUNDSOL
Definition type_result.h:56
enum SCIP_Retcode SCIP_RETCODE