60#define DEFAULT_MEM_VARAFTERDUAL 10
61#define DEFAULT_MEM_VAR 10
62#define DEFAULT_MEM_NODES 1000
63#define DEFAULT_MEM_RUN 200
64#define DEFAULT_MEM_DUALCONS 10
66#define DEFAULT_RANDSEED 67
69#define EVENTHDLR_NAME "Reopt"
70#define EVENTHDLR_DESC "node event handler for reoptimization"
95 if( eventnode ==
NULL )
185 assert(num <= reopt->nmaxactiveconss);
201 assert(runidx <= reopt->runsize);
212 assert(num <= reopt->soltree->solssize[runidx]);
236 for(
int s = reopt->
runsize; s < newsize; ++s )
248 assert(num < reopt->runsize);
273 for(
unsigned int id = reopttree->
reoptnodessize;
id < (
unsigned int)newsize; ++
id )
314 else if( reoptnode->
varssize < var_mem )
350 else if( reoptnode->
consssize < conss_mem )
382 sibling = solnode->
child;
385 while( sibling !=
NULL )
418 for(
int v = 0; v <
nvars; ++v )
455 assert(0 <= probidx && probidx < reopt->nobjvars);
457 c1 = reopt->
objs[obj1_id][probidx];
458 c2 = reopt->
objs[obj2_id][probidx];
462 norm_obj1 +=
SQR(c1);
463 norm_obj2 +=
SQR(c2);
468 norm_obj1 = sqrt(norm_obj1);
469 norm_obj2 = sqrt(norm_obj2);
472 similarity /= (norm_obj1 * norm_obj2);
475 similarity =
MAX(similarity, -1.0);
476 similarity =
MIN(similarity, 1.0);
492 if( (*reoptnode)->consssize > 0 )
496 for(
int c = 0;
c < (*reoptnode)->nconss; ++
c )
508 (*reoptnode)->nconss = 0;
509 (*reoptnode)->consssize = 0;
510 (*reoptnode)->conss =
NULL;
514 if( (*reoptnode)->childids !=
NULL )
517 (*reoptnode)->nchilds = 0;
518 (*reoptnode)->allocchildmem = 0;
519 (*reoptnode)->childids =
NULL;
523 if( (*reoptnode)->dualredscur !=
NULL )
525 assert((*reoptnode)->dualredscur->varssize > 0);
530 (*reoptnode)->dualredscur =
NULL;
534 if( (*reoptnode)->dualredsnex !=
NULL )
536 assert((*reoptnode)->dualredsnex->varssize > 0);
541 (*reoptnode)->dualredsnex =
NULL;
545 if ((*reoptnode)->varboundtypes !=
NULL )
547 assert((*reoptnode)->varssize > 0);
549 (*reoptnode)->varboundtypes =
NULL;
553 if ((*reoptnode)->varbounds !=
NULL )
555 assert((*reoptnode)->varssize > 0);
557 (*reoptnode)->varbounds =
NULL;
561 if ((*reoptnode)->vars !=
NULL )
563 assert((*reoptnode)->varssize > 0);
565 (*reoptnode)->vars =
NULL;
568 (*reoptnode)->varssize = 0;
571 if ((*reoptnode)->afterdualvarboundtypes !=
NULL )
573 assert((*reoptnode)->afterdualvarssize > 0);
575 (*reoptnode)->afterdualvarboundtypes =
NULL;
579 if ((*reoptnode)->afterdualvarbounds !=
NULL )
581 assert((*reoptnode)->afterdualvarssize > 0);
583 (*reoptnode)->afterdualvarbounds =
NULL;
587 if ((*reoptnode)->afterdualvars !=
NULL )
589 assert((*reoptnode)->afterdualvarssize > 0);
591 (*reoptnode)->afterdualvars =
NULL;
594 (*reoptnode)->afterdualvarssize = 0;
615 if( reoptnode->
nconss > 0 )
620 for(
int c = 0;
c < reoptnode->
nconss; ++
c )
622 if( !reoptnode->
conss[
c]->linear )
669 reoptnode->
nvars = 0;
689 assert(id < reopttree->reoptnodessize);
725 soltree->
nsols[s] = 0;
761 child = (*solnode)->
child;
764 while( child !=
NULL )
774 if( (*solnode)->sol !=
NULL )
833 *child = curnode->
child;
843 solnode->
father = curnode;
846 solnode->
value = val;
855 curnode->
child = *child;
857#ifdef SCIP_MORE_DEBUG
859 (
void*) solnode->sibling);
865 while( *child !=
NULL )
867#ifdef SCIP_MORE_DEBUG
869 (*child)->
value, (
void*) (*child)->sibling);
876 if( (*child)->sibling ==
NULL )
882 solnode->
father = curnode;
884 solnode->
value = val;
896 (*child)->sibling = solnode;
898#ifdef SCIP_MORE_DEBUG
900 (
void*) solnode->sibling);
907#ifdef SCIP_MORE_DEBUG
909 SCIPsetDebugMsg(
set,
" before switching: node %p witch child=%p, sibling=%p, sol=%p, value=%g\n",
910 (
void*) (*child), (
void*) (*child)->child, (
void*) (*child)->sibling, (
void*) (*child)->sol,
913 (
void*) solnode, (
void*) solnode->child, (
void*) solnode->sibling, (
void*) solnode->sol,
917 solnode->child = (*child)->child;
918 (*child)->child =
NULL;
921 solnode->value = (*child)->value;
922 (*child)->value = val;
926 solnode->sol = (*child)->sol;
927 (*child)->sol =
NULL;
928#ifdef SCIP_MORE_DEBUG
929 SCIPsetDebugMsg(
set,
" after switching: node %p witch child=%p, sibling=%p, sol=%p, value=%g\n",
930 (
void*) (*child), (
void*) (*child)->child, (
void*) (*child)->sibling, (
void*) (*child)->sol,
933 (
void*) solnode, (
void*) solnode->child, (
void*) solnode->sibling, (
void*) solnode->sol,
953 solnode->
father = curnode;
956 solnode->
value = val;
964 (*child)->sibling = solnode;
967#ifdef SCIP_MORE_DEBUG
969 (
void*) solnode->sibling);
975 *child = (*child)->sibling;
980 solnode = curnode->
child;
1025 if(
set->reopt_savesols > 0 )
1032 for(
int varid = 0; varid <
nvars; ++varid )
1048 if( (*added || bestsol) && !purelp )
1057 cursolnode->
sol = copysol;
1073 (*solnode) = cursolnode;
1096 child = node->
child;
1099 while( child !=
NULL )
1124 assert(id < reopttree->reoptnodessize);
1297 else if( reopt->
dualreds->varssize < size )
1303 reopt->
dualreds->varssize = newsize;
1404 assert(0 <
id && id < reopt->reopttree->reoptnodessize);
1411 if( nconsprops > 0 || npropprops > 0 )
1423 assert(
nvars + naddedbndchgs <= reopt->reopttree->reoptnodes[
id]->varssize);
1427 *transintoorig =
TRUE;
1458 assert(0 <
id && id < reopt->reopttree->reoptnodessize);
1510 if( nbranchvars > 0 )
1511 *transintoorig =
TRUE;
1513 SCIPsetDebugMsg(
set,
" -> save %d bound changes after dual reductions\n", nbranchvars);
1576 for(
int c = 0;
c < ncutvars; ++
c )
1590 if( cutvars[
c] !=
NULL )
1605 cutvals[
c] = cutvals[
c]/scalar;
1630 assert(0 <
id && id < reopt->reopttree->reoptnodessize);
1672 unsigned int* parentid,
1686 int nbranchings = 0;
1690 if(
set->reopt_saveprop )
1695 (*nbndchgs) = (*nbndchgs) + nbranchings + nconsprop + npropprops;
1733 unsigned int parentid,
1734 unsigned int childid
1766 unsigned int nodeid,
1767 unsigned int parentid
1770 unsigned int childid;
1775 assert(0 < nodeid && nodeid < reopt->reopttree->reoptnodessize);
1776 assert(parentid < reopt->reopttree->reoptnodessize);
1789 assert(0 < childid && childid < reopt->reopttree->reoptnodessize);
1833 assert(id < reopttree->reoptnodessize);
1839 SCIPsetDebugMsg(
set,
"-> delete subtree induced by ID %u (hard remove = %u)\n",
id, exitsolve);
1844 unsigned int childid;
1848 assert(0 < childid && childid < reopttree->reoptnodessize);
1881 assert(id < reopt->reopttree->reoptnodessize);
1887 if( reoptnodes[
id]->childids !=
NULL && reoptnodes[
id]->nchilds > 0 )
1890 unsigned int parentid = 0;
1897 assert(reoptnodes[parentid]->childids !=
NULL && reoptnodes[parentid]->nchilds);
1907 if( ndomchgs <= set->reopt_maxdiffofnodes )
1912 id, reoptnodes[
id]->nchilds);
1919 while( reoptnodes[parentid]->childids[
c] !=
id )
1922 assert(
c < reoptnodes[parentid]->nchilds);
1925 assert(reoptnodes[parentid]->childids[
c] ==
id);
1929 --reoptnodes[parentid]->
nchilds;
1953 assert(id < reopttree->reoptnodessize);
1958 unsigned int childid;
1964 while( seenids < nchildids )
1968 assert(childid < reopttree->reoptnodessize);
2047 *localrestart =
FALSE;
2050 assert(id < reopt->reopttree->reoptnodessize);
2056 if(
set->reopt_objsimdelay > -1 )
2069 for(
int v = 0; v < ntransvars; ++v )
2078 assert(0 <= idx && idx < ntransvars);
2083 sim += (oldcoef * newcoef);
2092 *localrestart =
TRUE;
2105 SCIPsetDebugMsg(
set,
" -> local similarity: %.4f%s\n", sim, *localrestart ?
" (solve subproblem from scratch)" :
"");
2120 unsigned int parentid
2128 assert(1 <=
id && id < reopttree->reoptnodessize);
2130 assert(parentid < reopttree->reoptnodessize);
2169 assert(nbranchvars <= reopttree->reoptnodes[
id]->varssize);
2173 assert(nbranchvars <= reopttree->reoptnodes[
id]->varssize);
2199 allocbuffervals =
FALSE;
2200 reoptconsdata->linear =
TRUE;
2210 reoptconsdata->varssize = reoptconsdata->nvars;
2213 reoptconsdata->boundtypes =
NULL;
2232 allocbuffervals =
TRUE;
2234 for(
int v = 0; v < reoptconsdata->nvars; ++v )
2237 reoptconsdata->lhs = 1.0;
2246 allocbuffervals =
TRUE;
2248 for(
int v = 0; v < reoptconsdata->nvars; ++v )
2253 reoptconsdata->lhs = 1.0;
2254 reoptconsdata->rhs = 1.0;
2258 reoptconsdata->rhs = 1.0;
2261 reoptconsdata->lhs = 1.0;
2281 for(
int v = 0; v < reoptconsdata->nvars; ++v )
2288 reoptconsdata->vars[v] =
vars[v];
2289 reoptconsdata->vals[v] = vals[v];
2295 reoptconsdata->vals[v] *= scalar;
2298 reoptconsdata->lhs -= constant;
2300 reoptconsdata->rhs -= constant;
2304 if( allocbuffervals )
2331 reoptconsdata->linear =
FALSE;
2339 SCIPerrorMessage(
"Cannot handle constraints of type <%s> in saveConsBounddisjuction.\n",
2354 reoptconsdata->varssize = reoptconsdata->nvars;
2359 for(
int v = 0; v < reoptconsdata->nvars; ++v )
2370 reoptconsdata->vals[v] -= constant;
2371 reoptconsdata->vals[v] *= scalar;
2398 assert(id < reopttree->reoptnodessize);
2417 for(
int c = nconss;
c < naddedconss; ++
c )
2491 assert(id < reopt->reopttree->reoptnodessize);
2513 &nbndchgs, reopt->
dualreds->varssize);
2514 assert(nbndchgs <= reopt->dualreds->varssize);
2520 for(
int v = 0; v < nbndchgs; ++v )
2544 cons_is_next =
FALSE;
2555 reopt->
dualreds->vars, nbndchgs) );
2557 reopt->
dualreds->vals, nbndchgs) );
2559 reopt->
dualreds->boundtypes, nbndchgs) );
2569 SCIPsetDebugMsg(
set,
" -> save dual information of type 1: node %lld, nvars %d, constype %d\n",
2581 reopt->
dualreds->vars, nbndchgs) );
2583 reopt->
dualreds->vals, nbndchgs) );
2585 reopt->
dualreds->boundtypes, nbndchgs) );
2593 SCIPsetDebugMsg(
set,
" -> save dual information of type 2: node %lld, nvars %d, constype %d\n",
2618 unsigned int parentid = 0;
2625 if(
set->reopt_maxsavednodes == 0 )
2649 assert(id < reopt->reopttree->reoptnodessize);
2698 transintoorig =
FALSE;
2701 if(
set->reopt_usecuts )
2714 if(
set->reopt_saveprop )
2730#ifdef SCIP_MORE_DEBUG
2762 if(
set->reopt_shrinkinner )
2782 if(
set->reopt_reducetofrontier )
2796 if(
set->reopt_reducetofrontier )
2846 if(
set->reopt_usecuts )
2880 SCIPsetDebugMsg(
set,
" -> nvars: 0, ncons: 0, parentID: -, reopttype: %d, lowerbound: %g\n", reopttype,
2894 if(
set->reopt_reducetofrontier )
2913 SCIPsetDebugMsg(
set,
" -> nvars: 0, ncons: 0, parentID: -, reopttype: %d, lowerbound: %g\n", reopttype,
2927 if(
set->reopt_reducetofrontier )
2946 SCIPsetDebugMsg(
set,
" -> nvars: 0, ncons: 0, parentID: -, reopttype: %d, lowerbound:%g \n", reopttype,
3007 assert(
id >= 1 && id < reopt->reopttree->reoptnodessize);
3058 if(
set->reopt_usecuts )
3074 SCIPsetDebugMsg(
set,
" -> nvars: %d, ncons: %d, parentID: %u, reopttype: %d, lowerbound: %g\n",
3078#ifdef SCIP_MORE_DEBUG
3266 reoptconsdata =
NULL;
3271 reoptconsdata = reopt->
glbconss[nglbconss];
3277 reoptconsdata->nvars = 0;
3284 reoptconsdata = reopt->
glbconss[nglbconss];
3299 reoptconsdata->lhs = 1.0;
3301 reoptconsdata->linear =
FALSE;
3304 for(
int v = 0; v <
nvars; ++v )
3306 assert(nvarsadded < reoptconsdata->varssize);
3321 reoptconsdata->vars[nvarsadded] =
vars[v];
3326 reoptconsdata->vals[nvarsadded] = 0.0;
3333 reoptconsdata->vals[nvarsadded] = 1.0;
3342 reoptconsdata->vals[nvarsadded] = vals[v];
3354 reoptconsdata->vars[nvarsadded] =
vars[v];
3370 reoptconsdata->vals[nvarsadded] = ubglb - 1.0;
3378 reoptconsdata->vals[nvarsadded] = lbglb + 1.0;
3382 else if( boundtypes !=
NULL )
3391 reoptconsdata->vals[nvarsadded] = roundedval + 1.0;
3399 reoptconsdata->vals[nvarsadded] = roundedval - 1.0;
3412 reoptconsdata->vals[nvarsadded] = roundedval - 1.0;
3417 reoptconsdata->vars[nvarsadded] =
vars[v];
3418 reoptconsdata->vals[nvarsadded] = roundedval + 1.0;
3427 reoptconsdata->nvars = nvarsadded;
3465 if( allocmem < nbranchvars )
3470 allocmem = nbranchvars;
3478 for(
int v = 0; v < nbranchvars; ++v )
3515 assert(id1 < reopttree->reoptnodessize);
3516 assert(id2 < reopttree->reoptnodessize);
3530 for(
int c = 0;
c < nchilds_id1; ++
c )
3535 for(
int k = 0; k < nchilds_id2; ++k )
3587 assert(id < reopttree->reoptnodessize);
3597 for(
int v = 0; v < reoptnode->
nvars; ++v )
3635#ifdef SCIP_MORE_DEBUG
3691#ifdef SCIP_MORE_DEBUG
3748 assert(id < reopt->reopttree->reoptnodessize);
3786 assert(!reoptconsdata->linear);
3791 var = reoptconsdata->vars[0];
3792 newbound = reoptconsdata->vals[0];
3793 boundtype = reoptconsdata->boundtypes[0];
3804 newbound = reoptconsdata->vals[0] - 1.0;
3812 newbound = reoptconsdata->vals[0] + 1.0;
3850 assert(!reoptconsdata->linear);
3859 for(
int v = 0; v < reoptconsdata->nvars; ++v )
3882 SCIPerrorMessage(
"Variable <%s> has to be either binary, (implied) integer, or continuous.\n",
3897 if( reoptconsdata->nvars ==
nbinvars )
3899 for(
int v = 0; v < reoptconsdata->nvars; ++v )
3901 consvars[v] = reoptconsdata->vars[v];
3902 consval = reoptconsdata->vals[v];
3933 for(
int v = 0; v < reoptconsdata->nvars; ++v )
3935 consvars[v] = reoptconsdata->vars[v];
3936 consvals[v] = reoptconsdata->vals[v];
3937 consboundtypes[v] = reoptconsdata->boundtypes[v];
3971 consvals,
FALSE,
FALSE,
TRUE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE,
TRUE) );
3979#ifdef SCIP_DEBUG_CONSS
4030 assert(0 <
id && id < reopttree->reoptnodessize);
4040 for(
int v = 0; v < reoptnode->
dualredscur->nvars; ++v )
4049 boundtype = reoptnode->
dualredscur->boundtypes[v];
4079#ifdef SCIP_MORE_DEBUG
4089 pos = reoptnode->
nvars;
4103 if( updatedualconss )
4160 assert(0 <
id && id < reopt->reopttree->reoptnodessize);
4179 for(
int v = 0; v < nbndchgs; ++v )
4182 val = vals[perm[v]];
4183 boundtype = boundtypes[perm[v]];
4189 if( v == nbndchgs-1 )
4217#ifdef SCIP_MORE_DEBUG
4246 assert(0 <
id && id < reopt->reopttree->reoptnodessize);
4261 assert(reoptconsdata->nvars > 0);
4262 assert(reoptconsdata->varssize >= reoptconsdata->nvars);
4274 if( reoptconsdata->linear )
4277 reoptconsdata->lhs, reoptconsdata->rhs,
FALSE,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE,
TRUE) );
4283 reoptconsdata->vals,
FALSE,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE,
TRUE) );
4285#ifdef SCIP_DEBUG_CONSS
4331 unsigned int* cutoffchilds;
4332 int ncutoffchilds = 0;
4333 unsigned int* redchilds;
4339 assert(id < reopt->reopttree->reoptnodessize);
4362 unsigned int childid;
4369 assert(childid < reopt->reopttree->reoptnodessize);
4372#ifdef SCIP_MORE_DEBUG
4375 if( child->
nvars > 0 )
4380 for(
int v = 0; v < child->
nvars && !
cutoff; ++v )
4388 transvar = child->
vars[v];
4401 SCIPsetDebugMsg(
set,
" -> <%s> is fixed to %g, can not change bound to %g -> cutoff\n",
4414 redundantvars[nredundantvars] = v;
4419 if( !
cutoff && nredundantvars > 0 )
4421 for(
int v = 0; v < nredundantvars; ++v )
4424 child->
vars[redundantvars[v]] = child->
vars[child->
nvars-1];
4434 else if( child->
nconss == 0 )
4442 cutoffchilds[ncutoffchilds] = childid;
4445 else if( redundant )
4447 redchilds[nredchilds] = childid;
4452 SCIPsetDebugMsg(
set,
"-> found %d redundant and %d infeasible nodes\n", nredchilds, ncutoffchilds);
4455 while( ncutoffchilds > 0 )
4475 while( nredchilds > 0 )
4510 for(
int cc = 0; cc < ncc; ++cc )
4545 assert(id < reopttree->reoptnodessize);
4563 assert(id < reopt->reopttree->reoptnodessize);
4569 unsigned int childid;
4572 assert(childid < reopt->reopttree->reoptnodessize);
4588 unsigned int* leaves,
4596 assert(id < reopt->reopttree->reoptnodessize);
4601 unsigned int childid;
4603 assert(*nleaves <= leavessize);
4606 assert(childid < reopt->reopttree->reoptnodessize);
4620 (*nleaves) += nleaves2;
4707 for(
int i = 0;
i < reopt->
run-1; ++
i )
4710 for(
int v = reopt->
nobjvars-1; v < norigvars; ++v )
4711 reopt->
objs[
i][v] = 0.0;
4718 for(
int v = 0; v < norigvars; ++v )
4730 for(
int i = 0;
i < reopt->
run; ++
i )
4733 for(
int j = reopt->
nobjvars; j < newsize; ++j )
4734 reopt->
objs[
i][j] = 0.0;
4738 assert(0 <= probidx && probidx < reopt->nobjvars);
4748 if( reopt->
firstobj == -1 && reopt->
objs[reopt->
run-1][probidx] != 0 )
4753 if( reopt->
run-1 >= 1 )
4794 for(
int v = 0; v <
nvars; ++v )
4853 for(
int v = 0; v <
nvars; ++v )
4867 origvars[v] =
vars[v];
4896#undef SCIPreoptGetNRestartsGlobal
4897#undef SCIPreoptGetNRestartsLocal
4898#undef SCIPreoptGetNTotalRestartsLocal
4899#undef SCIPreoptGetFirstRestarts
4900#undef SCIPreoptGetLastRestarts
4901#undef SCIPreoptGetNFeasNodes
4902#undef SCIPreoptGetNTotalFeasNodes
4903#undef SCIPreoptGetNPrunedNodes
4904#undef SCIPreoptGetNTotalPrunedNodes
4905#undef SCIPreoptGetNCutoffReoptnodes
4906#undef SCIPreoptGetNTotalCutoffReoptnodes
4907#undef SCIPreoptGetNInfNodes
4908#undef SCIPreoptGetNTotalInfNodes
4909#undef SCIPreoptGetNInfSubtrees
5056 (*reopt)->simtolastobj = -2.0;
5057 (*reopt)->simtofirstobj = -2.0;
5058 (*reopt)->firstobj = -1;
5059 (*reopt)->currentnode = -1;
5060 (*reopt)->lastbranched = -1;
5061 (*reopt)->dualreds =
NULL;
5062 (*reopt)->glbconss =
NULL;
5063 (*reopt)->nglbconss = 0;
5064 (*reopt)->allocmemglbconss = 0;
5065 (*reopt)->ncheckedsols = 0;
5066 (*reopt)->nimprovingsols = 0;
5067 (*reopt)->noptsolsbyreoptsol = 0;
5068 (*reopt)->nglbrestarts = 0;
5069 (*reopt)->nlocrestarts = 0;
5070 (*reopt)->ntotallocrestarts = 0;
5071 (*reopt)->firstrestart = -1;
5072 (*reopt)->lastrestart = 0;
5073 (*reopt)->nobjvars = 0;
5074 (*reopt)->objhaschanged =
FALSE;
5075 (*reopt)->consadded =
FALSE;
5076 (*reopt)->addedconss =
NULL;
5077 (*reopt)->naddedconss = 0;
5078 (*reopt)->addedconsssize = 0;
5079 (*reopt)->glblb =
NULL;
5080 (*reopt)->glbub =
NULL;
5081 (*reopt)->nactiveconss = 0;
5082 (*reopt)->nmaxactiveconss = 0;
5083 (*reopt)->activeconss =
NULL;
5084 (*reopt)->activeconssset =
NULL;
5090 for(
int i = 0;
i < (*reopt)->runsize; ++
i )
5092 (*reopt)->objs[
i] =
NULL;
5093 (*reopt)->prevbestsols[
i] =
NULL;
5094 (*reopt)->varhistory[
i] =
NULL;
5116 eventInitsolReopt, eventExitsolReopt,
NULL, eventExecReopt,
NULL) );
5173 for(
int p = (*reopt)->run-1; p >= 0; --p )
5175 if( (*reopt)->soltree->sols[p] !=
NULL )
5178 (*reopt)->soltree->sols[p] =
NULL;
5181 if(
set->reopt_storevarhistory && (*reopt)->varhistory[p] !=
NULL )
5189 (*reopt)->varhistory[p] =
NULL;
5195 if(
set->reopt_sepabestsol && (*reopt)->prevbestsols[p] !=
NULL )
5200 if( (*reopt)->objs[p] !=
NULL )
5210 if( (*reopt)->dualreds !=
NULL )
5212 if( (*reopt)->dualreds->varssize > 0 )
5214 assert(!(*reopt)->dualreds->linear);
5220 (*reopt)->dualreds =
NULL;
5224 if( (*reopt)->glbconss !=
NULL && (*reopt)->allocmemglbconss > 0 )
5227 for(
int c = 0;
c < (*reopt)->allocmemglbconss; ++
c )
5229 if( (*reopt)->glbconss[
c] !=
NULL )
5231 if( (*reopt)->glbconss[
c]->varssize > 0 )
5236 (*reopt)->glbconss[
c]->varssize = 0;
5239 --(*reopt)->nglbconss;
5242 assert((*reopt)->nglbconss == 0);
5245 (*reopt)->allocmemglbconss = 0;
5252 if( (*reopt)->activeconssset !=
NULL )
5258 if( (*reopt)->glblb !=
NULL )
5262 (*reopt)->glblb =
NULL;
5263 (*reopt)->glbub =
NULL;
5288 assert(id < reopt->reopttree->reoptnodessize);
5337 SCIP_CALL(
soltreeAddSol(reopt,
set, stat, origprimal, blkmem,
vars,
sol, &solnode,
nvars, bestsol, added) );
5380 if(
set->reopt_sepabestsol )
5473 assert(0 < run && run <= reopt->runsize);
5490 for(
int r = 0;
r < reopt->
run; ++
r )
5506 assert(run > 0 && run <= reopt->run);
5513 for(
int s = 0; s < reopt->
soltree->
nsols[run-1]; ++s )
5519 if( solssize < (*nsols) )
5523 for(
int s = 0; s < reopt->
soltree->
nsols[run-1]; ++s )
5589 if( reopt->
run > 1 &&
set->reopt_objsimdelay > -1.0 )
5600 SCIPsetDebugMsg(
set,
"-> restart reoptimization (objective functions are not similar enough)\n");
5612 SCIPsetDebugMsg(
set,
"-> restart reoptimization (found last %d optimal solutions by <reoptsols>)\n",
5661 assert(run1 > 0 && run1 <= reopt->run);
5662 assert(run2 > 0 && run2 <= reopt->run);
5677 if( reopt->
run-2 < 0 )
5691 assert(id < reopt->reopttree->reoptnodessize);
5705 assert(0 < run && run <= reopt->runsize);
5707 return reopt->
objs[run-1][idx];
5720 assert(0 < run && run <= reopt->run);
5744#ifdef SCIP_MORE_DEBUG
5773 while( child !=
NULL )
5794 assert(id < reopt->reopttree->reoptnodessize);
5800 assert(0 <
id && id < reopt->reopttree->reoptnodessize);
5813#undef SCIPreoptnodeGetNVars
5814#undef SCIPreoptnodeGetNConss
5815#undef SCIPreoptnodeGetNDualBoundChgs
5816#undef SCIPreoptnodeGetNChildren
5817#undef SCIPreoptnodeGetLowerbound
5818#undef SCIPreoptnodeGetType
5837 return reoptnode->
nconss;
5901 (*nconss) = reoptnode->
nconss;
5906 for(
int c = 0;
c < *nconss; ++
c )
5912 bounds[
c] = reoptnode->
conss[
c]->vals;
5913 boundtypes[
c] = reoptnode->
conss[
c]->boundtypes;
5921 unsigned int parentid
5925 assert(parentid <= 536870911);
5942 assert(id < reopt->reopttree->reoptnodessize);
5950 unsigned int childid;
5953 assert(childid < reopt->reopttree->reoptnodessize);
5977 if(
set->reopt_sepaglbinfsubtrees )
6000 int effectiverootdepth
6057 lowerbound =
MIN(lowerbound, cutoffbound);
6062 isrootnode, lowerbound) );
6117 if( strongbranched )
6200 if( strongbranched )
6226 if( strongbranched )
6294 allocmem = reopt->
dualreds->nvars + resizelength;
6309 newval = (newval - constant) / scalar;
6310 oldval = (oldval - constant) / scalar;
6316 SCIPerrorMessage(
"cannot store equal bounds: old = %g, new = %g\n", oldval, newval);
6352 int ndualbndchgs = 0;
6360 ndualbndchgs = reopt->
dualreds->nvars;
6363 return ndualbndchgs;
6372 unsigned int* childs,
6392 assert(id < reopt->reopttree->reoptnodessize);
6407 if( childssize < *nchilds )
6410 for(
int c = 0;
c < *nchilds; ++
c )
6421 unsigned int* leaves,
6439 if(
id == 0 && node !=
NULL )
6445 assert(id < reopt->reopttree->reoptnodessize);
6448 for(
int i = 0;
i < leavessize; ++
i )
6454 unsigned int childid;
6456 assert(*nleaves + 1 <= leavessize);
6459 assert(childid < reopt->reopttree->reoptnodessize);
6473 (*nleaves) += nleaves2;
6504 SCIPsetDebugMsg(
set,
"save unprocessed nodes (%d leaves, %d children, %d siblings)\n", nleaves, nchilds, nsiblings);
6507 for(
int n = 0; n < nleaves; ++n )
6514 for(
int n = 0; n < nchilds; ++n )
6521 for(
int n = 0; n < nsiblings; ++n )
6550 if( !
set->reopt_storevarhistory )
6555 bestrun = reopt->
run-2;
6576 for(
int v = 0; v <
nvars; ++v )
6591 for(
int d = 0; d <= 1; ++d )
6615 (d == 0 ?
"down" :
"up"), avginference[d], avgcutoff[d]);
6637 if( !
set->reopt_storevarhistory )
6647 for(
int v = 0; v <
nvars; ++v )
6654 for(
int v = 0; v <
nvars; ++v )
6683 int nrepresentatives,
6694 assert(nrepresentatives > 0);
6710 for(
int r = 0;
r < nrepresentatives; ++
r )
6714 assert(1 <=
id && id < reopttree->reoptnodessize);
6725 if( representatives[
r]->
nvars > 0 )
6727 assert(representatives[
r]->
nvars <= representatives[
r]->varssize);
6729 for(
int v = 0; v < representatives[
r]->
nvars; ++v )
6736 if( representatives[
r]->nconss > 0 )
6738 assert(representatives[
r]->nconss <= representatives[
r]->consssize);
6740 for(
int c = 0;
c < representatives[
r]->
nconss; ++
c )
6743 representatives[
r]->
conss[
c]->vals, representatives[
r]->
conss[
c]->boundtypes,
6744 representatives[
r]->
conss[
c]->lhs, representatives[
r]->
conss[
c]->rhs,
6745 representatives[
r]->
conss[
c]->nvars, representatives[
r]->
conss[
c]->constype,
6746 representatives[
r]->
conss[
c]->linear) );
6767 SCIPsetDebugMsg(
set,
"-> new tree consists of %d nodes, the root has %d child nodes.\n",
6795 consdata->boundtypes =
NULL;
6797 consdata->varssize = dualreds->nvars;
6798 consdata->nvars = dualreds->nvars;
6800 consdata->linear =
TRUE;
6803 consdata->lhs = 1.0;
6806 for(
int v = 0; v < consdata->nvars; ++v )
6814 consdata->vals[v] = 1.0;
6826 consdata->vals[v] = -1.0;
6827 consdata->lhs -= 1.0;
6857 consdata->varssize = dualreds->nvars;
6858 consdata->nvars = dualreds->nvars;
6860 consdata->linear =
FALSE;
6866 for(
int v = 0; v < consdata->nvars; ++v )
6879 consdata->vals[v] =
MIN(consdata->vals[v]+1.0, glbbd);
6885 consdata->vals[v] =
MAX(glbbd, consdata->vals[v]-1.0);
6900 int* ncreatedchilds,
6928 assert(reoptnodes[0]->dualreds);
6931 nchilds = reoptnodes[0]->
nchilds;
6936 (*ncreatedchilds) = 0;
6959 assert(reoptnodes[
id]->varssize >= nbndchgs);
6963 assert(reoptnodes[
id]->varboundtypes !=
NULL);
6966 if( !
set->reopt_usesplitcons )
6973 for( v = 0; v < nbndchgs; ++v )
6978 ++reoptnodes[id]->
nvars;
6981 if( !
set->reopt_usesplitcons )
6988 assert(reoptnodes[0]->nchilds == 0);
6993 ++(*ncreatedchilds);
6995 if(
set->reopt_usesplitcons )
7003 assert(*ncreatedchilds == 1);
7024 consdata = reoptnodes[id]->
conss[0];
7027 for( v = 0; v < nbndchgs; ++v )
7061 ++reoptnodes[id]->
nconss;
7065 ++(*ncreatedchilds);
7071 assert(*ncreatedchilds == 1);
7076 boundtypes = reoptnodes[0]->
dualredscur->boundtypes;
7081 switch (
set->reopt_varorderinterdiction)
7121 assert(reoptnodes[
id]->varssize >= perm[
c]+1);
7125 assert(reoptnodes[
id]->varboundtypes !=
NULL);
7128 if(
set->reopt_varorderinterdiction ==
'd' )
7131 for( v = 0; v <
c; ++v )
7134 reoptnodes[id]->
varbounds[v] = bounds[v];
7141 for( v = 0; v <
c; ++v )
7143 reoptnodes[id]->
vars[v] =
vars[perm[v]];
7144 reoptnodes[id]->
varbounds[v] = bounds[perm[v]];
7148 reoptnodes[id]->
nvars +=
c;
7162 ++reoptnodes[id]->
nvars;
7167 ++(*ncreatedchilds);
7179 assert(reoptnodes[0]->dualredscur->vals !=
NULL);
7180 assert(reoptnodes[0]->dualredscur->boundtypes !=
NULL);
7204 assert(id < reopt->reopttree->reoptnodessize);
7225 int* nbndchgsafterdual
7231 int nafterdualvars2;
7239 (*nbndchgs) = reoptnode->
nvars;
7243 if( varssize == 0 || varssize < *nbndchgs + *nbndchgsafterdual )
7247 for( v = 0; v < *nbndchgs; ++v )
7255 for( ; v < *nbndchgs + *nbndchgsafterdual; ++v )
7270 (*nbndchgs) += nvars2;
7271 (*nbndchgsafterdual) += nafterdualvars2;
7285 assert(id < reopt->reopttree->reoptnodessize);
7313 int* ncreatedchilds,
7334 assert(id < reopt->reopttree->reoptnodessize);
7348 if(
set->reopt_usesplitcons )
7354 (*ncreatedchilds) = 1;
7360 (*ncreatedchilds) = 2;
7366 if( childnodessize < *ncreatedchilds )
7370 for(
int c = 0;
c < *ncreatedchilds; ++
c )
7380 cliquetable, blkmem, childnodes[
c],
id,
c == 1) );
7396 SCIP_CALL(
addSplitcons(reopt,
scip,
set, stat, blkmem, transprob, origprob, tree, lp, branchcand,
7397 eventqueue, cliquetable, childnodes[
c],
id) );
7421 if( reoptnode->
nconss == 0 )
7428 SCIP_CALL(
fixBounds(reopt,
set, stat, transprob, origprob, tree, lp, branchcand, eventqueue, cliquetable,
7429 blkmem, childnodes[
c],
id,
TRUE) );
7460 *ncreatedchilds =
nvars+1;
7464 if( childnodessize < *ncreatedchilds )
7473 switch (
set->reopt_varorderinterdiction)
7508#ifdef SCIP_MORE_DEBUG
7514 cliquetable, blkmem, childnodes[
c],
id,
FALSE) );
7520 SCIP_CALL(
fixBounds(reopt,
set, stat, transprob, origprob, tree, lp, branchcand, eventqueue, cliquetable,
7521 blkmem, childnodes[
c],
id,
TRUE) );
7532 SCIP_CALL(
fixInterdiction(reopt,
set, stat, transprob, origprob, tree, lp, branchcand, eventqueue, cliquetable,
7533 blkmem, childnodes[
c],
id, perm,
vars, bounds, boundtypes,
nvars,
c) );
7562 (*ncreatedchilds) = 1;
7565 if( childnodessize < *ncreatedchilds )
7574 cliquetable, blkmem, childnodes[0],
id,
FALSE) );
7643 for(
int v = 0; v < reopt->
glbconss[
c]->nvars; ++v )
7652 SCIPerrorMessage(
"Expected variable type binary or (impl.) integer for variable <%s> in global constraint at pos. %d.\n",
7670 for(
int v = 0; v < reopt->
glbconss[
c]->nvars; ++v )
7672 consvars[v] = reopt->
glbconss[
c]->vars[v];
7685 consvars,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE) );
7702#ifdef SCIP_DEBUG_CONSS
7760 assert(id < reopt->reopttree->reoptnodessize);
7770 for(
int c = reoptnode->
nconss-1;
c >= 0; --
c )
7774 cons = reoptnode->
conss[
c];
7789 for(
int v = 0; v < cons->nvars; ++v )
7799 vals[ncols] = cons->vals[v];
7805 assert(ncols == cons->nvars);
7812 SCIP_CALL(
SCIProwCreate(&cut, blkmem,
set, stat, cutname, ncols, cols, vals, cons->lhs, cons->rhs,
7816 SCIPsetDebugMsg(
set,
"add cut <%s> of size %d to cutpool, [lhs, rhs] = [%g,%g] to node %lld\n", cutname,
7821 SCIP_CALL(
SCIProwCreate(&cut, blkmem,
set, stat, cutname, ncols, cols, vals, cons->lhs, cons->rhs,
7823 SCIP_CALL(
SCIPsepastoreAddCut(sepastore, blkmem,
set, stat, eventqueue, eventfilter, lp, cut,
FALSE, root,
7826 SCIPsetDebugMsg(
set,
"add cut <%s> of size %d to sepastore, [lhs, rhs] = [%g,%g] to node %lld\n", cutname,
7849 for(
int i =
c-1;
i >= 0; --
i )
7873 assert(id < reopt->reopttree->reoptnodessize);
7921 reoptnode->
nvars = 0;
8046 newbound = bounds[0] + 1.0;
8053 newbound = bounds[0] - 1.0;
8064 nconss = reoptnode->
nconss;
8072 if( boundtypes !=
NULL )
8078 reoptnode->
conss[nconss]->boundtypes =
NULL;
8082 reoptnode->
conss[nconss]->lhs = lhs;
8083 reoptnode->
conss[nconss]->rhs = rhs;
8084 reoptnode->
conss[nconss]->constype = constype;
8085 reoptnode->
conss[nconss]->linear = linear;
8104#ifdef SCIP_MORE_DEBUG
8197 conss = transprob->
conss;
8198 nconss = transprob->
nconss;
8206 for(
int i = 0;
i < nconss; ++
i )
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
void SCIPclockFree(SCIP_CLOCK **clck)
SCIP_RETCODE SCIPclockCreate(SCIP_CLOCK **clck, SCIP_CLOCKTYPE clocktype)
internal methods for clocks and timing issues
void SCIPconsCapture(SCIP_CONS *cons)
SCIP_RETCODE SCIPconsDeactivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPconsGetNVars(SCIP_CONS *cons, SCIP_SET *set, int *nvars, SCIP_Bool *success)
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
SCIP_RETCODE SCIPconsActivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
internal methods for constraints and constraint handlers
constraint handler for bound disjunction constraints
Constraint handler for linear constraints in their most general form, .
Constraint handler for logicor constraints (equivalent to set covering, but algorithms are suited fo...
Constraint handler for the set partitioning / packing / covering constraints .
SCIP_RETCODE SCIPcutpoolAddRow(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_ROW *row)
internal methods for storing cuts in a cut pool
common defines and data types used in all packages of SCIP
#define SCIP_LONGINT_FORMAT
SCIP_RETCODE SCIPeventhdlrCreate(SCIP_EVENTHDLR **eventhdlr, SCIP_SET *set, const char *name, const char *desc, SCIP_DECL_EVENTCOPY((*eventcopy)), SCIP_DECL_EVENTFREE((*eventfree)), SCIP_DECL_EVENTINIT((*eventinit)), SCIP_DECL_EVENTEXIT((*eventexit)), SCIP_DECL_EVENTINITSOL((*eventinitsol)), SCIP_DECL_EVENTEXITSOL((*eventexitsol)), SCIP_DECL_EVENTDELETE((*eventdelete)), SCIP_DECL_EVENTEXEC((*eventexec)), SCIP_EVENTHDLRDATA *eventhdlrdata)
internal methods for managing events
SCIP_Real SCIPgetRhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_Real * SCIPgetBoundsBounddisjunction(SCIP *scip, SCIP_CONS *cons)
SCIP_Real SCIPgetLhsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBasicBounddisjunction(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_BOUNDTYPE *boundtypes, SCIP_Real *bounds)
SCIP_Real * SCIPgetValsLinear(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsBounddisjunctionRedundant(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)
SCIP_BOUNDTYPE * SCIPgetBoundtypesBounddisjunction(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVarsSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_SETPPCTYPE SCIPgetTypeSetppc(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsLinear(SCIP *scip, SCIP_CONS **cons, const char *name, int nvars, SCIP_VAR **vars, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, 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)
SCIP_VAR ** SCIPgetVarsLogicor(SCIP *scip, SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateConsLogicor(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)
SCIP_VAR ** SCIPgetVarsBounddisjunction(SCIP *scip, SCIP_CONS *cons)
@ SCIP_SETPPCTYPE_PARTITIONING
@ SCIP_SETPPCTYPE_COVERING
@ SCIP_SETPPCTYPE_PACKING
SCIP_STAGE SCIPgetStage(SCIP *scip)
int SCIPgetNVars(SCIP *scip)
SCIP_RETCODE SCIPaddCons(SCIP *scip, SCIP_CONS *cons)
SCIP_VAR ** SCIPgetVars(SCIP *scip)
int SCIPgetNOrigVars(SCIP *scip)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
SCIP_Real SCIPhashmapGetImageReal(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapInsertReal(SCIP_HASHMAP *hashmap, void *origin, SCIP_Real image)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_Bool SCIPhashmapExists(SCIP_HASHMAP *hashmap, void *origin)
void SCIPhashsetFree(SCIP_HASHSET **hashset, BMS_BLKMEM *blkmem)
SCIP_Bool SCIPhashsetExists(SCIP_HASHSET *hashset, void *element)
void SCIPhashsetRemoveAll(SCIP_HASHSET *hashset)
SCIP_RETCODE SCIPhashsetInsert(SCIP_HASHSET *hashset, BMS_BLKMEM *blkmem, void *element)
SCIP_RETCODE SCIPhashsetCreate(SCIP_HASHSET **hashset, BMS_BLKMEM *blkmem, int size)
SCIP_RETCODE SCIPaddConsNode(SCIP *scip, SCIP_NODE *node, SCIP_CONS *cons, SCIP_NODE *validnode)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
void SCIPrandomPermuteIntArray(SCIP_RANDNUMGEN *randnumgen, int *array, int begin, int end)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_CONSHDLR * SCIPconsGetHdlr(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsDeleted(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPreleaseCons(SCIP *scip, SCIP_CONS **cons)
const char * SCIPeventhdlrGetName(SCIP_EVENTHDLR *eventhdlr)
SCIP_RETCODE SCIPcatchVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int *filterpos)
SCIP_RETCODE SCIPdropVarEvent(SCIP *scip, SCIP_VAR *var, SCIP_EVENTTYPE eventtype, SCIP_EVENTHDLR *eventhdlr, SCIP_EVENTDATA *eventdata, int filterpos)
SCIP_Real SCIPeventGetOldbound(SCIP_EVENT *event)
SCIP_VAR * SCIPeventGetVar(SCIP_EVENT *event)
SCIP_Real SCIPeventGetNewbound(SCIP_EVENT *event)
const char * SCIPheurGetName(SCIP_HEUR *heur)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
void SCIPnodeGetAncestorBranchings(SCIP_NODE *node, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize)
void SCIPnodeSetReopttype(SCIP_NODE *node, SCIP_REOPTTYPE reopttype)
void SCIPnodeSetReoptID(SCIP_NODE *node, unsigned int id)
void SCIPnodeGetAncestorBranchingsPart(SCIP_NODE *node, SCIP_NODE *parent, SCIP_VAR **branchvars, SCIP_Real *branchbounds, SCIP_BOUNDTYPE *boundtypes, int *nbranchvars, int branchvarssize)
SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)
SCIP_Real SCIPnodeGetLowerbound(SCIP_NODE *node)
void SCIPnodeGetNDomchg(SCIP_NODE *node, int *nbranchings, int *nconsprop, int *nprop)
SCIP_Longint SCIPnodeGetNumber(SCIP_NODE *node)
SCIP_NODE * SCIPnodeGetParent(SCIP_NODE *node)
int SCIPnodeGetNAddedConss(SCIP_NODE *node)
void SCIPnodeGetAddedConss(SCIP_NODE *node, SCIP_CONS **addedconss, int *naddedconss, int addedconsssize)
int SCIPnodeGetDepth(SCIP_NODE *node)
SCIP_REOPTTYPE SCIPnodeGetReopttype(SCIP_NODE *node)
unsigned int SCIPnodeGetReoptID(SCIP_NODE *node)
SCIP_RETCODE SCIPaddReoptDualBndchg(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound, SCIP_Real oldbound)
SCIP_Bool SCIPisReoptEnabled(SCIP *scip)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
int SCIProwGetAge(SCIP_ROW *row)
int SCIProwGetNLPNonz(SCIP_ROW *row)
int SCIProwGetLPPos(SCIP_ROW *row)
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
SCIP_ROWORIGINTYPE SCIProwGetOrigintype(SCIP_ROW *row)
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)
SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisLE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetEffectiveRootDepth(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_RETCODE SCIPvarGetProbvarBound(SCIP_VAR **var, SCIP_Real *bound, SCIP_BOUNDTYPE *boundtype)
SCIP_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
int SCIPvarGetIndex(SCIP_VAR *var)
int SCIPvarGetProbindex(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetTransVar(SCIP_VAR *var)
int SCIPqueueNElems(SCIP_QUEUE *queue)
unsigned int SCIPqueueRemoveUInt(SCIP_QUEUE *queue)
void SCIPqueueFree(SCIP_QUEUE **queue)
SCIP_RETCODE SCIPqueueInsertUInt(SCIP_QUEUE *queue, unsigned int elem)
SCIP_RETCODE SCIPqueueCreate(SCIP_QUEUE **queue, int initsize, SCIP_Real sizefac)
void SCIPqueueClear(SCIP_QUEUE *queue)
SCIP_Bool SCIPqueueIsEmpty(SCIP_QUEUE *queue)
void SCIPsortDownRealInt(SCIP_Real *realarray, int *intarray, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
static SCIP_LPSOLSTAT lpsolstat
assert(minobj< SCIPgetCutoffbound(scip))
void SCIPhistoryReset(SCIP_HISTORY *history)
SCIP_Real SCIPhistoryGetAvgInferences(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_Real SCIPhistoryGetAvgCutoffs(SCIP_HISTORY *history, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPhistoryCreate(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)
void SCIPhistoryIncInferenceSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
void SCIPhistoryIncCutoffSum(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, SCIP_Real weight)
void SCIPhistoryIncNBranchings(SCIP_HISTORY *history, SCIP_BRANCHDIR dir, int depth)
void SCIPhistoryFree(SCIP_HISTORY **history, BMS_BLKMEM *blkmem)
void SCIPhistoryUnite(SCIP_HISTORY *history, SCIP_HISTORY *addhistory, SCIP_Bool switcheddirs)
internal methods for branching and inference history
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
SCIP_RETCODE SCIProwCreate(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_ROWORIGINTYPE origintype, void *origin, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)
SCIP_Real SCIPlpGetCutoffbound(SCIP_LP *lp)
SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)
int SCIPlpGetNRows(SCIP_LP *lp)
SCIP_RETCODE SCIProwRelease(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
internal methods for LP management
methods for block memory pools and memory buffers
memory allocation routines
#define BMSduplicateBlockMemoryArray(mem, ptr, source, num)
#define BMSfreeMemory(ptr)
#define BMSfreeBlockMemory(mem, ptr)
#define BMSallocBlockMemory(mem, ptr)
#define BMSreallocMemoryArray(ptr, num)
#define BMSfreeBlockMemoryArrayNull(mem, ptr, num)
#define BMSallocMemoryArray(ptr, num)
#define BMSfreeMemoryArray(ptr)
#define BMSallocBlockMemoryArray(mem, ptr, num)
#define BMSfreeBlockMemoryNull(mem, ptr)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
#define BMSreallocBlockMemoryArray(mem, ptr, oldnum, newnum)
#define BMSallocClearBlockMemoryArray(mem, ptr, num)
#define BMSclearMemoryArray(ptr, num)
#define BMSallocClearMemoryArray(ptr, num)
struct BMS_BlkMem BMS_BLKMEM
#define BMSallocMemory(ptr)
void SCIPrandomFree(SCIP_RANDNUMGEN **randnumgen, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPrandomCreate(SCIP_RANDNUMGEN **randnumgen, BMS_BLKMEM *blkmem, unsigned int initialseed)
internal miscellaneous methods
internal methods for collecting primal CIP solutions and primal informations
int SCIPprobGetNVars(SCIP_PROB *prob)
SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)
SCIP_Bool SCIPprobIsTransformed(SCIP_PROB *prob)
internal methods for storing and manipulating the main problem
#define SCIPdebugPrintCons(x, y, z)
static SCIP_RETCODE reoptMoveIDs(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int id1, unsigned int id2)
SCIP_RETCODE SCIPreoptUpdateVarHistory(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_VAR **vars, int nvars)
static SCIP_RETCODE changeReopttypeOfSubtree(SCIP_REOPTTREE *reopttree, unsigned int id, SCIP_REOPTTYPE reopttype)
int SCIPreoptGetNDualBndchgs(SCIP_REOPT *reopt, SCIP_NODE *node)
SCIP_RETCODE SCIPreoptSaveActiveConss(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_PROB *transprob, BMS_BLKMEM *blkmem)
static int soltreeNInducedSols(SCIP_SOLNODE *solnode)
int SCIPreoptGetNTotalPrunedNodes(SCIP_REOPT *reopt)
SCIP_RETCODE SCIPreoptnodeReset(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_REOPTNODE *reoptnode)
SCIP_RETCODE SCIPreoptAddRun(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR **origvars, int norigvars, int size)
SCIP_RETCODE SCIPreoptAddCons(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONS *cons)
int SCIPreoptGetNTotalFeasNodes(SCIP_REOPT *reopt)
void SCIPreoptAddNCheckedSols(SCIP_REOPT *reopt, int ncheckedsols)
static SCIP_RETCODE ensureSolsSize(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, int num, int runidx)
static SCIP_RETCODE reopttreeDeleteNode(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int id, SCIP_Bool softreset)
int SCIPreoptGetFirstRestarts(SCIP_REOPT *reopt)
static SCIP_RETCODE saveAfterDualBranchings(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, SCIP_Bool *transintoorig)
SCIP_RETCODE SCIPreoptAddSol(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *origprimal, BMS_BLKMEM *blkmem, SCIP_SOL *sol, SCIP_Bool bestsol, SCIP_Bool *added, SCIP_VAR **vars, int nvars, int run)
int SCIPreoptGetNTotalRestartsLocal(SCIP_REOPT *reopt)
SCIP_RETCODE SCIPreoptCheckCutoff(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_EVENTTYPE eventtype, SCIP_LP *lp, SCIP_LPSOLSTAT lpsolstat, SCIP_Bool isrootnode, SCIP_Bool isfocusnode, SCIP_Real lowerbound, int effectiverootdepth)
static SCIP_RETCODE transformDualredsToBounddisjunction(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_REOPTCONSDATA *consdata, SCIP_REOPTCONSDATA *dualreds)
static SCIP_RETCODE transformIntoOrig(SCIP_REOPT *reopt, unsigned int id)
static SCIP_RETCODE saveLocalConssData(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id)
int SCIPreoptGetNImprovingSols(SCIP_REOPT *reopt)
static SCIP_RETCODE addGlobalCut(SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, int nvars, int nbinvars, int nintvars)
static SCIP_RETCODE addNode(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_REOPTTYPE reopttype, SCIP_Bool saveafterdual, SCIP_Bool isrootnode, SCIP_Real lowerbound)
static SCIP_RETCODE shrinkNode(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_NODE *node, unsigned int id, SCIP_Bool *shrank, BMS_BLKMEM *blkmem)
static void deleteLastDualBndchgs(SCIP_REOPT *reopt)
SCIP_RETCODE SCIPreoptAddInfNode(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node)
static SCIP_RETCODE clearReoptnodes(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_Bool softreset)
static SCIP_RETCODE reoptResetTree(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_Bool softreset)
SCIP_RETCODE SCIPreoptApplyCuts(SCIP_REOPT *reopt, SCIP_NODE *node, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_Bool root)
static SCIP_RETCODE reopttreeCheckMemory(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem)
SCIP_SOL * SCIPreoptGetLastBestSol(SCIP_REOPT *reopt)
static SCIP_RETCODE separateSolution(SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol, SCIP_VAR **vars, int nvars)
SCIP_RETCODE SCIPreoptnodeAddBndchg(SCIP_REOPTNODE *reoptnode, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR *var, SCIP_Real val, SCIP_BOUNDTYPE boundtype)
SCIP_RETCODE SCIPreoptnodeAddCons(SCIP_REOPTNODE *reoptnode, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_BOUNDTYPE *boundtypes, SCIP_Real lhs, SCIP_Real rhs, int nvars, REOPT_CONSTYPE constype, SCIP_Bool linear)
SCIP_RETCODE SCIPreoptSplitRoot(SCIP_REOPT *reopt, SCIP_TREE *tree, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, int *ncreatedchilds, int *naddedconss)
#define DEFAULT_MEM_DUALCONS
static SCIP_RETCODE createSolTree(SCIP_SOLTREE *soltree, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPreoptGetSolsRun(SCIP_REOPT *reopt, int run, SCIP_SOL **sols, int solssize, int *nsols)
static void resetStats(SCIP_REOPT *reopt)
static SCIP_RETCODE reoptRestart(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)
static SCIP_RETCODE fixBounds(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, SCIP_Bool updatedualconss)
SCIP_Bool SCIPreoptConsCanBeDeleted(SCIP_REOPT *reopt, SCIP_CONS *cons)
static SCIP_RETCODE freeReoptTree(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem)
int SCIPreoptGetNPrunedNodes(SCIP_REOPT *reopt)
int SCIPreoptGetNFeasNodes(SCIP_REOPT *reopt)
static SCIP_RETCODE reoptnodeDelete(SCIP_REOPTNODE **reoptnode, BMS_BLKMEM *blkmem)
static int reoptGetNLeaves(SCIP_REOPT *reopt, unsigned int id)
static SCIP_RETCODE saveGlobalCons(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, REOPT_CONSTYPE consttype)
static SCIP_RETCODE deleteChildrenBelow(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int id, SCIP_Bool delnodeitself, SCIP_Bool exitsolve)
SCIP_RETCODE SCIPreoptDeleteNode(SCIP_REOPT *reopt, SCIP_SET *set, unsigned int id, BMS_BLKMEM *blkmem)
SCIP_Real SCIPreoptnodeGetLowerbound(SCIP_REOPTNODE *reoptnode)
static SCIP_RETCODE reoptnodeReset(SCIP_REOPTNODE *reoptnode, SCIP_SET *set, BMS_BLKMEM *blkmem)
int SCIPreoptGetNRestartsLocal(SCIP_REOPT *reopt)
SCIP_RETCODE SCIPreoptReleaseData(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPreoptResetDualBndchgs(SCIP_REOPT *reopt, SCIP_NODE *node, BMS_BLKMEM *blkmem)
void SCIPreoptResetSolMarks(SCIP_REOPT *reopt)
static SCIP_RETCODE getInferenceOrder(SCIP_SET *set, SCIP_STAT *stat, int *perm, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_BOUNDTYPE *boundtypes, int nvars)
static SCIP_RETCODE freeSolTree(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_PRIMAL *origprimal, BMS_BLKMEM *blkmem)
int SCIPreoptGetNSols(SCIP_REOPT *reopt)
int SCIPreoptGetNSolsRun(SCIP_REOPT *reopt, int run)
void SCIPreoptnodeSetParentID(SCIP_REOPTNODE *reoptnode, unsigned int parentid)
SCIP_Real SCIPreoptGetSimToFirst(SCIP_REOPT *reopt)
static SCIP_RETCODE saveConsBounddisjuction(SCIP_REOPTCONSDATA *reoptconsdata, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONS *cons, SCIP_Bool *success)
static SCIP_RETCODE reoptAddChild(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int parentid, unsigned int childid)
SCIP_RETCODE SCIPreoptApply(SCIP_REOPT *reopt, SCIP *scip, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_REOPTNODE *reoptnode, unsigned int id, SCIP_Real estimate, SCIP_NODE **childnodes, int *ncreatedchilds, int *naddedconss, int childnodessize, SCIP_Bool *success)
#define DEFAULT_MEM_VARAFTERDUAL
int SCIPreoptGetNSavedSols(SCIP_REOPT *reopt)
#define DEFAULT_MEM_NODES
SCIP_Real SCIPreoptGetOldObjCoef(SCIP_REOPT *reopt, int run, int idx)
static void soltreeResetMarks(SCIP_SOLNODE *node)
static SCIP_RETCODE reoptnodeCheckMemory(SCIP_REOPTNODE *reoptnode, SCIP_SET *set, BMS_BLKMEM *blkmem, int var_mem, int child_mem, int conss_mem)
static SCIP_RETCODE cleanActiveConss(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)
int SCIPreoptGetNCheckedSols(SCIP_REOPT *reopt)
static SCIP_RETCODE reoptGetLeaves(SCIP_REOPT *reopt, unsigned int id, unsigned int *leaves, int leavessize, int *nleaves)
static SCIP_RETCODE getLastSavedNode(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_NODE *node, SCIP_NODE **parent, unsigned int *parentid, int *nbndchgs)
static SCIP_RETCODE reoptCheckLocalRestart(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_VAR **transvars, int ntransvars, SCIP_Bool *localrestart)
static SCIP_RETCODE storeCuts(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_LP *lp, unsigned int id)
static SCIP_RETCODE transformDualredsToLinear(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_REOPTCONSDATA *consdata, SCIP_REOPTCONSDATA *dualreds)
SCIP_RETCODE SCIPreoptFree(SCIP_REOPT **reopt, SCIP_SET *set, SCIP_PRIMAL *origprimal, BMS_BLKMEM *blkmem)
static SCIP_RETCODE addLocalConss(SCIP *scip, SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id)
int SCIPreoptnodeGetNConss(SCIP_REOPTNODE *reoptnode)
static SCIP_RETCODE solnodeAddChild(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_SOLNODE *curnode, SCIP_SOLNODE **child, SCIP_VAR *var, SCIP_Real val, SCIP_Bool *added)
void SCIPreoptnodeGetConss(SCIP_REOPTNODE *reoptnode, SCIP_VAR ***vars, SCIP_Real **bounds, SCIP_BOUNDTYPE **boundtypes, int mem, int *nconss, int *nvars)
static SCIP_RETCODE checkMemGlbCons(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, int mem)
int SCIPreoptGetLastRestarts(SCIP_REOPT *reopt)
static SCIP_RETCODE reoptnodeResetDualConss(SCIP_REOPTNODE *reoptnode, BMS_BLKMEM *blkmem)
static SCIP_RETCODE createReopttree(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem)
int SCIPreoptnodeGetNVars(SCIP_REOPTNODE *reoptnode)
static SCIP_RETCODE ensureActiveconssSize(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, int num)
int SCIPreoptGetNTotalCutoffReoptnodes(SCIP_REOPT *reopt)
static int reopttreeGetNNodes(SCIP_REOPTTREE *reopttree, unsigned int id)
static SCIP_RETCODE createReoptnode(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int id)
void SCIPreoptnodeGetPath(SCIP_REOPT *reopt, SCIP_REOPTNODE *reoptnode, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, int varssize, int *nbndchgs, int *nbndchgsafterdual)
SCIP_RETCODE SCIPreoptAddOptSol(SCIP_REOPT *reopt, SCIP_SOL *sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *origprimal, SCIP_VAR **vars, int nvars)
SCIP_REOPTTYPE SCIPreoptnodeGetType(SCIP_REOPTNODE *reoptnode)
int SCIPreoptGetNNodes(SCIP_REOPT *reopt, SCIP_NODE *node)
static SCIP_RETCODE moveChildrenUp(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, unsigned int nodeid, unsigned int parentid)
SCIP_Real SCIPreoptGetSavingtime(SCIP_REOPT *reopt)
SCIP_RETCODE SCIPreoptResetActiveConss(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPreoptnodeDelete(SCIP_REOPTNODE **reoptnode, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPreoptCreate(SCIP_REOPT **reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)
int SCIPreoptGetNTotalInfNodes(SCIP_REOPT *reopt)
SCIP_RETCODE SCIPreoptAddDualBndchg(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newval, SCIP_Real oldval)
static SCIP_Real reoptSimilarity(SCIP_REOPT *reopt, SCIP_SET *set, int obj1_id, int obj2_id, SCIP_VAR **vars, int nvars)
static SCIP_RETCODE collectDualInformation(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, SCIP_REOPTTYPE reopttype)
SCIP_Real SCIPreoptGetSimilarity(SCIP_REOPT *reopt, SCIP_SET *set, int run1, int run2, SCIP_VAR **origvars, int norigvars)
static SCIP_RETCODE ensureRunSize(SCIP_REOPT *reopt, SCIP_SET *set, int num, BMS_BLKMEM *blkmem)
static SCIP_RETCODE dryBranch(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_Bool *runagain, unsigned int id)
static SCIP_RETCODE soltreefreeNode(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SOLNODE **solnode)
SCIP_RETCODE SCIPreoptGetLeaves(SCIP_REOPT *reopt, SCIP_NODE *node, unsigned int *leaves, int leavessize, int *nleaves)
static SCIP_RETCODE updatePropagation(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, SCIP_Bool *transintoorig)
static SCIP_RETCODE soltreeAddSol(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *origprimal, BMS_BLKMEM *blkmem, SCIP_VAR **vars, SCIP_SOL *sol, SCIP_SOLNODE **solnode, int nvars, SCIP_Bool bestsol, SCIP_Bool *added)
int SCIPreoptGetNAddedConss(SCIP_REOPT *reopt, SCIP_NODE *node)
SCIP_RETCODE SCIPreoptMergeVarHistory(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **vars, int nvars)
static SCIP_RETCODE checkMemDualCons(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, int size)
static SCIP_RETCODE fixInterdiction(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, int *perm, SCIP_VAR **vars, SCIP_Real *vals, SCIP_BOUNDTYPE *boundtypes, int nvars, int negbndchg)
SCIP_RETCODE SCIPreoptSaveGlobalBounds(SCIP_REOPT *reopt, SCIP_PROB *transprob, BMS_BLKMEM *blkmem)
SCIP_REOPTNODE * SCIPreoptGetReoptnode(SCIP_REOPT *reopt, unsigned int id)
void SCIPreoptAddNImprovingSols(SCIP_REOPT *reopt, int nimprovingsols)
static SCIP_RETCODE reoptnodeUpdateDualConss(SCIP_REOPTNODE *reoptnode, BMS_BLKMEM *blkmem)
SCIP_Bool SCIPreoptGetSolveLP(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_NODE *node)
SCIP_RETCODE SCIPreoptCheckRestart(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_VAR **transvars, int ntransvars, SCIP_Bool *restart)
static SCIP_RETCODE addSplitcons(SCIP_REOPT *reopt, SCIP *scip, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_NODE *node, unsigned int id)
int SCIPreoptGetNCutoffReoptnodes(SCIP_REOPT *reopt)
SCIP_RETCODE SCIPreoptInstallBounds(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem)
static SCIP_RETCODE reoptSaveNewObj(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR **origvars, int norigvars)
int SCIPreoptnodeGetNChildren(SCIP_REOPTNODE *reoptnode)
SCIP_RETCODE SCIPreoptApplyGlbConss(SCIP *scip, SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPreoptApplyCompression(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_REOPTNODE **representatives, int nrepresentatives, SCIP_Bool *success)
static SCIP_RETCODE changeAncestorBranchings(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int id, SCIP_Bool afterdualbranching)
int SCIPreoptnodeGetNDualBoundChgs(SCIP_REOPTNODE *reoptnode)
SCIP_Real SCIPreoptGetSimToPrevious(SCIP_REOPT *reopt)
SCIP_RETCODE SCIPreoptReset(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPreoptGetChildIDs(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, unsigned int *childs, int childssize, int *nchilds)
static SCIP_RETCODE saveAncestorBranchings(SCIP_REOPTTREE *reopttree, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_NODE *parent, unsigned int id, unsigned int parentid)
int SCIPreoptGetNRestartsGlobal(SCIP_REOPT *reopt)
SCIP_RETCODE SCIPreoptSaveOpenNodes(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_NODE **leaves, int nleaves, SCIP_NODE **childs, int nchilds, SCIP_NODE **siblings, int nsiblings)
static SCIP_RETCODE saveConsLinear(SCIP_REOPTCONSDATA *reoptconsdata, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_CONS *cons, SCIP_Bool *success)
SCIP_SOL * SCIPreoptGetBestSolRun(SCIP_REOPT *reopt, int run)
void SCIPreoptnodeInit(SCIP_REOPTNODE *reoptnode, SCIP_SET *set)
int SCIPreoptGetNLeaves(SCIP_REOPT *reopt, SCIP_NODE *node)
int SCIPreoptGetNInfNodes(SCIP_REOPT *reopt)
data structures and methods for collecting reoptimization information
SCIP_RETCODE SCIPsepastoreAddCut(SCIP_SEPASTORE *sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_LP *lp, SCIP_ROW *cut, SCIP_Bool forcecut, SCIP_Bool root, SCIP_Bool *infeasible)
internal methods for storing separated cuts
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_RETCODE SCIPsetGetIntParam(SCIP_SET *set, const char *name, int *value)
SCIP_RETCODE SCIPsetIncludeEventhdlr(SCIP_SET *set, SCIP_EVENTHDLR *eventhdlr)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
SCIP_BRANCHRULE * SCIPsetFindBranchrule(SCIP_SET *set, const char *name)
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetRound(SCIP_SET *set, SCIP_Real val)
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
SCIP_Bool SCIPsetIsNegative(SCIP_SET *set, SCIP_Real val)
unsigned int SCIPsetInitializeRandomSeed(SCIP_SET *set, unsigned int initialseedvalue)
internal methods for global SCIP settings
#define SCIPsetFreeBufferArray(set, ptr)
#define SCIPsetAllocBufferArray(set, ptr, num)
#define SCIPsetReallocBufferArray(set, ptr, num)
SCIP_RETCODE SCIPsolFree(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_PRIMAL *primal)
SCIP_Real SCIPsolGetVal(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR *var)
SCIP_RETCODE SCIPsolCopy(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_SOL *sourcesol)
internal methods for storing primal CIP solutions
SCIP_Real pscostweightedmean[2]
SCIP_Real pscostvariance[2]
SCIP_VAR ** afterdualvars
SCIP_REOPTCONSDATA * dualredscur
SCIP_REOPTCONSDATA * dualredsnex
SCIP_BOUNDTYPE * afterdualvarboundtypes
SCIP_BOUNDTYPE * varboundtypes
SCIP_Real * afterdualvarbounds
SCIP_REOPTCONSDATA ** conss
unsigned int reoptnodessize
SCIP_REOPTNODE ** reoptnodes
int ntotalcutoffreoptnodes
SCIP_REOPTCONSDATA ** glbconss
SCIP_REOPTTREE * reopttree
SCIP_REOPTCONSDATA * dualreds
SCIP_Longint lastbranched
SCIP_RANDNUMGEN * randnumgen
SCIP_Longint lastseennode
SCIP_HASHSET * activeconssset
SCIP_HISTORY *** varhistory
void SCIPnodeGetDualBoundchgs(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *bounds, SCIP_BOUNDTYPE *boundtypes, int *nvars, int varssize)
void SCIPnodeSetEstimate(SCIP_NODE *node, SCIP_SET *set, SCIP_Real newestimate)
void SCIPnodeGetPropsAfterDual(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *varbounds, SCIP_BOUNDTYPE *varboundtypes, int *nvars, int varssize)
SCIP_NODE * SCIPtreeGetRootNode(SCIP_TREE *tree)
SCIP_RETCODE SCIPnodeCreateChild(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_Real nodeselprio, SCIP_Real estimate)
SCIP_RETCODE SCIPnodeAddBoundchg(SCIP_NODE *node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_Real newbound, SCIP_BOUNDTYPE boundtype, SCIP_Bool probingchange)
int SCIPnodeGetNDualBndchgs(SCIP_NODE *node)
void SCIPnodeGetPropsBeforeDual(SCIP_NODE *node, SCIP_VAR **vars, SCIP_Real *varbounds, SCIP_BOUNDTYPE *varboundtypes, int *npropvars, int propvarssize)
internal methods for branch and bound tree
struct SCIP_BranchCand SCIP_BRANCHCAND
struct SCIP_Cons SCIP_CONS
struct SCIP_Conshdlr SCIP_CONSHDLR
struct SCIP_Cutpool SCIP_CUTPOOL
struct SCIP_Eventhdlr SCIP_EVENTHDLR
#define SCIP_DECL_EVENTINITSOL(x)
#define SCIP_EVENTTYPE_NODEFEASIBLE
#define SCIP_EVENTTYPE_GBDCHANGED
struct SCIP_EventFilter SCIP_EVENTFILTER
#define SCIP_EVENTTYPE_NODEINFEASIBLE
#define SCIP_DECL_EVENTEXEC(x)
#define SCIP_EVENTTYPE_NODEBRANCHED
struct SCIP_EventQueue SCIP_EVENTQUEUE
#define SCIP_EVENTTYPE_FORMAT
#define SCIP_DECL_EVENTEXITSOL(x)
struct SCIP_Heur SCIP_HEUR
@ SCIP_BRANCHDIR_DOWNWARDS
enum SCIP_BranchDir SCIP_BRANCHDIR
struct SCIP_CliqueTable SCIP_CLIQUETABLE
enum SCIP_LPSolStat SCIP_LPSOLSTAT
@ SCIP_ROWORIGINTYPE_REOPT
@ SCIP_ROWORIGINTYPE_SEPA
enum SCIP_BoundType SCIP_BOUNDTYPE
@ SCIP_LPSOLSTAT_NOTSOLVED
@ SCIP_LPSOLSTAT_INFEASIBLE
@ SCIP_LPSOLSTAT_OBJLIMIT
struct SCIP_Primal SCIP_PRIMAL
struct SCIP_Prob SCIP_PROB
@ SCIP_REOPTTYPE_INFSUBTREE
@ SCIP_REOPTTYPE_LOGICORNODE
@ SCIP_REOPTTYPE_FEASIBLE
@ SCIP_REOPTTYPE_STRBRANCHED
enum SCIP_ReoptType SCIP_REOPTTYPE
struct SCIP_ReoptConsData SCIP_REOPTCONSDATA
struct SCIP_Reopt SCIP_REOPT
@ REOPT_CONSTYPE_DUALREDS
@ REOPT_CONSTYPE_INFSUBTREE
struct SCIP_ReoptTree SCIP_REOPTTREE
struct SCIP_ReoptNode SCIP_REOPTNODE
struct SCIP_SolNode SCIP_SOLNODE
enum Reopt_ConsType REOPT_CONSTYPE
struct SCIP_SolTree SCIP_SOLTREE
enum SCIP_Retcode SCIP_RETCODE
struct SCIP_SepaStore SCIP_SEPASTORE
struct SCIP_Stat SCIP_STAT
struct SCIP_Node SCIP_NODE
struct SCIP_Tree SCIP_TREE
@ SCIP_NODETYPE_PROBINGNODE
@ SCIP_NODETYPE_FOCUSNODE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_VARSTATUS_MULTAGGR
void SCIPvarAdjustLb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *lb)
SCIP_RETCODE SCIPvarChgLbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
SCIP_RETCODE SCIPvarChgUbGlobal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Real newbound)
SCIP_Real SCIPvarGetAvgInferences(SCIP_VAR *var, SCIP_STAT *stat, SCIP_BRANCHDIR dir)
SCIP_RETCODE SCIPvarChgLbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
SCIP_RETCODE SCIPvarNegate(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **negvar)
void SCIPvarAdjustUb(SCIP_VAR *var, SCIP_SET *set, SCIP_Real *ub)
SCIP_RETCODE SCIPvarChgUbLocal(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newbound)
internal methods for problem variables