43 #define OBJSCALE_MAXDNOM 1000000LL 44 #define OBJSCALE_MAXSCALE 1000000.0 45 #define OBJSCALE_MAXFINALSCALE 1000.0 72 assert(num <= prob->varssize);
96 assert(num <= prob->fixedvarssize);
109 assert(prob != NULL);
120 assert(num <= prob->deletedvarssize);
133 assert(prob != NULL);
144 assert(num <= prob->consssize);
159 return (name != NULL && name[0] !=
'\0');
172 return (name != NULL && name[0] !=
'\0');
203 assert(prob != NULL);
205 assert(blkmem != NULL);
206 assert(sourcescip != NULL);
207 assert(sourceprob != NULL);
208 assert(varmap != NULL);
209 assert(consmap != NULL);
212 SCIP_CALL(
SCIPprobCreate(prob, blkmem,
set, name, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
FALSE) );
215 if( sourceprob->
probdata != NULL && sourceprob->probcopy != NULL )
217 SCIP_CALL( sourceprob->probcopy(set->scip, sourcescip, sourceprob->
probdata, varmap, consmap, &targetdata, global, &result) );
222 SCIPerrorMessage(
"probdata copying method returned invalid result <%d>\n", result);
231 assert( targetdata != NULL );
232 (*prob)->probdelorig = sourceprob->probdelorig;
233 (*prob)->probtrans = sourceprob->probtrans;
234 (*prob)->probdeltrans = sourceprob->probdeltrans;
235 (*prob)->probinitsol = sourceprob->probinitsol;
236 (*prob)->probexitsol = sourceprob->probexitsol;
237 (*prob)->probcopy = sourceprob->probcopy;
264 assert(prob != NULL);
269 (*prob)->probdata = probdata;
270 (*prob)->probcopy = probcopy;
271 (*prob)->probdelorig = probdelorig;
272 (*prob)->probtrans = probtrans;
273 (*prob)->probdeltrans = probdeltrans;
274 (*prob)->probinitsol = probinitsol;
275 (*prob)->probexitsol = probexitsol;
276 if( set->misc_usevartable )
280 SCIPhashGetKeyVar, SCIPhashKeyEqString, SCIPhashKeyValString, NULL) );
283 (*prob)->varnames = NULL;
284 (*prob)->vars = NULL;
285 (*prob)->varssize = 0;
287 (*prob)->nbinvars = 0;
288 (*prob)->nintvars = 0;
289 (*prob)->nimplvars = 0;
290 (*prob)->ncontvars = 0;
291 (*prob)->ncolvars = 0;
292 (*prob)->fixedvars = NULL;
293 (*prob)->fixedvarssize = 0;
294 (*prob)->nfixedvars = 0;
295 (*prob)->deletedvars = NULL;
296 (*prob)->deletedvarssize = 0;
297 (*prob)->ndeletedvars = 0;
298 (*prob)->nobjvars = 0;
299 if( set->misc_useconstable )
303 SCIPhashGetKeyCons, SCIPhashKeyEqString, SCIPhashKeyValString, NULL) );
306 (*prob)->consnames = NULL;
307 (*prob)->conss = NULL;
308 (*prob)->consssize = 0;
310 (*prob)->maxnconss = 0;
311 (*prob)->startnvars = 0;
312 (*prob)->startnconss = 0;
314 (*prob)->objoffset = 0.0;
315 (*prob)->objscale = 1.0;
318 (*prob)->objisintegral =
FALSE;
319 (*prob)->transformed = transformed;
320 (*prob)->nlpenabled =
FALSE;
321 (*prob)->permuted =
FALSE;
322 (*prob)->conscompression =
FALSE;
333 assert(prob != NULL);
335 prob->probdelorig = probdelorig;
344 assert(prob != NULL);
346 prob->probtrans = probtrans;
355 assert(prob != NULL);
357 prob->probdeltrans = probdeltrans;
366 assert(prob != NULL);
368 prob->probinitsol= probinitsol;
377 assert(prob != NULL);
379 prob->probexitsol= probexitsol;
388 assert(prob != NULL);
390 prob->probcopy= probcopy;
407 assert(prob != NULL);
408 assert(*prob != NULL);
412 while( (*prob)->nconss > 0 )
415 assert((*prob)->conss != NULL);
419 if( (*prob)->transformed )
424 for( h = 0; h <
set->nconshdlrs; ++h )
437 if( (*prob)->transformed )
439 if( (*prob)->probdeltrans != NULL )
441 SCIP_CALL( (*prob)->probdeltrans(set->scip, &(*prob)->probdata) );
446 if( (*prob)->probdelorig != NULL )
448 SCIP_CALL( (*prob)->probdelorig(set->scip, &(*prob)->probdata) );
453 for( v = (*prob)->nvars - 1; v >= 0; --v )
459 SCIPmessageFPrintWarning(messagehdlr,
"%s variable <%s> not released when freeing SCIP. Consider releasing variable first.\n",
460 (*prob)->transformed ?
"Transformed" :
"Original",
SCIPvarGetName((*prob)->vars[v]));
461 warnreleasevar =
FALSE;
470 for( v = (*prob)->nfixedvars - 1; v >= 0; --v )
476 SCIPmessageFPrintWarning(messagehdlr,
"%s variable <%s> not released when freeing SCIP. Consider releasing variable first.\n",
477 (*prob)->transformed ?
"Transformed" :
"Original",
SCIPvarGetName((*prob)->fixedvars[v]));
478 warnreleasevar =
FALSE;
489 if( (*prob)->varnames != NULL )
493 if( (*prob)->consnames != NULL )
528 assert(source != NULL);
529 assert(blkmem != NULL);
530 assert(target != NULL);
536 SCIP_CALL(
SCIPprobCreate(target, blkmem,
set, transname, source->probdelorig, source->probtrans, source->probdeltrans,
537 source->probinitsol, source->probexitsol, source->probcopy, NULL,
TRUE) );
550 for( v = 0; v < source->
nvars; ++v )
556 assert((*target)->nvars == source->
nvars);
560 if( source->probtrans != NULL )
562 SCIP_CALL( source->probtrans(set->scip, source->
probdata, &(*target)->probdata) );
565 (*target)->probdata = source->
probdata;
568 for( c = 0; c < source->nconss; ++c )
576 for( h = 0; h <
set->nconshdlrs; ++h )
596 (*target)->permuted = source->
permuted;
614 assert(prob != NULL);
617 for( v = 0; v < prob->
nvars; ++v )
653 assert(vars != NULL);
654 assert(nbinvars + nintvars + nimplvars + ncontvars == nvars);
656 SCIPdebugMessage(
"entering sorting with respect to original block structure! \n");
664 SCIPsortPtr((
void**)&vars[nbinvars], SCIPvarComp, nintvars);
668 SCIPsortPtr((
void**)&vars[nbinvars + nintvars], SCIPvarComp, nimplvars);
672 SCIPsortPtr((
void**)&vars[nbinvars + nintvars + nimplvars], SCIPvarComp, ncontvars);
675 for( v = 0; v < nvars; ++v )
677 vars[v]->probindex = v;
678 SCIPdebugMessage(
"Variable: Problem index <%d>, original index <%d> \n", vars[v]->probindex, vars[v]->index);
694 assert(prob != NULL);
711 assert(prob != NULL);
712 assert(prob->
vars != NULL);
723 insertpos = prob->
nvars;
725 implstart = intstart + prob->
nintvars;
732 if( insertpos > contstart )
734 prob->
vars[insertpos] = prob->
vars[contstart];
736 insertpos = contstart;
738 assert(insertpos == contstart);
744 if( insertpos > implstart )
746 prob->
vars[insertpos] = prob->
vars[implstart];
748 insertpos = implstart;
750 assert(insertpos == implstart);
757 if( insertpos > intstart )
759 prob->
vars[insertpos] = prob->
vars[intstart];
761 insertpos = intstart;
763 assert(insertpos == intstart);
778 prob->
vars[insertpos] = var;
802 assert(prob != NULL);
805 assert(prob->
vars != NULL);
809 implstart = intstart + prob->
nintvars;
838 if( freepos < intstart-1 )
841 prob->
vars[freepos] = prob->
vars[intstart-1];
843 freepos = intstart-1;
845 if( freepos < implstart-1 )
848 prob->
vars[freepos] = prob->
vars[implstart-1];
850 freepos = implstart-1;
852 if( freepos < contstart-1 )
855 prob->
vars[freepos] = prob->
vars[contstart-1];
857 freepos = contstart-1;
859 if( freepos < prob->nvars-1 )
864 freepos = prob->
nvars-1;
866 assert(freepos == prob->
nvars-1);
925 assert(prob != NULL);
937 if( var->
scip != set->scip )
963 SCIPsetDebugMsg(
set,
"added variable <%s> to problem (%d variables: %d binary, %d integer, %d implicit, %d continuous)\n",
978 if( set->reopt_enable || !set->misc_allowdualreds )
1002 assert(prob != NULL);
1003 assert(
set != NULL);
1004 assert(var != NULL);
1005 assert(deleted != NULL);
1026 SCIPsetDebugMsg(
set,
"deleting variable <%s> from problem (%d variables: %d binary, %d integer, %d implicit, %d continuous)\n",
1036 assert(eventqueue != NULL);
1067 assert(prob != NULL);
1068 assert(
set != NULL);
1075 for( i = 0; i <
set->nconshdlrs; ++i )
1135 assert(prob != NULL);
1136 assert(var != NULL);
1147 if( branchcand != NULL )
1162 if( branchcand != NULL )
1180 assert(prob != NULL);
1181 assert(var != NULL);
1254 if( currentcons == cons )
1273 assert(prob != NULL);
1274 assert(cons != NULL);
1280 if( cons->
scip != set->scip )
1286 SCIPsetDebugMsg(
set,
"adding constraint <%s> to global problem -> %d constraints\n",
1344 assert(prob != NULL);
1345 assert(blkmem != NULL);
1346 assert(cons != NULL);
1349 assert(prob->
conss != NULL);
1376 assert(prob->
conss[arraypos] != NULL);
1398 assert(prob != NULL);
1412 assert(prob != NULL);
1425 assert(prob != NULL);
1438 assert(prob != NULL);
1449 assert(prob != NULL);
1459 assert(prob != NULL);
1483 assert(transprob != NULL);
1484 assert(origprob != NULL);
1491 if( set->nactivepricers != 0 )
1499 for( v = 0; v < transprob->
nvars; ++v )
1518 if( v == transprob->
nvars )
1578 assert(prob != NULL);
1600 assert(transprob != NULL);
1601 assert(
set != NULL);
1604 if( set->nactivepricers != 0 )
1610 for( v = nints; v < transprob->
nvars; ++v )
1621 if( v == transprob->
nvars )
1631 for( v = 0; v < nints; ++v )
1636 &intscalar, &success) );
1638 SCIPsetDebugMsg(
set,
"integral objective scalar: success=%u, intscalar=%g\n", success, intscalar);
1644 assert(intscalar > 0.0);
1648 for( v = 0; v < nints && gcd != 1; ++v )
1662 else if( absobj > 0 )
1667 SCIPsetDebugMsg(
set,
"integral objective scalar: gcd=%" SCIP_LONGINT_FORMAT
", intscalar=%g\n", gcd, intscalar);
1676 for( v = 0; v < nints; ++v )
1690 for( v = 0; v < nints; ++v )
1725 assert(prob != NULL);
1730 for( v = 0; v < prob->
nvars; ++v )
1752 assert(prob != NULL);
1770 for( v = 0; v < prob->
nvars; ++v )
1777 var = prob->
vars[v];
1778 assert(var != NULL);
1785 assert(col != NULL);
1821 if( -lbrootredcost > ubrootredcost )
1823 rootredcost = lbrootredcost;
1828 rootredcost = ubrootredcost;
1857 assert(prob != NULL);
1859 assert(
set != NULL);
1862 for( c = 0; c < prob->
nconss; ++c )
1868 for( v = 0; v < prob->
nvars; ++v )
1872 if( prob->probinitsol != NULL )
1896 assert(prob != NULL);
1898 assert(
set != NULL);
1901 if( prob->probexitsol != NULL )
1909 for( v = 0; v < prob->
nvars; ++v )
1911 var = prob->
vars[v];
1939 assert(prob != NULL);
1960 int nimplbinvars = 0;
1968 return nimplbinvars;
1980 #ifdef SCIP_MORE_DEBUG 1986 for( v = prob->
nvars - 1; v >= 0; --v )
1993 assert(prob->
nobjvars == nobjvars);
2004 for( v = prob->
nvars - 1; v >= 0; --v )
2029 for( v = 0; v < prob->
nvars; v++ )
2056 for( v = 0; v < prob->
nvars; v++ )
2076 assert(
set != NULL);
2077 assert(origprob != NULL);
2078 assert(transprob != NULL);
2098 assert(
set != NULL);
2099 assert(origprob != NULL);
2100 assert(transprob != NULL);
2118 assert(prob != NULL);
2119 assert(name != NULL);
2123 SCIPerrorMessage(
"Cannot find variable if variable-names hashtable was disabled (due to parameter <misc/usevartable>)\n");
2137 assert(prob != NULL);
2138 assert(name != NULL);
2142 SCIPerrorMessage(
"Cannot find constraint if constraint-names hashtable was disabled (due to parameter <misc/useconstable>)\n");
2161 for( v = 0; v < prob->
nvars; ++v )
2163 var = prob->
vars[v];
2164 assert(var != NULL);
2180 assert(prob != NULL);
2183 SCIPmessageFPrintInfo(messagehdlr, file,
" Variables : %d (%d binary, %d integer, %d implicit integer, %d continuous)\n",
2186 SCIPmessageFPrintInfo(messagehdlr, file,
" Objective : %s, %d non-zeros (abs.min = %g, abs.max = %g)\n",
2200 #undef SCIPprobIsPermuted 2201 #undef SCIPprobMarkPermuted 2202 #undef SCIPprobIsTransformed 2203 #undef SCIPprobIsObjIntegral 2204 #undef SCIPprobAllColsInLP 2205 #undef SCIPprobGetObjlim 2206 #undef SCIPprobGetData 2207 #undef SCIPprobGetName 2208 #undef SCIPprobGetNVars 2209 #undef SCIPprobGetNBinVars 2210 #undef SCIPprobGetNIntVars 2211 #undef SCIPprobGetNImplVars 2212 #undef SCIPprobGetNContVars 2213 #undef SCIPprobGetNConss 2214 #undef SCIPprobGetVars 2215 #undef SCIPprobGetObjoffset 2216 #undef SCIPisConsCompressedEnabled 2217 #undef SCIPprobEnableConsCompression 2224 assert(prob != NULL);
2234 assert(prob != NULL);
2244 assert(prob != NULL);
2254 assert(prob != NULL);
2279 assert(prob != NULL);
2280 assert(
set != NULL);
2290 assert(prob != NULL);
2300 assert(prob != NULL);
2309 assert(prob != NULL);
2318 assert(prob != NULL);
2327 assert(prob != NULL);
2336 assert(prob != NULL);
2345 assert(prob != NULL);
2354 assert(prob != NULL);
2363 assert(prob != NULL);
2372 assert(prob != NULL);
2381 assert(prob != NULL);
2390 assert(prob != NULL);
2400 assert(prob != NULL);
enum SCIP_Result SCIP_RESULT
SCIP_Bool SCIPsetIsInfinity(SCIP_SET *set, SCIP_Real val)
internal methods for managing events
SCIP_VAR * SCIPprobFindVar(SCIP_PROB *prob, const char *name)
int SCIPprobGetNBinVars(SCIP_PROB *prob)
void SCIPvarUpdateBestRootSol(SCIP_VAR *var, SCIP_SET *set, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
SCIP_RETCODE SCIPlpUpdateAddVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
static void probInsertVar(SCIP_PROB *prob, SCIP_VAR *var)
void SCIPstatComputeRootLPBestEstimate(SCIP_STAT *stat, SCIP_SET *set, SCIP_Real rootlpobjval, SCIP_VAR **vars, int nvars)
SCIP_HASHTABLE * varnames
SCIP_RETCODE SCIPconsActivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat, int depth, SCIP_Bool focusnode)
#define BMSfreeMemoryArrayNull(ptr)
int SCIPprobGetNConss(SCIP_PROB *prob)
internal methods for branch and bound tree
SCIP_Bool SCIPprobIsConsCompressionEnabled(SCIP_PROB *prob)
void SCIPprobSetData(SCIP_PROB *prob, SCIP_PROBDATA *probdata)
SCIP_PROBDATA * SCIPprobGetData(SCIP_PROB *prob)
SCIP_RETCODE SCIPhashtableInsert(SCIP_HASHTABLE *hashtable, void *element)
void SCIPprobUpdateBestRootSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_Bool SCIPsetIsFeasEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
enum SCIP_BaseStat SCIP_BASESTAT
#define SCIP_DECL_PROBINITSOL(x)
void SCIPlpSetRootLPIsRelax(SCIP_LP *lp, SCIP_Bool isrelax)
SCIP_RETCODE SCIPeventqueueAdd(SCIP_EVENTQUEUE *eventqueue, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENT **event)
SCIP_RETCODE SCIPconflictstoreTransform(SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_REOPT *reopt)
#define SCIP_DECL_PROBDELORIG(x)
SCIP_BASESTAT SCIPcolGetBasisStatus(SCIP_COL *col)
SCIP_Real SCIPvarGetLbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPprobChgVarType(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BRANCHCAND *branchcand, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var, SCIP_VARTYPE vartype)
SCIP_RETCODE SCIPvarAddLocks(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, int addnlocksdown, int addnlocksup)
SCIP_RETCODE SCIPprobVarChangedStatus(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_BRANCHCAND *branchcand, SCIP_CLIQUETABLE *cliquetable, SCIP_VAR *var)
void SCIPprobAddObjoffset(SCIP_PROB *prob, SCIP_Real addval)
SCIP_Bool SCIPvarIsBinary(SCIP_VAR *var)
SCIP_Real SCIPsetInfinity(SCIP_SET *set)
SCIP_Longint nactiveconssadded
SCIP_Real SCIPvarGetSol(SCIP_VAR *var, SCIP_Bool getlpval)
int SCIPprobGetNVars(SCIP_PROB *prob)
#define SCIP_DECL_PROBDELTRANS(x)
void SCIPvarSetProbindex(SCIP_VAR *var, int probindex)
static SCIP_Bool consHasName(SCIP_CONS *cons)
SCIP_Bool SCIPlpIsSolBasic(SCIP_LP *lp)
SCIP_Bool SCIPsetIsFeasIntegral(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPvarTransform(SCIP_VAR *origvar, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_OBJSENSE objsense, SCIP_VAR **transvar)
int SCIPsnprintf(char *t, int len, const char *s,...)
SCIP_Bool SCIPsetIsZero(SCIP_SET *set, SCIP_Real val)
void SCIPprobSetExitsol(SCIP_PROB *prob, SCIP_DECL_PROBEXITSOL((*probexitsol)))
void SCIPprobMarkNConss(SCIP_PROB *prob)
enum SCIP_Retcode SCIP_RETCODE
SCIP_Real SCIPprobInternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
#define SCIPsetAllocBufferArray(set, ptr, num)
int SCIPvarGetProbindex(SCIP_VAR *var)
internal methods for branching rules and branching candidate storage
int SCIPsetCalcMemGrowSize(SCIP_SET *set, int num)
void SCIPvarInitSolve(SCIP_VAR *var)
SCIP_RETCODE SCIPprobInitSolve(SCIP_PROB *prob, SCIP_SET *set)
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_EVENTQUEUE *eventqueue)
void SCIPprobUpdateNObjVars(SCIP_PROB *prob, SCIP_SET *set, SCIP_Real oldobj, SCIP_Real newobj)
#define SCIP_DECL_PROBCOPY(x)
#define SCIPsetFreeBufferArray(set, ptr)
#define BMSfreeMemory(ptr)
SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)
internal methods for LP management
SCIP_Bool SCIPconsIsActive(SCIP_CONS *cons)
SCIP_RETCODE SCIPconsResetAge(SCIP_CONS *cons, SCIP_SET *set)
SCIP_HASHTABLE * consnames
internal methods for collecting primal CIP solutions and primal informations
SCIP_CONSSETCHG * addconssetchg
SCIP_RETCODE SCIPhashtableCreate(SCIP_HASHTABLE **hashtable, BMS_BLKMEM *blkmem, int tablesize, SCIP_DECL_HASHGETKEY((*hashgetkey)), SCIP_DECL_HASHKEYEQ((*hashkeyeq)), SCIP_DECL_HASHKEYVAL((*hashkeyval)), void *userptr)
void SCIPprobSetObjIntegral(SCIP_PROB *prob)
int SCIPlpGetNCols(SCIP_LP *lp)
SCIP_VAR * SCIPvarGetNegatedVar(SCIP_VAR *var)
void SCIPprobPrintPseudoSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr)
SCIP_RETCODE SCIPprobFree(SCIP_PROB **prob, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
void SCIPprobPrintStatistics(SCIP_PROB *prob, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)
SCIP_Real SCIPprobGetObjlim(SCIP_PROB *prob, SCIP_SET *set)
SCIP_RETCODE SCIPprobAddConsName(SCIP_PROB *prob, SCIP_CONS *cons)
void SCIPprobSetInitsol(SCIP_PROB *prob, SCIP_DECL_PROBINITSOL((*probinitsol)))
SCIP_Bool SCIPsetIsLT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Real SCIPprobGetObjscale(SCIP_PROB *prob)
static SCIP_RETCODE probEnsureVarsMem(SCIP_PROB *prob, SCIP_SET *set, int num)
SCIP_RETCODE SCIPvarChgType(SCIP_VAR *var, SCIP_VARTYPE vartype)
void SCIPprobSetCopy(SCIP_PROB *prob, SCIP_DECL_PROBCOPY((*probcopy)))
SCIP_Real SCIPvarGetImplRedcost(SCIP_VAR *var, SCIP_SET *set, SCIP_Bool varfixing, SCIP_STAT *stat, SCIP_PROB *prob, SCIP_LP *lp)
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)
static SCIP_RETCODE probEnsureDeletedvarsMem(SCIP_PROB *prob, SCIP_SET *set, int num)
SCIP_RETCODE SCIPprobRemoveVarName(SCIP_PROB *prob, SCIP_VAR *var)
void SCIPprobSetObjsense(SCIP_PROB *prob, SCIP_OBJSENSE objsense)
SCIP_Real SCIPcolGetPrimsol(SCIP_COL *col)
int SCIPprobGetNImplVars(SCIP_PROB *prob)
#define BMSfreeMemoryArray(ptr)
#define OBJSCALE_MAXFINALSCALE
internal methods for storing and manipulating the main problem
SCIP_RETCODE SCIPconsTransform(SCIP_CONS *origcons, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_CONS **transcons)
SCIP_Bool SCIPlpIsDualReliable(SCIP_LP *lp)
SCIP_RETCODE SCIPprobExitSolve(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Bool restart)
SCIP_CONS * SCIPprobFindCons(SCIP_PROB *prob, const char *name)
SCIP_RETCODE SCIPvarChgObj(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_PRIMAL *primal, SCIP_LP *lp, SCIP_EVENTQUEUE *eventqueue, SCIP_Real newobj)
void SCIPprobEnableConsCompression(SCIP_PROB *prob)
SCIP_RETCODE SCIPvarRelease(SCIP_VAR **var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)
SCIP_Bool SCIPvarIsTransformedOrigvar(SCIP_VAR *var)
SCIP_RETCODE SCIPeventCreateVarAdded(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_RETCODE SCIPconshdlrDelVars(SCIP_CONSHDLR *conshdlr, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
const char * SCIPconsGetName(SCIP_CONS *cons)
static SCIP_RETCODE probEnsureConssMem(SCIP_PROB *prob, SCIP_SET *set, int num)
const char * SCIPvarGetName(SCIP_VAR *var)
int SCIPprobGetNObjVars(SCIP_PROB *prob, SCIP_SET *set)
SCIP_RETCODE SCIPprobSetName(SCIP_PROB *prob, const char *name)
SCIP_Bool SCIPprobIsObjIntegral(SCIP_PROB *prob)
void SCIPsortPtr(void **ptrarray, SCIP_DECL_SORTPTRCOMP((*ptrcomp)), int len)
internal methods for global SCIP settings
internal methods for storing conflicts
void SCIPmessageFPrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
SCIP_RETCODE SCIPprobAddVarName(SCIP_PROB *prob, SCIP_VAR *var)
SCIP_RETCODE SCIPprobResetBounds(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
void SCIPmessagePrintInfo(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
SCIP_RETCODE SCIPhashtableRemove(SCIP_HASHTABLE *hashtable, void *element)
int SCIPprobGetNContVars(SCIP_PROB *prob)
SCIP_RETCODE SCIPconsAddLocks(SCIP_CONS *cons, SCIP_SET *set, int nlockspos, int nlocksneg)
SCIP_RETCODE SCIPprobCreate(SCIP_PROB **prob, BMS_BLKMEM *blkmem, SCIP_SET *set, const char *name, SCIP_DECL_PROBDELORIG((*probdelorig)), SCIP_DECL_PROBTRANS((*probtrans)), SCIP_DECL_PROBDELTRANS((*probdeltrans)), SCIP_DECL_PROBINITSOL((*probinitsol)), SCIP_DECL_PROBEXITSOL((*probexitsol)), SCIP_DECL_PROBCOPY((*probcopy)), SCIP_PROBDATA *probdata, SCIP_Bool transformed)
SCIP_Bool SCIPsetIsEQ(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_Bool conscompression
SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
void SCIPprobResortVars(SCIP_PROB *prob)
int SCIPprobGetNIntVars(SCIP_PROB *prob)
SCIP_Bool SCIPconshdlrNeedsCons(SCIP_CONSHDLR *conshdlr)
#define BMSduplicateMemoryArray(ptr, source, num)
SCIP_RETCODE SCIPconshdlrUnlockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
void SCIPvarSetBestRootSol(SCIP_VAR *var, SCIP_Real rootsol, SCIP_Real rootredcost, SCIP_Real rootlpobjval)
#define SCIP_DECL_PROBTRANS(x)
data structures and methods for collecting reoptimization information
internal methods for problem variables
SCIP_Bool SCIPsetIsIntegral(SCIP_SET *set, SCIP_Real val)
public data structures and miscellaneous methods
#define SCIP_DECL_PROBEXITSOL(x)
void SCIPvarCapture(SCIP_VAR *var)
SCIP_Bool SCIPprobIsPermuted(SCIP_PROB *prob)
SCIP_Real SCIPprobGetObjoffset(SCIP_PROB *prob)
enum SCIP_Objsense SCIP_OBJSENSE
SCIP_RETCODE SCIPvarRemove(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_Bool final)
SCIP_RETCODE SCIPconsRelease(SCIP_CONS **cons, BMS_BLKMEM *blkmem, SCIP_SET *set)
void SCIPvarStoreRootSol(SCIP_VAR *var, SCIP_Bool roothaslp)
void SCIPprobSetTrans(SCIP_PROB *prob, SCIP_DECL_PROBTRANS((*probtrans)))
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_EVENTQUEUE *eventqueue)
SCIP_RETCODE SCIPeventCreateVarDeleted(SCIP_EVENT **event, BMS_BLKMEM *blkmem, SCIP_VAR *var)
SCIP_Bool SCIPconsIsChecked(SCIP_CONS *cons)
SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)
SCIP_RETCODE SCIPprobRemoveConsName(SCIP_PROB *prob, SCIP_CONS *cons)
SCIP_Real SCIPvarGetObj(SCIP_VAR *var)
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_COL * SCIPvarGetCol(SCIP_VAR *var)
SCIP_RETCODE SCIPbranchcandUpdateVar(SCIP_BRANCHCAND *branchcand, SCIP_SET *set, SCIP_VAR *var)
SCIP_Real SCIPprobGetAbsMaxObjCoef(SCIP_PROB *prob, SCIP_SET *set)
void * SCIPhashtableRetrieve(SCIP_HASHTABLE *hashtable, void *key)
void SCIPprobSetObjlim(SCIP_PROB *prob, SCIP_Real objlim)
SCIP_RETCODE SCIPprobDelCons(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)
void SCIPprobStoreRootSol(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Bool roothaslp)
SCIP_Bool SCIPprobIsTransformed(SCIP_PROB *prob)
void SCIPhashtableFree(SCIP_HASHTABLE **hashtable)
#define SCIP_HASHSIZE_NAMES
SCIP_Bool SCIPsetIsDualfeasPositive(SCIP_SET *set, SCIP_Real val)
SCIP_RETCODE SCIPvarLoose(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp)
SCIP_Real SCIPprobGetAbsMinObjCoef(SCIP_PROB *prob, SCIP_SET *set)
SCIP_Real SCIPsetFeasFloor(SCIP_SET *set, SCIP_Real val)
void SCIPlpStoreRootObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)
void SCIPconsCapture(SCIP_CONS *cons)
struct SCIP_ProbData SCIP_PROBDATA
static SCIP_RETCODE probEnsureFixedvarsMem(SCIP_PROB *prob, SCIP_SET *set, int num)
static SCIP_RETCODE probRemoveVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_CLIQUETABLE *cliquetable, SCIP_SET *set, SCIP_VAR *var)
SCIP_RETCODE SCIPprobCopy(SCIP_PROB **prob, BMS_BLKMEM *blkmem, SCIP_SET *set, const char *name, SCIP *sourcescip, SCIP_PROB *sourceprob, SCIP_HASHMAP *varmap, SCIP_HASHMAP *consmap, SCIP_Bool global)
#define SCIP_HASHSIZE_NAMES_SMALL
public methods for message output
void SCIPprobUpdateDualbound(SCIP_PROB *prob, SCIP_Real newbound)
void SCIPprobSetDelorig(SCIP_PROB *prob, SCIP_DECL_PROBDELORIG((*probdelorig)))
void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)
SCIP_Bool SCIPsetIsGT(SCIP_SET *set, SCIP_Real val1, SCIP_Real val2)
SCIP_VARSTATUS SCIPvarGetStatus(SCIP_VAR *var)
SCIP_RETCODE SCIPvarResetBounds(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)
internal methods for problem statistics
void SCIPprobSetDualbound(SCIP_PROB *prob, SCIP_Real dualbound)
SCIP_VAR ** SCIPprobGetVars(SCIP_PROB *prob)
#define BMSallocMemory(ptr)
#define BMSreallocMemoryArray(ptr, num)
internal methods for constraints and constraint handlers
int SCIPvarGetNUses(SCIP_VAR *var)
SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)
SCIP_RETCODE SCIPprimalUpdateObjoffset(SCIP_PRIMAL *primal, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp)
SCIP_RETCODE SCIPcalcIntegralScalar(SCIP_Real *vals, int nvals, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Real *intscalar, SCIP_Bool *success)
int SCIPprobGetNImplBinVars(SCIP_PROB *prob)
SCIP_RETCODE SCIPbranchcandRemoveVar(SCIP_BRANCHCAND *branchcand, SCIP_VAR *var)
SCIP_VARTYPE SCIPvarGetType(SCIP_VAR *var)
SCIP_Bool SCIPhashtableExists(SCIP_HASHTABLE *hashtable, void *element)
void SCIPprobInvalidateDualbound(SCIP_PROB *prob)
void SCIPprobSetDeltrans(SCIP_PROB *prob, SCIP_DECL_PROBDELTRANS((*probdeltrans)))
SCIP_Real SCIPsetEpsilon(SCIP_SET *set)
SCIP_STAGE SCIPsetGetStage(SCIP_SET *set)
unsigned int updatedeactivate
enum SCIP_Vartype SCIP_VARTYPE
SCIP_Real SCIPprobExternObjval(SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_SET *set, SCIP_Real objval)
static SCIP_Bool varHasName(SCIP_VAR *var)
SCIP_Real SCIPvarGetUbLocal(SCIP_VAR *var)
SCIP_RETCODE SCIPprobAddCons(SCIP_PROB *prob, SCIP_SET *set, SCIP_STAT *stat, SCIP_CONS *cons)
SCIP_RETCODE SCIPconsDeactivate(SCIP_CONS *cons, SCIP_SET *set, SCIP_STAT *stat)
SCIP_Bool SCIPsetIsDualfeasNegative(SCIP_SET *set, SCIP_Real val)
void SCIPconsSetLocal(SCIP_CONS *cons, SCIP_Bool local)
SCIP_RETCODE SCIPprobDelVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var, SCIP_Bool *deleted)
common defines and data types used in all packages of SCIP
SCIP_RETCODE SCIPprobExitPresolve(SCIP_PROB *prob, SCIP_SET *set)
struct BMS_BlkMem BMS_BLKMEM
SCIP_RETCODE SCIPlpUpdateDelVar(SCIP_LP *lp, SCIP_SET *set, SCIP_VAR *var)
SCIP_Real SCIPvarGetPseudoSol(SCIP_VAR *var)
SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)
SCIP_Real SCIPlpGetColumnObjval(SCIP_LP *lp)
SCIP_Bool SCIPvarIsIntegral(SCIP_VAR *var)
SCIP_RETCODE SCIPconshdlrLockVars(SCIP_CONSHDLR *conshdlr, SCIP_SET *set)
const char * SCIPprobGetName(SCIP_PROB *prob)
SCIP_Longint SCIPcalcGreComDiv(SCIP_Longint val1, SCIP_Longint val2)
void SCIPprobMarkPermuted(SCIP_PROB *prob)
void SCIPvarMarkDeleted(SCIP_VAR *var)
#define OBJSCALE_MAXSCALE
SCIP_RETCODE SCIPprobAddVar(SCIP_PROB *prob, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTFILTER *eventfilter, SCIP_EVENTQUEUE *eventqueue, SCIP_VAR *var)