55#define HEUR_NAME "twoopt"
56#define HEUR_DESC "primal heuristic to improve incumbent solution by flipping pairs of variables"
57#define HEUR_DISPCHAR SCIP_HEURDISPCHAR_ITERATIVE
58#define HEUR_PRIORITY -20100
61#define HEUR_MAXDEPTH -1
63#define HEUR_TIMING SCIP_HEURTIMING_AFTERNODE
64#define HEUR_USESSUBSCIP FALSE
67#define DEFAULT_INTOPT FALSE
68#define DEFAULT_WAITINGNODES 0
69#define DEFAULT_MATCHINGRATE 0.5
71#define DEFAULT_MAXNSLAVES 199
72#define DEFAULT_ARRAYSIZE 10
73#define DEFAULT_RANDSEED 37
83 SCIP_Real matchingrate;
157 SCIP_Real mastersolval,
159 SCIP_Real slavesolval,
170 SCIP_Real* mastercolvals;
171 SCIP_Real* slavecolvals;
192 assert(ncolmasterrows == 0 || masterrows !=
NULL);
198 assert(ncolslaverows == 0 || slaverows !=
NULL);
210 activities[rowpos] += mastercolvals[
i] * (int)masterdir * shiftval;
214 for(
int j = 0; j < ncolslaverows &&
SCIProwGetLPPos(slaverows[j]) >= 0; ++j )
224 activities[rowpos] += slavecolvals[j] * (int)slavedir * shiftval;
284 for(
int i = 0;
i < nnonzeros1 &&
i < nnonzeros2; ++
i )
293 return nnonzeros2 - nnonzeros1 ;
311 SCIP_Real matchingrate
342 if( nnonzeros1 == 0 && nnonzeros2 == 0 )
346 if( matchingrate == 0.0 )
350 nrowmaximum =
MAX(nnonzeros1, nnonzeros2);
352 nrowabs =
ABS(nnonzeros1 - nnonzeros2);
353 nrows1not2 = nrowmaximum - nnonzeros2;
354 nrows2not1 = nrowmaximum - nnonzeros1;
361 if( (nrowmaximum - nrowabs) / (SCIP_Real) nrowmaximum < matchingrate )
368 while(
i < nnonzeros1 && j < nnonzeros2 )
394 return (
SCIPisFeasLE(
scip, matchingrate, (nnonzeros1 - nrows1not2) / (SCIP_Real)(nnonzeros1)) ||
395 SCIPisFeasLE(
scip, matchingrate, (nnonzeros2 - nrows2not1) / (SCIP_Real)(nnonzeros2)) );
416 SCIP_Real masterbound;
417 SCIP_Real slavebound;
419 SCIP_Real mastersolval;
420 SCIP_Real slavesolval;
425 SCIP_Real* mastercolvals;
426 SCIP_Real* slavecolvals;
447 masterbound =
bound - mastersolval;
448 masterbound =
SCIPisFeasLE(
scip, mastersolval + ceil(masterbound),
bound) ? ceil(masterbound) : floor(masterbound);
453 masterbound = mastersolval -
bound;
454 masterbound =
SCIPisFeasGE(
scip, mastersolval - ceil(masterbound),
bound) ? ceil(masterbound) : floor(masterbound);
460 slavebound =
bound - slavesolval;
461 slavebound =
SCIPisFeasLE(
scip, slavesolval + ceil(slavebound),
bound) ? ceil(slavebound) : floor(slavebound);
466 slavebound = slavesolval -
bound;
467 slavebound =
SCIPisFeasGE(
scip, slavesolval - ceil(slavebound),
bound) ? ceil(slavebound) : floor(slavebound);
470 bound =
MIN(masterbound, slavebound);
487 assert(nslaverows == 0 || slavecolvals !=
NULL);
488 assert(nmasterrows == 0 || mastercolvals !=
NULL);
491 (
int)masterdirection, nmasterrows,
SCIPvarGetName(slave), (
int)slavedirection, nslaverows);
498 while(
i < nslaverows || j < nmasterrows )
504 SCIP_Bool slaveincrement;
505 SCIP_Bool masterincrement;
521 slaveincrement =
FALSE;
527 slaveindex = INT_MAX;
529 if( j < nmasterrows )
532 masterindex = INT_MAX;
534 assert(0 <= slaveindex && 0 <= masterindex);
536 assert(slaveindex < INT_MAX || masterindex < INT_MAX);
539 if( slaveindex <= masterindex )
543 slaveincrement =
TRUE;
544 masterincrement = (slaveindex == masterindex);
552 masterincrement =
TRUE;
565 if( slaveindex <= masterindex )
566 effect += (slavecolvals[
i] * (int)slavedirection);
567 if( masterindex <= slaveindex )
568 effect += (mastercolvals[j] * (int)masterdirection);
584 SCIPdebugMsg(
scip,
" %g <= %g <= %g, bound = %g, effect = %g (%g * %d + %g * %d) (i=%d,j=%d)\n",
586 slaveindex <= masterindex ? slavecolvals[
i] : 0.0, (int)slavedirection,
587 masterindex <= slaveindex ? mastercolvals[j] : 0.0, (int)masterdirection,
i, j);
589 newval = (side -
activities[rowpos]) / effect;
596 activity =
activities[rowpos] + effect * ceil(newval);
600 bound = ceil(newval);
602 bound = floor(newval);
615 SCIPdebugMsg(
scip,
" No influence of row %s, effect %g, master coeff: %g slave coeff: %g (i=%d, j=%d)\n",
628 if( masterincrement )
649 assert(varindex <= *blockend);
700 for(
int v = 1; v <
nvars; ++v )
706 if( v - startindex >= 2 )
709 (*nblockvars) += v - startindex;
710 (*maxblocksize) =
MAX((*maxblocksize), v - startindex);
711 (*blockstart)[*nblocks] = startindex;
712 (*blockend)[*nblocks] = v - 1;
717 else if( v ==
nvars - 1 && v - startindex >= 1 )
720 (*nblockvars) += v - startindex + 1;
721 (*maxblocksize) =
MAX((*maxblocksize), v - startindex + 1);
722 (*blockstart)[*nblocks] = startindex;
723 (*blockend)[*nblocks] = v;
765 int nbinblockvars = 0;
767 int maxbinblocksize = 0;
794 heurdata->binnblockvars += nbinblockvars;
798 SCIPstatisticMessage(
" Twoopt BINARY presolving finished with <%d> blocks, <%d> block variables \n",
799 heurdata->nbinblocks, nbinblockvars);
813 heurdata->intnblockvars += nintblockvars;
816 SCIPstatisticMessage(
" Twoopt Integer presolving finished with <%d> blocks, <%d> block variables \n",
817 heurdata->nintblocks, nintblockvars);
940 SCIP_Bool* improvement,
941 SCIP_Bool* varboundserr,
945 SCIP_Real* objchanges;
960 *varboundserr =
FALSE;
969 for(
int b = 0;
b < nblocks; ++
b )
973 blocklen = blockend[
b] - blockstart[
b] + 1;
976 for(
int m = 0; m < blocklen; ++m )
981 SCIP_Real mastersolval;
982 SCIP_Real bestimprovement;
991 master =
vars[blockstart[
b] + m];
999 *varboundserr =
TRUE;
1000 SCIPdebugMsg(
scip,
"Solution has violated variable bounds for var %s: %g <= %g <= %g \n",
1020 bestimprovement = 0.0;
1031 firstslave = blockstart[
b] + m + 1;
1038 for(
int s = 0; s < nslaves; ++s )
1042 SCIP_Real slavesolval;
1043 SCIP_Real changedobj;
1044 SCIP_Real diffdirbound;
1045 SCIP_Real equaldirbound;
1049 slaveindex = (firstslave + s - blockstart[
b]) % blocklen;
1050 slaveindex += blockstart[
b];
1053 if( (blocklen <= heurdata->maxnslaves ||
heurdata->maxnslaves == -1) && slaveindex < blockstart[
b] + m )
1056 if( slaveindex == blockstart[
b] + m )
1060 slave =
vars[slaveindex];
1072 *varboundserr =
TRUE;
1073 SCIPdebugMsg(
scip,
"Solution has violated variable bounds for var %s: %g <= %g <= %g \n",
1094 equaldirbound = 0.0;
1101 changedobj = (masterobj - slaveobj) * diffdirbound;
1107 changedobj = (slaveobj - masterobj) * diffdirbound;
1113 if( (masterobj + slaveobj) * equaldirbound < changedobj )
1115 changedobj = (masterobj + slaveobj) * equaldirbound;
1122 if( -(masterobj + slaveobj) * equaldirbound < changedobj )
1124 changedobj = -(masterobj + slaveobj) * equaldirbound;
1135 && changedobj < bestimprovement )
1137 bestimprovement = changedobj;
1138 bestslavepos = slaveindex;
1139 bestdirection = directions;
1145 if( directions / 2 == 1 )
1150 if( directions % 2 == 1 )
1155 if( bestmasterdir == bestslavedir )
1156 bestbound = equaldirbound;
1158 bestbound = diffdirbound;
1163 if( bestslavepos >= 0 )
1165 if( npairs == arraysize )
1171 arraysize = 2 * arraysize;
1173 assert( npairs < arraysize );
1175 bestmasters[npairs] = master;
1176 bestslaves[npairs] =
vars[bestslavepos];
1177 objchanges[npairs] = ((int)bestslavedir *
SCIPvarGetObj(bestslaves[npairs]) + (int)bestmasterdir * masterobj) * bestbound;
1178 bestdirections[npairs] = bestdirection;
1180 assert(objchanges[npairs] < 0);
1182 SCIPdebugMsg(
scip,
" Saved candidate pair {%s=%g, %s=%g} with objectives <%g>, <%g> to be set to {%g, %g} %d\n",
1185 + (
int)bestslavedir * bestbound, bestdirections[npairs]);
1197 for(
int b = 0;
b < npairs; ++
b )
1201 SCIP_Real mastersolval;
1202 SCIP_Real slavesolval;
1203 SCIP_Real masterobj;
1209 master = bestmasters[
b];
1210 slave = bestslaves[
b];
1216 assert(0 <= bestdirections[
b] && bestdirections[
b] < 4);
1218 if( bestdirections[
b] / 2 == 1 )
1223 if( bestdirections[
b] % 2 == 1 )
1234 SCIP_Real changedobj;
1237 SCIPdebugMsg(
scip,
" Promising candidates {%s=%g, %s=%g} with objectives <%g>, <%g> to be set to {%g, %g}\n",
1239 masterobj, slaveobj, mastersolval + (
int)masterdir *
bound, slavesolval + (
int)slavedir *
bound);
1243 changedobj = ((int)slavedir * slaveobj + (
int)masterdir * masterobj) *
bound;
1261 SCIPdebugMsg(
scip,
" Feasible shift: <%s>[%g, %g] (obj: %f) <%f> --> <%f>\n",
1266#ifdef SCIP_STATISTIC
1274 *improvement =
TRUE;
1299#ifdef SCIP_STATISTIC
1302 " Twoopt Binary Statistics : "
1303 "%6.2g %6.2g %4.2g %4.0g %6d (blocks/run, variables/run, varpercentage, avg. block size, max block size) \n",
1311 " Twoopt Integer statistics : "
1312 "%6.2g %6.2g %4.2g %4.0g %6d (blocks/run, variables/run, varpercentage, avg block size, max block size) \n",
1320 " Twoopt results : "
1321 "%6d %6d %4d %4.2g (runs, binary exchanges, Integer shiftings, matching rate)\n",
1407#ifdef SCIP_STATISTIC
1495 int ncolsforsorting;
1496 SCIP_Bool improvement;
1497 SCIP_Bool presolthiscall;
1498 SCIP_Bool varboundserr;
1534 presolthiscall =
FALSE;
1537 ncolsforsorting =
MIN(ncols, ndiscvars);
1544 for(
int i = 0;
i < ncolsforsorting; ++
i )
1548 presolthiscall =
TRUE;
1600 if( !presolthiscall )
1602 for(
int i = 0;
i < ncolsforsorting; ++
i )
1605 SCIPdebugMsg(
scip,
" Twoopt heuristic has initialized activities and sorted rows! \n");
1608 improvement =
FALSE;
1609 varboundserr =
FALSE;
1634 if( ! improvement || varboundserr )
1655#ifdef SCIP_STATISTIC
1670 SCIPdebugMsg(
scip,
"shifted solution should be feasible -> solve LP to fix continuous variables to best values\n");
1677 SCIPdebugMsg(
scip,
" Cont. variable <%s>, status %d with bounds [%g <= %g <= x <= %g <= %g]\n",
1697 for(
int i = 0;
i < ndiscvars; ++
i )
1711 for(
int i = 0;
i < ndiscvars; ++
i )
1724 SCIPwarningMessage(
scip,
"Error while solving LP in Twoopt heuristic; LP solve terminated with code <%d>\n",retstat);
1755#ifdef SCIP_STATISTIC
1810 "nodes to wait after last best solution before calling heuristic",
1819 "parameter to determine the percentage of rows two variables have to share before they are considered equal",
#define SCIP_LONGINT_FORMAT
int SCIPgetNIntVars(SCIP *scip)
SCIP_RETCODE SCIPgetVarsData(SCIP *scip, SCIP_VAR ***vars, int *nvars, int *nbinvars, int *nintvars, int *nimplvars, int *ncontvars)
int SCIPgetNVars(SCIP *scip)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIPgetNBinVars(SCIP *scip)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
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)
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)
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)
SCIP_RETCODE SCIPincludeHeurTwoopt(SCIP *scip)
int SCIPcolGetNNonz(SCIP_COL *col)
SCIP_Real * SCIPcolGetVals(SCIP_COL *col)
SCIP_ROW ** SCIPcolGetRows(SCIP_COL *col)
void SCIPcolSort(SCIP_COL *col)
SCIP_RETCODE SCIPsetHeurFree(SCIP *scip, SCIP_HEUR *heur,)
SCIP_HEURDATA * SCIPheurGetData(SCIP_HEUR *heur)
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)
SCIP_RETCODE SCIPsetHeurInitsol(SCIP *scip, SCIP_HEUR *heur,)
SCIP_RETCODE SCIPsetHeurCopy(SCIP *scip, SCIP_HEUR *heur,)
SCIP_RETCODE SCIPsetHeurExitsol(SCIP *scip, SCIP_HEUR *heur,)
SCIP_RETCODE SCIPsetHeurExit(SCIP *scip, SCIP_HEUR *heur,)
SCIP_RETCODE SCIPsetHeurInit(SCIP *scip, SCIP_HEUR *heur,)
const char * SCIPheurGetName(SCIP_HEUR *heur)
void SCIPheurSetData(SCIP_HEUR *heur, SCIP_HEURDATA *heurdata)
SCIP_RETCODE SCIPchgVarLbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_RETCODE SCIPchgVarUbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)
SCIP_Real SCIPgetVarLbDive(SCIP *scip, SCIP_VAR *var)
SCIP_Real SCIPgetVarUbDive(SCIP *scip, SCIP_VAR *var)
SCIP_RETCODE SCIPstartDive(SCIP *scip)
SCIP_RETCODE SCIPsolveDiveLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)
SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)
SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)
SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)
int SCIPgetNLPRows(SCIP *scip)
SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)
#define SCIPfreeBlockMemoryArray(scip, ptr, num)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPreallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPallocBlockMemoryArray(scip, ptr, num)
#define SCIPreallocBlockMemoryArray(scip, ptr, oldnum, newnum)
#define SCIPfreeBlockMemory(scip, ptr)
#define SCIPallocBlockMemory(scip, ptr)
#define SCIPduplicateBlockMemoryArray(scip, ptr, source, num)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
int SCIProwGetLPPos(SCIP_ROW *row)
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)
const char * SCIProwGetName(SCIP_ROW *row)
int SCIProwGetIndex(SCIP_ROW *row)
SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
SCIP_RETCODE SCIPcreateSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol)
SCIP_RETCODE SCIPprintSol(SCIP *scip, SCIP_SOL *sol, FILE *file, SCIP_Bool printzeros)
SCIP_Longint SCIPsolGetNodenum(SCIP_SOL *sol)
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)
int SCIPsolGetIndex(SCIP_SOL *sol)
SCIP_RETCODE SCIPtrySol(SCIP *scip, SCIP_SOL *sol, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool *stored)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real SCIPgetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var)
void SCIPsolSetHeur(SCIP_SOL *sol, SCIP_HEUR *heur)
SCIP_Longint SCIPgetNNodes(SCIP *scip)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Bool SCIPisFeasGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisPositive(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasIntegral(SCIP *scip, SCIP_Real val)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisZero(SCIP *scip, SCIP_Real val)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
int SCIPrandomGetInt(SCIP_RANDNUMGEN *randnumgen, int minrandval, int maxrandval)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPsortRealPtrPtrInt(SCIP_Real *realarray, void **ptrarray1, void **ptrarray2, int *intarray, int len)
SCIPfreeSol(scip, &heurdata->sol))
SCIPfreeRandom(scip, &heurdata->randnumgen)
SCIPcreateRandom(scip, &heurdata->randnumgen, DEFAULT_RANDSEED, TRUE))
assert(minobj< SCIPgetCutoffbound(scip))
SCIPlinkLPSol(scip, sol))
static SCIP_Real determineBound(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *master, DIRECTION masterdirection, SCIP_VAR *slave, DIRECTION slavedirection, SCIP_Real *activities, int nrows)
static void disposeVariable(SCIP_VAR **vars, int *blockend, int varindex)
#define DEFAULT_MATCHINGRATE
#define DEFAULT_WAITINGNODES
static SCIP_Bool checkConstraintMatching(SCIP *scip, SCIP_VAR *var1, SCIP_VAR *var2, SCIP_Real matchingrate)
static int varColCompare(SCIP_VAR *var1, SCIP_VAR *var2)
#define DEFAULT_ARRAYSIZE
#define DEFAULT_MAXNSLAVES
static SCIP_RETCODE shiftValues(SCIP *scip, SCIP_VAR *master, SCIP_VAR *slave, SCIP_Real mastersolval, DIRECTION masterdir, SCIP_Real slavesolval, DIRECTION slavedir, SCIP_Real shiftval, SCIP_Real *activities, int nrows, SCIP_Bool *feasible)
static SCIP_RETCODE innerPresolve(SCIP *scip, SCIP_VAR **vars, SCIP_VAR ***varspointer, int nvars, int *nblocks, int *maxblocksize, int *nblockvars, int **blockstart, int **blockend, SCIP_HEUR *heur, SCIP_HEURDATA *heurdata)
static SCIP_RETCODE optimize(SCIP *scip, SCIP_SOL *worksol, SCIP_VAR **vars, int *blockstart, int *blockend, int nblocks, OPTTYPE opttype, SCIP_Real *activities, int nrows, SCIP_Bool *improvement, SCIP_Bool *varboundserr, SCIP_HEURDATA *heurdata)
static SCIP_RETCODE presolveTwoOpt(SCIP *scip, SCIP_HEUR *heur, SCIP_HEURDATA *heurdata)
Primal heuristic to improve incumbent solution by flipping pairs of variables.
memory allocation routines
public methods for primal heuristics
public methods for LP management
public methods for message output
#define SCIPstatisticMessage
public data structures and miscellaneous methods
methods for sorting joint arrays of various types
public methods for primal CIP solutions
public methods for problem variables
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 random numbers
public methods for solutions
public methods for querying solving statistics
#define SCIP_DECL_HEURINITSOL(x)
#define SCIP_DECL_HEURCOPY(x)
struct SCIP_HeurData SCIP_HEURDATA
#define SCIP_DECL_HEURINIT(x)
#define SCIP_DECL_HEUREXIT(x)
#define SCIP_DECL_HEURFREE(x)
#define SCIP_DECL_HEUREXITSOL(x)
#define SCIP_DECL_HEUREXEC(x)
#define SCIP_DECL_SORTPTRCOMP(x)
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_VARTYPE_CONTINUOUS