26 #if defined(_WIN32) || defined(_WIN64) 44 #ifdef SCIP_DEBUG_SOLUTION 46 #define SCIP_HASHSIZE_DEBUG 500 48 struct SCIP_DebugSolData
70 assert(debugsoldata !=
NULL);
74 (*debugsoldata)->solnames =
NULL;
75 (*debugsoldata)->solvals =
NULL;
76 (*debugsoldata)->nsolvals = 0;
77 (*debugsoldata)->solsize = 0;
78 (*debugsoldata)->debugsol =
NULL;
80 (*debugsoldata)->solinnode =
NULL;
81 (*debugsoldata)->falseptr =
FALSE;
82 (*debugsoldata)->trueptr =
TRUE;
83 (*debugsoldata)->solisachieved =
FALSE;
84 (*debugsoldata)->debugsolval = 0.0;
85 (*debugsoldata)->debugsoldisabled =
TRUE;
90 #ifdef SCIP_MORE_DEBUG 104 const char* solfilename,
125 assert(solfilename !=
NULL);
126 assert(names !=
NULL);
127 assert(*names ==
NULL);
128 assert(vals !=
NULL);
129 assert(*vals ==
NULL);
130 assert(nvals !=
NULL);
131 assert(valssize !=
NULL);
133 printf(
"***** debug: reading solution file <%s>\n", solfilename);
139 SCIPerrorMessage(
"cannot open solution file <%s> specified in scip/debug.h\n", solfilename);
147 unknownvariablemessage =
FALSE;
168 if( strncasecmp(buf,
"solution status:", 16) == 0 || strncasecmp(buf,
"objective value:", 16) == 0 ||
169 strncasecmp(buf,
"Log started", 11) == 0 || strncasecmp(buf,
"Variable Name", 13) == 0 ||
170 strncasecmp(buf,
"All other variables", 19) == 0 || strncasecmp(buf,
"\n", 1) == 0 ||
171 strncasecmp(buf,
"NAME", 4) == 0 || strncasecmp(buf,
"ENDATA", 6) == 0 )
177 nread = sscanf(buf,
"%s %s %s\n", name, valuestring, objstring);
180 printf(
"invalid input line %d in solution file <%s>: <%s>\n", *nvals + nonvalues, SCIP_DEBUG_SOLUTION, name);
189 if( !unknownvariablemessage )
192 name, *nvals + nonvalues, SCIP_DEBUG_SOLUTION);
194 unknownvariablemessage =
TRUE;
200 if( strncasecmp(valuestring,
"inv", 3) == 0 )
202 else if( strncasecmp(valuestring,
"+inf", 4) == 0 || strncasecmp(valuestring,
"inf", 3) == 0 )
204 else if( strncasecmp(valuestring,
"-inf", 4) == 0 )
208 nread = sscanf(valuestring,
"%lf", &val);
211 SCIPerrorMessage(
"Invalid solution value <%s> for variable <%s> in line %d of solution file <%s>.\n",
212 valuestring, name, *nvals + nonvalues, SCIP_DEBUG_SOLUTION);
219 if( *nvals >= *valssize )
221 *valssize =
MAX(2 * *valssize, (*nvals)+1);
225 assert(*nvals < *valssize);
228 for( i = *nvals; i > 0 && strcmp(name, (*names)[i-1]) < 0; --i )
230 (*names)[i] = (*names)[i-1];
231 (*vals)[i] = (*vals)[i-1];
234 SCIPdebugMsg(set->scip,
"found variable <%s>: value <%g>\n", (*names)[i], val);
247 for( i = 0; i < *nvals; ++i)
254 solvalues[nfound] = (*vals)[i];
259 SCIPdebugMsg(set->scip,
"Debug Solution value is %g.\n", debugsolval);
261 #ifdef SCIP_MORE_DEBUG 264 for( i = 0; i < nfound - 1; ++i)
270 if( debugsolptr !=
NULL )
283 if( debugsolptr !=
NULL )
284 *debugsolptr = debugsol;
286 if( debugsolvalptr !=
NULL )
287 *debugsolvalptr = debugsolval;
292 printf(
"***** debug: read %d non-zero entries (%d variables found)\n", *nvals, nfound);
309 if( debugsoldata ==
NULL || debugsoldata->nsolvals > 0 )
312 SCIP_CALL( readSolfile(
set, SCIP_DEBUG_SOLUTION, &debugsoldata->debugsol, &debugsoldata->debugsolval,
313 &debugsoldata->debugsolstage, &(debugsoldata->solnames), &(debugsoldata->solvals), &(debugsoldata->nsolvals),
314 &(debugsoldata->solsize)) );
342 assert(debugsoldata !=
NULL);
345 if( debugsoldata->debugsoldisabled )
352 SCIPsetDebugMsg(
set,
"Now handling variable <%s>, which has status %d, is of type %d, and was deleted: %d, negated: %d, transformed: %d\n",
396 right = debugsoldata->nsolvals-1;
397 while( left <= right )
399 middle = (left+right)/2;
400 cmp = strcmp(name, debugsoldata->solnames[middle]);
407 *val = scalar * debugsoldata->solvals[middle] + constant;
438 assert(scip !=
NULL);
444 if( debugsoldata->debugsol ==
NULL )
450 *sol = debugsoldata->debugsol;
483 assert(debugsoldata !=
NULL);
485 if( debugsoldata->solisachieved )
491 assert(scip !=
NULL);
495 if( bestsol !=
NULL )
510 debugsoldata->solisachieved =
TRUE;
513 return debugsoldata->solisachieved;
529 assert(blkmem !=
NULL);
530 assert(node !=
NULL);
531 assert(solcontained !=
NULL);
535 assert(debugsoldata !=
NULL);
537 if( debugsoldata ->debugsoldisabled )
539 *solcontained =
FALSE;
544 if( debugsoldata->solinnode ==
NULL )
551 if( boolptr !=
NULL )
553 if( boolptr != &debugsoldata->falseptr && boolptr != &debugsoldata->trueptr )
559 *solcontained = *boolptr;
564 *solcontained =
TRUE;
567 SCIP_CALL( isSolutionInNode(blkmem,
set, node->
parent, solcontained) );
581 for( i = 0; i < (int)domchgbound->
nboundchgs && *solcontained; ++i )
586 SCIP_CALL( getSolutionValue(
set, boundchgs[i].var, &varsol) );
598 SCIPerrorMessage(
"debugging solution was cut off in local node %p at depth %d by inference <%s>[%.15g] %s %.15g\n",
607 *solcontained =
FALSE;
614 SCIP_CALL(
SCIPhashmapSetImage(debugsoldata->solinnode, (
void*)node, *solcontained ? (
void*)(&debugsoldata->trueptr) : (
void*)(&debugsoldata->falseptr)) );
627 assert(debugsoldata !=
NULL);
648 assert(debugsoldata !=
NULL);
650 if( debugsoldata->solinnode !=
NULL )
669 assert(debugsoldata !=
NULL);
671 for( s = debugsoldata->nsolvals - 1; s >= 0; --s )
677 debugsoldata->nsolvals = 0;
678 debugsoldata->debugsolval= 0.0;
679 debugsoldata->solisachieved =
FALSE;
681 if( debugsoldata->solinnode !=
NULL)
689 set->debugsoldata =
NULL;
713 assert(conss !=
NULL || nconss == 0);
714 assert(debugsoldata->debugsol !=
NULL);
719 if( debugSolIsAchieved(scip->
set) )
725 for( c = nconss - 1; c >= 0; --c )
727 assert(conss[c] !=
NULL);
779 assert(debugsoldata !=
NULL);
782 if( debugsoldata->debugsoldisabled )
786 if( debugSolIsAchieved(
set) )
807 maxactivity = minactivity;
808 for( i = 0; i < nnonz; ++i )
814 SCIP_CALL( getSolutionValue(
set, var, &solval) );
818 minactivity += vals[i] * solval;
819 maxactivity += vals[i] * solval;
821 else if( vals[i] > 0.0 )
826 else if( vals[i] < 0.0 )
832 SCIPsetDebugMsg(
set,
"debugging solution on row <%s>: %g <= [%g,%g] <= %g\n",
838 printf(
"***** debug: row <%s> violates debugging solution (lhs=%.15g, rhs=%.15g, activity=[%.15g,%.15g], local=%d)\n",
846 for( i = 0; i < nnonz; ++i )
852 printf(
" <= %.15g\n", rhs);
869 assert(scip !=
NULL);
877 if( debugSolIsAchieved(scip->
set) )
904 assert(scip !=
NULL);
910 if( debugsoldata->debugsoldisabled )
914 if( debugSolIsAchieved(scip->
set) )
946 assert(blkmem !=
NULL);
947 assert(node !=
NULL);
955 assert(debugsoldata !=
NULL);
958 if( debugsoldata->debugsoldisabled )
962 if( debugSolIsAchieved(
set) )
966 SCIP_CALL( isSolutionInNode(blkmem,
set, node, &solcontained) );
971 SCIP_CALL( getSolutionValue(
set, var, &varsol) );
1000 assert(
set !=
NULL);
1001 assert(blkmem !=
NULL);
1002 assert(node !=
NULL);
1005 assert(debugsoldata !=
NULL);
1008 if( debugsoldata->debugsoldisabled )
1012 if( debugSolIsAchieved(
set) )
1020 solisinnode =
FALSE;
1022 SCIP_CALL( isSolutionInNode(blkmem,
set, node, &solisinnode) );
1026 SCIPerrorMessage(
"debugging solution was cut off in local node #%" SCIP_LONGINT_FORMAT
" (%p) at depth %d\n",
1033 if( debugsoldata->solinnode !=
NULL )
1056 assert(
set !=
NULL);
1057 assert(var !=
NULL);
1060 assert(debugsoldata !=
NULL);
1063 if( debugsoldata->debugsoldisabled )
1067 if( debugSolIsAchieved(
set) )
1071 SCIP_CALL( getSolutionValue(
set, var, &varsol) );
1072 SCIP_CALL( getSolutionValue(
set, vbvar, &vbvarsol) );
1077 vb = vbcoef * vbvarsol + vbconstant;
1081 SCIPerrorMessage(
"invalid variable bound: <%s>[%.15g] %s %.15g<%s>[%.15g] %+.15g\n",
1104 assert(
set !=
NULL);
1105 assert(var !=
NULL);
1109 assert(debugsoldata !=
NULL);
1112 if( debugsoldata->debugsoldisabled )
1116 if( debugSolIsAchieved(
set) )
1120 SCIP_CALL( getSolutionValue(
set, var, &solval) );
1126 if( (solval > 0.5) != varfixing )
1130 SCIP_CALL( getSolutionValue(
set, implvar, &solval) );
1138 SCIPerrorMessage(
"invalid implication <%s> == %d -> <%s> >= %.15g (variable has value %.15g in solution)\n",
1147 SCIPerrorMessage(
"invalid implication <%s> == %d -> <%s> <= %.15g (variable has value %.15g in solution)\n",
1170 assert(
set !=
NULL);
1171 assert(vars !=
NULL);
1174 assert(debugsoldata !=
NULL);
1177 if( debugsoldata->debugsoldisabled )
1181 if( debugSolIsAchieved(
set) )
1187 for( v = 0; v < nvars; ++v )
1189 assert(vars[v] !=
NULL);
1193 SCIP_CALL( getSolutionValue(
set, vars[v], &solval) );
1201 if( values !=
NULL && values[v] == 0 )
1202 solval = 1.0 - solval;
1221 SCIPerrorMessage(
"clique violates debugging solution, (at least) variable <%s%s> and variable <%s%s> are both one in the debugging solution\n",
1246 for( i = 0; i < nbdchginfos; ++i )
1252 bdchginfo = bdchginfos[i];
1253 assert(bdchginfo !=
NULL);
1256 assert(var !=
NULL);
1258 if( relaxedbds !=
NULL )
1259 newbound = relaxedbds[i];
1263 SCIP_CALL( getSolutionValue(
set, var, &solval) );
1335 for( i = 0; i < nbdchginfos; ++i )
1339 bdchginfo = bdchginfos[i];
1340 assert(bdchginfo !=
NULL);
1361 assert(
set !=
NULL);
1362 assert(blkmem !=
NULL);
1363 assert(node !=
NULL);
1364 assert(nbdchginfos == 0 || bdchginfos !=
NULL);
1367 assert(debugsoldata !=
NULL);
1370 if( debugsoldata->debugsoldisabled )
1374 if( debugSolIsAchieved(
set) )
1378 SCIP_CALL( isSolutionInNode(blkmem,
set, node, &solcontained) );
1383 if( debugCheckBdchginfos(
set, bdchginfos, relaxedbds, nbdchginfos) )
1389 SCIP_CALL( printBdchginfos(
set, bdchginfos, relaxedbds, nbdchginfos) );
1415 int nforcedbdchgqueued;
1417 assert(
set !=
NULL);
1418 assert(blkmem !=
NULL);
1419 assert(node !=
NULL);
1420 assert(nbdchginfos == 0 || bdchginfos !=
NULL);
1423 assert(debugsoldata !=
NULL);
1426 if( debugsoldata->debugsoldisabled )
1430 if( debugSolIsAchieved(
set) )
1434 SCIP_CALL( isSolutionInNode(blkmem,
set, node, &solcontained) );
1439 if( debugCheckBdchginfos(
set, bdchginfos, relaxedbds, nbdchginfos) )
1447 if( debugCheckBdchginfos(
set, bdchgqueued,
NULL, nbdchgqueued) )
1455 if( debugCheckBdchginfos(
set, forcedbdchgqueued,
NULL, nforcedbdchgqueued) )
1460 if( bdchginfo !=
NULL )
1462 printf(
" (after resolving bound change ");
1469 SCIP_CALL( printBdchginfos(
set, bdchginfos, relaxedbds, nbdchginfos) );
1472 SCIP_CALL( printBdchginfos(
set, bdchgqueued,
NULL, nbdchgqueued) );
1475 SCIP_CALL( printBdchginfos(
set, forcedbdchgqueued,
NULL, nforcedbdchgqueued) );
1493 *isvalidinsubtree =
FALSE;
1498 assert(debugsoldata !=
NULL);
1501 if( debugsoldata->debugsoldisabled )
1505 if( debugSolIsAchieved(scip->
set) )
1512 *isvalidinsubtree =
TRUE;
1522 assert(scip !=
NULL);
1533 assert(scip !=
NULL);
1537 assert(debugsoldata !=
NULL);
1539 debugsoldata->debugsoldisabled =
FALSE;
1548 assert(scip !=
NULL);
1552 assert(debugsoldata !=
NULL);
1554 debugsoldata->debugsoldisabled =
TRUE;
1563 assert(scip !=
NULL);
1567 assert(debugsoldata !=
NULL);
1569 return (!debugsoldata->debugsoldisabled);
1580 assert(scip !=
NULL);
1581 assert(result !=
NULL);
1586 if( !SCIPdebugIsMainscip(scip) )
1593 if( debugSolIsAchieved(scip->
set) )
1604 for( i = 0; i < nvars; ++i )
1612 SCIP_CALL( getSolutionValue(scip->
set, vars[i], &solval) );
1623 SCIPerrorMessage(
"solution value %.15g of <%s> outside bounds loc=[%.15g,%.15g], glb=[%.15g,%.15g]\n",
1643 assert(scip !=
NULL);
1647 SCIP_PROPTIMING_ALWAYS, 99999999, 0,
SCIP_PRESOLTIMING_FAST,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
1664 const char* varname;
1667 assert(scip !=
NULL);
1668 assert(var !=
NULL);
1672 assert(debugsoldata !=
NULL);
1678 if( debugsoldata->debugsol ==
NULL )
1685 if( debugsoldata->nsolvals >= debugsoldata->solsize )
1687 debugsoldata->solsize =
MAX(2*debugsoldata->solsize, debugsoldata->nsolvals+1);
1691 assert(debugsoldata->nsolvals < debugsoldata->solsize);
1695 for( i = debugsoldata->nsolvals; i > 0 && strcmp(varname, debugsoldata->solnames[i-1]) < 0; --i )
1697 debugsoldata->solnames[i] = debugsoldata->solnames[i-1];
1698 debugsoldata->solvals[i] = debugsoldata->solvals[i-1];
1700 if( i > 0 && strcmp(varname, debugsoldata->solnames[i-1]) == 0 )
1702 if(
REALABS(debugsoldata->solvals[i-1] - val) > 1e-9 )
1704 SCIPerrorMessage(
"already have stored different debugging solution value (%g) for variable <%s>, cannot store %g\n", debugsoldata->solvals[i-1], varname, val);
1709 SCIPdebugMsg(scip,
"already have stored debugging solution value %g for variable <%s>, do not store same value again\n", val, varname);
1710 for( ; i < debugsoldata->nsolvals; ++i )
1712 debugsoldata->solnames[i] = debugsoldata->solnames[i+1];
1713 debugsoldata->solvals[i] = debugsoldata->solvals[i+1];
1721 SCIPdebugMsg(scip,
"add variable <%s>: value <%g>\n", debugsoldata->solnames[i], val);
1722 debugsoldata->solvals[i] = val;
1723 debugsoldata->nsolvals++;
1726 debugsoldata->debugsolval += debugsoldata->solvals[i] *
SCIPvarGetObj(var);
1727 SCIPdebugMsg(scip,
"Debug Solution value is now %g.\n", debugsoldata->debugsolval);
1756 #ifdef SCIP_DEBUG_LP_INTERFACE 1774 assert(scip !=
NULL);
1784 for( k = 0; k < nrows; ++k )
1798 for( i = 0; i < nrows; ++i )
1801 vecval += coef[i] * matrixval;
1813 assert( idx >= 0 && idx < nrows );
enum SCIP_Result SCIP_RESULT
enum SCIP_BoundType SCIP_BOUNDTYPE
SCIP_Bool SCIPisFeasZero(SCIP *scip, SCIP_Real val)
int SCIPpqueueNElems(SCIP_PQUEUE *pqueue)
SCIP_Bool SCIPsetIsLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPsetIsFeasZero(SCIP_SET *set, SCIP_Real val)
SCIP_Bool SCIPisFeasEQ(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPlpDiving(SCIP_LP *lp)
SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)
SCIP_STAGE SCIPgetStage(SCIP *scip)
#define SCIPdebugRemoveNode(blkmem, set, node)
#define BMSfreeMemoryArrayNull(ptr)
internal methods for branch and bound tree
SCIP_Longint SCIPgetNLPIterations(SCIP *scip)
SCIP_Bool SCIPisFeasLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define SCIPdebugFreeDebugData(set)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_VAR * SCIPbdchginfoGetVar(SCIP_BDCHGINFO *bdchginfo)
SCIP_Real SCIPvarGetLbGlobal(SCIP_VAR *var)
SCIP_BOUNDCHG * boundchgs
int SCIProwGetNNonz(SCIP_ROW *row)
#define SCIPdebugCheckImplic(set, var, varfixing, implvar, impltype, implbound)
int SCIPgetNOrigVars(SCIP *scip)
#define SCIPdebugSolDataCreate(debugsoldata)
const char * SCIProwGetName(SCIP_ROW *row)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_BOUNDTYPE SCIPboundchgGetBoundtype(SCIP_BOUNDCHG *boundchg)
#define SCIPdebugCheckClique(set, vars, values, nvars)
SCIP_Real SCIProwGetLhs(SCIP_ROW *row)
SCIP_RETCODE SCIPhashmapCreate(SCIP_HASHMAP **hashmap, BMS_BLKMEM *blkmem, int mapsize)
#define SCIPdebugCheckRow(set, row)
enum SCIP_Retcode SCIP_RETCODE
SCIP_Real SCIPvarGetNegationConstant(SCIP_VAR *var)
SCIP_VAR ** SCIPgetOrigVars(SCIP *scip)
#define BMSallocMemoryArray(ptr, num)
SCIP_MESSAGEHDLR * SCIPgetMessagehdlr(SCIP *scip)
void * SCIPhashmapGetImage(SCIP_HASHMAP *hashmap, void *origin)
int SCIPnodeGetDepth(SCIP_NODE *node)
#define SCIPfreeBufferArray(scip, ptr)
#define SCIP_DECL_PROPEXEC(x)
#define SCIPdebugCheckVbound(set, var, vbtype, vbvar, vbcoef, vbconstant)
SCIP_VAR * SCIPvarGetNegationVar(SCIP_VAR *var)
internal methods for LP management
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_RETCODE SCIPcreateOrigSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)
#define SCIP_PRESOLTIMING_FAST
SCIP_Bool SCIPsetIsGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
#define SCIPdebugCheckConflict(blkmem, set, node, bdchginfos, relaxedbds, nliterals)
SCIP_VAR * SCIPfindVar(SCIP *scip, const char *name)
SCIP_FILE * SCIPfopen(const char *path, const char *mode)
struct SCIP_DebugSolData SCIP_DEBUGSOLDATA
SCIP_Real SCIPvarGetUbGlobal(SCIP_VAR *var)
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)
#define SCIPdebugIncludeProp(scip)
#define BMSfreeMemoryArray(ptr)
internal methods for storing and manipulating the main problem
SCIP_Bool SCIPisLT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
#define SCIPdebugCheckInference(blkmem, set, node, var, newbound, boundtype)
SCIP_Bool SCIProwIsLocal(SCIP_ROW *row)
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
int SCIPfeof(SCIP_FILE *stream)
BMS_BLKMEM * SCIPblkmem(SCIP *scip)
SCIP_RETCODE SCIPcheckCons(SCIP *scip, SCIP_CONS *cons, SCIP_SOL *sol, SCIP_Bool checkintegrality, SCIP_Bool checklprows, SCIP_Bool printreason, SCIP_RESULT *result)
struct SCIP_File SCIP_FILE
char * SCIPfgets(char *s, int size, SCIP_FILE *stream)
const char * SCIPconsGetName(SCIP_CONS *cons)
const char * SCIPvarGetName(SCIP_VAR *var)
void SCIPhashmapFree(SCIP_HASHMAP **hashmap)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
#define SCIP_PROPTIMING_ALWAYS
int SCIPgetNLPRows(SCIP *scip)
internal methods for global SCIP settings
SCIP main data structure.
SCIP_Bool SCIPsetIsFeasGE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool SCIPisFeasGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIProwGetRhs(SCIP_ROW *row)
void SCIPverbMessage(SCIP *scip, SCIP_VERBLEVEL msgverblevel, FILE *file, const char *formatstr,...)
void SCIPdummyDebugMethodForSun(void)
SCIP_Bool SCIPconsIsLocal(SCIP_CONS *cons)
#define SCIPdebugCheckBInvRow(scip, r, coef)
#define SCIPdebugCheckLbGlobal(scip, var, lb)
#define SCIPdebugGetSolVal(scip, var, val)
void SCIProwPrint(SCIP_ROW *row, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
SCIP_Bool SCIPsetIsFeasLE(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_COL ** SCIProwGetCols(SCIP_ROW *row)
#define SCIPdebugCheckUbGlobal(scip, var, ub)
#define BMSduplicateMemoryArray(ptr, source, num)
#define SCIPdebugCheckConss(scip, conss, nconss)
internal methods for problem variables
#define SCIPallocBufferArray(scip, ptr, num)
SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)
SCIP_Real * SCIProwGetVals(SCIP_ROW *row)
public data structures and miscellaneous methods
SCIP_BOUNDCHGTYPE SCIPboundchgGetBoundchgtype(SCIP_BOUNDCHG *boundchg)
void SCIPprintSysError(const char *message)
SCIP_RETCODE SCIPhashmapRemoveAll(SCIP_HASHMAP *hashmap)
int SCIPgetDepth(SCIP *scip)
#define SCIPdebugSolIsValidInSubtree(scip, isvalidinsubtree)
#define SCIPdebugCheckConflictFrontier(blkmem, set, node, bdchginfo, bdchginfos, relaxedbds, nliterals, bdchgqueue, forcedbdchgqueue)
SCIP_RETCODE SCIPfreeSol(SCIP *scip, SCIP_SOL **sol)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
SCIP_Real SCIPbdchginfoGetNewbound(SCIP_BDCHGINFO *bdchginfo)
void ** SCIPpqueueElems(SCIP_PQUEUE *pqueue)
SCIP_RETCODE SCIPfixVar(SCIP *scip, SCIP_VAR *var, SCIP_Real fixedval, SCIP_Bool *infeasible, SCIP_Bool *fixed)
SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)
SCIP_Real SCIPgetSolOrigObj(SCIP *scip, SCIP_SOL *sol)
SCIP_RETCODE SCIPvarGetOrigvarSum(SCIP_VAR **var, SCIP_Real *scalar, SCIP_Real *constant)
SCIP_Bool SCIPsetIsFeasLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIProwGetConstant(SCIP_ROW *row)
#define SCIPdebugReset(set)
SCIP_DOMCHGBOUND domchgbound
SCIP_RETCODE SCIPhashmapRemove(SCIP_HASHMAP *hashmap, void *origin)
SCIP_SOL * SCIPgetBestSol(SCIP *scip)
SCIP_Bool SCIPisGT(SCIP *scip, SCIP_Real val1, SCIP_Real val2)
SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)
#define SCIP_DECL_SORTPTRCOMP(x)
#define BMSfreeMemoryNull(ptr)
public methods for message output
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_RETCODE SCIPhashmapSetImage(SCIP_HASHMAP *hashmap, void *origin, void *image)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
#define SCIPdebugSolDisable(scip)
SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)
enum SCIP_Stage SCIP_STAGE
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_DEBUGSOLDATA * SCIPsetGetDebugSolData(SCIP_SET *set)
#define BMSallocMemory(ptr)
#define BMSreallocMemoryArray(ptr, num)
void SCIPsortPtrReal(void **ptrarray, SCIP_Real *realarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
#define SCIPdebugAddSolVal(scip, var, val)
SCIP_Bool SCIPsetIsFeasGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_OBJSENSE SCIPgetObjsense(SCIP *scip)
SCIP_RETCODE SCIPsetSolVals(SCIP *scip, SCIP_SOL *sol, int nvars, SCIP_VAR **vars, SCIP_Real *vals)
#define SCIPdebugSolIsEnabled(scip)
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
int SCIPconsGetActiveDepth(SCIP_CONS *cons)
SCIP_Bool SCIPvarIsTransformed(SCIP_VAR *var)
SCIP_BOUNDTYPE SCIPbdchginfoGetBoundtype(SCIP_BDCHGINFO *bdchginfo)
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPlpiGetCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real *val)
struct BMS_BlkMem BMS_BLKMEM
int SCIPfclose(SCIP_FILE *fp)
#define SCIPdebugSolEnable(scip)
SCIP_Bool SCIPvarIsDeleted(SCIP_VAR *var)
#define SCIPdebugFreeSol(set)
SCIP_Bool SCIPvarIsNegated(SCIP_VAR *var)
memory allocation routines