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)
188#define COLS_PER_PACKET SCIP_DUALPACKETSIZE
190#define ROWS_PER_PACKET SCIP_DUALPACKETSIZE
223 assert(num <= lpi->cstatsize);
247 assert(num <= lpi->rstatsize);
373 return HighsBasisStatus::kLower;
375 return HighsBasisStatus::kBasic;
377 return HighsBasisStatus::kUpper;
379 return HighsBasisStatus::kZero;
382 SCIPerrorMessage(
"Unknown Basis Status returned. Please use supported HiGHS version!\n");
383 return HighsBasisStatus::kZero;
398 return "Dual (serial)";
400 return "Dual (PAMI)";
418 SCIP_Real small_matrix_value;
419 SCIP_Real large_matrix_value;
421 HIGHS_CALL( lpi->
highs->getOptionValue(
"small_matrix_value", small_matrix_value) );
422 HIGHS_CALL( lpi->
highs->getOptionValue(
"large_matrix_value", large_matrix_value) );
424 assert(value == 0.0 || fabs(value) > small_matrix_value);
425 assert(fabs(value) < large_matrix_value);
437 std::string presolvestring;
440 int ck_ca_n = -99999;
453 lpi->
highs->zeroAllClocks();
460 HighsModelStatus model_status = lpi->
highs->getModelStatus();
461 switch( model_status )
464 case HighsModelStatus::kModelEmpty:
465 case HighsModelStatus::kOptimal:
466 case HighsModelStatus::kInfeasible:
467 case HighsModelStatus::kUnboundedOrInfeasible:
468 case HighsModelStatus::kUnbounded:
469 case HighsModelStatus::kObjectiveBound:
470 case HighsModelStatus::kTimeLimit:
471 case HighsModelStatus::kIterationLimit:
474 int simplex_strategy = -1;
475 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_strategy", simplex_strategy) );
476 SCIPdebugMessage(
"HiGHS terminated with model status <%s> (%d) after simplex strategy <%s> (%d)\n",
477 lpi->
highs->modelStatusToString(model_status).c_str(), (
int)model_status,
483 case HighsModelStatus::kNotset:
484 case HighsModelStatus::kLoadError:
485 case HighsModelStatus::kModelError:
486 case HighsModelStatus::kPresolveError:
487 case HighsModelStatus::kSolveError:
488 case HighsModelStatus::kPostsolveError:
489 case HighsModelStatus::kSolutionLimit:
490 case HighsModelStatus::kObjectiveTarget:
491 case HighsModelStatus::kUnknown:
494 int simplex_strategy = -1;
495 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_strategy", simplex_strategy) );
496 SCIPerrorMessage(
"HiGHS terminated with model status <%s> (%d) after simplex strategy <%s> (%d)\n",
497 lpi->
highs->modelStatusToString(model_status).c_str(), (
int)model_status,
505 assert(presolvestring ==
"on" || presolvestring ==
"off");
506 if( !lpi->
highs->hasInvert() && presolvestring ==
"on" )
510 SCIPdebugMessage(
"No inverse: running HiGHS again without presolve . . .\n");
515 HighsModelStatus model_status2 = lpi->
highs->getModelStatus();
516 SCIPerrorMessage(
"HiGHS terminated with model status <%s> (%d) after trying to recover inverse\n",
517 lpi->
highs->modelStatusToString(model_status2).c_str(), (
int)model_status2);
525 int highs_iterations;
526 HIGHS_CALL( lpi->
highs->getInfoValue(
"simplex_iteration_count", highs_iterations) );
528 lpi->
highs->getObjectiveValue(), highs_iterations,
529 lpi->
highs->modelStatusToString(lpi->
highs->getModelStatus()).c_str());
558 snprintf(
highsname, 30,
"HiGHS %d.%d.%d", HIGHS_VERSION_MAJOR, HIGHS_VERSION_MINOR, HIGHS_VERSION_PATCH);
569 snprintf(
highsdesc, 200,
"%s [GitHash: %s]",
570 "Linear optimization suite written and engineered at the University of Edinburgh",
582 return (
void *) lpi->
highs;
598 SCIPerrorMessage(
"SCIPlpiSetIntegralityInformation() has not been implemented yet\n");
655 (*lpi)->cstat =
NULL;
656 (*lpi)->rstat =
NULL;
657 (*lpi)->cstatsize = 0;
658 (*lpi)->rstatsize = 0;
659 (*lpi)->nthreads = 1;
660 (*lpi)->fromscratch =
FALSE;
661 (*lpi)->solved =
FALSE;
663 (*lpi)->messagehdlr = messagehdlr;
671 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"output_flag",
false) );
672#ifdef HIGHS_LOGDEVLEVEL
673 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"log_dev_level", HIGHS_LOGDEVLEVEL) );
675#ifdef HIGHS_DEBUGLEVEL
676 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"highs_debug_level", HIGHS_DEBUGLEVEL) );
684 HIGHS_CALL( (*lpi)->highs->setOptionValue(
"lp_presolve_requires_basis_postsolve",
true) );
703 (*lpi)->highs->~HighsSCIP();
729 const SCIP_Real*
obj,
734 const SCIP_Real* lhs,
735 const SCIP_Real* rhs,
759 assert(nnonz == 0 || ( nrows > 0 && ncols > 0));
761 for(
int j = 0; j < nnonz; ++j )
763 assert(0 <= ind[j] && ind[j] < nrows);
769 int objectiveSenseInt = objsen ==
SCIP_OBJSEN_MAXIMIZE ? (int)ObjSense::kMaximize : (int)ObjSense::kMinimize;
770 HIGHS_CALL( lpi->
highs->passModel(ncols, nrows, nnonz, 1, objectiveSenseInt, 0,
obj, lb, ub, lhs, rhs, beg, ind, val) );
782 const SCIP_Real*
obj,
815 int nrows = lpi->
highs->getLp().num_row_;
816 for(
int j = 0; j < nnonz; ++j )
818 assert(0 <= ind[j] && ind[j] < nrows);
881 const SCIP_Real* lhs,
882 const SCIP_Real* rhs,
908 int ncols = lpi->
highs->getLp().num_col_;
909 for(
int j = 0; j < nnonz; ++j )
911 assert(0 <= ind[j] && ind[j] < ncols);
919 HIGHS_CALL( lpi->
highs->addRows(nrows, lhs, rhs, nnonz, beg, ind, val) );
939 assert(0 <= firstrow && firstrow <= lastrow );
1012 for(
i = 0;
i < ncols; ++
i )
1014 assert(0 <= ind[
i] && ind[
i] < lpi->
highs->getLp().num_col_);
1018 SCIPerrorMessage(
"LP Error: fixing lower bound for variable %d to infinity\n", ind[
i]);
1023 SCIPerrorMessage(
"LP Error: fixing upper bound for variable %d to -infinity\n", ind[
i]);
1038 const SCIP_Real* lhs,
1039 const SCIP_Real* rhs
1054 for(
i = 0;
i < nrows; ++
i )
1055 assert(0 <= ind[
i] && ind[
i] < lpi->
highs->getLp().num_row_);
1106 const SCIP_Real*
obj
1183 *nrows = lpi->
highs->getNumRow();
1200 *ncols = lpi->
highs->getNumCol();
1217 *nnonz = lpi->
highs->getNumNz();
1245 HIGHS_CALL( lpi->
highs->getCols(firstcol, lastcol, num_col,
NULL, lb, ub, *nnonz, beg, ind, val) );
1270 HIGHS_CALL( lpi->
highs->getRows(firstrow, lastrow, num_row, lhs, rhs, *nnonz, beg, ind, val) );
1281 int namestoragesize,
1301 int namestoragesize,
1326 if( lpi->
highs->getLp().sense_ == ObjSense::kMaximize )
1345 assert(0 <= firstcol && firstcol <= lastcol && lastcol < lpi->highs->getLp().num_col_);
1348 for(
int i = firstcol;
i < lastcol + 1; ++
i )
1349 vals[
i - firstcol] = lpi->
highs->getLp().col_cost_[
i];
1367 assert(0 <= firstcol && firstcol <= lastcol && lastcol < lpi->highs->getLp().num_col_);
1369 for(
int i = firstcol;
i < lastcol + 1; ++
i )
1372 lbs[
i - firstcol] = lpi->
highs->getLp().col_lower_[
i];
1374 ubs[
i - firstcol] = lpi->
highs->getLp().col_upper_[
i];
1394 assert(0 <= firstrow && firstrow <= lastrow && lastrow < lpi->highs->getLp().num_row_);
1396 for(
int i = firstrow;
i < lastrow + 1; ++
i )
1399 lhss[
i - firstrow] = lpi->
highs->getLp().row_lower_[
i];
1401 rhss[
i - firstrow] = lpi->
highs->getLp().row_upper_[
i];
1419 assert(0 <= col && col < lpi->highs->getNumCol());
1420 assert(0 <= row && row < lpi->highs->getNumCol());
1446#ifdef SCIP_WITH_HIGHSPRIMAL
1469#ifdef SCIP_WITH_HIGHSPARALLEL
1502 SCIPdebugMessage(
"HiGHS does not support Barrier - switching to dual simplex\n");
1540 SCIP_Bool* downvalid,
1556 SCIP_Real dualbound = (lpi->
highs->getLp().sense_ == ObjSense::kMinimize
1564 *down = *up = dualbound;
1583 SCIP_Bool* downvalid,
1600 SCIP_Real dualbound = (lpi->
highs->getLp().sense_ == ObjSense::kMinimize
1608 for(
int j = 0; j < ncols; ++j )
1610 down[j] = up[j] = dualbound;
1611 downvalid[j] = upvalid[j] =
TRUE;
1628 SCIP_Bool* downvalid,
1657 SCIP_Bool* downvalid,
1712 SCIP_Bool* primalfeasible,
1713 SCIP_Bool* dualfeasible
1740 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1742 return model_status == HighsModelStatus::kUnbounded || model_status == HighsModelStatus::kUnboundedOrInfeasible;
1761 if( lpi->
highs->getNumRow() == 0 )
1764 bool has_primal_ray =
false;
1766 return has_primal_ray;
1779 return lpi->
highs->getModelStatus() == HighsModelStatus::kUnbounded;
1792 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1795 if( model_status == HighsModelStatus::kModelEmpty )
1797 int numrow = lpi->
highs->getNumRow();
1801 for(
int i = 0;
i < numrow;
i++ )
1803 if( lpi->
highs->getLp().row_lower_[
i] > 0.0 || lpi->
highs->getLp().row_upper_[
i] < 0.0 )
1810 const bool primal_infeasible =
1811 model_status == HighsModelStatus::kInfeasible ||
1812 model_status == HighsModelStatus::kUnboundedOrInfeasible;
1813 return primal_infeasible;
1826 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1829 if( model_status == HighsModelStatus::kModelEmpty )
1831 int numrow = lpi->
highs->getNumRow();
1835 for(
int i = 0;
i < numrow;
i++ )
1837 if( lpi->
highs->getLp().row_lower_[
i] > 0.0 || lpi->
highs->getLp().row_upper_[
i] < 0.0 )
1844 const bool primal_feasible =
1845 model_status == HighsModelStatus::kOptimal ||
1846 model_status == HighsModelStatus::kUnbounded;
1847 return primal_feasible;
1876 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1879 if( model_status == HighsModelStatus::kModelEmpty )
1883 bool has_dual_ray =
false;
1885 return has_dual_ray;
1911 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1912 const bool dual_infeasible =
1913 model_status == HighsModelStatus::kUnbounded ||
1914 model_status == HighsModelStatus::kUnboundedOrInfeasible;
1915 return dual_infeasible;
1928 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1930 if( model_status == HighsModelStatus::kOptimal || model_status == HighsModelStatus::kModelEmpty )
1932 else if( model_status == HighsModelStatus::kUnbounded || model_status == HighsModelStatus::kUnboundedOrInfeasible )
1935 int num_dual_infeasibilities = 1;
1936 HighsStatus status = lpi->
highs->getInfoValue(
"num_dual_infeasibilities", num_dual_infeasibilities);
1937 bool has_dual_feasible_sol = (status == HighsStatus::kOk) && (num_dual_infeasibilities == 0);
1938 return has_dual_feasible_sol;
1951 HighsModelStatus model_status = lpi->
highs->getModelStatus();
1953 if( model_status == HighsModelStatus::kModelEmpty )
1959 return lpi->
highs->getModelStatus() == HighsModelStatus::kOptimal;
1980 HIGHS_CALL( lpi->
highs->getOptionValue(
"objective_bound", objlimit) );
1981 HIGHS_CALL( lpi->
highs->getInfoValue(
"objective_function_value", objvalue) );
1983 if( lpi->
highs->getLp().sense_ == ObjSense::kMaximize )
2005 return lpi->
highs->getModelStatus() == HighsModelStatus::kObjectiveBound;
2018 return lpi->
highs->getModelStatus() == HighsModelStatus::kIterationLimit;
2031 return lpi->
highs->getModelStatus() == HighsModelStatus::kTimeLimit;
2044 return (
int) lpi->
highs->getModelStatus();
2077 assert(lpi->
highs->getModelStatus() != HighsModelStatus::kModelEmpty || *
objval == 0.0);
2092 SCIP_Real* activity,
2108 assert(lpi->
highs->getModelStatus() != HighsModelStatus::kModelEmpty || *
objval == 0.0);
2111 const std::vector<double> &colValue = lpi->
highs->getSolution().col_value;
2112 const std::vector<double> &colDual = lpi->
highs->getSolution().col_dual;
2113 const std::vector<double> &rowValue = lpi->
highs->getSolution().row_value;
2114 const std::vector<double> &rowDual = lpi->
highs->getSolution().row_dual;
2118 if( colValue.size() != (
size_t) ncols || colDual.size() != (
size_t) ncols
2119 || rowValue.size() != (
size_t) nrows || rowDual.size() != (
size_t) nrows )
2125 assert((
int) rowValue.size() == nrows);
2131 for(
i = 0;
i < ncols;
i++ )
2133 if( dualsol !=
NULL )
2134 for(
i = 0;
i < nrows;
i++ )
2135 dualsol[
i] = rowDual[
i];
2136 if( activity !=
NULL )
2137 for(
i = 0;
i < nrows;
i++ )
2138 activity[
i] = rowValue[
i];
2139 if( redcost !=
NULL )
2140 for(
i = 0;
i < ncols;
i++ )
2141 redcost[
i] = colDual[
i];
2155 bool success =
false;
2162 if( lpi->
highs->getNumRow() == 0 )
2164 int numcol = lpi->
highs->getNumCol();
2166 for(
int i = 0;
i < numcol;
i++ )
2169 if( lpi->
highs->getLp().sense_ == ObjSense::kMaximize )
2197 SCIP_Real* dualfarkas
2206 HighsModelStatus model_status = lpi->
highs->getModelStatus();
2209 if( model_status == HighsModelStatus::kModelEmpty )
2211 SCIP_Real dualdir = lpi->
highs->getLp().sense_ == ObjSense::kMinimize ? 1.0 : -1.0;
2212 int numrow = lpi->
highs->getNumRow();
2216 for(
int i = 0;
i < numrow;
i++ )
2218 if( lpi->
highs->getLp().row_lower_[
i] > 0.0 )
2219 dualfarkas[
i] = dualdir;
2220 else if( lpi->
highs->getLp().row_upper_[
i] < 0.0 )
2221 dualfarkas[
i] = -dualdir;
2223 dualfarkas[
i] = 0.0;
2229 bool has_dual_ray =
false;
2250 assert(*iterations >= 0);
2299 for(
int i = 0;
i < lpi->
highs->getLp().num_col_; ++
i )
2300 cstat[
i] = (
int) lpi->
highs->getBasis().col_status[
i];
2304 for(
int i = 0;
i < lpi->
highs->getLp().num_row_; ++
i )
2305 rstat[
i] = (
int) lpi->
highs->getBasis().row_status[
i];
2323 HighsBasis local_highs_basis;
2325 local_highs_basis.col_status.resize(lpi->
highs->getLp().num_col_);
2326 local_highs_basis.row_status.resize(lpi->
highs->getLp().num_row_);
2330 for(
int i = 0;
i < lpi->
highs->getLp().num_col_; ++
i )
2335 for(
int i = 0;
i < lpi->
highs->getLp().num_row_; ++
i )
2355 if( !lpi->
highs->getBasis().valid )
2357 SCIPdebugMessage(
"HiGHS Basis is not valid in function call SCIPlpiGetBasisInd()\n" );
2385 if( lpi->
highs->getBasisInverseRow(
r, coef, ninds, inds) != HighsStatus::kOk )
2418 if( lpi->
highs->getBasisInverseCol(
c, coef, ninds, inds) != HighsStatus::kOk )
2437 const SCIP_Real* binvrow,
2449 if( lpi->
highs->getReducedRow(
r, coef, ninds, inds, binvrow) != HighsStatus::kOk )
2480 if( lpi->
highs->getReducedColumn(
c, coef, ninds, inds) != HighsStatus::kOk )
2516 ncols = lpi->
highs->getLp().num_col_;
2517 nrows = lpi->
highs->getLp().num_row_;
2532 (*lpistate)->ncols = ncols;
2533 (*lpistate)->nrows = nrows;
2559 lpncols = lpi->
highs->getLp().num_col_;
2560 lpnrows = lpi->
highs->getLp().num_row_;
2572 for(
i = lpistate->
ncols;
i < lpncols; ++
i )
2584 for(
i = lpistate->
nrows;
i < lpnrows; ++
i )
2619 if( *lpistate !=
NULL )
2763 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_scale_strategy", *ival) );
2764 assert(*ival == 0 || *ival == 2 || *ival == 4);
2767 else if( *ival <= 2 )
2787 HIGHS_CALL( lpi->
highs->getOptionValue(
"simplex_iteration_limit", *ival) );
2822 assert(ival >= 0 && ival <= 2);
2825 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_scale_strategy", 0) );
2826 else if( ival == 1 )
2828 HIGHS_CALL( lpi->
highs->setOptionValue(
"simplex_scale_strategy", 2) );
2831 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
static SCIP_RETCODE presolve(SCIP *scip, SCIP_Bool *unbounded, SCIP_Bool *infeasible, SCIP_Bool *vanished)
SCIP_MESSAGEHDLR * messagehdlr
type definitions for LP management
@ SCIP_PRICING_STEEPQSTART
@ SCIP_PRICING_LPIDEFAULT
enum SCIP_Pricing SCIP_PRICING
enum SCIP_LPParam SCIP_LPPARAM
enum SCIP_LPSolQuality SCIP_LPSOLQUALITY
enum SCIP_ObjSen SCIP_OBJSEN
enum SCIP_Retcode SCIP_RETCODE