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; \
154 const char* probname =
NULL
158 _messagehdlr(messagehdlr)
186#define COLS_PER_PACKET SCIP_DUALPACKETSIZE
188#define ROWS_PER_PACKET SCIP_DUALPACKETSIZE
221 assert(num <= lpi->cstatsize);
245 assert(num <= lpi->rstatsize);
371 return HighsBasisStatus::kLower;
373 return HighsBasisStatus::kBasic;
375 return HighsBasisStatus::kUpper;
377 return HighsBasisStatus::kZero;
380 SCIPerrorMessage(
"Unknown Basis Status returned. Please use supported HiGHS version!\n");
381 return HighsBasisStatus::kZero;
396 return "Dual (serial)";
398 return "Dual (PAMI)";
419 HIGHS_CALL( lpi->
highs->getOptionValue(
"small_matrix_value", small_matrix_value) );
420 HIGHS_CALL( lpi->
highs->getOptionValue(
"large_matrix_value", large_matrix_value) );
422 assert(value == 0.0 || fabs(value) > small_matrix_value);
423 assert(fabs(value) < large_matrix_value);
435 std::string presolvestring;
445 lpi->
highs->zeroAllClocks();
453 HighsModelStatus model_status = lpi->
highs->getModelStatus();
454 switch( model_status )
457 case HighsModelStatus::kModelEmpty:
458 case HighsModelStatus::kOptimal:
459 case HighsModelStatus::kInfeasible:
460 case HighsModelStatus::kUnboundedOrInfeasible:
461 case HighsModelStatus::kUnbounded:
462 case HighsModelStatus::kObjectiveBound:
463 case HighsModelStatus::kTimeLimit:
464 case HighsModelStatus::kIterationLimit:
467 int simplex_strategy = -1;
468 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_strategy", simplex_strategy) );
469 SCIPdebugMessage(
"HiGHS terminated with model status <%s> (%d) after simplex strategy <%s> (%d)\n",
470 lpi->
highs->modelStatusToString(model_status).c_str(), (
int)model_status,
476 case HighsModelStatus::kNotset:
477 case HighsModelStatus::kLoadError:
478 case HighsModelStatus::kModelError:
479 case HighsModelStatus::kPresolveError:
480 case HighsModelStatus::kSolveError:
481 case HighsModelStatus::kPostsolveError:
482 case HighsModelStatus::kSolutionLimit:
483 case HighsModelStatus::kObjectiveTarget:
484 case HighsModelStatus::kUnknown:
487 int simplex_strategy = -1;
488 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_strategy", simplex_strategy) );
489 SCIPerrorMessage(
"HiGHS terminated with model status <%s> (%d) after simplex strategy <%s> (%d)\n",
490 lpi->
highs->modelStatusToString(model_status).c_str(), (
int)model_status,
498 assert(presolvestring ==
"on" || presolvestring ==
"off");
500 if( !lpi->
highs->hasInvert() && presolvestring ==
"on" )
504 SCIPdebugMessage(
"No inverse: running HiGHS again without presolve . . .\n");
509 HighsModelStatus model_status2 = lpi->
highs->getModelStatus();
510 SCIPerrorMessage(
"HiGHS terminated with model status <%s> (%d) after trying to recover inverse\n",
511 lpi->
highs->modelStatusToString(model_status2).c_str(), (
int)model_status2);
517#if SCIP_DISABLED_CODE
518 int highs_iterations;
519 HIGHS_CALL( lpi->
highs->getInfoValue(
"simplex_iteration_count", highs_iterations) );
521 lpi->
highs->getObjectiveValue(), highs_iterations,
522 lpi->
highs->modelStatusToString(lpi->
highs->getModelStatus()).c_str());
551 snprintf(
highsname, 30,
"HiGHS %d.%d.%d", HIGHS_VERSION_MAJOR, HIGHS_VERSION_MINOR, HIGHS_VERSION_PATCH);
562 snprintf(
highsdesc, 200,
"%s [GitHash: %s]",
563 "Linear optimization suite written and engineered at the University of Edinburgh",
575 return (
void *) lpi->
highs;
591 SCIPerrorMessage(
"SCIPlpiSetIntegralityInformation() has not been implemented yet\n");
648 (*lpi)->cstat =
NULL;
649 (*lpi)->rstat =
NULL;
650 (*lpi)->cstatsize = 0;
651 (*lpi)->rstatsize = 0;
652 (*lpi)->nthreads = 1;
653 (*lpi)->fromscratch =
FALSE;
654 (*lpi)->solved =
FALSE;
655 (*lpi)->presolve =
TRUE;
657 (*lpi)->messagehdlr = messagehdlr;
665 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"output_flag",
false) );
666#ifdef HIGHS_LOGDEVLEVEL
667 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"log_dev_level", HIGHS_LOGDEVLEVEL) );
669#ifdef HIGHS_DEBUGLEVEL
670 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"highs_debug_level", HIGHS_DEBUGLEVEL) );
678 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"lp_presolve_requires_basis_postsolve",
true) );
697 (*lpi)->highs->~HighsSCIP();
753 assert(nnonz == 0 || ( nrows > 0 && ncols > 0));
755 for(
int j = 0; j < nnonz; ++j )
757 assert(0 <= ind[j] && ind[j] < nrows);
763 int objectiveSenseInt = objsen ==
SCIP_OBJSEN_MAXIMIZE ? (int)ObjSense::kMaximize : (int)ObjSense::kMinimize;
764 HIGHS_CALL( lpi->
highs->passModel(ncols, nrows, nnonz, 1, objectiveSenseInt, 0,
obj, lb, ub, lhs, rhs, beg, ind, val) );
809 int nrows = lpi->
highs->getLp().num_row_;
810 for(
int j = 0; j < nnonz; ++j )
812 assert(0 <= ind[j] && ind[j] < nrows);
902 int ncols = lpi->
highs->getLp().num_col_;
903 for(
int j = 0; j < nnonz; ++j )
905 assert(0 <= ind[j] && ind[j] < ncols);
913 HIGHS_CALL( lpi->
highs->addRows(nrows, lhs, rhs, nnonz, beg, ind, val) );
933 assert(0 <= firstrow && firstrow <= lastrow );
1006 for(
i = 0;
i < ncols; ++
i )
1008 assert(0 <= ind[
i] && ind[
i] < lpi->
highs->getLp().num_col_);
1012 SCIPerrorMessage(
"LP Error: fixing lower bound for variable %d to infinity\n", ind[
i]);
1017 SCIPerrorMessage(
"LP Error: fixing upper bound for variable %d to -infinity\n", ind[
i]);
1048 for(
i = 0;
i < nrows; ++
i )
1049 assert(0 <= ind[
i] && ind[
i] < lpi->
highs->getLp().num_row_);
1177 *nrows = lpi->
highs->getNumRow();
1194 *ncols = lpi->
highs->getNumCol();
1211 *nnonz = lpi->
highs->getNumNz();
1239 HIGHS_CALL( lpi->
highs->getCols(firstcol, lastcol, num_col,
NULL, lb, ub, *nnonz, beg, ind, val) );
1264 HIGHS_CALL( lpi->
highs->getRows(firstrow, lastrow, num_row, lhs, rhs, *nnonz, beg, ind, val) );
1275 int namestoragesize,
1295 int namestoragesize,
1320 if( lpi->
highs->getLp().sense_ == ObjSense::kMaximize )
1339 assert(0 <= firstcol && firstcol <= lastcol && lastcol < lpi->highs->getLp().num_col_);
1342 for(
int i = firstcol;
i < lastcol + 1; ++
i )
1343 vals[
i - firstcol] = lpi->
highs->getLp().col_cost_[
i];
1361 assert(0 <= firstcol && firstcol <= lastcol && lastcol < lpi->highs->getLp().num_col_);
1363 for(
int i = firstcol;
i < lastcol + 1; ++
i )
1366 lbs[
i - firstcol] = lpi->
highs->getLp().col_lower_[
i];
1368 ubs[
i - firstcol] = lpi->
highs->getLp().col_upper_[
i];
1388 assert(0 <= firstrow && firstrow <= lastrow && lastrow < lpi->highs->getLp().num_row_);
1390 for(
int i = firstrow;
i < lastrow + 1; ++
i )
1393 lhss[
i - firstrow] = lpi->
highs->getLp().row_lower_[
i];
1395 rhss[
i - firstrow] = lpi->
highs->getLp().row_upper_[
i];
1413 assert(0 <= col && col < lpi->highs->getNumCol());
1414 assert(0 <= row && row < lpi->highs->getNumCol());
1440#ifdef SCIP_WITH_HIGHSPRIMAL
1463#ifdef SCIP_WITH_HIGHSPARALLEL
1496 SCIPdebugMessage(
"HiGHS does not support Barrier - switching to dual simplex\n");
1550 SCIP_Real dualbound = (lpi->
highs->getLp().sense_ == ObjSense::kMinimize
1558 *down = *up = dualbound;
1594 SCIP_Real dualbound = (lpi->
highs->getLp().sense_ == ObjSense::kMinimize
1602 for(
int j = 0; j < ncols; ++j )
1604 down[j] = up[j] = dualbound;
1605 downvalid[j] = upvalid[j] =
TRUE;
1734 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1736 return model_status == HighsModelStatus::kUnbounded || model_status == HighsModelStatus::kUnboundedOrInfeasible;
1755 if( lpi->
highs->getNumRow() == 0 )
1758 bool has_primal_ray =
false;
1760 return has_primal_ray;
1773 return lpi->
highs->getModelStatus() == HighsModelStatus::kUnbounded;
1786 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1789 if( model_status == HighsModelStatus::kModelEmpty )
1791 int numrow = lpi->
highs->getNumRow();
1795 for(
int i = 0;
i < numrow;
i++ )
1797 if( lpi->
highs->getLp().row_lower_[
i] > 0.0 || lpi->
highs->getLp().row_upper_[
i] < 0.0 )
1804 const bool primal_infeasible =
1805 model_status == HighsModelStatus::kInfeasible ||
1806 model_status == HighsModelStatus::kUnboundedOrInfeasible;
1807 return primal_infeasible;
1820 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1823 if( model_status == HighsModelStatus::kModelEmpty )
1825 int numrow = lpi->
highs->getNumRow();
1829 for(
int i = 0;
i < numrow;
i++ )
1831 if( lpi->
highs->getLp().row_lower_[
i] > 0.0 || lpi->
highs->getLp().row_upper_[
i] < 0.0 )
1838 const bool primal_feasible =
1839 model_status == HighsModelStatus::kOptimal ||
1840 model_status == HighsModelStatus::kUnbounded;
1841 return primal_feasible;
1870 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1873 if( model_status == HighsModelStatus::kModelEmpty )
1877 bool has_dual_ray =
false;
1879 return has_dual_ray;
1905 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1906 const bool dual_infeasible =
1907 model_status == HighsModelStatus::kUnbounded ||
1908 model_status == HighsModelStatus::kUnboundedOrInfeasible;
1909 return dual_infeasible;
1922 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1924 if( model_status == HighsModelStatus::kOptimal || model_status == HighsModelStatus::kModelEmpty )
1926 else if( model_status == HighsModelStatus::kUnbounded || model_status == HighsModelStatus::kUnboundedOrInfeasible )
1929 int num_dual_infeasibilities = 1;
1930 HighsStatus status = lpi->
highs->getInfoValue(
"num_dual_infeasibilities", num_dual_infeasibilities);
1931 bool has_dual_feasible_sol = (status == HighsStatus::kOk) && (num_dual_infeasibilities == 0);
1932 return has_dual_feasible_sol;
1945 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1947 if( model_status == HighsModelStatus::kModelEmpty )
1953 return lpi->
highs->getModelStatus() == HighsModelStatus::kOptimal;
1974 HIGHS_CALL( lpi->
highs->getOptionValue(
"objective_bound", objlimit) );
1975 HIGHS_CALL( lpi->
highs->getInfoValue(
"objective_function_value", objvalue) );
1977 if( lpi->
highs->getLp().sense_ == ObjSense::kMaximize )
1999 return lpi->
highs->getModelStatus() == HighsModelStatus::kObjectiveBound;
2012 return lpi->
highs->getModelStatus() == HighsModelStatus::kIterationLimit;
2025 return lpi->
highs->getModelStatus() == HighsModelStatus::kTimeLimit;
2038 return (
int) lpi->
highs->getModelStatus();
2071 assert(lpi->
highs->getModelStatus() != HighsModelStatus::kModelEmpty || *
objval == 0.0);
2102 assert(lpi->
highs->getModelStatus() != HighsModelStatus::kModelEmpty || *
objval == 0.0);
2105 const std::vector<double> &colValue = lpi->
highs->getSolution().col_value;
2106 const std::vector<double> &colDual = lpi->
highs->getSolution().col_dual;
2107 const std::vector<double> &rowValue = lpi->
highs->getSolution().row_value;
2108 const std::vector<double> &rowDual = lpi->
highs->getSolution().row_dual;
2112 if( colValue.size() != (
size_t) ncols || colDual.size() != (
size_t) ncols
2113 || rowValue.size() != (
size_t) nrows || rowDual.size() != (
size_t) nrows )
2119 assert((
int) rowValue.size() == nrows);
2125 for(
i = 0;
i < ncols;
i++ )
2127 if( dualsol !=
NULL )
2128 for(
i = 0;
i < nrows;
i++ )
2129 dualsol[
i] = rowDual[
i];
2130 if( activity !=
NULL )
2131 for(
i = 0;
i < nrows;
i++ )
2132 activity[
i] = rowValue[
i];
2133 if( redcost !=
NULL )
2134 for(
i = 0;
i < ncols;
i++ )
2135 redcost[
i] = colDual[
i];
2149 bool success =
false;
2156 if( lpi->
highs->getNumRow() == 0 )
2158 int numcol = lpi->
highs->getNumCol();
2160 for(
int i = 0;
i < numcol;
i++ )
2163 if( lpi->
highs->getLp().sense_ == ObjSense::kMaximize )
2200 HighsModelStatus model_status = lpi->
highs->getModelStatus();
2203 if( model_status == HighsModelStatus::kModelEmpty )
2205 SCIP_Real dualdir = lpi->
highs->getLp().sense_ == ObjSense::kMinimize ? 1.0 : -1.0;
2206 int numrow = lpi->
highs->getNumRow();
2210 for(
int i = 0;
i < numrow;
i++ )
2212 if( lpi->
highs->getLp().row_lower_[
i] > 0.0 )
2213 dualfarkas[
i] = dualdir;
2214 else if( lpi->
highs->getLp().row_upper_[
i] < 0.0 )
2215 dualfarkas[
i] = -dualdir;
2217 dualfarkas[
i] = 0.0;
2223 bool has_dual_ray =
false;
2244 assert(*iterations >= 0);
2293 for(
int i = 0;
i < lpi->
highs->getLp().num_col_; ++
i )
2294 cstat[
i] = (
int) lpi->
highs->getBasis().col_status[
i];
2298 for(
int i = 0;
i < lpi->
highs->getLp().num_row_; ++
i )
2299 rstat[
i] = (
int) lpi->
highs->getBasis().row_status[
i];
2317 HighsBasis local_highs_basis;
2319 local_highs_basis.col_status.resize(lpi->
highs->getLp().num_col_);
2320 local_highs_basis.row_status.resize(lpi->
highs->getLp().num_row_);
2324 for(
int i = 0;
i < lpi->
highs->getLp().num_col_; ++
i )
2329 for(
int i = 0;
i < lpi->
highs->getLp().num_row_; ++
i )
2349 if( !lpi->
highs->getBasis().valid )
2351 SCIPdebugMessage(
"HiGHS Basis is not valid in function call SCIPlpiGetBasisInd()\n" );
2379 if( lpi->
highs->getBasisInverseRow(
r, coef, ninds, inds) != HighsStatus::kOk )
2412 if( lpi->
highs->getBasisInverseCol(
c, coef, ninds, inds) != HighsStatus::kOk )
2443 if( lpi->
highs->getReducedRow(
r, coef, ninds, inds, binvrow) != HighsStatus::kOk )
2474 if( lpi->
highs->getReducedColumn(
c, coef, ninds, inds) != HighsStatus::kOk )
2510 ncols = lpi->
highs->getLp().num_col_;
2511 nrows = lpi->
highs->getLp().num_row_;
2526 (*lpistate)->ncols = ncols;
2527 (*lpistate)->nrows = nrows;
2553 lpncols = lpi->
highs->getLp().num_col_;
2554 lpnrows = lpi->
highs->getLp().num_row_;
2566 for(
i = lpistate->
ncols;
i < lpncols; ++
i )
2578 for(
i = lpistate->
nrows;
i < lpnrows; ++
i )
2613 if( *lpistate !=
NULL )
2757 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_scale_strategy", *ival) );
2758 assert(*ival == 0 || *ival == 2 || *ival == 4);
2761 else if( *ival <= 2 )
2776 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_iteration_limit", *ival) );
2811 assert(ival >= 0 && ival <= 2);
2814 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_scale_strategy", 0) );
2815 else if( ival == 1 )
2817 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_scale_strategy", 2) );
2820 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_scale_strategy", 4) );
2825 HIGHS_CALL( lpi->
highs->setOptionValue(
"presolve", ival ?
"on" :
"off") );
2834 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_primal_edge_weight_strategy", -1) );
2835 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_dual_edge_weight_strategy", -1) );
2838 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_primal_edge_weight_strategy", 1) );
2839 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_dual_edge_weight_strategy", 1) );
2844 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_primal_edge_weight_strategy", 2) );
2845 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_dual_edge_weight_strategy", 2) );
2855 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_iteration_limit", ival) );
2883 HIGHS_CALL( lpi->
highs->getOptionValue(
"primal_feasibility_tolerance", *dval) );
2886 HIGHS_CALL( lpi->
highs->getOptionValue(
"dual_feasibility_tolerance", *dval) );
2917 dval =
MAX(dval, 1e-10);
2918 HIGHS_CALL( lpi->
highs->setOptionValue(
"primal_feasibility_tolerance", dval) );
2922 dval =
MAX(dval, 1e-10);
2923 HIGHS_CALL( lpi->
highs->setOptionValue(
"dual_feasibility_tolerance", dval) );
2985 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