*nchecknonzeros = 0LL;
140*nactivenonzeros = 0LL;
141*approxchecknonzeros =
FALSE;
142*approxactivenonzeros =
FALSE;
145 for(
h=
scip->set->nconshdlrs - 1;
h>= 0; --
h)
154 for( c = nconss - 1; c >= 0; --c )
161*approxactivenonzeros =
TRUE;
163*approxchecknonzeros =
TRUE;
167*nactivenonzeros += nvars;
169*nchecknonzeros += nvars;
180 for( c = nconss - 1; c >= 0; --c )
187*approxchecknonzeros =
TRUE;
189*nchecknonzeros += nvars;
233 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPtransformProb",
FALSE,
TRUE,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE) );
275&
scip->transprob) );
292ncandsols =
scip->origprimal->nsols;
300 if( !
scip->set->reopt_enable &&
scip->set->nactivebenders == 0 )
302oldnsolsfound =
scip->primal->nsolsfound;
303 for( s =
scip->origprimal->nsols - 1; s >= 0; --s )
308sol =
scip->origprimal->sols[s];
347 scip->origprimal->nsols--;
351assert(
scip->origprimal->nsols == 0);
353 scip->stat->nexternalsolsfound +=
scip->primal->nsolsfound - oldnsolsfound;
358 "%d/%d feasible solution%s given by solution candidate storage, new primal bound %.6e\n\n",
361 else if( ncandsols > 0 && !
scip->set->reopt_enable )
364 "all %d solutions given by solution candidate storage are infeasible\n\n", ncandsols);
369 "transformed problem has %d variables (%d bin, %d int, %d impl, %d cont) and %d constraints\n",
370 scip->transprob->nvars,
scip->transprob->nbinvars,
scip->transprob->nintvars,
scip->transprob->nimplvars,
371 scip->transprob->ncontvars,
scip->transprob->nconss);
373 for(
h= 0;
h<
scip->set->nconshdlrs; ++
h)
378 if( nactiveconss > 0 )
395maxnonzeros =
MAX(maxnonzeros, 1.0);
397 scip->stat->nnz = nactivenonzeros;
402approxactivenonzeros ?
"more than ":
"", nactivenonzeros, nactivenonzeros/maxnonzeros * 100,
403approxchecknonzeros ?
"more than ":
"", nchecknonzeros, nchecknonzeros/maxnonzeros * 100);
411 if(
scip->set->random_permutationseed > 0 )
417permuteconss =
scip->set->random_permuteconss;
418permutevars =
scip->set->random_permutevars;
419permutationseed =
scip->set->random_permutationseed;
421 SCIP_CALL(
SCIPpermuteProb(
scip, (
unsigned int)permutationseed, permuteconss, permutevars, permutevars, permutevars, permutevars) );
424 if(
scip->set->misc_estimexternmem )
442 size_tnusedcleanbuffers;
456 scip->stat->nruns++;
459 scip->stat->prevrunnvars =
scip->transprob->nvars;
467 scip->conflictstore,
scip->eventfilter,
scip->eventqueue,
scip->cliquetable) );
479 scip->tree->root->estimate =
scip->tree->root->lowerbound;
480 scip->stat->rootlowerbound =
scip->tree->root->lowerbound;
482 if(
scip->set->misc_calcintegral )
519 size_tnusedcleanbuffers;
528assert(infeasible !=
NULL);
530*infeasible =
FALSE;
544assert(nvars == 0 || vars !=
NULL);
546 for( v = nvars - 1; v >= 0; --v )
554assert(var !=
NULL);
590 intnlocalbdchgs = 0;
600 "clique table cleanup detected %d bound changes%s\n", nlocalbdchgs, *infeasible ?
" and infeasibility":
"");
624 scip->conflictstore,
scip->eventfilter,
scip->eventqueue,
scip->cliquetable) );
677#ifdef SCIP_DISABLED_CODE 678 intoldpresolstart = 0;
679 intoldpropstart = 0;
680 intoldconsstart = 0;
689 size_tnusedcleanbuffers;
694assert(unbounded !=
NULL);
695assert(infeasible !=
NULL);
696assert(presolstart !=
NULL);
697assert(propstart !=
NULL);
698assert(consstart !=
NULL);
700assert((presolend ==
scip->set->npresols && propend ==
scip->set->nprops && consend ==
scip->set->nconshdlrs)
701|| (*presolstart == 0 && *propstart == 0 && *consstart == 0));
704*infeasible =
FALSE;
707assert(
scip->set->propspresolsorted );
727#ifdef SCIP_DISABLED_CODE 732 if( i >= presolend && j >= propend && k >= consend )
735 if( i == 0 && j == 0 && k == 0 )
736++(
scip->stat->npresolroundsext);
741assert(presolend ==
scip->set->npresols);
742assert(propend ==
scip->set->nprops);
743assert(consend ==
scip->set->nconshdlrs);
750++(
scip->stat->npresolroundsfast);
752++(
scip->stat->npresolroundsmed);
755 SCIPdebugMsg(
scip,
"starting presolving round %d (%d/%d/%d), timing = %u\n",
756 scip->stat->npresolrounds,
scip->stat->npresolroundsfast,
scip->stat->npresolroundsmed,
757 scip->stat->npresolroundsext, *timing);
760 while( !(*unbounded) && !(*infeasible) && !aborted && (i < presolend || j < propend) )
773 if( prioprop >= priopresol )
781&
scip->stat->npresolfixedvars, &
scip->stat->npresolaggrvars, &
scip->stat->npresolchgvartypes,
782&
scip->stat->npresolchgbds, &
scip->stat->npresoladdholes, &
scip->stat->npresoldelconss,
783&
scip->stat->npresoladdconss, &
scip->stat->npresolupgdconss, &
scip->stat->npresolchgcoefs,
784&
scip->stat->npresolchgsides, &result) );
788lastranpresol =
FALSE;
795 if( priopresol < 0 )
800&
scip->stat->npresolfixedvars, &
scip->stat->npresolaggrvars, &
scip->stat->npresolchgvartypes,
801&
scip->stat->npresolchgbds, &
scip->stat->npresoladdholes, &
scip->stat->npresoldelconss,
802&
scip->stat->npresoladdconss, &
scip->stat->npresolupgdconss, &
scip->stat->npresolchgcoefs,
803&
scip->stat->npresolchgsides, &result) );
807lastranpresol =
TRUE;
820 "propagator <%s> detected infeasibility\n",
SCIPpropGetName(
scip->set->props_presol[j-1]));
828 "presolver <%s> detected unboundedness (or infeasibility)\n",
SCIPpresolGetName(
scip->set->presols[i-1]));
831 "propagator <%s> detected unboundedness (or infeasibility)\n",
SCIPpropGetName(
scip->set->props_presol[j-1]));
836 scip->branchcand) );
838 SCIPdebugMsg(
scip,
"presolving callback returned result <%d>\n", result);
843assert(*consstart == 0);
847*presolstart = i + 1;
862 while( k < consend && !(*unbounded) && !(*infeasible) && !aborted )
864 SCIPdebugMsg(
scip,
"executing presolve method of constraint handler <%s>\n",
867*timing,
scip->stat->npresolrounds,
868&
scip->stat->npresolfixedvars, &
scip->stat->npresolaggrvars, &
scip->stat->npresolchgvartypes,
869&
scip->stat->npresolchgbds, &
scip->stat->npresoladdholes, &
scip->stat->npresoldelconss,
870&
scip->stat->npresoladdconss, &
scip->stat->npresolupgdconss, &
scip->stat->npresolchgcoefs,
871&
scip->stat->npresolchgsides, &result) );
887 "constraint handler <%s> detected unboundedness (or infeasibility)\n",
893 scip->branchcand) );
895 SCIPdebugMsg(
scip,
"presolving callback returned with result <%d>\n", result);
909assert(
scip->set->propspresolsorted );
912 while( !(*unbounded) && !(*infeasible) && !aborted && (i < presolend || j < propend) )
914 if( i < scip->
set->npresols )
917priopresol = -INT_MAX;
919 if( j < scip->
set->nprops )
925 if( prioprop >= priopresol )
927assert(prioprop <= 0);
931&
scip->stat->npresolfixedvars, &
scip->stat->npresolaggrvars, &
scip->stat->npresolchgvartypes,
932&
scip->stat->npresolchgbds, &
scip->stat->npresoladdholes, &
scip->stat->npresoldelconss,
933&
scip->stat->npresoladdconss, &
scip->stat->npresolupgdconss, &
scip->stat->npresolchgcoefs,
934&
scip->stat->npresolchgsides, &result) );
938lastranpresol =
FALSE;
943assert(priopresol < 0);
947&
scip->stat->npresolfixedvars, &
scip->stat->npresolaggrvars, &
scip->stat->npresolchgvartypes,
948&
scip->stat->npresolchgbds, &
scip->stat->npresoladdholes, &
scip->stat->npresoldelconss,
949&
scip->stat->npresoladdconss, &
scip->stat->npresolupgdconss, &
scip->stat->npresolchgcoefs,
950&
scip->stat->npresolchgsides, &result) );
954lastranpresol =
TRUE;
967 "propagator <%s> detected infeasibility\n",
SCIPpropGetName(
scip->set->props_presol[j-1]));
975 "presolver <%s> detected unboundedness (or infeasibility)\n",
SCIPpresolGetName(
scip->set->presols[i-1]));
978 "propagator <%s> detected unboundedness (or infeasibility)\n",
SCIPpropGetName(
scip->set->props_presol[j-1]));
983 scip->branchcand) );
985 SCIPdebugMsg(
scip,
"presolving callback return with result <%d>\n", result);
990assert(k == consend);
994*presolstart = i + 1;
1009 if( !(*unbounded) && !(*infeasible) )
1011 intnlocalbdchgs = 0;
1017 if( nlocalbdchgs > 0 || *infeasible )
1019 "clique table cleanup detected %d bound changes%s\n", nlocalbdchgs, *infeasible ?
" and infeasibility":
"");
1021 scip->stat->npresolfixedvars += nlocalbdchgs;
1026 if( !*infeasible &&
scip->set->nheurs > 0 &&
scip->set->nactivebenders == 0 )
1044assert(sol !=
NULL);
1048 "feasible solution found by %s heuristic after %.1f seconds, objective value %.6e\n",
1054 if( !(*unbounded) && !(*infeasible) )
1063 SCIPdebugMsg(
scip,
"not enough reductions in %s presolving, running %s presolving now...\n",
1080propstart, propend, consstart, consend) );
1082#ifdef SCIP_DISABLED_CODE 1084 else if( (oldpresolstart > 0 || oldpropstart > 0 || oldconsstart > 0) && presolend ==
scip->set->npresols
1085&& propend ==
scip->set->nprops && consend ==
scip->set->nconshdlrs )
1087 intnewpresolstart = 0;
1088 intnewpropstart = 0;
1089 intnewconsstart = 0;
1091 SCIPdebugMsg(
scip,
"reached end of exhaustive presolving loop, starting from the beginning...\n");
1094oldpresolstart, &newpropstart, oldpropstart, &newconsstart, oldconsstart) );
1096*presolstart = newpresolstart;
1097*propstart = newpropstart;
1098*consstart = newconsstart;
1125 intpresolstart = 0;
1130 size_tnusedbuffers;
1131 size_tnusedcleanbuffers;
1139assert(
scip->transprob !=
NULL);
1141assert(unbounded !=
NULL);
1142assert(infeasible !=
NULL);
1144*unbounded =
FALSE;
1177 if(
scip->set->nheurs > 0 &&
scip->set->nactivebenders == 0 )
1194assert(sol !=
NULL);
1198 "feasible solution found by %s heuristic after %.1f seconds, objective value %.6e\n",
1205*infeasible =
FALSE;
1207*vanished =
scip->transprob->nvars == 0 &&
scip->transprob->nconss == 0 &&
scip->set->nactivepricers == 0;
1209finished = (
scip->set->presol_maxrounds != -1 &&
scip->stat->npresolrounds >=
scip->set->presol_maxrounds)
1210|| (*unbounded) || (*vanished) || (
scip->set->reopt_enable &&
scip->stat->nreoptruns >= 1);
1216 while( !finished && !stopped )
1219 scip->stat->lastnpresolfixedvars =
scip->stat->npresolfixedvars;
1220 scip->stat->lastnpresolaggrvars =
scip->stat->npresolaggrvars;
1221 scip->stat->lastnpresolchgvartypes =
scip->stat->npresolchgvartypes;
1222 scip->stat->lastnpresolchgbds =
scip->stat->npresolchgbds;
1223 scip->stat->lastnpresoladdholes =
scip->stat->npresoladdholes;
1224 scip->stat->lastnpresoldelconss =
scip->stat->npresoldelconss;
1225 scip->stat->lastnpresoladdconss =
scip->stat->npresoladdconss;
1226 scip->stat->lastnpresolupgdconss =
scip->stat->npresolupgdconss;
1227 scip->stat->lastnpresolchgcoefs =
scip->stat->npresolchgcoefs;
1228 scip->stat->lastnpresolchgsides =
scip->stat->npresolchgsides;
1229#ifdef SCIP_DISABLED_CODE 1230 scip->stat->lastnpresolimplications =
scip->stat->nimplications;
1235 scip->stat->performpresol =
TRUE;
1244lastround = (
scip->set->presol_maxrounds == -1 ?
FALSE: (
scip->stat->npresolrounds + 1 >=
scip->set->presol_maxrounds));
1249assert(!(*unbounded));
1250assert(!(*infeasible));
1252&presolstart,
scip->set->npresols, &propstart,
scip->set->nprops, &consstart,
scip->set->nconshdlrs) );
1257 SCIPdebugMsg(
scip,
"presolving round %d returned with unbounded = %u, infeasible = %u, finished = %u\n",
scip->stat->npresolrounds, *unbounded, *infeasible, finished);
1260*vanished =
scip->transprob->nvars == 0 &&
scip->transprob->nconss == 0 &&
scip->set->nactivepricers == 0;
1261finished = finished || *unbounded || *infeasible || *vanished;
1264 scip->stat->npresolrounds++;
1270 "(round %d, %-11s %d del vars, %d del conss, %d add conss, %d chg bounds, %d chg sides, %d chg coeffs, %d upgd conss, %d impls, %d clqs\n",
1275 scip->stat->npresolfixedvars +
scip->stat->npresolaggrvars,
1276 scip->stat->npresoldelconss,
scip->stat->npresoladdconss,
1277 scip->stat->npresolchgbds,
scip->stat->npresolchgsides,
1278 scip->stat->npresolchgcoefs,
scip->stat->npresolupgdconss,
1287 for( i = 0; i <
scip->transprob->nfixedvars; ++i )
1299 if(
scip->primal->nlimsolsfound > 0 )
1306 else if( *unbounded )
1308 if(
scip->primal->nsols >= 1 )
1316 else if(
scip->transprob->nvars == 0 &&
scip->transprob->nconss == 0 )
1324 if(
scip->set->nactivepricers == 0 )
1328 if(
scip->primal->nlimsolsfound > 0 )
1336 if( finished && (!stopped || *unbounded || *infeasible || *vanished) )
1346*infeasible = *infeasible || infeas;
1351 if( !
scip->set->random_permutevars && !(*infeasible) && !(*unbounded) && !(*vanished) )
1364maxnonzeros =
MAX(maxnonzeros, 1.0);
1366 scip->stat->nnz = nactivenonzeros;
1371approxactivenonzeros ?
"more than ":
"", nactivenonzeros, nactivenonzeros/maxnonzeros * 100,
1372approxchecknonzeros ?
"more than ":
"", nchecknonzeros, nchecknonzeros/maxnonzeros * 100);
1384 "presolving (%d rounds: %d fast, %d medium, %d exhaustive):\n",
scip->stat->npresolrounds,
1385 scip->stat->npresolroundsfast,
scip->stat->npresolroundsmed,
scip->stat->npresolroundsext);
1387 " %d deleted vars, %d deleted constraints, %d added constraints, %d tightened bounds, %d added holes, %d changed sides, %d changed coefficients\n",
1388 scip->stat->npresolfixedvars +
scip->stat->npresolaggrvars,
scip->stat->npresoldelconss,
scip->stat->npresoladdconss,
1389 scip->stat->npresolchgbds,
scip->stat->npresoladdholes,
scip->stat->npresolchgsides,
scip->stat->npresolchgcoefs);
1418oldnsolsfound =
scip->primal->nsolsfound;
1424 SCIPdebugMsg(
scip,
"try to transfer %d original solutions into the transformed problem space\n", nsols);
1426ntransvars =
scip->transprob->nvars;
1439 for( s = nsols-1; s >= 0; --s )
1452solvalset, ntransvars, &added) );
1458 if( naddedsols > 0 )
1461 "transformed %d/%d original solutions to the transformed problem space\n",
1464 scip->stat->nexternalsolsfound +=
scip->primal->nsolsfound - oldnsolsfound;
1508 if(
scip->transprob->nlpenabled && !
scip->set->nlp_disable )
1519 if(
scip->set->misc_estimexternmem &&
scip->stat->nruns <= 1 )
1521 scip->stat->externmemestim *= 2;
1539 if(
scip->set->misc_transorigsols )
1548 scip->tree->root->estimate =
scip->tree->root->lowerbound;
1549 scip->stat->rootlowerbound =
scip->tree->root->lowerbound;
1551 if(
scip->set->misc_calcintegral )
1568 if(
scip->set->nactivepricers == 0 )
1579var =
scip->transprob->vars[v];
1587objbound += obj * bd;
1708assert( ! restart ||
scip->stat->inrestart );
1808 if(
scip->set->reopt_enable )
1817 if(
scip->set->misc_resetstat )
1863 if( !
scip->set->reopt_enable &&
scip->set->limit_maxorigsol > 0 &&
scip->set->misc_transsolsorig &&
scip->set->nactivebenders == 0 )
1871assert(
scip->origprimal->nsols == 0);
1873nsols =
scip->primal->nsols;
1874maxsols =
scip->set->limit_maxorigsol;
1879 while( s < nsols && scip->origprimal->nsols < maxsols )
1883sol =
scip->primal->sols[s];
1884assert(sol !=
NULL);
1895 if( !
scip->set->misc_finitesolstore )
1911 if( newsol !=
NULL)
1926 if(
scip->origprimal->nsols > 1 )
1929 "stored the %d best primal solutions in the original solution candidate list\n",
scip->origprimal->nsols);
1931 else if(
scip->origprimal->nsols == 1 )
1934 "stored the best primal solution in the original solution candidate list\n");
1942assert(!
scip->set->reopt_enable ||
scip->reopt !=
NULL);
1943 if(
scip->set->reopt_enable &&
scip->reopt !=
NULL)
1978 if(
scip->set->misc_resetstat && !reducedfree )
2031 if(
scip->set->misc_resetstat )
2066objlimitreached =
TRUE;
2072 if(
scip->set->reopt_enable )
2076 if(
scip->stat->nruns > 1 )
2078 scip->stat->nnodes,
scip->stat->ntotalnodes,
scip->stat->nruns);
2079 else if(
scip->set->reopt_enable )
2084assert(branchrule !=
NULL);
2092 if( objlimitreached )
2096 if(
scip->primal->nsolsfound > 0 )
2105 if(
scip->primal->nsolsfound !=
scip->primal->nlimsolsfound )
2183 if( noldnodes <= 1 )
2187 if(
scip->transprob->nintvars > 0 ||
scip->transprob->nimplvars > 0 )
2191 "tree compression:\n");
2193 " given tree has %d nodes.\n", noldnodes);
2198 for(c = 0; c <
scip->set->ncomprs; c++)
2209 " <%s> compressed the search tree to %d nodes (rate %g).\n",
SCIPcomprGetName(
scip->set->comprs[c]),
2210nnewnodes, ((
SCIP_Real)nnewnodes)/noldnodes);
2220 " search tree could not be compressed.\n");
2235assert(
scip->set->reopt_enable);
2240++
scip->stat->nreoptruns;
2244 scip->origprob->nvars,
scip->set->limit_maxsol) );
2247 if(
scip->set->reopt_sepaglbinfsubtrees ||
scip->set->reopt_sepabestsol )
2255 if(
scip->stat->nreoptruns == 1 )
2266assert(
scip->transprob !=
NULL);
2282 scip->transprob->nvars, &reoptrestart) );
2289 scip->eventqueue,
scip->cliquetable,
scip->mem->probmem) );
2305 if(
scip->set->compr_enable )
2341 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPpresolve",
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
FALSE,
TRUE,
FALSE,
FALSE,
FALSE) );
2348 if(
scip->set->misc_catchctrlc )
2355 switch(
scip->set->stage )
2376 if( infeasible || unbounded || vanished )
2387 switch(
scip->stat->status )
2396 "presolving detected infeasibility\n");
2401 "presolving detected unboundedness\n");
2406 "presolving detected unboundedness (or infeasibility)\n");
2422 "presolved problem has %d variables (%d bin, %d int, %d impl, %d cont) and %d constraints\n",
2423 scip->transprob->nvars,
scip->transprob->nbinvars,
scip->transprob->nintvars,
scip->transprob->nimplvars,
2424 scip->transprob->ncontvars,
scip->transprob->nconss);
2426 for(
h= 0;
h<
scip->set->nconshdlrs; ++
h)
2431 if( nactiveconss > 0 )
2441 "transformed objective value is always integral (scale: %.15g)\n",
scip->transprob->objscale);
2465 if(
scip->set->misc_catchctrlc )
2516 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPsolve",
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE) );
2548 intdecompindex = 0;
2559 if(
scip->set->misc_catchctrlc )
2567restart =
scip->stat->userrestart;
2573transferstatistics =
TRUE;
2583 if(
scip->stat->userrestart )
2586 scip->stat->nruns,
scip->stat->nnodes);
2589 "(run %d, node %" SCIP_LONGINT_FORMAT ") restarting after %d global fixings of integer variables\n",
2590 scip->stat->nruns,
scip->stat->nnodes,
scip->stat->nrootintfixingsrun);
2604 switch(
scip->set->stage )
2614statsprinted =
TRUE;
2618 if(
scip->set->reopt_enable )
2633 if(
scip->set->reopt_enable )
2650 if( transferstatistics )
2663 scip->cutpool,
scip->delayedcutpool,
scip->branchcand,
scip->conflict,
scip->conflictstore,
2664 scip->eventfilter,
scip->eventqueue,
scip->cliquetable, &restart) );
2720children, nchildren, siblings, nsiblings) );
2725 if(
scip->set->misc_catchctrlc )
2728 if(
scip->set->reopt_enable )
2734nsols =
scip->set->reopt_savesols == -1 ? INT_MAX :
MAX(
scip->set->reopt_savesols, 1);
2735nsols =
MIN(
scip->primal->nsols, nsols);
2737 for( s = 0; s < nsols; s++ )
2742sol =
scip->primal->sols[s];
2743assert(sol !=
NULL);
2756 if( s == 0 &&
scip->set->reopt_sepabestsol )
2759 scip->origprob->vars,
scip->origprob->nvars) );
2769sol, s == 0, &added,
scip->origprob->vars,
scip->origprob->nvars,
scip->stat->nreoptruns) );
2777 if(
scip->set->reopt_storevarhistory )
2780 scip->origprob->vars,
scip->origprob->nvars) );
2789 if(
scip->set->reopt_enable &&
scip->set->reopt_commontimelimit )
2796timelimit = timelimit - usedtime;
2797timelimit =
MAX(0, timelimit);
2802 if( !statsprinted )
2838 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPsolveParallel",
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE) );
2874 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPsolveConcurrent",
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE) );
2878 SCIPerrorMessage(
"SCIP was compiled without task processing interface. Concurrent solve not possible\n");
2884minnthreads =
scip->set->parallel_minnthreads;
2885maxnthreads =
scip->set->parallel_maxnthreads;
2887 if( minnthreads > maxnthreads )
2889 SCIPerrorMessage(
"minimum number of threads greater than maximum number of threads\n");
2894 intnconcsolvertypes;
2901 intncandsolvertypes;
2907 if(
scip->set->concurrent_presolvebefore )
2934memorylimit =
scip->set->limit_memory;
2940 if( !
scip->set->misc_avoidmemout )
2947nthreads = minnthreads;
2954 if( minnthreads > nthreads )
2959 SCIPwarningMessage(
scip,
"requested minimum number of threads could not be satisfied with given memory limit\n");
2964 if( nthreads == 1 )
2970nthreads =
MIN(nthreads, maxnthreads);
2977 for( i = 0; i < nconcsolvertypes; ++i )
2979assert(prefpriosum != 0.0);
2981ncandsolvertypes = 0;
2985 for( i = 0; i < nconcsolvertypes; ++i )
2990 while( prio > 0.0 )
2992j = ncandsolvertypes++;
2993assert(j < 2*nthreads);
2996prios[j] =
MIN(1.0, prio);
3009 for( i = 0; i < nthreads; ++i )
3057 if( (enable &&
scip->set->reopt_enable &&
scip->reopt !=
NULL)
3058|| (!enable && !
scip->set->reopt_enable &&
scip->reopt ==
NULL) )
3071 SCIPerrorMessage(
"Reoptimization cannot be %s after starting the (pre)solving process.\n", enable ?
"enabled":
"disabled");
3079 if( enable &&
scip->reopt ==
NULL)
3082 scip->set->reopt_enable = enable;
3088 else if( (!enable &&
scip->reopt !=
NULL) || (!enable &&
scip->set->reopt_enable &&
scip->reopt ==
NULL) )
3091 scip->set->reopt_enable = enable;
3104 scip->set->reopt_enable = enable;
3127 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPaddReoptDualBndchg",
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE) );
3147 if(
scip->set->reopt_enable &&
scip->stat->nreoptruns > 1 )
3172assert(var !=
NULL);
3173assert(0 < run && run <= scip->stat->nreoptruns);
3175 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPgetReoptOldObjCoef",
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
TRUE,
FALSE,
FALSE,
FALSE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE) );
3192assert(origvar !=
NULL);
3225 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPfreeSolve",
TRUE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE) );
3227 switch(
scip->set->stage )
3291 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPfreeReoptSolve",
TRUE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE) );
3293 switch(
scip->set->stage )
3356 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPfreeTransform",
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
FALSE,
TRUE,
TRUE,
FALSE,
FALSE,
FALSE) );
3364 switch(
scip->set->stage )
3440 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPinterruptSolve",
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE) );
3443 scip->stat->userinterrupt =
TRUE;
3472 SCIP_CALL_ABORT(
SCIPcheckStage(
scip,
"SCIPisSolveInterrupted",
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE) );
3474 return scip->stat->userinterrupt;
3495 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPrestartSolve",
FALSE,
FALSE,
FALSE,
FALSE,
TRUE,
TRUE,
TRUE,
FALSE,
FALSE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE) );
3510 return scip->set->reopt_enable;
3523assert(sols !=
NULL);
3524assert(solssize > 0);
3526 if(
scip->set->reopt_enable )
3528assert(run > 0 && run <= scip->stat->nreoptruns);
3545assert(
scip->set->reopt_enable);
3548 if(
scip->set->reopt_enable )
3571assert(
scip->set->reopt_enable);
3574 SCIP_CALL(
SCIPcheckStage(
scip,
"SCIPcheckReoptRestart",
FALSE,
FALSE,
FALSE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE,
FALSE,
TRUE,
FALSE,
FALSE,
FALSE,
FALSE) );
3577 scip->transprob->nvars, restart) );
3601 SCIP_CALL_ABORT(
SCIPcheckStage(
scip,
"SCIPisInRestart",
FALSE,
FALSE,
FALSE,
FALSE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
FALSE) );
3604 return scip->stat->inrestart;
SCIP_RETCODE SCIPbranchcandCreate(SCIP_BRANCHCAND **branchcand)
void SCIPbranchcandInvalidate(SCIP_BRANCHCAND *branchcand)
SCIP_RETCODE SCIPbranchcandFree(SCIP_BRANCHCAND **branchcand)
internal methods for branching rules and branching candidate storage
void SCIPclockStop(SCIP_CLOCK *clck, SCIP_SET *set)
void SCIPclockStart(SCIP_CLOCK *clck, SCIP_SET *set)
SCIP_Real SCIPclockGetTime(SCIP_CLOCK *clck)
internal methods for clocks and timing issues
SCIP_RETCODE SCIPcomprExec(SCIP_COMPR *compr, SCIP_SET *set, SCIP_REOPT *reopt, SCIP_RESULT *result)
internal methods for tree compressions
SCIP_RETCODE SCIPconcsolverCreateInstance(SCIP_SET *set, SCIP_CONCSOLVERTYPE *concsolvertype, SCIP_CONCSOLVER **concsolver)
SCIP_RETCODE SCIPconcsolverInitSeeds(SCIP_CONCSOLVER *concsolver, unsigned int seed)
SCIP_Real SCIPconcsolverTypeGetPrefPrio(SCIP_CONCSOLVERTYPE *concsolvertype)
datastructures for concurrent solvers
SCIP_RETCODE SCIPconcurrentSolve(SCIP *scip)
SCIP_RETCODE SCIPfreeConcurrent(SCIP *scip)
int SCIPgetNConcurrentSolvers(SCIP *scip)
helper functions for concurrent scip solvers
internal methods for conflict analysis
SCIP_RETCODE SCIPconflictCreate(SCIP_CONFLICT **conflict, BMS_BLKMEM *blkmem, SCIP_SET *set)
SCIP_RETCODE SCIPconflictFree(SCIP_CONFLICT **conflict, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPconflictstoreClear(SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_REOPT *reopt)
SCIP_RETCODE SCIPconflictstoreClean(SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_REOPT *reopt)
internal methods for storing conflicts
SCIP_RETCODE SCIPconsGetNVars(SCIP_CONS *cons, SCIP_SET *set, int *nvars, SCIP_Bool *success)
SCIP_RETCODE SCIPconshdlrPresolve(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRESOLTIMING timing, int nrounds, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
internal methods for constraints and constraint handlers
void SCIPcutpoolAddNCutsFound(SCIP_CUTPOOL *cutpool, SCIP_Longint ncutsfound)
void SCIPcutpoolSetTime(SCIP_CUTPOOL *cutpool, SCIP_Real time)
SCIP_RETCODE SCIPcutpoolCreate(SCIP_CUTPOOL **cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, int agelimit, SCIP_Bool globalcutpool)
SCIP_RETCODE SCIPcutpoolFree(SCIP_CUTPOOL **cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
void SCIPcutpoolAddNCalls(SCIP_CUTPOOL *cutpool, SCIP_Longint ncalls)
void SCIPcutpoolAddMaxNCuts(SCIP_CUTPOOL *cutpool, SCIP_Longint ncuts)
void SCIPcutpoolAddNCutsAdded(SCIP_CUTPOOL *cutpool, SCIP_Longint ncutsadded)
void SCIPcutpoolAddNRootCalls(SCIP_CUTPOOL *cutpool, SCIP_Longint nrootcalls)
SCIP_RETCODE SCIPcutpoolClear(SCIP_CUTPOOL *cutpool, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)
internal methods for storing cuts in a cut pool
void SCIPexitSolveDecompstore(SCIP *scip)
int SCIPdecompstoreGetNOrigDecomps(SCIP_DECOMPSTORE *decompstore)
SCIP_RETCODE SCIPtransformDecompstore(SCIP *scip)
internal methods for decompositions and the decomposition store
SCIP_RETCODE SCIPcheckStage(SCIP *scip, const char *method, SCIP_Bool init, SCIP_Bool problem, SCIP_Bool transforming, SCIP_Bool transformed, SCIP_Bool initpresolve, SCIP_Bool presolving, SCIP_Bool exitpresolve, SCIP_Bool presolved, SCIP_Bool initsolve, SCIP_Bool solving, SCIP_Bool solved, SCIP_Bool exitsolve, SCIP_Bool freetrans, SCIP_Bool freescip)
#define SCIPdebugFreeSol(set)
#define SCIPdebugReset(set)
#define SCIP_CALL_ABORT(x)
#define SCIP_LONGINT_FORMAT
SCIP_RETCODE SCIPeventqueueFree(SCIP_EVENTQUEUE **eventqueue)
SCIP_RETCODE SCIPeventfilterFree(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem, SCIP_SET *set)
SCIP_RETCODE SCIPeventfilterCreate(SCIP_EVENTFILTER **eventfilter, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPeventProcess(SCIP_EVENT *event, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter)
SCIP_RETCODE SCIPeventChgType(SCIP_EVENT *event, SCIP_EVENTTYPE eventtype)
SCIP_RETCODE SCIPeventqueueCreate(SCIP_EVENTQUEUE **eventqueue)
internal methods for managing events
SCIP_RETCODE SCIPprintStage(SCIP *scip, FILE *file)
SCIP_Bool SCIPisPresolveFinished(SCIP *scip)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_RETCODE SCIPpermuteProb(SCIP *scip, unsigned int randseed, SCIP_Bool permuteconss, SCIP_Bool permutebinvars, SCIP_Bool permuteintvars, SCIP_Bool permuteimplvars, SCIP_Bool permutecontvars)
int SCIPgetNIntVars(SCIP *scip)
SCIP_RETCODE SCIPsetObjlimit(SCIP *scip, SCIP_Real objlimit)
int SCIPgetNVars(SCIP *scip)
int SCIPgetNConss(SCIP *scip)
int SCIPgetNFixedVars(SCIP *scip)
int SCIPgetNBinVars(SCIP *scip)
SCIP_VAR ** SCIPgetFixedVars(SCIP *scip)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
void SCIPwarningMessage(SCIP *scip, const char *formatstr,...)
SCIP_Real SCIPnextafter(SCIP_Real from, SCIP_Real to)
SCIP_RETCODE SCIPgetBoolParam(SCIP *scip, const char *name, SCIP_Bool *value)
SCIP_RETCODE SCIPsetIntParam(SCIP *scip, const char *name, int value)
SCIP_RETCODE SCIPgetRealParam(SCIP *scip, const char *name, SCIP_Real *value)
SCIP_RETCODE SCIPsetRealParam(SCIP *scip, const char *name, SCIP_Real value)
int SCIPgetNActiveBenders(SCIP *scip)
SCIP_RETCODE SCIPapplyBendersDecomposition(SCIP *scip, int decompindex)
SCIP_BRANCHRULE * SCIPfindBranchrule(SCIP *scip, const char *name)
SCIP_Longint SCIPbranchruleGetNChildren(SCIP_BRANCHRULE *branchrule)
const char * SCIPcomprGetName(SCIP_COMPR *compr)
SCIP_CONCSOLVERTYPE ** SCIPgetConcsolverTypes(SCIP *scip)
int SCIPgetNConcsolverTypes(SCIP *scip)
int SCIPconshdlrGetNCheckConss(SCIP_CONSHDLR *conshdlr)
SCIP_CONS ** SCIPconshdlrGetCheckConss(SCIP_CONSHDLR *conshdlr)
const char * SCIPconshdlrGetName(SCIP_CONSHDLR *conshdlr)
SCIP_CONSHDLR * SCIPfindConshdlr(SCIP *scip, const char *name)
int SCIPconshdlrGetNActiveConss(SCIP_CONSHDLR *conshdlr)
SCIP_CONS ** SCIPconshdlrGetConss(SCIP_CONSHDLR *conshdlr)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_Longint SCIPcutpoolGetNRootCalls(SCIP_CUTPOOL *cutpool)
SCIP_Longint SCIPcutpoolGetNCutsFound(SCIP_CUTPOOL *cutpool)
SCIP_Real SCIPcutpoolGetTime(SCIP_CUTPOOL *cutpool)
SCIP_Longint SCIPcutpoolGetMaxNCuts(SCIP_CUTPOOL *cutpool)
SCIP_Longint SCIPcutpoolGetNCalls(SCIP_CUTPOOL *cutpool)
SCIP_Longint SCIPcutpoolGetNCutsAdded(SCIP_CUTPOOL *cutpool)
const char * SCIPheurGetName(SCIP_HEUR *heur)
SCIP_RETCODE SCIPinterruptLP(SCIP *scip, SCIP_Bool interrupt)
SCIP_Longint SCIPgetMemExternEstim(SCIP *scip)
BMS_BUFMEM * SCIPcleanbuffer(SCIP *scip)
SCIP_Longint SCIPgetMemUsed(SCIP *scip)
BMS_BUFMEM * SCIPbuffer(SCIP *scip)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIPduplicateBufferArray(scip, ptr, source, num)
SCIP_SYNCSTORE * SCIPgetSyncstore(SCIP *scip)
int SCIPpresolGetPriority(SCIP_PRESOL *presol)
const char * SCIPpresolGetName(SCIP_PRESOL *presol)
int SCIPpropGetPresolPriority(SCIP_PROP *prop)
const char * SCIPpropGetName(SCIP_PROP *prop)
SCIP_SOL * SCIPgetReoptLastOptSol(SCIP *scip)
void SCIPresetReoptSolMarks(SCIP *scip)
SCIP_RETCODE SCIPgetReoptOldObjCoef(SCIP *scip, SCIP_VAR *var, int run, SCIP_Real *objcoef)
SCIP_RETCODE SCIPcheckReoptRestart(SCIP *scip, SCIP_NODE *node, SCIP_Bool *restart)
SCIP_RETCODE SCIPaddReoptDualBndchg(SCIP *scip, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newbound, SCIP_Real oldbound)
SCIP_Bool SCIPisReoptEnabled(SCIP *scip)
SCIP_RETCODE SCIPenableReoptimization(SCIP *scip, SCIP_Bool enable)
SCIP_RETCODE SCIPgetReoptSolsRun(SCIP *scip, int run, SCIP_SOL **sols, int solssize, int *nsols)
SCIP_RETCODE SCIPfreeReoptSolve(SCIP *scip)
SCIP_RETCODE SCIPcheckSolOrig(SCIP *scip, SCIP_SOL *sol, SCIP_Bool *feasible, SCIP_Bool printreason, SCIP_Bool completely)
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_Longint SCIPsolGetNodenum(SCIP_SOL *sol)
int SCIPgetNSols(SCIP *scip)
SCIP_HEUR * SCIPsolGetHeur(SCIP_SOL *sol)
SCIP_RETCODE SCIPcreateFiniteSolCopy(SCIP *scip, SCIP_SOL **sol, SCIP_SOL *sourcesol, SCIP_Bool *success)
SCIP_Bool SCIPsolIsOriginal(SCIP_SOL *sol)
SCIP_SOL ** SCIPgetSols(SCIP *scip)
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)
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPtransformProb(SCIP *scip)
SCIP_RETCODE SCIPrestartSolve(SCIP *scip)
SCIP_RETCODE SCIPsolveParallel(SCIP *scip)
SCIP_RETCODE SCIPpresolve(SCIP *scip)
SCIP_RETCODE SCIPsolveConcurrent(SCIP *scip)
SCIP_Bool SCIPisSolveInterrupted(SCIP *scip)
SCIP_RETCODE SCIPfreeTransform(SCIP *scip)
SCIP_RETCODE SCIPinterruptSolve(SCIP *scip)
SCIP_RETCODE SCIPfreeSolve(SCIP *scip, SCIP_Bool restart)
SCIP_Bool SCIPisInRestart(SCIP *scip)
SCIP_RETCODE SCIPsolve(SCIP *scip)
SCIP_Real SCIPgetPrimalbound(SCIP *scip)
SCIP_Real SCIPgetGap(SCIP *scip)
SCIP_Real SCIPgetDualbound(SCIP *scip)
void SCIPstoreSolutionGap(SCIP *scip)
SCIP_Real SCIPgetSolvingTime(SCIP *scip)
SCIP_Real SCIPinfinity(SCIP *scip)
SCIP_Bool SCIPisInfinity(SCIP *scip, SCIP_Real val)
SCIP_RETCODE SCIPchgFeastol(SCIP *scip, SCIP_Real feastol)
SCIP_Real SCIPfeastol(SCIP *scip)
SCIP_Bool SCIPisEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPgetChildren(SCIP *scip, SCIP_NODE ***children, int *nchildren)
int SCIPgetNNodesLeft(SCIP *scip)
SCIP_RETCODE SCIPgetLeaves(SCIP *scip, SCIP_NODE ***leaves, int *nleaves)
SCIP_RETCODE SCIPgetSiblings(SCIP *scip, SCIP_NODE ***siblings, int *nsiblings)
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Bool SCIPvarIsActive(SCIP_VAR *var)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
int SCIPvarGetIndex(SCIP_VAR *var)
SCIP_Real SCIPvarGetWorstBoundGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPflattenVarAggregationGraph(SCIP *scip, SCIP_VAR *var)
SCIP_VAR ** SCIPvarGetMultaggrVars(SCIP_VAR *var)
int SCIPvarGetMultaggrNVars(SCIP_VAR *var)
SCIP_Bool SCIPvarIsOriginal(SCIP_VAR *var)
SCIP_RETCODE SCIPclearRelaxSolVals(SCIP *scip, SCIP_RELAX *relax)
void SCIPfreeRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen)
int SCIPrandomGetInt(SCIP_RANDNUMGEN *randnumgen, int minrandval, int maxrandval)
SCIP_RETCODE SCIPcreateRandom(SCIP *scip, SCIP_RANDNUMGEN **randnumgen, unsigned int initialseed, SCIP_Bool useglobalseed)
void SCIPselectDownRealInt(SCIP_Real *realarray, int *intarray, int k, int len)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_RETCODE SCIPcliquetableFree(SCIP_CLIQUETABLE **cliquetable, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPcliquetableCreate(SCIP_CLIQUETABLE **cliquetable, SCIP_SET *set, BMS_BLKMEM *blkmem)
int SCIPcliquetableGetNCliques(SCIP_CLIQUETABLE *cliquetable)
SCIP_RETCODE SCIPcliquetableCleanup(SCIP_CLIQUETABLE *cliquetable, 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, int *nchgbds, SCIP_Bool *infeasible)
methods for implications, variable bounds, and cliques
void SCIPinterruptRelease(SCIP_INTERRUPT *interrupt)
void SCIPinterruptCapture(SCIP_INTERRUPT *interrupt)
methods for catching the user CTRL-C interrupt
void SCIPlpRecomputeLocalAndGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
SCIP_RETCODE SCIPlpFree(SCIP_LP **lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
SCIP_RETCODE SCIPlpCreate(SCIP_LP **lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, const char *name)
SCIP_RETCODE SCIPlpReset(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter)
void SCIPlpInvalidateRootObjval(SCIP_LP *lp)
internal methods for LP management
size_t BMSgetNUsedBufferMemory(BMS_BUFMEM *buffer)
memory allocation routines
#define BMSgarbagecollectBlockMemory(mem)
void SCIPmessagePrintInfo(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
void SCIPmessagePrintVerbInfo(SCIP_MESSAGEHDLR *messagehdlr, SCIP_VERBLEVEL verblevel, SCIP_VERBLEVEL msgverblevel, const char *formatstr,...)
SCIP_RETCODE SCIPnlpFree(SCIP_NLP **nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPnlpAddVars(SCIP_NLP *nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, int nvars, SCIP_VAR **vars)
SCIP_RETCODE SCIPnlpCreate(SCIP_NLP **nlp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, int nvars_estimate)
internal methods for NLP management
SCIP_RETCODE SCIPpresolExec(SCIP_PRESOL *presol, SCIP_SET *set, SCIP_PRESOLTIMING timing, int nrounds, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
internal methods for presolvers
SCIP_RETCODE SCIPpricestoreCreate(SCIP_PRICESTORE **pricestore)
SCIP_RETCODE SCIPpricestoreFree(SCIP_PRICESTORE **pricestore)
internal methods for storing priced variables
SCIP_RETCODE SCIPprimalFree(SCIP_PRIMAL **primal, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPprimalAddOrigSol(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_SOL *sol, SCIP_Bool *stored)
SCIP_RETCODE SCIPprimalCreate(SCIP_PRIMAL **primal)
SCIP_RETCODE SCIPprimalTransformSol(SCIP_PRIMAL *primal, SCIP_SOL *sol, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_Real *solvals, SCIP_Bool *solvalset, int solvalssize, SCIP_Bool *added)
SCIP_RETCODE SCIPprimalUpdateObjlimit(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp)
SCIP_RETCODE SCIPprimalAddSol(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_SOL *sol, SCIP_Bool *stored)
SCIP_RETCODE SCIPprimalSetCutoffbound(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_Real cutoffbound, SCIP_Bool useforobjlimit)
SCIP_RETCODE SCIPprimalRetransformSolutions(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp)
SCIP_RETCODE SCIPprimalClear(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem)
internal methods for collecting primal CIP solutions and primal informations
SCIP_RETCODE SCIPprobScaleObj(SCIP_PROB *transprob, SCIP_PROB *origprob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPprobExitPresolve(SCIP_PROB *prob, SCIP_SET *set)
void SCIPprobInvalidateDualbound(SCIP_PROB *prob)
const char * SCIPprobGetName(SCIP_PROB *prob)
SCIP_RETCODE SCIPprobPerformVarDeletions(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand)
void SCIPprobUpdateDualbound(SCIP_PROB *prob, SCIP_Real newbound)
SCIP_RETCODE SCIPprobInitSolve(SCIP_PROB *prob, SCIP_SET *set)
void SCIPprobMarkNConss(SCIP_PROB *prob)
SCIP_RETCODE SCIPprobTransform(SCIP_PROB *source, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CONFLICTSTORE *conflictstore, SCIP_PROB **target)
SCIP_RETCODE SCIPprobCheckObjIntegral(SCIP_PROB *transprob, SCIP_PROB *origprob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPprobExitSolve(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Bool restart)
SCIP_Bool SCIPprobIsObjIntegral(SCIP_PROB *prob)
void SCIPprobResortVars(SCIP_PROB *prob)
SCIP_RETCODE SCIPprobFree(SCIP_PROB **prob, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPprobResetBounds(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
internal methods for storing and manipulating the main problem
SCIP_RETCODE SCIPpropPresol(SCIP_PROP *prop, SCIP_SET *set, SCIP_PRESOLTIMING timing, int nrounds, int *nfixedvars, int *naggrvars, int *nchgvartypes, int *nchgbds, int *naddholes, int *ndelconss, int *naddconss, int *nupgdconss, int *nchgcoefs, int *nchgsides, SCIP_RESULT *result)
internal methods for propagators
public methods for branching rules
public methods for tree compressions
public methods for managing constraints
public methods for primal heuristics
public methods for message output
public data structures and miscellaneous methods
methods for selecting (weighted) k-medians
public methods for presolvers
public methods for propagators
public methods for primal CIP solutions
public methods for problem variables
SCIP_RETCODE SCIPrelaxationFree(SCIP_RELAXATION **relaxation)
SCIP_RETCODE SCIPrelaxationCreate(SCIP_RELAXATION **relaxation, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PRIMAL *primal, SCIP_TREE *tree)
internal methods for relaxators
SCIP_RETCODE SCIPreoptUpdateVarHistory(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem, SCIP_VAR **vars, int nvars)
SCIP_RETCODE SCIPreoptSaveActiveConss(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_PROB *transprob, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPreoptAddRun(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_VAR **origvars, int norigvars, int size)
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)
SCIP_SOL * SCIPreoptGetLastBestSol(SCIP_REOPT *reopt)
SCIP_RETCODE SCIPreoptGetSolsRun(SCIP_REOPT *reopt, int run, SCIP_SOL **sols, int solssize, int *nsols)
SCIP_RETCODE SCIPreoptReleaseData(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)
void SCIPreoptResetSolMarks(SCIP_REOPT *reopt)
SCIP_Real SCIPreoptGetOldObjCoef(SCIP_REOPT *reopt, int run, int idx)
SCIP_RETCODE SCIPreoptFree(SCIP_REOPT **reopt, SCIP_SET *set, SCIP_PRIMAL *origprimal, BMS_BLKMEM *blkmem)
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)
int SCIPreoptGetNNodes(SCIP_REOPT *reopt, SCIP_NODE *node)
SCIP_RETCODE SCIPreoptResetActiveConss(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat)
SCIP_RETCODE SCIPreoptCreate(SCIP_REOPT **reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPreoptAddDualBndchg(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_VAR *var, SCIP_Real newval, SCIP_Real oldval)
SCIP_RETCODE SCIPreoptMergeVarHistory(SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, SCIP_VAR **vars, int nvars)
SCIP_RETCODE SCIPreoptSaveGlobalBounds(SCIP_REOPT *reopt, SCIP_PROB *transprob, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPreoptCheckRestart(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_NODE *node, SCIP_VAR **transvars, int ntransvars, SCIP_Bool *restart)
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)
SCIP_RETCODE SCIPreoptApplyGlbConss(SCIP *scip, SCIP_REOPT *reopt, SCIP_SET *set, SCIP_STAT *stat, BMS_BLKMEM *blkmem)
SCIP_RETCODE SCIPreoptReset(SCIP_REOPT *reopt, SCIP_SET *set, BMS_BLKMEM *blkmem)
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)
data structures and methods for collecting reoptimization information
public methods for Benders decomposition
public methods for branching rule plugins and branching
public methods for concurrent solving mode
public methods for constraint handler plugins and constraints
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
static SCIP_RETCODE prepareReoptimization(SCIP *scip)
static SCIP_RETCODE freeTransforming(SCIP *scip)
static SCIP_RETCODE freeReoptSolve(SCIP *scip)
static SCIP_RETCODE displayRelevantStats(SCIP *scip)
static SCIP_RETCODE initSolve(SCIP *scip, SCIP_Bool solved)
static SCIP_RETCODE exitPresolve(SCIP *scip, SCIP_Bool solved, SCIP_Bool *infeasible)
static SCIP_RETCODE freeTransform(SCIP *scip)
static SCIP_RETCODE calcNonZeros(SCIP *scip, SCIP_Longint *nchecknonzeros, SCIP_Longint *nactivenonzeros, SCIP_Bool *approxchecknonzeros, SCIP_Bool *approxactivenonzeros)
static SCIP_RETCODE initPresolve(SCIP *scip)
static SCIP_RETCODE freeSolve(SCIP *scip, SCIP_Bool restart)
static SCIP_RETCODE compressReoptTree(SCIP *scip)
static SCIP_RETCODE presolve(SCIP *scip, SCIP_Bool *unbounded, SCIP_Bool *infeasible, SCIP_Bool *vanished)
static SCIP_RETCODE transformSols(SCIP *scip)
static SCIP_RETCODE presolveRound(SCIP *scip, SCIP_PRESOLTIMING *timing, SCIP_Bool *unbounded, SCIP_Bool *infeasible, SCIP_Bool lastround, int *presolstart, int presolend, int *propstart, int propend, int *consstart, int consend)
public methods for querying solving statistics
public methods for timing
public methods for the branch-and-bound tree
public methods for SCIP variables
SCIP_RETCODE SCIPsepastoreCreate(SCIP_SEPASTORE **sepastore, BMS_BLKMEM *blkmem, SCIP_SET *set)
SCIP_RETCODE SCIPsepastoreFree(SCIP_SEPASTORE **sepastore, BMS_BLKMEM *blkmem)
internal methods for storing separated cuts
void SCIPsetSortPresols(SCIP_SET *set)
SCIP_RETCODE SCIPsetInitsolPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
SCIP_RETCODE SCIPsetInitPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
SCIP_RETCODE SCIPsetSetReoptimizationParams(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
void SCIPsetSortPropsPresol(SCIP_SET *set)
void SCIPsetSortComprs(SCIP_SET *set)
SCIP_RETCODE SCIPsetExitprePlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPsetExitsolPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_Bool restart)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
SCIP_Real SCIPsetCutoffbounddelta(SCIP_SET *set)
SCIP_RETCODE SCIPsetExitPlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
SCIP_RETCODE SCIPsetInitprePlugins(SCIP_SET *set, BMS_BLKMEM *blkmem, SCIP_STAT *stat)
SCIP_NODESEL * SCIPsetGetNodesel(SCIP_SET *set, SCIP_STAT *stat)
internal methods for global SCIP settings
SCIP_RETCODE SCIPsolFree(SCIP_SOL **sol, BMS_BLKMEM *blkmem, SCIP_PRIMAL *primal)
void SCIPsolRecomputeObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *origprob)
SCIP_RETCODE SCIPsolRetransform(SCIP_SOL *sol, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_Bool *hasinfval)
SCIP_Real SCIPsolGetObj(SCIP_SOL *sol, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
SCIP_RETCODE SCIPsolPrint(SCIP_SOL *sol, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PROB *transprob, FILE *file, SCIP_Bool mipstart, SCIP_Bool printzeros)
SCIP_RETCODE SCIPsolCheckOrig(SCIP_SOL *sol, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_Bool printreason, SCIP_Bool completely, SCIP_Bool checkbounds, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool checkmodifiable, SCIP_Bool *feasible)
internal methods for storing primal CIP solutions
SCIP_RETCODE SCIPsolveCIP(BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_MEM *mem, SCIP_PROB *origprob, SCIP_PROB *transprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_RELAXATION *relaxation, SCIP_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_CUTPOOL *delayedcutpool, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *restart)
SCIP_Bool SCIPsolveIsStopped(SCIP_SET *set, SCIP_STAT *stat, SCIP_Bool checknodelimits)
SCIP_RETCODE SCIPprimalHeuristics(SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_LP *lp, SCIP_NODE *nextnode, SCIP_HEURTIMING heurtiming, SCIP_Bool nodeinfeasible, SCIP_Bool *foundsol, SCIP_Bool *unbounded)
internal methods for main solving loop and node processing
void SCIPstatUpdatePrimalDualIntegrals(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Real upperbound, SCIP_Real lowerbound)
void SCIPstatMark(SCIP_STAT *stat)
void SCIPstatResetDisplay(SCIP_STAT *stat)
void SCIPstatResetPrimalDualIntegrals(SCIP_STAT *stat, SCIP_SET *set, SCIP_Bool partialreset)
void SCIPstatResetPresolving(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
void SCIPstatReset(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob)
void SCIPstatEnforceLPUpdates(SCIP_STAT *stat)
void SCIPstatResetCurrentRun(SCIP_STAT *stat, SCIP_SET *set, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_Bool solved)
internal methods for problem statistics
datastructures for managing events
datastructures for block memory pools and memory buffers
datastructures for collecting primal CIP solutions and primal informations
datastructures for storing and manipulating the main problem
SCIP main data structure.
datastructures for global SCIP settings
datastructures for problem statistics
data structures for branch and bound tree
void SCIPsyncstoreSetSolveIsStopped(SCIP_SYNCSTORE *syncstore, SCIP_Bool stopped)
SCIP_RETCODE SCIPsyncstoreInit(SCIP *scip)
the function declarations for the synchronization store
the type definitions for the SCIP parallel interface
SCIP_Bool SCIPtpiIsAvailable(void)
SCIP_NODE * SCIPtreeGetFocusNode(SCIP_TREE *tree)
SCIP_RETCODE SCIPtreeFree(SCIP_TREE **tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)
SCIP_RETCODE SCIPtreeCreatePresolvingRoot(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable)
int SCIPtreeGetNNodes(SCIP_TREE *tree)
SCIP_RETCODE SCIPtreeClear(SCIP_TREE *tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPnodeFocus(SCIP_NODE **node, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *cutoff, SCIP_Bool postponed, SCIP_Bool exitsolve)
SCIP_RETCODE SCIPtreeCreate(SCIP_TREE **tree, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_NODESEL *nodesel)
SCIP_RETCODE SCIPtreeCreateRoot(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_RETCODE SCIPtreeFreePresolvingRoot(SCIP_TREE *tree, SCIP_REOPT *reopt, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable)
internal methods for branch and bound tree
#define SCIP_EVENTTYPE_PRESOLVEROUND
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_INITPRESOLVE
@ SCIP_STAGE_EXITPRESOLVE
@ SCIP_STAGE_TRANSFORMING
#define SCIP_HEURTIMING_BEFOREPRESOL
#define SCIP_PRESOLTIMING_FINAL
#define SCIP_PRESOLTIMING_MEDIUM
unsigned int SCIP_PRESOLTIMING
#define SCIP_HEURTIMING_DURINGPRESOLLOOP
#define SCIP_PRESOLTIMING_FAST
#define SCIP_PRESOLTIMING_EXHAUSTIVE
@ SCIP_VARSTATUS_MULTAGGR
SCIP_RETCODE SCIPvarFlattenAggregationGraph(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue)
internal methods for problem variables
SCIP_RETCODE SCIPvisualInit(SCIP_VISUAL *visual, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
void SCIPvisualExit(SCIP_VISUAL *visual, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
methods for creating output for visualization tools (VBC, BAK)
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4