SCIP_DebugSolData
80assert(debugsoldata !=
NULL);
84(*debugsoldata)->solnames =
NULL;
85(*debugsoldata)->solvals =
NULL;
86(*debugsoldata)->nsolvals = 0;
87(*debugsoldata)->solsize = 0;
88(*debugsoldata)->debugsol =
NULL;
90(*debugsoldata)->solinnode =
NULL;
91(*debugsoldata)->falseptr =
FALSE;
92(*debugsoldata)->trueptr =
TRUE;
93(*debugsoldata)->solisachieved =
FALSE;
94(*debugsoldata)->debugsolval = 0.0;
95(*debugsoldata)->debugsoldisabled =
TRUE;
100#ifdef SCIP_MORE_DEBUG 118 if( strcmp(
set->misc_debugsol,
"-") == 0 )
124 "SCIP is compiled with 'DEBUGSOL=true' but no debug solution is given:\n");
126 "*** Please set the parameter 'misc/debugsol' and reload the problem again to use the debugging-mechanism ***\n\n");
138 const char* solfilename,
159assert(solfilename !=
NULL);
160assert(names !=
NULL);
161assert(*names ==
NULL);
162assert(vals !=
NULL);
163assert(*vals ==
NULL);
164assert(nvals !=
NULL);
165assert(valssize !=
NULL);
167printf(
"***** debug: reading solution file <%s>\n", solfilename);
173 SCIPerrorMessage(
"cannot open solution file <%s> specified in scip/debug.h\n", solfilename);
181unknownvariablemessage =
FALSE;
204 SCIPstrncasecmp(buf,
"All other variables", 19) == 0 || strspn(buf,
" \n\r\t\f") == strlen(buf) ||
213nread = sscanf(buf,
"%s %s %s\n", name, valuestring, objstring);
216printf(
"invalid input line %d in solution file <%s>: <%s>\n", *nvals + nonvalues, solfilename, name);
225 if( !unknownvariablemessage )
228name, *nvals + nonvalues, solfilename);
230unknownvariablemessage =
TRUE;
245nread = sscanf(valuestring,
"%lf", &val);
248 SCIPerrorMessage(
"Invalid solution value <%s> for variable <%s> in line %d of solution file <%s>.\n",
249valuestring, name, *nvals + nonvalues, solfilename);
256 if( *nvals >= *valssize )
258*valssize =
MAX(2 * *valssize, (*nvals)+1);
262assert(*nvals < *valssize);
265 for( i = *nvals; i > 0 && strcmp(name, (*names)[i-1]) < 0; --i )
267(*names)[i] = (*names)[i-1];
268(*vals)[i] = (*vals)[i-1];
271 SCIPdebugMsg(
set->scip,
"found variable <%s>: value <%g>\n", (*names)[i], val);
284 for( i = 0; i < *nvals; ++i)
291solvalues[nfound] = (*vals)[i];
296 SCIPdebugMsg(
set->scip,
"Debug Solution value is %g.\n", debugsolval);
298#ifdef SCIP_MORE_DEBUG 299 SCIPsortPtrReal((
void**)vars, solvalues, sortVarsAfterNames, nfound);
301 for( i = 0; i < nfound - 1; ++i)
307 if( debugsolptr !=
NULL)
320 if( debugsolptr !=
NULL)
321*debugsolptr = debugsol;
323 if( debugsolvalptr !=
NULL)
324*debugsolvalptr = debugsolval;
329printf(
"***** debug: read %d non-zero entries (%d variables found)\n", *nvals, nfound);
345 if( !debugSolutionAvailable(
set) )
349assert(debugsoldata !=
NULL);
352 if( debugsoldata->debugsol !=
NULL)
355 SCIP_CALL( readSolfile(
set,
set->misc_debugsol, &debugsoldata->debugsol, &debugsoldata->debugsolval,
356&debugsoldata->debugsolstage, &(debugsoldata->solnames), &(debugsoldata->solvals), &(debugsoldata->nsolvals),
357&(debugsoldata->solsize)) );
381assert(var !=
NULL);
382assert(val !=
NULL);
385 if( !debugSolutionAvailable(
set) )
389assert(debugsoldata !=
NULL);
399 SCIPsetDebugMsg(
set,
"Now handling variable <%s>, which has status %d, is of type %d, and was deleted: %d, negated: %d, transformed: %d\n",
424 if( solvar ==
NULL)
443right = debugsoldata->nsolvals-1;
444 while( left <= right )
446middle = (left+right)/2;
447cmp = strcmp(name, debugsoldata->solnames[middle]);
454*val = scalar * debugsoldata->solvals[middle] + constant;
486assert(sol !=
NULL);
491 if( !debugSolutionAvailable(
scip->set) )
496 if( debugsoldata->debugsol ==
NULL)
499*sol = debugsoldata->debugsol;
530 if( !debugSolutionAvailable(
set) )
536assert(debugsoldata !=
NULL);
538 if( debugsoldata->solisachieved )
548 if( bestsol !=
NULL)
563debugsoldata->solisachieved =
TRUE;
566 returndebugsoldata->solisachieved;
582assert(blkmem !=
NULL);
583assert(node !=
NULL);
584assert(solcontained !=
NULL);
587 if( !debugSolutionAvailable(
set) )
591assert(debugsoldata !=
NULL);
593 if( debugsoldata ->debugsoldisabled )
595*solcontained =
FALSE;
600 if( debugsoldata->solinnode ==
NULL)
607 if( boolptr !=
NULL)
609 if( boolptr != &debugsoldata->falseptr && boolptr != &debugsoldata->trueptr )
615*solcontained = *boolptr;
620*solcontained =
TRUE;
637 for( i = 0; i < (int)domchgbound->
nboundchgs&& *solcontained; ++i )
642 SCIP_CALL( getSolutionValue(
set, boundchgs[i].var, &varsol) );
654 SCIPerrorMessage(
"debugging solution was cut off in local node %p at depth %d by inference <%s>[%.15g] %s %.15g\n",
663*solcontained =
FALSE;
677 for( i = 0; i < naddedcons && *solcontained; ++i )
683*solcontained =
FALSE;
691 SCIP_CALL(
SCIPhashmapSetImage(debugsoldata->solinnode, (
void*)node, *solcontained ? (
void*)(&debugsoldata->trueptr) : (
void*)(&debugsoldata->falseptr)) );
704assert(debugsoldata !=
NULL);
725assert(debugsoldata !=
NULL);
727 if( debugsoldata->solinnode !=
NULL)
746assert(debugsoldata !=
NULL);
748 for( s = debugsoldata->nsolvals - 1; s >= 0; --s )
754debugsoldata->nsolvals = 0;
755debugsoldata->debugsolval= 0.0;
756debugsoldata->solisachieved =
FALSE;
758 if( debugsoldata->solinnode !=
NULL)
777assert(debugsoldata !=
NULL);
805 if( !debugSolutionAvailable(
scip->set) )
810assert(conss !=
NULL|| nconss == 0);
811assert(debugsoldata->debugsol !=
NULL);
816 if( debugSolIsAchieved(
scip->set) )
822 for( c = nconss - 1; c >= 0; --c )
824assert(conss[c] !=
NULL);
872assert(row !=
NULL);
879 if( !debugSolutionAvailable(
set) )
883 if( debugSolIsAchieved(
set) )
904maxactivity = minactivity;
905 for( i = 0; i < nnonz; ++i )
915minactivity += vals[i] * solval;
916maxactivity += vals[i] * solval;
918 else if( vals[i] > 0.0 )
923 else if( vals[i] < 0.0 )
935printf(
"***** debug: row <%s> violates debugging solution (lhs=%.15g, rhs=%.15g, activity=[%.15g,%.15g], local=%u, lpfeastol=%g)\n",
941printf(
"***** debug: violated row <%s>:\n",
SCIProwGetName(row));
943 for( i = 0; i < nnonz; ++i )
949printf(
" <= %.15g\n", rhs);
967assert(var !=
NULL);
974 if( !debugSolutionAvailable(
scip->set) )
991 if( debugSolIsAchieved(
scip->set) )
1018assert(var !=
NULL);
1025 if( !debugSolutionAvailable(
scip->set) )
1036 if( debugSolIsAchieved(
scip->set) )
1067assert(blkmem !=
NULL);
1068assert(node !=
NULL);
1069assert(var !=
NULL);
1080 if( !debugSolutionAvailable(
set) )
1084 if( debugSolIsAchieved(
set) )
1088 SCIP_CALL( isSolutionInNode(blkmem,
set, node, &solcontained) );
1089 if( !solcontained )
1123assert(blkmem !=
NULL);
1124assert(node !=
NULL);
1127assert(debugsoldata !=
NULL);
1134 if( !debugSolutionAvailable(
set) )
1138 if( debugSolIsAchieved(
set) )
1147solisinnode =
FALSE;
1149 SCIP_CALL( isSolutionInNode(blkmem,
set, node, &solisinnode) );
1160 if( debugsoldata->solinnode !=
NULL)
1178assert(blkmem !=
NULL);
1185 if( !debugSolutionAvailable(
set) )
1199assert(debugsoldata !=
NULL);
1202 if( debugsoldata->debugsol ==
NULL)
1213 SCIPerrorMessage(
"global lower bound %g is larger than the value of the debugging solution %g.\n", treelowerbound,
SCIPsolGetOrigObj(debugsoldata->debugsol));
1218 SCIPerrorMessage(
"global upper bound %g is smaller than the value of the debugging solution %g.\n", treelowerbound,
SCIPsolGetOrigObj(debugsoldata->debugsol));
1236assert(blkmem !=
NULL);
1247 if( !debugSolutionAvailable(
set) )
1257assert(debugsoldata !=
NULL);
1260 if( debugsoldata->debugsol ==
NULL)
1266 SCIP_CALL( isSolutionInNode(blkmem,
set, node, &solisinnode) );
1284 SCIPerrorMessage(
"local upper bound %g of node #%" SCIP_LONGINT_FORMAT " at depth %d is smaller than the value of the debugging solution %g contained in this node.\n",
1308assert(var !=
NULL);
1315 if( !debugSolutionAvailable(
set) )
1319 if( debugSolIsAchieved(
set) )
1324 SCIP_CALL( getSolutionValue(
set, vbvar, &vbvarsol) );
1329vb = vbcoef * vbvarsol + vbconstant;
1333 SCIPerrorMessage(
"invalid variable bound: <%s>[%.15g] %s %.15g<%s>[%.15g] %+.15g\n",
1356assert(var !=
NULL);
1364 if( !debugSolutionAvailable(
set) )
1368 if( debugSolIsAchieved(
set) )
1378 if( (solval > 0.5) != varfixing )
1382 SCIP_CALL( getSolutionValue(
set, implvar, &solval) );
1390 SCIPerrorMessage(
"invalid implication <%s> == %d -> <%s> >= %.15g (variable has value %.15g in solution)\n",
1399 SCIPerrorMessage(
"invalid implication <%s> == %d -> <%s> <= %.15g (variable has value %.15g in solution)\n",
1423assert(var !=
NULL);
1424assert(aggrvars !=
NULL);
1426assert(naggrvars >= 0);
1433 if( !debugSolutionAvailable(
set) )
1437 if( debugSolIsAchieved(
set) )
1448 for( i = 0; i < naggrvars; i++ )
1453 SCIP_CALL( getSolutionValue(
set, aggrvars[i], &aggrsolval) );
1458val +=
scalars[i] * aggrsolval;
1464 if( naggrvars == 1 )
1469 SCIP_CALL( getSolutionValue(
set, aggrvars[0], &aggrsolval) );
1471 SCIPerrorMessage(
"aggregation <%s>[%g] = %g<%s>[%g] + %g violates debugging solution (expected %g)\n",
1476 SCIPerrorMessage(
"multi-aggregation <%s>[%g] = ... %d vars ... + %g violates debugging solution (expected %g)\n",
1499assert(vars !=
NULL);
1506 if( !debugSolutionAvailable(
set) )
1510 if( debugSolIsAchieved(
set) )
1516 for( v = 0; v < nvars; ++v )
1518assert(vars[v] !=
NULL);
1522 SCIP_CALL( getSolutionValue(
set, vars[v], &solval) );
1530 if( values !=
NULL&& values[v] == 0 )
1531solval = 1.0 - solval;
1550 SCIPerrorMessage(
"clique violates debugging solution, (at least) variable <%s%s> and variable <%s%s> are both one in the debugging solution\n",
1571 if( !debugSolutionAvailable(
set) )
1578 for( i = 0; i < nbdchginfos; ++i )
1584bdchginfo = bdchginfos[i];
1585assert(bdchginfo !=
NULL);
1588assert(var !=
NULL);
1590 if( relaxedbds !=
NULL)
1591newbound = relaxedbds[i];
1646 if( !debugSolutionAvailable(
set) )
1672 if( !debugSolutionAvailable(
set) )
1675 for( i = 0; i < nbdchginfos; ++i )
1679bdchginfo = bdchginfos[i];
1680assert(bdchginfo !=
NULL);
1701assert(blkmem !=
NULL);
1702assert(node !=
NULL);
1703assert(nbdchginfos == 0 || bdchginfos !=
NULL);
1710 if( !debugSolutionAvailable(
set) )
1714 if( debugSolIsAchieved(
set) )
1718 SCIP_CALL( isSolutionInNode(blkmem,
set, node, &solcontained) );
1719 if( !solcontained )
1723 if( debugCheckBdchginfos(
set, bdchginfos, relaxedbds, nbdchginfos) )
1729 SCIP_CALL( printBdchginfos(
set, bdchginfos, relaxedbds, nbdchginfos) );
1754 intnforcedbdchgqueued;
1757assert(blkmem !=
NULL);
1758assert(node !=
NULL);
1759assert(nbdchginfos == 0 || bdchginfos !=
NULL);
1766 if( !debugSolutionAvailable(
set) )
1770 if( debugSolIsAchieved(
set) )
1774 SCIP_CALL( isSolutionInNode(blkmem,
set, node, &solcontained) );
1775 if( !solcontained )
1779 if( debugCheckBdchginfos(
set, bdchginfos, relaxedbds, nbdchginfos) )
1787 if( debugCheckBdchginfos(
set, bdchgqueued,
NULL, nbdchgqueued) )
1795 if( debugCheckBdchginfos(
set, forcedbdchgqueued,
NULL, nforcedbdchgqueued) )
1800 if( bdchginfo !=
NULL)
1802printf(
" (after resolving bound change ");
1809 SCIP_CALL( printBdchginfos(
set, bdchginfos, relaxedbds, nbdchginfos) );
1815 SCIP_CALL( printBdchginfos(
set, forcedbdchgqueued,
NULL, nforcedbdchgqueued) );
1832*isvalidinsubtree =
FALSE;
1841 if( !debugSolutionAvailable(
scip->set) )
1845 if( debugSolIsAchieved(
scip->set) )
1852*isvalidinsubtree =
TRUE;
1877assert(debugsoldata !=
NULL);
1879debugsoldata->debugsoldisabled =
FALSE;
1892assert(debugsoldata !=
NULL);
1894debugsoldata->debugsoldisabled =
TRUE;
1907assert(debugsoldata !=
NULL);
1909 return(!debugsoldata->debugsoldisabled);
1915#ifdef WITH_DEBUG_SOLUTION 1932assert(result !=
NULL);
1937 if( !SCIPdebugIsMainscip(
scip) )
1944 if( !debugSolutionAvailable(
scip->set) )
1948 if( debugSolIsAchieved(
scip->set) )
1959 for( i = 0; i < nvars; ++i )
1967 SCIP_CALL( getSolutionValue(
scip->set, vars[i], &solval) );
1970 SCIPerrorMessage(
"original variable without debugging solution value\n");
1978 SCIPerrorMessage(
"solution value %.15g of <%s> outside bounds loc=[%.15g,%.15g], glb=[%.15g,%.15g]\n",
2002 SCIP_PROPTIMING_ALWAYS, 99999999, 0,
SCIP_PRESOLTIMING_FAST,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
2019 const char* varname;
2023assert(var !=
NULL);
2027assert(debugsoldata !=
NULL);
2036 if( !debugSolutionAvailable(
scip->set) )
2039 if( debugsoldata->debugsol ==
NULL)
2046 if( debugsoldata->nsolvals >= debugsoldata->solsize )
2048debugsoldata->solsize =
MAX(2*debugsoldata->solsize, debugsoldata->nsolvals+1);
2052assert(debugsoldata->nsolvals < debugsoldata->solsize);
2056 for( i = debugsoldata->nsolvals; i > 0 && strcmp(varname, debugsoldata->solnames[i-1]) < 0; --i )
2058debugsoldata->solnames[i] = debugsoldata->solnames[i-1];
2059debugsoldata->solvals[i] = debugsoldata->solvals[i-1];
2061 if( i > 0 && strcmp(varname, debugsoldata->solnames[i-1]) == 0 )
2063 if(
REALABS(debugsoldata->solvals[i-1] - val) > 1e-9 )
2065 SCIPerrorMessage(
"already have stored different debugging solution value (%g) for variable <%s>, cannot store %g\n", debugsoldata->solvals[i-1], varname, val);
2070 SCIPdebugMsg(
scip,
"already have stored debugging solution value %g for variable <%s>, do not store same value again\n", val, varname);
2071 for( ; i < debugsoldata->nsolvals; ++i )
2073debugsoldata->solnames[i] = debugsoldata->solnames[i+1];
2074debugsoldata->solvals[i] = debugsoldata->solvals[i+1];
2082 SCIPdebugMsg(
scip,
"add variable <%s>: value <%g>\n", debugsoldata->solnames[i], val);
2083debugsoldata->solvals[i] = val;
2084debugsoldata->nsolvals++;
2087debugsoldata->debugsolval += debugsoldata->solvals[i] *
SCIPvarGetObj(var);
2088 SCIPdebugMsg(
scip,
"Debug Solution value is now %g.\n", debugsoldata->debugsolval);
2117#ifdef SCIP_DEBUG_LP_INTERFACE 2144 for( k = 0; k < nrows; ++k )
2158 for( i = 0; i < nrows; ++i )
2161vecval += coef[i] * matrixval;
2173assert( idx >= 0 && idx < nrows );
2205 const char* method,
2223assert(method !=
NULL);
2230assert(
scip->interrupt !=
NULL);
2231assert(
scip->dialoghdlr !=
NULL);
2232assert(
scip->totaltime !=
NULL);
2234 switch(
scip->set->stage )
2239assert(
scip->eventfilter ==
NULL);
2240assert(
scip->eventqueue ==
NULL);
2241assert(
scip->branchcand ==
NULL);
2247assert(
scip->transprob ==
NULL);
2248assert(
scip->pricestore ==
NULL);
2249assert(
scip->sepastore ==
NULL);
2251assert(
scip->delayedcutpool ==
NULL);
2255 SCIPerrorMessage(
"cannot call method <%s> in initialization stage\n", method);
2263assert(
scip->eventfilter ==
NULL);
2264assert(
scip->eventqueue ==
NULL);
2265assert(
scip->branchcand ==
NULL);
2271assert(
scip->transprob ==
NULL);
2272assert(
scip->pricestore ==
NULL);
2273assert(
scip->sepastore ==
NULL);
2275assert(
scip->delayedcutpool ==
NULL);
2279 SCIPerrorMessage(
"cannot call method <%s> in problem creation stage\n", method);
2287assert(
scip->eventfilter !=
NULL);
2288assert(
scip->eventqueue !=
NULL);
2289assert(
scip->branchcand !=
NULL);
2294assert(
scip->transprob !=
NULL);
2295assert(
scip->pricestore ==
NULL);
2296assert(
scip->sepastore ==
NULL);
2298assert(
scip->delayedcutpool ==
NULL);
2300 if( !transforming )
2302 SCIPerrorMessage(
"cannot call method <%s> in problem transformation stage\n", method);
2310assert(
scip->eventfilter !=
NULL);
2311assert(
scip->eventqueue !=
NULL);
2312assert(
scip->branchcand !=
NULL);
2317assert(
scip->transprob !=
NULL);
2318assert(
scip->pricestore ==
NULL);
2319assert(
scip->sepastore ==
NULL);
2321assert(
scip->delayedcutpool ==
NULL);
2325 SCIPerrorMessage(
"cannot call method <%s> in problem transformed stage\n", method);
2333assert(
scip->eventfilter !=
NULL);
2334assert(
scip->eventqueue !=
NULL);
2335assert(
scip->branchcand !=
NULL);
2340assert(
scip->transprob !=
NULL);
2341assert(
scip->pricestore ==
NULL);
2342assert(
scip->sepastore ==
NULL);
2344assert(
scip->delayedcutpool ==
NULL);
2346 if( !initpresolve )
2348 SCIPerrorMessage(
"cannot call method <%s> in init presolving stage\n", method);
2356assert(
scip->eventfilter !=
NULL);
2357assert(
scip->eventqueue !=
NULL);
2358assert(
scip->branchcand !=
NULL);
2363assert(
scip->transprob !=
NULL);
2364assert(
scip->pricestore ==
NULL);
2365assert(
scip->sepastore ==
NULL);
2367assert(
scip->delayedcutpool ==
NULL);
2371 SCIPerrorMessage(
"cannot call method <%s> in presolving stage\n", method);
2379assert(
scip->eventfilter !=
NULL);
2380assert(
scip->eventqueue !=
NULL);
2381assert(
scip->branchcand !=
NULL);
2386assert(
scip->transprob !=
NULL);
2387assert(
scip->pricestore ==
NULL);
2388assert(
scip->sepastore ==
NULL);
2390assert(
scip->delayedcutpool ==
NULL);
2392 if( !exitpresolve )
2394 SCIPerrorMessage(
"cannot call method <%s> in exit presolving stage\n", method);
2402assert(
scip->eventfilter !=
NULL);
2403assert(
scip->eventqueue !=
NULL);
2404assert(
scip->branchcand !=
NULL);
2409assert(
scip->transprob !=
NULL);
2410assert(
scip->pricestore ==
NULL);
2411assert(
scip->sepastore ==
NULL);
2413assert(
scip->delayedcutpool ==
NULL);
2417 SCIPerrorMessage(
"cannot call method <%s> in problem presolved stage\n", method);
2425assert(
scip->eventfilter !=
NULL);
2426assert(
scip->eventqueue !=
NULL);
2427assert(
scip->branchcand !=
NULL);
2431assert(
scip->transprob !=
NULL);
2435 SCIPerrorMessage(
"cannot call method <%s> in init solve stage\n", method);
2443assert(
scip->eventfilter !=
NULL);
2444assert(
scip->eventqueue !=
NULL);
2445assert(
scip->branchcand !=
NULL);
2450assert(
scip->transprob !=
NULL);
2451assert(
scip->pricestore !=
NULL);
2452assert(
scip->sepastore !=
NULL);
2454assert(
scip->delayedcutpool !=
NULL);
2466assert(
scip->eventfilter !=
NULL);
2467assert(
scip->eventqueue !=
NULL);
2468assert(
scip->branchcand !=
NULL);
2473assert(
scip->transprob !=
NULL);
2474assert(
scip->pricestore !=
NULL);
2475assert(
scip->sepastore !=
NULL);
2477assert(
scip->delayedcutpool !=
NULL);
2481 SCIPerrorMessage(
"cannot call method <%s> in problem solved stage\n", method);
2489assert(
scip->eventfilter !=
NULL);
2490assert(
scip->eventqueue !=
NULL);
2491assert(
scip->branchcand !=
NULL);
2495assert(
scip->transprob !=
NULL);
2499 SCIPerrorMessage(
"cannot call method <%s> in solve deinitialization stage\n", method);
2507assert(
scip->pricestore ==
NULL);
2508assert(
scip->sepastore ==
NULL);
2510assert(
scip->delayedcutpool ==
NULL);
2514 SCIPerrorMessage(
"cannot call method <%s> in free transformed problem stage\n", method);
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)
void SCIPdummyDebugMethodForSun(void)
#define SCIPdebugCheckLbGlobal(scip, var, lb)
#define SCIPdebugCheckClique(set, vars, values, nvars)
#define SCIPdebugFree(set)
struct SCIP_DebugSolData SCIP_DEBUGSOLDATA
#define SCIPdebugCheckRow(set, row)
#define SCIPdebugSolDisable(scip)
#define SCIPdebugCheckConflict(blkmem, set, node, bdchginfos, relaxedbds, nliterals)
#define SCIPdebugCheckImplic(set, var, varfixing, implvar, impltype, implbound)
#define SCIPdebugGetSolVal(scip, var, val)
#define SCIPdebugFreeSol(set)
#define SCIPdebugCheckUbGlobal(scip, var, ub)
#define SCIPdebugSolEnable(scip)
#define SCIPdebugCheckGlobalLowerbound(blkmem, set)
#define SCIPdebugCheckLocalLowerbound(blkmem, set, node)
#define SCIPdebugAddSolVal(scip, var, val)
#define SCIPdebugCheckVbound(set, var, vbtype, vbvar, vbcoef, vbconstant)
#define SCIPdebugCheckConss(scip, conss, nconss)
#define SCIPdebugFreeDebugData(set)
#define SCIPdebugSolIsEnabled(scip)
#define SCIPdebugCheckAggregation(set, var, aggrvars, scalars, constant, naggrvars)
#define SCIPdebugCheckBInvRow(scip, r, coef)
#define SCIPdebugRemoveNode(blkmem, set, node)
#define SCIPdebugSolIsValidInSubtree(scip, isvalidinsubtree)
#define SCIPdebugReset(set)
#define SCIPdebugCheckConflictFrontier(blkmem, set, node, bdchginfo, bdchginfos, relaxedbds, nliterals, bdchgqueue, forcedbdchgqueue)
#define SCIPdebugIncludeProp(scip)
#define SCIPdebugCheckInference(blkmem, set, node, var, newbound, boundtype)
#define SCIPwithDebugSol(void)
#define SCIPdebugSolDataCreate(debugsoldata)
common defines and data types used in all packages of SCIP
#define SCIP_LONGINT_FORMAT
SCIP_FILE * SCIPfopen(const char *path, const char *mode)
int SCIPfeof(SCIP_FILE *stream)
int SCIPfclose(SCIP_FILE *fp)
char * SCIPfgets(char *s, int size, SCIP_FILE *stream)
SCIP_STATUS SCIPgetStatus(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)
int SCIPgetNOrigVars(SCIP *scip)
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPhashmapSetImage(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
SCIP_RETCODE SCIPhashmapRemoveAll(SCIP_HASHMAP *hashmap)
SCIP_RETCODE SCIPhashmapRemove(SCIP_HASHMAP *hashmap, void *origin)
SCIP_RETCODE SCIPlpiGetCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real *val)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
void ** SCIPpqueueElems(SCIP_PQUEUE *pqueue)
int SCIPpqueueNElems(SCIP_PQUEUE *pqueue)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
SCIP_RETCODE SCIPcheckCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
int SCIPconsGetActiveDepth(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
const char * SCIPconsGetName(SCIP_CONS *cons)
SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)
int SCIPgetNLPRows(SCIP *scip)
SCIP_Real SCIPgetLPFeastol(SCIP *scip)
#define SCIPallocBufferArray(scip, ptr, num)
#define SCIPfreeBufferArray(scip, ptr)
SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)
SCIP_Real SCIPnodeGetLowerbound(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_RETCODE SCIPincludeProp(SCIP *scip, const char *name, const char *desc, int priority, int freq, SCIP_Bool delay, SCIP_PROPTIMING timingmask, int presolpriority, int presolmaxrounds, SCIP_PRESOLTIMING presoltiming, SCIP_DECL_PROPCOPY((*propcopy)), SCIP_DECL_PROPFREE((*propfree)), SCIP_DECL_PROPINIT((*propinit)), SCIP_DECL_PROPEXIT((*propexit)), SCIP_DECL_PROPINITPRE((*propinitpre)), SCIP_DECL_PROPEXITPRE((*propexitpre)), SCIP_DECL_PROPINITSOL((*propinitsol)), SCIP_DECL_PROPEXITSOL((*propexitsol)), SCIP_DECL_PROPPRESOL((*proppresol)), SCIP_DECL_PROPEXEC((*propexec)), SCIP_DECL_PROPRESPROP((*propresprop)), SCIP_PROPDATA *propdata)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
int SCIProwGetNNonz(SCIP_ROW *row)
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
const char * SCIProwGetName(SCIP_ROW *row)
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
SCIP_Real SCIPsolGetOrigObj(SCIP_SOL *sol)
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
SCIP_RETCODE SCIPcreateOrigSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
SCIP_RETCODE SCIPsetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Bool SCIPisInRestart(SCIP *scip)
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
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 SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
int SCIPgetDepth(SCIP *scip)
int SCIPgetNLeaves(SCIP *scip)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)
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 SCIPvarGetNUses(SCIP_VAR *var)
const char * SCIPvarGetName(SCIP_VAR *var)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
SCIP_Bool SCIPvarIsRelaxationOnly(SCIP_VAR *var)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
void SCIPsortPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
void SCIPprintSysError(const char *message)
int SCIPstrncasecmp(const char *s1, const char *s2, int length)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
void SCIProwPrint(SCIP_ROW *row, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
static const SCIP_Real scalars[]
internal methods for LP management
memory allocation routines
#define BMSreallocMemoryArray(ptr, num)
#define BMSduplicateMemoryArray(ptr, source, num)
#define BMSfreeMemoryNull(ptr)
#define BMSallocMemoryArray(ptr, num)
#define BMSfreeMemoryArray(ptr)
struct BMS_BlkMem BMS_BLKMEM
#define BMSfreeMemoryArrayNull(ptr)
#define BMSallocMemory(ptr)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
internal methods for storing and manipulating the main problem
struct SCIP_File SCIP_FILE
public methods for message output
public data structures and miscellaneous methods
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsRelEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasGT(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 SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
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 SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_DEBUGSOLDATA * SCIPsetGetDebugSolData(SCIP_SET *set)
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
internal methods for global SCIP settings
#define SCIPsetFreeBufferArray(set, ptr)
#define SCIPsetAllocBufferArray(set, ptr, num)
SCIP_BOUNDCHG * boundchgs
SCIP main data structure.
SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)
SCIP_Real SCIPtreeGetLowerbound(SCIP_TREE *tree, SCIP_SET *set)
internal methods for branch and bound tree
enum SCIP_BoundType SCIP_BOUNDTYPE
#define SCIP_DECL_SORTPTRCOMP(x)
#define SCIP_DECL_PROPEXEC(x)
enum SCIP_Result SCIP_RESULT
enum SCIP_Retcode SCIP_RETCODE
@ SCIP_STAGE_INITPRESOLVE
@ SCIP_STAGE_EXITPRESOLVE
@ SCIP_STAGE_TRANSFORMING
enum SCIP_Stage SCIP_STAGE
#define SCIP_PRESOLTIMING_FAST
#define SCIP_PROPTIMING_ALWAYS
@ SCIP_NODETYPE_PROBINGNODE
@ SCIP_VARTYPE_CONTINUOUS
@ SCIP_BOUNDCHGTYPE_BRANCHING
@ SCIP_VARSTATUS_ORIGINAL
SCIP_DOMCHGBOUND domchgbound
internal methods for problem variables
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