RetroSearch Browse

SCIP_RETCODE SCIPconflictAnalyzeLP(SCIP_CONFLICT *conflict, SCIP_CONFLICTSTORE *conflictstore, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_TREE *tree, SCIP_REOPT *reopt, SCIP_LP *lp, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool *success)

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 SCIPdebugCheckBInvRow(scip, r, coef)

#define SCIP_CALL_ABORT(x)

SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)

SCIP_Real SCIPgetColRedcost(SCIP *scip, SCIP_COL *col)

SCIP_VAR * SCIPcolGetVar(SCIP_COL *col)

SCIP_Real SCIPgetColFarkasCoef(SCIP *scip, SCIP_COL *col)

void SCIPmarkColNotRemovableLocal(SCIP *scip, SCIP_COL *col)

SCIP_RETCODE SCIPchgVarLbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

SCIP_RETCODE SCIPchgVarUbDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newbound)

SCIP_RETCODE SCIPchgCutoffboundDive(SCIP *scip, SCIP_Real newcutoffbound)

SCIP_RETCODE SCIPchgRowLhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newlhs)

SCIP_RETCODE SCIPaddRowDive(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIPgetVarLbDive(SCIP *scip, SCIP_VAR *var)

SCIP_Real SCIPgetVarUbDive(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPchgRowRhsDive(SCIP *scip, SCIP_ROW *row, SCIP_Real newrhs)

SCIP_Real SCIPgetVarObjDive(SCIP *scip, SCIP_VAR *var)

SCIP_RETCODE SCIPstartDive(SCIP *scip)

SCIP_RETCODE SCIPgetLPDualDegeneracy(SCIP *scip, SCIP_Real *degeneracy, SCIP_Real *varconsratio)

SCIP_RETCODE SCIPchgVarObjDive(SCIP *scip, SCIP_VAR *var, SCIP_Real newobj)

SCIP_RETCODE SCIPsolveDiveLP(SCIP *scip, int itlim, SCIP_Bool *lperror, SCIP_Bool *cutoff)

SCIP_RETCODE SCIPendDive(SCIP *scip)

SCIP_Bool SCIPinDive(SCIP *scip)

SCIP_Longint SCIPgetLastDivenode(SCIP *scip)

SCIP_RETCODE SCIPflushLP(SCIP *scip)

SCIP_Bool SCIPhasCurrentNodeLP(SCIP *scip)

SCIP_Real SCIPgetLPLooseObjval(SCIP *scip)

SCIP_RETCODE SCIPconstructLP(SCIP *scip, SCIP_Bool *cutoff)

SCIP_Bool SCIPisLPRelax(SCIP *scip)

SCIP_RETCODE SCIPprintLPSolutionQuality(SCIP *scip, FILE *file)

SCIP_Bool SCIPisLPPrimalReliable(SCIP *scip)

SCIP_Bool SCIPisLPConstructed(SCIP *scip)

SCIP_RETCODE SCIPgetLPBasisInd(SCIP *scip, int *basisind)

SCIP_RETCODE SCIPgetLPBInvACol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)

SCIP_RETCODE SCIPgetLPColsData(SCIP *scip, SCIP_COL ***cols, int *ncols)

SCIP_RETCODE SCIPgetLPRowsData(SCIP *scip, SCIP_ROW ***rows, int *nrows)

SCIP_ROW ** SCIPgetLPRows(SCIP *scip)

SCIP_Real SCIPgetPseudoObjval(SCIP *scip)

SCIP_RETCODE SCIPcomputeLPRelIntPoint(SCIP *scip, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_SOL **point)

void SCIPresetLPFeastol(SCIP *scip)

SCIP_Real SCIPgetLPColumnObjval(SCIP *scip)

int SCIPgetNLPRows(SCIP *scip)

SCIP_RETCODE SCIPsumLPRows(SCIP *scip, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)

SCIP_RETCODE SCIPgetLPI(SCIP *scip, SCIP_LPI **lpi)

SCIP_RETCODE SCIPgetLPBInvARow(SCIP *scip, int r, SCIP_Real *binvrow, SCIP_Real *coefs, int *inds, int *ninds)

SCIP_Real SCIPgetGlobalPseudoObjval(SCIP *scip)

SCIP_LPSOLSTAT SCIPgetLPSolstat(SCIP *scip)

SCIP_COL ** SCIPgetLPCols(SCIP *scip)

SCIP_Real SCIPgetLPRootObjval(SCIP *scip)

SCIP_RETCODE SCIPwriteMIP(SCIP *scip, const char *filename, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_Bool lazyconss)

SCIP_Bool SCIPallColsInLP(SCIP *scip)

SCIP_Real SCIPgetLPRootColumnObjval(SCIP *scip)

SCIP_Real SCIPgetLPObjval(SCIP *scip)

void SCIPsetLPFeastol(SCIP *scip, SCIP_Real newfeastol)

SCIP_Real SCIPgetLPFeastol(SCIP *scip)

int SCIPgetNUnfixedLPCols(SCIP *scip)

int SCIPgetNLPCols(SCIP *scip)

SCIP_RETCODE SCIPgetLPBInvCol(SCIP *scip, int c, SCIP_Real *coefs, int *inds, int *ninds)

SCIP_RETCODE SCIPwriteLP(SCIP *scip, const char *filename)

SCIP_Bool SCIPisLPSolBasic(SCIP *scip)

SCIP_RETCODE SCIPgetLPBInvRow(SCIP *scip, int r, SCIP_Real *coefs, int *inds, int *ninds)

SCIP_Real SCIPgetLPRootLooseObjval(SCIP *scip)

SCIP_Bool SCIPisLPDualReliable(SCIP *scip)

SCIP_RETCODE SCIPinterruptLP(SCIP *scip, SCIP_Bool interrupt)

SCIP_Bool SCIPisRootLPRelax(SCIP *scip)

#define SCIPallocBufferArray(scip, ptr, num)

#define SCIPfreeBufferArray(scip, ptr)

SCIP_NODETYPE SCIPnodeGetType(SCIP_NODE *node)

int SCIPnodeGetDepth(SCIP_NODE *node)

SCIP_Real SCIPgetRowMaxCoef(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIPgetRowMinCoef(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPcreateRow(SCIP *scip, SCIP_ROW **row, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPcreateRowConshdlr(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPcacheRowExtensions(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPchgRowLhs(SCIP *scip, SCIP_ROW *row, SCIP_Real lhs)

SCIP_Real SCIPgetRowMinActivity(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIPgetRowFeasibility(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPcreateRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

int SCIProwGetNNonz(SCIP_ROW *row)

SCIP_Real SCIPgetRowLPActivity(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPaddVarsToRowSameCoef(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real val)

SCIP_RETCODE SCIPcreateEmptyRowCons(SCIP *scip, SCIP_ROW **row, SCIP_CONS *cons, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_Real SCIPgetRowMaxActivity(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPrecalcRowPseudoActivity(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPflushRowExtensions(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPrecalcRowActivity(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPcreateEmptyRowConshdlr(SCIP *scip, SCIP_ROW **row, SCIP_CONSHDLR *conshdlr, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_Real SCIPgetRowPseudoActivity(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPmakeRowIntegral(SCIP *scip, SCIP_ROW *row, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Bool *success)

SCIP_RETCODE SCIPaddVarToRow(SCIP *scip, SCIP_ROW *row, SCIP_VAR *var, SCIP_Real val)

SCIP_RETCODE SCIPprintRow(SCIP *scip, SCIP_ROW *row, FILE *file)

SCIP_Real SCIPgetRowActivity(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPcaptureRow(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIPgetRowSolFeasibility(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)

SCIP_RETCODE SCIPreleaseRow(SCIP *scip, SCIP_ROW **row)

SCIP_Real SCIPgetRowPseudoFeasibility(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPcreateRowUnspec(SCIP *scip, SCIP_ROW **row, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPcreateEmptyRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_RETCODE SCIPrecalcRowLPActivity(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPcreateEmptyRowUnspec(SCIP *scip, SCIP_ROW **row, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

void SCIPmarkRowNotRemovableLocal(SCIP *scip, SCIP_ROW *row)

SCIP_Real SCIPgetRowLPFeasibility(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPchgRowRhs(SCIP *scip, SCIP_ROW *row, SCIP_Real rhs)

SCIP_RETCODE SCIPcreateEmptyRow(SCIP *scip, SCIP_ROW **row, const char *name, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_Real SCIPgetRowObjParallelism(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPaddVarsToRow(SCIP *scip, SCIP_ROW *row, int nvars, SCIP_VAR **vars, SCIP_Real *vals)

SCIP_RETCODE SCIPcreateRowSepa(SCIP *scip, SCIP_ROW **row, SCIP_SEPA *sepa, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

int SCIPgetRowNumIntCols(SCIP *scip, SCIP_ROW *row)

SCIP_RETCODE SCIPcalcRowIntegralScalar(SCIP *scip, SCIP_ROW *row, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Real *intscalar, SCIP_Bool *success)

SCIP_Real SCIPgetRowSolActivity(SCIP *scip, SCIP_ROW *row, SCIP_SOL *sol)

SCIP_RETCODE SCIPcreateSol(SCIP *scip, SCIP_SOL **sol, SCIP_HEUR *heur)

SCIP_RETCODE SCIPsetSolVal(SCIP *scip, SCIP_SOL *sol, SCIP_VAR *var, SCIP_Real val)

SCIP_Real SCIPgetCutoffbound(SCIP *scip)

SCIP_Bool SCIPisGE(SCIP *scip, SCIP_Real val1, SCIP_Real val2)

SCIP_NODE * SCIPgetCurrentNode(SCIP *scip)

SCIP_Bool SCIPisRelaxSolValid(SCIP *scip)

SCIP_Bool SCIPlpIsSolBasic(SCIP_LP *lp)

SCIP_Real SCIProwGetMaxval(SCIP_ROW *row, SCIP_SET *set)

SCIP_Real SCIProwGetLPFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)

SCIP_RETCODE SCIPlpGetBInvRow(SCIP_LP *lp, int r, SCIP_Real *coef, int *inds, int *ninds)

void SCIProwCapture(SCIP_ROW *row)

SCIP_Real SCIProwGetPseudoFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPlpGetBInvCol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)

SCIP_RETCODE SCIPlpInterrupt(SCIP_LP *lp, SCIP_Bool interrupt)

int SCIProwGetNumIntCols(SCIP_ROW *row, SCIP_SET *set)

SCIP_Real SCIProwGetSolFeasibility(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)

void SCIProwRecalcPseudoActivity(SCIP_ROW *row, SCIP_STAT *stat)

SCIP_RETCODE SCIProwEnsureSize(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, int num)

SCIP_Real SCIPlpGetLooseObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

SCIP_Real SCIProwGetMaxActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIProwMakeIntegral(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_STAT *stat, SCIP_LP *lp, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Bool *success)

SCIP_Bool SCIPlpDivingObjChanged(SCIP_LP *lp)

SCIP_RETCODE SCIPlpFlush(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_PROB *prob, SCIP_EVENTQUEUE *eventqueue)

void SCIPlpSetFeastol(SCIP_LP *lp, SCIP_SET *set, SCIP_Real newfeastol)

SCIP_RETCODE SCIPlpWrite(SCIP_LP *lp, const char *fname)

SCIP_Real SCIProwGetLPActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_LP *lp)

void SCIProwMarkNotRemovableLocal(SCIP_ROW *row, SCIP_STAT *stat)

SCIP_LPSOLSTAT SCIPlpGetSolstat(SCIP_LP *lp)

SCIP_RETCODE SCIProwCreate(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, const char *name, int len, SCIP_COL **cols, SCIP_Real *vals, SCIP_Real lhs, SCIP_Real rhs, SCIP_ROWORIGINTYPE origintype, void *origin, SCIP_Bool local, SCIP_Bool modifiable, SCIP_Bool removable)

SCIP_Real SCIPlpGetColumnObjval(SCIP_LP *lp)

SCIP_Bool SCIPlpIsPrimalReliable(SCIP_LP *lp)

SCIP_Bool SCIPlpIsRelax(SCIP_LP *lp)

SCIP_RETCODE SCIPlpSolveAndEval(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, BMS_BLKMEM *blkmem, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_Longint itlim, SCIP_Bool limitresolveiters, SCIP_Bool aging, SCIP_Bool keepsol, SCIP_Bool forcedlpsolve, SCIP_Bool *lperror)

SCIP_Real SCIPlpGetObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

void SCIProwRecalcLPActivity(SCIP_ROW *row, SCIP_STAT *stat)

SCIP_Real SCIProwGetMinval(SCIP_ROW *row, SCIP_SET *set)

SCIP_Real SCIPlpGetRootObjval(SCIP_LP *lp)

SCIP_Real SCIProwGetSolActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat, SCIP_SOL *sol)

void SCIPlpMarkDivingObjChanged(SCIP_LP *lp)

SCIP_RETCODE SCIPlpGetBInvARow(SCIP_LP *lp, int r, SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)

SCIP_LPI * SCIPlpGetLPI(SCIP_LP *lp)

SCIP_Bool SCIPlpDiving(SCIP_LP *lp)

SCIP_RETCODE SCIPlpGetBasisInd(SCIP_LP *lp, int *basisind)

SCIP_RETCODE SCIPlpComputeRelIntPoint(SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_LP *lp, SCIP_PROB *prob, SCIP_Bool relaxrows, SCIP_Bool inclobjcutoff, SCIP_Real timelimit, int iterlimit, SCIP_Real *point, SCIP_Bool *success)

SCIP_RETCODE SCIPlpGetDualDegeneracy(SCIP_LP *lp, SCIP_SET *set, SCIP_STAT *stat, SCIP_Real *degeneracy, SCIP_Real *varconsratio)

SCIP_Real SCIPlpGetRootLooseObjval(SCIP_LP *lp)

void SCIProwPrint(SCIP_ROW *row, SCIP_MESSAGEHDLR *messagehdlr, FILE *file)

SCIP_RETCODE SCIPlpSetCutoffbound(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real cutoffbound)

SCIP_RETCODE SCIPlpRecordOldRowSideDive(SCIP_LP *lp, SCIP_ROW *row, SCIP_SIDETYPE sidetype)

SCIP_Real SCIPlpGetFeastol(SCIP_LP *lp)

SCIP_RETCODE SCIPlpGetBInvACol(SCIP_LP *lp, int c, SCIP_Real *coef, int *inds, int *ninds)

SCIP_Bool SCIPlpDivingRowsChanged(SCIP_LP *lp)

SCIP_Real SCIPcolGetRedcost(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)

SCIP_Bool SCIPlpIsRootLPRelax(SCIP_LP *lp)

SCIP_Bool SCIPlpIsSolved(SCIP_LP *lp)

SCIP_Real SCIPcolGetFarkasCoef(SCIP_COL *col, SCIP_STAT *stat, SCIP_LP *lp)

SCIP_Real SCIPlpGetGlobalPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

SCIP_Bool SCIPlpIsDualReliable(SCIP_LP *lp)

SCIP_RETCODE SCIPlpAddRow(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_ROW *row, int depth)

SCIP_RETCODE SCIPlpWriteMip(SCIP_LP *lp, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, const char *fname, SCIP_Bool genericnames, SCIP_Bool origobj, SCIP_OBJSENSE objsense, SCIP_Real objscale, SCIP_Real objoffset, SCIP_Bool lazyconss)

SCIP_RETCODE SCIPlpStartDive(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat)

SCIP_RETCODE SCIPlpEndDive(SCIP_LP *lp, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_MESSAGEHDLR *messagehdlr, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_PROB *prob, SCIP_VAR **vars, int nvars)

SCIP_COL ** SCIPlpGetCols(SCIP_LP *lp)

int SCIPlpGetNCols(SCIP_LP *lp)

SCIP_RETCODE SCIProwChgRhs(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real rhs)

SCIP_Real SCIPlpGetRootColumnObjval(SCIP_LP *lp)

SCIP_RETCODE SCIProwCalcIntegralScalar(SCIP_ROW *row, SCIP_SET *set, SCIP_Real mindelta, SCIP_Real maxdelta, SCIP_Longint maxdnom, SCIP_Real maxscale, SCIP_Bool usecontvars, SCIP_Real *intscalar, SCIP_Bool *success)

SCIP_Real SCIProwGetPseudoActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)

SCIP_ROW ** SCIPlpGetRows(SCIP_LP *lp)

SCIP_RETCODE SCIProwChgLhs(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp, SCIP_Real lhs)

void SCIProwForceSort(SCIP_ROW *row, SCIP_SET *set)

void SCIPcolMarkNotRemovableLocal(SCIP_COL *col, SCIP_STAT *stat)

SCIP_RETCODE rowLink(SCIP_ROW *row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_EVENTQUEUE *eventqueue, SCIP_LP *lp)

int SCIPlpGetNUnfixedCols(SCIP_LP *lp, SCIP_Real eps)

SCIP_Real SCIProwGetMinActivity(SCIP_ROW *row, SCIP_SET *set, SCIP_STAT *stat)

void SCIPlpResetFeastol(SCIP_LP *lp, SCIP_SET *set)

void SCIProwDelaySort(SCIP_ROW *row)

int SCIPlpGetNRows(SCIP_LP *lp)

SCIP_Real SCIProwGetObjParallelism(SCIP_ROW *row, SCIP_SET *set, SCIP_LP *lp)

SCIP_RETCODE SCIPlpSumRows(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob, SCIP_Real *weights, SCIP_REALARRAY *sumcoef, SCIP_Real *sumlhs, SCIP_Real *sumrhs)

SCIP_Real SCIPlpGetPseudoObjval(SCIP_LP *lp, SCIP_SET *set, SCIP_PROB *prob)

SCIP_RETCODE SCIProwRelease(SCIP_ROW **row, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_LP *lp)

internal methods for LP management

interface methods for specific LP solvers

memory allocation routines

void SCIPmessageFPrintInfo(SCIP_MESSAGEHDLR *messagehdlr, FILE *file, const char *formatstr,...)

SCIP_Bool SCIPprobAllColsInLP(SCIP_PROB *prob, SCIP_SET *set, SCIP_LP *lp)

internal methods for storing and manipulating the main problem

public methods for LP management

public methods for message output

public methods for branch and bound tree

public methods for the LP relaxation, rows and columns

public methods for memory management

public methods for numerical tolerances

public methods for solutions

public methods for querying solving statistics

public methods for the branch-and-bound tree

public methods for SCIP variables

SCIP_Real SCIPsetInfinity(SCIP_SET *set)

internal methods for global SCIP settings

SCIP_RETCODE SCIPconstructCurrentLP(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_PRICESTORE *pricestore, SCIP_SEPASTORE *sepastore, SCIP_CUTPOOL *cutpool, SCIP_BRANCHCAND *branchcand, SCIP_EVENTQUEUE *eventqueue, SCIP_EVENTFILTER *eventfilter, SCIP_CLIQUETABLE *cliquetable, SCIP_Bool newinitconss, SCIP_Bool *cutoff)

internal methods for main solving loop and node processing

data structures for LP management

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

SCIP_Bool SCIPtreeIsFocusNodeLPConstructed(SCIP_TREE *tree)

SCIP_Bool SCIPtreeProbing(SCIP_TREE *tree)

SCIP_NODE * SCIPtreeGetCurrentNode(SCIP_TREE *tree)

SCIP_RETCODE SCIPtreeStoreRelaxSol(SCIP_TREE *tree, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob)

SCIP_Bool SCIPtreeHasCurrentNodeLP(SCIP_TREE *tree)

SCIP_RETCODE SCIPtreeRestoreRelaxSol(SCIP_TREE *tree, SCIP_SET *set, SCIP_RELAXATION *relaxation, SCIP_PROB *transprob)

SCIP_RETCODE SCIPnodeUpdateLowerboundLP(SCIP_NODE *node, SCIP_SET *set, SCIP_STAT *stat, SCIP_TREE *tree, SCIP_PROB *transprob, SCIP_PROB *origprob, SCIP_LP *lp)

SCIP_RETCODE SCIPtreeCutoff(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_Real cutoffbound)

internal methods for branch and bound tree

enum SCIP_LPSolStat SCIP_LPSOLSTAT

@ SCIP_ROWORIGINTYPE_CONSHDLR

@ SCIP_ROWORIGINTYPE_UNSPEC

@ SCIP_ROWORIGINTYPE_SEPA

@ SCIP_ROWORIGINTYPE_CONS

@ SCIP_LPSOLSTAT_NOTSOLVED

@ SCIP_LPSOLSTAT_INFEASIBLE

@ SCIP_LPSOLSTAT_OBJLIMIT

@ SCIP_LPSOLQUALITY_EXACTCONDITION

@ SCIP_LPSOLQUALITY_ESTIMCONDITION

enum SCIP_Retcode SCIP_RETCODE

@ SCIP_STAGE_INITPRESOLVE

@ SCIP_STAGE_EXITPRESOLVE

@ SCIP_NODETYPE_FOCUSNODE

SCIP_Real SCIPvarGetObjLP(SCIP_VAR *var)

SCIP_RETCODE SCIPvarAddToRow(SCIP_VAR *var, BMS_BLKMEM *blkmem, SCIP_SET *set, SCIP_STAT *stat, SCIP_EVENTQUEUE *eventqueue, SCIP_PROB *prob, SCIP_LP *lp, SCIP_ROW *row, SCIP_Real val)

SCIP_Real SCIPvarGetLbLP(SCIP_VAR *var, SCIP_SET *set)

SCIP_RETCODE SCIPvarChgObjDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newobj)

SCIP_Real SCIPvarGetUbLP(SCIP_VAR *var, SCIP_SET *set)

SCIP_RETCODE SCIPvarChgUbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)

SCIP_RETCODE SCIPvarChgLbDive(SCIP_VAR *var, SCIP_SET *set, SCIP_LP *lp, SCIP_Real newbound)

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