49#ifdef CMAKE_BUILD_TYPE
50#define SCIP_CMAKE_BUILD_TYPE (CMAKE_BUILD_TYPE)
51#undef CMAKE_BUILD_TYPE
57#include <lp_data/HighsLpUtils.h>
60#undef CMAKE_BUILD_TYPE
61#ifdef SCIP_CMAKE_BUILD_TYPE
62#define CMAKE_BUILD_TYPE (SCIP_CMAKE_BUILD_TYPE)
63#undef SCIP_CMAKE_BUILD_TYPE
78#define HIGHS_relDiff(val1, val2) ( ((val1)-(val2))/(MAX3(1.0,REALABS(val1),REALABS(val2))) )
84#define HIGHS_CALL(x) do \
88 HighsStatus _restat_; \
90 if( _restat_ == HighsStatus::kWarning ) \
92 SCIPerrorMessage("Warning in HiGHS function call\n"); \
93 return SCIP_LPERROR; \
95 else if( _restat_ != HighsStatus::kOk ) \
97 SCIPerrorMessage("Error in HiGHS function call\n"); \
98 return SCIP_LPERROR; \
101 catch( std::exception & E ) \
103 std::string s = E.what(); \
104 SCIPerrorMessage( "HiGHS threw an exception: %s\n", s.c_str()); \
105 return SCIP_LPERROR; \
109 SCIPerrorMessage("HiGHS threw an unidentified exception\n"); \
110 return SCIP_LPERROR; \
116#define HIGHS_CALL_WITH_WARNING(x) do \
120 HighsStatus _restat_; \
122 if( _restat_ != HighsStatus::kOk && _restat_ != HighsStatus::kWarning ) \
124 SCIPerrorMessage("Error in HiGHS in function call (returned %d)\n", \
126 return SCIP_LPERROR; \
129 catch( std::exception & E ) \
131 std::string s = E.what(); \
132 SCIPerrorMessage( "HiGHS threw an exception: %s\n", s.c_str()); \
133 return SCIP_LPERROR; \
137 SCIPerrorMessage("HiGHS threw an unidentified exception\n"); \
138 return SCIP_LPERROR; \
157 const char* probname =
NULL
161 _messagehdlr(messagehdlr)
189#define COLS_PER_PACKET SCIP_DUALPACKETSIZE
191#define ROWS_PER_PACKET SCIP_DUALPACKETSIZE
224 assert(num <= lpi->cstatsize);
248 assert(num <= lpi->rstatsize);
374 return HighsBasisStatus::kLower;
376 return HighsBasisStatus::kBasic;
378 return HighsBasisStatus::kUpper;
380 return HighsBasisStatus::kZero;
383 SCIPerrorMessage(
"Unknown Basis Status returned. Please use supported HiGHS version!\n");
384 return HighsBasisStatus::kZero;
399 return "Dual (serial)";
401 return "Dual (PAMI)";
422 HIGHS_CALL( lpi->
highs->getOptionValue(
"small_matrix_value", small_matrix_value) );
423 HIGHS_CALL( lpi->
highs->getOptionValue(
"large_matrix_value", large_matrix_value) );
425 assert(value == 0.0 || fabs(value) > small_matrix_value);
426 assert(fabs(value) < large_matrix_value);
438 std::string presolvestring;
441 int ck_ca_n = -99999;
454 lpi->
highs->zeroAllClocks();
462 HighsModelStatus model_status = lpi->
highs->getModelStatus();
463 switch( model_status )
466 case HighsModelStatus::kModelEmpty:
467 case HighsModelStatus::kOptimal:
468 case HighsModelStatus::kInfeasible:
469 case HighsModelStatus::kUnboundedOrInfeasible:
470 case HighsModelStatus::kUnbounded:
471 case HighsModelStatus::kObjectiveBound:
472 case HighsModelStatus::kTimeLimit:
473 case HighsModelStatus::kIterationLimit:
476 int simplex_strategy = -1;
477 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_strategy", simplex_strategy) );
478 SCIPdebugMessage(
"HiGHS terminated with model status <%s> (%d) after simplex strategy <%s> (%d)\n",
479 lpi->
highs->modelStatusToString(model_status).c_str(), (
int)model_status,
485 case HighsModelStatus::kNotset:
486 case HighsModelStatus::kLoadError:
487 case HighsModelStatus::kModelError:
488 case HighsModelStatus::kPresolveError:
489 case HighsModelStatus::kSolveError:
490 case HighsModelStatus::kPostsolveError:
491 case HighsModelStatus::kSolutionLimit:
492 case HighsModelStatus::kObjectiveTarget:
493 case HighsModelStatus::kUnknown:
496 int simplex_strategy = -1;
497 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_strategy", simplex_strategy) );
498 SCIPerrorMessage(
"HiGHS terminated with model status <%s> (%d) after simplex strategy <%s> (%d)\n",
499 lpi->
highs->modelStatusToString(model_status).c_str(), (
int)model_status,
507 assert(presolvestring ==
"on" || presolvestring ==
"off");
509 if( !lpi->
highs->hasInvert() && presolvestring ==
"on" )
513 SCIPdebugMessage(
"No inverse: running HiGHS again without presolve . . .\n");
518 HighsModelStatus model_status2 = lpi->
highs->getModelStatus();
519 SCIPerrorMessage(
"HiGHS terminated with model status <%s> (%d) after trying to recover inverse\n",
520 lpi->
highs->modelStatusToString(model_status2).c_str(), (
int)model_status2);
528 int highs_iterations;
529 HIGHS_CALL( lpi->
highs->getInfoValue(
"simplex_iteration_count", highs_iterations) );
531 lpi->
highs->getObjectiveValue(), highs_iterations,
532 lpi->
highs->modelStatusToString(lpi->
highs->getModelStatus()).c_str());
561 snprintf(
highsname, 30,
"HiGHS %d.%d.%d", HIGHS_VERSION_MAJOR, HIGHS_VERSION_MINOR, HIGHS_VERSION_PATCH);
572 snprintf(
highsdesc, 200,
"%s [GitHash: %s]",
573 "Linear optimization suite written and engineered at the University of Edinburgh",
585 return (
void *) lpi->
highs;
601 SCIPerrorMessage(
"SCIPlpiSetIntegralityInformation() has not been implemented yet\n");
658 (*lpi)->cstat =
NULL;
659 (*lpi)->rstat =
NULL;
660 (*lpi)->cstatsize = 0;
661 (*lpi)->rstatsize = 0;
662 (*lpi)->nthreads = 1;
663 (*lpi)->fromscratch =
FALSE;
664 (*lpi)->solved =
FALSE;
665 (*lpi)->presolve =
TRUE;
667 (*lpi)->messagehdlr = messagehdlr;
675 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"output_flag",
false) );
676#ifdef HIGHS_LOGDEVLEVEL
677 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"log_dev_level", HIGHS_LOGDEVLEVEL) );
679#ifdef HIGHS_DEBUGLEVEL
680 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"highs_debug_level", HIGHS_DEBUGLEVEL) );
688 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"lp_presolve_requires_basis_postsolve",
true) );
707 (*lpi)->highs->~HighsSCIP();
763 assert(nnonz == 0 || ( nrows > 0 && ncols > 0));
765 for(
int j = 0; j < nnonz; ++j )
767 assert(0 <= ind[j] && ind[j] < nrows);
773 int objectiveSenseInt = objsen ==
SCIP_OBJSEN_MAXIMIZE ? (int)ObjSense::kMaximize : (int)ObjSense::kMinimize;
774 HIGHS_CALL( lpi->
highs->passModel(ncols, nrows, nnonz, 1, objectiveSenseInt, 0,
obj, lb, ub, lhs, rhs, beg, ind, val) );
819 int nrows = lpi->
highs->getLp().num_row_;
820 for(
int j = 0; j < nnonz; ++j )
822 assert(0 <= ind[j] && ind[j] < nrows);
912 int ncols = lpi->
highs->getLp().num_col_;
913 for(
int j = 0; j < nnonz; ++j )
915 assert(0 <= ind[j] && ind[j] < ncols);
923 HIGHS_CALL( lpi->
highs->addRows(nrows, lhs, rhs, nnonz, beg, ind, val) );
943 assert(0 <= firstrow && firstrow <= lastrow );
1016 for(
i = 0;
i < ncols; ++
i )
1018 assert(0 <= ind[
i] && ind[
i] < lpi->
highs->getLp().num_col_);
1022 SCIPerrorMessage(
"LP Error: fixing lower bound for variable %d to infinity\n", ind[
i]);
1027 SCIPerrorMessage(
"LP Error: fixing upper bound for variable %d to -infinity\n", ind[
i]);
1058 for(
i = 0;
i < nrows; ++
i )
1059 assert(0 <= ind[
i] && ind[
i] < lpi->
highs->getLp().num_row_);
1187 *nrows = lpi->
highs->getNumRow();
1204 *ncols = lpi->
highs->getNumCol();
1221 *nnonz = lpi->
highs->getNumNz();
1249 HIGHS_CALL( lpi->
highs->getCols(firstcol, lastcol, num_col,
NULL, lb, ub, *nnonz, beg, ind, val) );
1274 HIGHS_CALL( lpi->
highs->getRows(firstrow, lastrow, num_row, lhs, rhs, *nnonz, beg, ind, val) );
1285 int namestoragesize,
1305 int namestoragesize,
1330 if( lpi->
highs->getLp().sense_ == ObjSense::kMaximize )
1349 assert(0 <= firstcol && firstcol <= lastcol && lastcol < lpi->highs->getLp().num_col_);
1352 for(
int i = firstcol;
i < lastcol + 1; ++
i )
1353 vals[
i - firstcol] = lpi->
highs->getLp().col_cost_[
i];
1371 assert(0 <= firstcol && firstcol <= lastcol && lastcol < lpi->highs->getLp().num_col_);
1373 for(
int i = firstcol;
i < lastcol + 1; ++
i )
1376 lbs[
i - firstcol] = lpi->
highs->getLp().col_lower_[
i];
1378 ubs[
i - firstcol] = lpi->
highs->getLp().col_upper_[
i];
1398 assert(0 <= firstrow && firstrow <= lastrow && lastrow < lpi->highs->getLp().num_row_);
1400 for(
int i = firstrow;
i < lastrow + 1; ++
i )
1403 lhss[
i - firstrow] = lpi->
highs->getLp().row_lower_[
i];
1405 rhss[
i - firstrow] = lpi->
highs->getLp().row_upper_[
i];
1423 assert(0 <= col && col < lpi->highs->getNumCol());
1424 assert(0 <= row && row < lpi->highs->getNumCol());
1450#ifdef SCIP_WITH_HIGHSPRIMAL
1473#ifdef SCIP_WITH_HIGHSPARALLEL
1506 SCIPdebugMessage(
"HiGHS does not support Barrier - switching to dual simplex\n");
1560 SCIP_Real dualbound = (lpi->
highs->getLp().sense_ == ObjSense::kMinimize
1568 *down = *up = dualbound;
1604 SCIP_Real dualbound = (lpi->
highs->getLp().sense_ == ObjSense::kMinimize
1612 for(
int j = 0; j < ncols; ++j )
1614 down[j] = up[j] = dualbound;
1615 downvalid[j] = upvalid[j] =
TRUE;
1744 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1746 return model_status == HighsModelStatus::kUnbounded || model_status == HighsModelStatus::kUnboundedOrInfeasible;
1765 if( lpi->
highs->getNumRow() == 0 )
1768 bool has_primal_ray =
false;
1770 return has_primal_ray;
1783 return lpi->
highs->getModelStatus() == HighsModelStatus::kUnbounded;
1796 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1799 if( model_status == HighsModelStatus::kModelEmpty )
1801 int numrow = lpi->
highs->getNumRow();
1805 for(
int i = 0;
i < numrow;
i++ )
1807 if( lpi->
highs->getLp().row_lower_[
i] > 0.0 || lpi->
highs->getLp().row_upper_[
i] < 0.0 )
1814 const bool primal_infeasible =
1815 model_status == HighsModelStatus::kInfeasible ||
1816 model_status == HighsModelStatus::kUnboundedOrInfeasible;
1817 return primal_infeasible;
1830 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1833 if( model_status == HighsModelStatus::kModelEmpty )
1835 int numrow = lpi->
highs->getNumRow();
1839 for(
int i = 0;
i < numrow;
i++ )
1841 if( lpi->
highs->getLp().row_lower_[
i] > 0.0 || lpi->
highs->getLp().row_upper_[
i] < 0.0 )
1848 const bool primal_feasible =
1849 model_status == HighsModelStatus::kOptimal ||
1850 model_status == HighsModelStatus::kUnbounded;
1851 return primal_feasible;
1880 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1883 if( model_status == HighsModelStatus::kModelEmpty )
1887 bool has_dual_ray =
false;
1889 return has_dual_ray;
1915 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1916 const bool dual_infeasible =
1917 model_status == HighsModelStatus::kUnbounded ||
1918 model_status == HighsModelStatus::kUnboundedOrInfeasible;
1919 return dual_infeasible;
1932 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1934 if( model_status == HighsModelStatus::kOptimal || model_status == HighsModelStatus::kModelEmpty )
1936 else if( model_status == HighsModelStatus::kUnbounded || model_status == HighsModelStatus::kUnboundedOrInfeasible )
1939 int num_dual_infeasibilities = 1;
1940 HighsStatus status = lpi->
highs->getInfoValue(
"num_dual_infeasibilities", num_dual_infeasibilities);
1941 bool has_dual_feasible_sol = (status == HighsStatus::kOk) && (num_dual_infeasibilities == 0);
1942 return has_dual_feasible_sol;
1955 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1957 if( model_status == HighsModelStatus::kModelEmpty )
1963 return lpi->
highs->getModelStatus() == HighsModelStatus::kOptimal;
1984 HIGHS_CALL( lpi->
highs->getOptionValue(
"objective_bound", objlimit) );
1985 HIGHS_CALL( lpi->
highs->getInfoValue(
"objective_function_value", objvalue) );
1987 if( lpi->
highs->getLp().sense_ == ObjSense::kMaximize )
2009 return lpi->
highs->getModelStatus() == HighsModelStatus::kObjectiveBound;
2022 return lpi->
highs->getModelStatus() == HighsModelStatus::kIterationLimit;
2035 return lpi->
highs->getModelStatus() == HighsModelStatus::kTimeLimit;
2048 return (
int) lpi->
highs->getModelStatus();
2081 assert(lpi->
highs->getModelStatus() != HighsModelStatus::kModelEmpty || *
objval == 0.0);
2112 assert(lpi->
highs->getModelStatus() != HighsModelStatus::kModelEmpty || *
objval == 0.0);
2115 const std::vector<double> &colValue = lpi->
highs->getSolution().col_value;
2116 const std::vector<double> &colDual = lpi->
highs->getSolution().col_dual;
2117 const std::vector<double> &rowValue = lpi->
highs->getSolution().row_value;
2118 const std::vector<double> &rowDual = lpi->
highs->getSolution().row_dual;
2122 if( colValue.size() != (
size_t) ncols || colDual.size() != (
size_t) ncols
2123 || rowValue.size() != (
size_t) nrows || rowDual.size() != (
size_t) nrows )
2129 assert((
int) rowValue.size() == nrows);
2135 for(
i = 0;
i < ncols;
i++ )
2137 if( dualsol !=
NULL )
2138 for(
i = 0;
i < nrows;
i++ )
2139 dualsol[
i] = rowDual[
i];
2140 if( activity !=
NULL )
2141 for(
i = 0;
i < nrows;
i++ )
2142 activity[
i] = rowValue[
i];
2143 if( redcost !=
NULL )
2144 for(
i = 0;
i < ncols;
i++ )
2145 redcost[
i] = colDual[
i];
2159 bool success =
false;
2166 if( lpi->
highs->getNumRow() == 0 )
2168 int numcol = lpi->
highs->getNumCol();
2170 for(
int i = 0;
i < numcol;
i++ )
2173 if( lpi->
highs->getLp().sense_ == ObjSense::kMaximize )
2210 HighsModelStatus model_status = lpi->
highs->getModelStatus();
2213 if( model_status == HighsModelStatus::kModelEmpty )
2215 SCIP_Real dualdir = lpi->
highs->getLp().sense_ == ObjSense::kMinimize ? 1.0 : -1.0;
2216 int numrow = lpi->
highs->getNumRow();
2220 for(
int i = 0;
i < numrow;
i++ )
2222 if( lpi->
highs->getLp().row_lower_[
i] > 0.0 )
2223 dualfarkas[
i] = dualdir;
2224 else if( lpi->
highs->getLp().row_upper_[
i] < 0.0 )
2225 dualfarkas[
i] = -dualdir;
2227 dualfarkas[
i] = 0.0;
2233 bool has_dual_ray =
false;
2254 assert(*iterations >= 0);
2303 for(
int i = 0;
i < lpi->
highs->getLp().num_col_; ++
i )
2304 cstat[
i] = (
int) lpi->
highs->getBasis().col_status[
i];
2308 for(
int i = 0;
i < lpi->
highs->getLp().num_row_; ++
i )
2309 rstat[
i] = (
int) lpi->
highs->getBasis().row_status[
i];
2327 HighsBasis local_highs_basis;
2329 local_highs_basis.col_status.resize(lpi->
highs->getLp().num_col_);
2330 local_highs_basis.row_status.resize(lpi->
highs->getLp().num_row_);
2334 for(
int i = 0;
i < lpi->
highs->getLp().num_col_; ++
i )
2339 for(
int i = 0;
i < lpi->
highs->getLp().num_row_; ++
i )
2359 if( !lpi->
highs->getBasis().valid )
2361 SCIPdebugMessage(
"HiGHS Basis is not valid in function call SCIPlpiGetBasisInd()\n" );
2389 if( lpi->
highs->getBasisInverseRow(
r, coef, ninds, inds) != HighsStatus::kOk )
2422 if( lpi->
highs->getBasisInverseCol(
c, coef, ninds, inds) != HighsStatus::kOk )
2453 if( lpi->
highs->getReducedRow(
r, coef, ninds, inds, binvrow) != HighsStatus::kOk )
2484 if( lpi->
highs->getReducedColumn(
c, coef, ninds, inds) != HighsStatus::kOk )
2520 ncols = lpi->
highs->getLp().num_col_;
2521 nrows = lpi->
highs->getLp().num_row_;
2536 (*lpistate)->ncols = ncols;
2537 (*lpistate)->nrows = nrows;
2563 lpncols = lpi->
highs->getLp().num_col_;
2564 lpnrows = lpi->
highs->getLp().num_row_;
2576 for(
i = lpistate->
ncols;
i < lpncols; ++
i )
2588 for(
i = lpistate->
nrows;
i < lpnrows; ++
i )
2623 if( *lpistate !=
NULL )
2767 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_scale_strategy", *ival) );
2768 assert(*ival == 0 || *ival == 2 || *ival == 4);
2771 else if( *ival <= 2 )
2786 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_iteration_limit", *ival) );
2821 assert(ival >= 0 && ival <= 2);
2824 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_scale_strategy", 0) );
2825 else if( ival == 1 )
2827 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_scale_strategy", 2) );
2830 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_scale_strategy", 4) );
2835 HIGHS_CALL( lpi->
highs->setOptionValue(
"presolve", ival ?
"on" :
"off") );
2844 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_primal_edge_weight_strategy", -1) );
2845 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_dual_edge_weight_strategy", -1) );
2848 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_primal_edge_weight_strategy", 1) );
2849 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_dual_edge_weight_strategy", 1) );
2854 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_primal_edge_weight_strategy", 2) );
2855 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_dual_edge_weight_strategy", 2) );
2865 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_iteration_limit", ival) );
2893 HIGHS_CALL( lpi->
highs->getOptionValue(
"primal_feasibility_tolerance", *dval) );
2896 HIGHS_CALL( lpi->
highs->getOptionValue(
"dual_feasibility_tolerance", *dval) );
2927 dval =
MAX(dval, 1e-10);
2928 HIGHS_CALL( lpi->
highs->setOptionValue(
"primal_feasibility_tolerance", dval) );
2932 dval =
MAX(dval, 1e-10);
2933 HIGHS_CALL( lpi->
highs->setOptionValue(
"dual_feasibility_tolerance", dval) );
2995 return val >= kHighsInf;
void SCIPdecodeDualBit(const SCIP_DUALPACKET *inp, int *out, int count)
void SCIPencodeDualBit(const int *inp, SCIP_DUALPACKET *out, int count)
packing single and dual bit values
unsigned int SCIP_DUALPACKET
HighsSCIP(SCIP_MESSAGEHDLR *messagehdlr=NULL, const char *probname=NULL)
SCIP_RETCODE SCIPlpiChgSides(SCIP_LPI *lpi, int nrows, const int *ind, const SCIP_Real *lhs, const SCIP_Real *rhs)
SCIP_RETCODE SCIPlpiSetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPISTATE *lpistate)
SCIP_RETCODE SCIPlpiGetBInvACol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiGetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real *dval)
SCIP_Real SCIPlpiInfinity(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiIsObjlimExc(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgObjsen(SCIP_LPI *lpi, SCIP_OBJSEN objsen)
SCIP_Bool SCIPlpiIsInfinity(SCIP_LPI *lpi, SCIP_Real val)
SCIP_RETCODE SCIPlpiClear(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiClearState(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiExistsDualRay(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiExistsPrimalRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetBase(SCIP_LPI *lpi, int *cstat, int *rstat)
SCIP_RETCODE SCIPlpiReadState(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiAddRows(SCIP_LPI *lpi, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiGetPrimalRay(SCIP_LPI *lpi, SCIP_Real *ray)
SCIP_RETCODE SCIPlpiGetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int *ival)
SCIP_RETCODE SCIPlpiWriteLP(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiSetIntegralityInformation(SCIP_LPI *lpi, int ncols, int *intInfo)
SCIP_Bool SCIPlpiIsDualInfeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
SCIP_RETCODE SCIPlpiStrongbranchFrac(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiSetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, const SCIP_LPINORMS *lpinorms)
SCIP_RETCODE SCIPlpiGetNNonz(SCIP_LPI *lpi, int *nnonz)
SCIP_Bool SCIPlpiHasPrimalSolve(void)
SCIP_RETCODE SCIPlpiStrongbranchInt(SCIP_LPI *lpi, int col, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiGetBounds(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lbs, SCIP_Real *ubs)
SCIP_Bool SCIPlpiHasBarrierSolve(void)
SCIP_RETCODE SCIPlpiGetDualfarkas(SCIP_LPI *lpi, SCIP_Real *dualfarkas)
SCIP_RETCODE SCIPlpiGetObjval(SCIP_LPI *lpi, SCIP_Real *objval)
SCIP_RETCODE SCIPlpiScaleCol(SCIP_LPI *lpi, int col, SCIP_Real scaleval)
int SCIPlpiGetInternalStatus(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiStartStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetSolFeasibility(SCIP_LPI *lpi, SCIP_Bool *primalfeasible, SCIP_Bool *dualfeasible)
SCIP_RETCODE SCIPlpiFreeNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_Bool SCIPlpiIsIterlimExc(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgBounds(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *lb, const SCIP_Real *ub)
SCIP_Bool SCIPlpiIsPrimalUnbounded(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiIgnoreInstability(SCIP_LPI *lpi, SCIP_Bool *success)
SCIP_RETCODE SCIPlpiWriteState(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiFree(SCIP_LPI **lpi)
SCIP_RETCODE SCIPlpiStrongbranchesFrac(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiGetCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real *val)
SCIP_Bool SCIPlpiIsPrimalFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiReadLP(SCIP_LPI *lpi, const char *fname)
SCIP_RETCODE SCIPlpiGetRealSolQuality(SCIP_LPI *lpi, SCIP_LPSOLQUALITY qualityindicator, SCIP_Real *quality)
SCIP_Bool SCIPlpiIsDualFeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetNorms(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPINORMS **lpinorms)
SCIP_Bool SCIPlpiIsTimelimExc(SCIP_LPI *lpi)
SCIP_Bool SCIPlpiHasStateBasis(SCIP_LPI *lpi, SCIP_LPISTATE *lpistate)
SCIP_RETCODE SCIPlpiSetIntpar(SCIP_LPI *lpi, SCIP_LPPARAM type, int ival)
const char * SCIPlpiGetSolverName(void)
SCIP_RETCODE SCIPlpiSetBase(SCIP_LPI *lpi, const int *cstat, const int *rstat)
SCIP_Bool SCIPlpiHasPrimalRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetBInvRow(SCIP_LPI *lpi, int r, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiDelRows(SCIP_LPI *lpi, int firstrow, int lastrow)
SCIP_RETCODE SCIPlpiGetCols(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *lb, SCIP_Real *ub, int *nnonz, int *beg, int *ind, SCIP_Real *val)
SCIP_RETCODE SCIPlpiGetBInvCol(SCIP_LPI *lpi, int c, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiGetColNames(SCIP_LPI *lpi, int firstcol, int lastcol, char **colnames, char *namestorage, int namestoragesize, int *storageleft)
SCIP_RETCODE SCIPlpiGetBInvARow(SCIP_LPI *lpi, int r, const SCIP_Real *binvrow, SCIP_Real *coef, int *inds, int *ninds)
SCIP_RETCODE SCIPlpiGetRows(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhs, SCIP_Real *rhs, int *nnonz, int *beg, int *ind, SCIP_Real *val)
SCIP_Bool SCIPlpiWasSolved(SCIP_LPI *lpi)
const char * SCIPlpiGetSolverDesc(void)
SCIP_RETCODE SCIPlpiSolveBarrier(SCIP_LPI *lpi, SCIP_Bool crossover)
SCIP_Bool SCIPlpiIsOptimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetRowNames(SCIP_LPI *lpi, int firstrow, int lastrow, char **rownames, char *namestorage, int namestoragesize, int *storageleft)
SCIP_Bool SCIPlpiHasDualSolve(void)
SCIP_RETCODE SCIPlpiEndStrongbranch(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetSides(SCIP_LPI *lpi, int firstrow, int lastrow, SCIP_Real *lhss, SCIP_Real *rhss)
SCIP_RETCODE SCIPlpiStrongbranchesInt(SCIP_LPI *lpi, int *cols, int ncols, SCIP_Real *psols, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
SCIP_RETCODE SCIPlpiGetSol(SCIP_LPI *lpi, SCIP_Real *objval, SCIP_Real *primsol, SCIP_Real *dualsol, SCIP_Real *activity, SCIP_Real *redcost)
SCIP_Bool SCIPlpiHasDualRay(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiDelColset(SCIP_LPI *lpi, int *dstat)
SCIP_RETCODE SCIPlpiGetObj(SCIP_LPI *lpi, int firstcol, int lastcol, SCIP_Real *vals)
SCIP_RETCODE SCIPlpiFreeState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_Bool SCIPlpiIsPrimalInfeasible(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiSolveDual(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiAddCols(SCIP_LPI *lpi, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_RETCODE SCIPlpiSolvePrimal(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiLoadColLP(SCIP_LPI *lpi, SCIP_OBJSEN objsen, int ncols, const SCIP_Real *obj, const SCIP_Real *lb, const SCIP_Real *ub, char **colnames, int nrows, const SCIP_Real *lhs, const SCIP_Real *rhs, char **rownames, int nnonz, const int *beg, const int *ind, const SCIP_Real *val)
SCIP_Bool SCIPlpiIsDualUnbounded(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetIterations(SCIP_LPI *lpi, int *iterations)
SCIP_RETCODE SCIPlpiGetBasisInd(SCIP_LPI *lpi, int *bind)
SCIP_RETCODE SCIPlpiCreate(SCIP_LPI **lpi, SCIP_MESSAGEHDLR *messagehdlr, const char *name, SCIP_OBJSEN objsen)
void * SCIPlpiGetSolverPointer(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiChgObj(SCIP_LPI *lpi, int ncols, const int *ind, const SCIP_Real *obj)
SCIP_RETCODE SCIPlpiGetObjsen(SCIP_LPI *lpi, SCIP_OBJSEN *objsen)
SCIP_Bool SCIPlpiIsStable(SCIP_LPI *lpi)
SCIP_RETCODE SCIPlpiGetNCols(SCIP_LPI *lpi, int *ncols)
SCIP_RETCODE SCIPlpiInterrupt(SCIP_LPI *lpi, SCIP_Bool interrupt)
SCIP_RETCODE SCIPlpiDelCols(SCIP_LPI *lpi, int firstcol, int lastcol)
SCIP_RETCODE SCIPlpiDelRowset(SCIP_LPI *lpi, int *dstat)
SCIP_RETCODE SCIPlpiScaleRow(SCIP_LPI *lpi, int row, SCIP_Real scaleval)
SCIP_RETCODE SCIPlpiGetNRows(SCIP_LPI *lpi, int *nrows)
SCIP_RETCODE SCIPlpiGetState(SCIP_LPI *lpi, BMS_BLKMEM *blkmem, SCIP_LPISTATE **lpistate)
SCIP_RETCODE SCIPlpiChgCoef(SCIP_LPI *lpi, int row, int col, SCIP_Real newval)
assert(minobj< SCIPgetCutoffbound(scip))
interface methods for specific LP solvers
SCIP_DUALPACKET ROWPACKET
SCIP_DUALPACKET COLPACKET
static void lpistatePack(SCIP_LPISTATE *lpistate, const int *cstat, const int *rstat)
static HighsBasisStatus basestatToHighsBasisStatus(const int &stat)
static void lpistateUnpack(const SCIP_LPISTATE *lpistate, int *cstat, int *rstat)
static int rowpacketNum(int nrows)
static SCIP_RETCODE ensureCstatMem(SCIP_LPI *lpi, int num)
static std::string simplexStrategyToString(const int &strategy)
static char highsname[30]
static void lpistateFree(SCIP_LPISTATE **lpistate, BMS_BLKMEM *blkmem)
static SCIP_RETCODE lpiSolve(SCIP_LPI *lpi)
static SCIP_RETCODE ensureRstatMem(SCIP_LPI *lpi, int num)
static int colpacketNum(int ncols)
static SCIP_RETCODE checkMatrixValue(SCIP_LPI *lpi, SCIP_Real value)
#define HIGHS_CALL_WITH_WARNING(x)
static SCIP_RETCODE lpistateCreate(SCIP_LPISTATE **lpistate, BMS_BLKMEM *blkmem, int ncols, int nrows)
static void invalidateSolution(SCIP_LPI *lpi)
#define HIGHS_relDiff(val1, val2)
static char highsdesc[200]
#define BMSfreeMemory(ptr)
#define BMSfreeBlockMemory(mem, ptr)
#define BMSallocBlockMemory(mem, ptr)
#define BMSreallocMemoryArray(ptr, num)
#define BMSallocBlockMemoryArray(mem, ptr, num)
#define BMSfreeBlockMemoryArray(mem, ptr, num)
struct BMS_BlkMem BMS_BLKMEM
#define BMSfreeMemoryArrayNull(ptr)
#define BMSallocMemory(ptr)
void SCIPmessagePrintWarning(SCIP_MESSAGEHDLR *messagehdlr, const char *formatstr,...)
public methods for message output
SCIP_MESSAGEHDLR * messagehdlr
type definitions for LP management
@ SCIP_PRICING_STEEPQSTART
@ SCIP_PRICING_LPIDEFAULT
enum SCIP_Pricing SCIP_PRICING
enum SCIP_LPParam SCIP_LPPARAM
struct SCIP_LPiState SCIP_LPISTATE
struct SCIP_LPiNorms SCIP_LPINORMS
enum SCIP_LPSolQuality SCIP_LPSOLQUALITY
enum SCIP_ObjSen SCIP_OBJSEN
struct SCIP_Messagehdlr SCIP_MESSAGEHDLR
enum SCIP_Retcode SCIP_RETCODE