35#pragma GCC diagnostic ignored "-Wsign-compare"
36#pragma GCC diagnostic ignored "-Wpedantic"
37#pragma GCC diagnostic ignored "-Wignored-qualifiers"
38#pragma GCC diagnostic ignored "-Wshadow"
39#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
40#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
41#pragma GCC diagnostic ignored "-Woverflow"
43#include "ortools/base/version.h"
44#include "ortools/glop/lp_solver.h"
45#include "ortools/glop/revised_simplex.h"
46#include "ortools/lp_data/lp_print_utils.h"
47#include "ortools/lp_data/lp_data_utils.h"
48#include "ortools/lp_data/proto_utils.h"
49#include "ortools/util/file_util.h"
50#include "ortools/util/stats.h"
51#include "ortools/util/time_limit.h"
53#include "ortools/base/logging.h"
54#include "ortools/base/vlog_is_on.h"
62#pragma GCC diagnostic warning "-Wsign-compare"
63#pragma GCC diagnostic warning "-Wpedantic"
64#pragma GCC diagnostic warning "-Wignored-qualifiers"
65#pragma GCC diagnostic warning "-Wshadow"
66#pragma GCC diagnostic warning "-Wnon-virtual-dtor"
67#pragma GCC diagnostic warning "-Wctor-dtor-privacy"
68#pragma GCC diagnostic warning "-Woverflow"
71using operations_research::TimeLimit;
72using operations_research::glop::BasisState;
73using operations_research::glop::ColIndex;
74using operations_research::glop::ColIndexVector;
75using operations_research::glop::ConstraintStatus;
76using operations_research::glop::ConstraintStatusColumn;
77using operations_research::glop::DenseBooleanColumn;
78using operations_research::glop::DenseBooleanRow;
79using operations_research::glop::DenseColumn;
80using operations_research::glop::DenseRow;
81using operations_research::glop::SparseColumn;
82using operations_research::glop::ScatteredColumn;
83using operations_research::glop::ScatteredColumnIterator;
84using operations_research::glop::SparseMatrix;
85using operations_research::glop::Fractional;
86using operations_research::glop::GetProblemStatusString;
87using operations_research::glop::ProblemStatus;
88using operations_research::glop::RowIndex;
89using operations_research::glop::ScatteredRow;
90using operations_research::glop::ScatteredRowIterator;
91using operations_research::glop::VariableStatus;
92using operations_research::glop::VariableStatusRow;
93using operations_research::MPModelProto;
99 operations_research::glop::LinearProgram*
scaled_lp;
100 operations_research::glop::RevisedSimplex*
solver;
102 operations_research::glop::LpScalingHelper*
scaler;
133#define UNSCALEDFEAS_CHECK 0
135#define UNSCALEDFEAS_CHECK 2
150 (
void)
snprintf(
glopname, 100,
"Glop %d.%d", operations_research::OrToolsMajorVersion(), operations_research::OrToolsMinorVersion());
167 return "Glop Linear Solver, developed by Google, part of OR-Tools (developers.google.com/optimization)";
177 SCIPerrorMessage(
"SCIPlpiGetSolverPointer() has not been implemented yet.\n");
194 for (ColIndex col(0); col < ColIndex(ncols); ++col)
197 int info =
intInfo[col.value()];
198 assert( info == 0 || info == 1 );
200 lpi->
linear_program->SetVariableType(col, operations_research::glop::LinearProgram::VariableType::CONTINUOUS);
202 lpi->
linear_program->SetVariableType(col, operations_research::glop::LinearProgram::VariableType::INTEGER);
253 (*lpi)->linear_program =
new operations_research::glop::LinearProgram();
254 (*lpi)->scaled_lp =
new operations_research::glop::LinearProgram();
255 (*lpi)->solver =
new operations_research::glop::RevisedSimplex();
256 (*lpi)->parameters =
new operations_research::glop::GlopParameters();
257 (*lpi)->scaler =
new operations_research::glop::LpScalingHelper();
260 (*lpi)->linear_program->SetName(std::string(name));
263 (*lpi)->from_scratch =
false;
264 (*lpi)->lp_info =
false;
266 (*lpi)->lp_modified_since_last_solve =
true;
267 (*lpi)->lp_time_limit_was_reached =
false;
268 (*lpi)->conditionlimit = -1.0;
269 (*lpi)->checkcondition =
false;
270 (*lpi)->niterations = 0
LL;
272 (*lpi)->tmp_row =
new ScatteredRow();
273 (*lpi)->tmp_column =
new ScatteredColumn();
276 (*lpi)->parameters->set_use_scaling(
false);
289 delete (*lpi)->scaler;
290 delete (*lpi)->parameters;
291 delete (*lpi)->solver;
292 delete (*lpi)->scaled_lp;
293 delete (*lpi)->linear_program;
295 delete (*lpi)->tmp_row;
296 delete (*lpi)->tmp_column;
320 const SCIP_Real*
obj,
325 const SCIP_Real* lhs,
326 const SCIP_Real* rhs,
355 const SCIP_Real*
obj,
386 for (
int j = 0;
j < nnonz; ++
j)
394 for (
int i = 0;
i < ncols; ++
i)
399 const int end = (nnonz == 0 ||
i == ncols - 1) ? nnonz :
beg[
i + 1];
410 for (
int i = 0;
i < ncols; ++
i)
463 for (ColIndex col(0); col <
num_cols; ++col)
486 const SCIP_Real* lhs,
487 const SCIP_Real* rhs,
515 for (
int j = 0;
j < nnonz; ++
j)
523 for (
int i = 0;
i < nrows; ++
i)
527 const int end = (nnonz == 0 ||
i == nrows - 1) ? nnonz :
beg[
i + 1];
538 for (
int i = 0;
i < nrows; ++
i)
561 BasisState state = lpi->
solver->GetState();
574 lpi->
solver->LoadStateForNextSolve(state);
670 for (
int i = 0;
i < ncols; ++
i)
697 const SCIP_Real* lhs,
709 for (
int i = 0;
i < nrows; ++
i)
780 for (
int i = 0;
i < ncols; ++
i)
817 for (
int j = 0;
j < nnonz; ++
j)
827 else if ( scaleval < 0.0 )
832 else if ( scaleval < 0.0 )
835 if ( scaleval > 0.0 )
881 for (
int j = 0;
j < nnonz; ++
j)
896 else if ( scaleval < 0.0 )
901 else if ( scaleval < 0.0 )
904 if ( scaleval > 0.0 )
1022 if ( nnonz !=
NULL )
1030 for (ColIndex col(
firstcol); col <= ColIndex(
lastcol); ++col, ++index)
1033 lb[index] =
tmplb[col];
1035 ub[index] =
tmpub[col];
1037 beg[index] = *nnonz;
1042 ind[*nnonz] = row.value();
1043 val[*nnonz] =
entry.coefficient();
1051 for (ColIndex col(
firstcol); col <= ColIndex(
lastcol); ++col, ++index)
1054 lb[index] =
tmplb[col];
1056 ub[index] =
tmpub[col];
1088 if ( nnonz !=
NULL )
1101 lhs[index] =
tmplhs[row];
1103 rhs[index] =
tmprhs[row];
1105 beg[index] = *nnonz;
1110 ind[*nnonz] = rowidx.value();
1111 val[*nnonz] =
entry.coefficient();
1122 lhs[index] =
tmplhs[row];
1124 rhs[index] =
tmprhs[row];
1197 vals[index] = lpi->
linear_program->objective_coefficients()[col];
1277 const SparseMatrix& matrix = lpi->
linear_program->GetSparseMatrix();
1278 *val = matrix.LookUpValue(
RowIndex(row), ColIndex(col));
1305 lpi->
scaled_lp->AddSlackVariablesWhereNecessary(
false);
1325#if UNSCALEDFEAS_CHECK == 1
1329 for (ColIndex col = ColIndex(0); col <
num_cols; ++col)
1333 const double feastol = lpi->
parameters->primal_feasibility_tolerance();
1336#elif UNSCALEDFEAS_CHECK == 2
1337 const double feastol = lpi->
parameters->primal_feasibility_tolerance();
1341 for (ColIndex col = ColIndex(0); col <
num_cols; ++col)
1343 const Fractional val = lpi->
scaler->UnscaleVariableValue(col, lpi->
solver->GetVariableValue(col));
1344 const Fractional lb = lpi->
linear_program->variable_lower_bounds()[col];
1345 if ( val < lb - feastol )
1347 const Fractional ub = lpi->
linear_program->variable_upper_bounds()[col];
1348 if ( val > ub + feastol )
1356 const Fractional val = lpi->
scaler->UnscaleConstraintActivity(row, lpi->
solver->GetConstraintActivity(row));
1357 const Fractional lhs = lpi->
linear_program->constraint_lower_bounds()[row];
1358 if ( val < lhs - feastol )
1360 const Fractional rhs = lpi->
linear_program->constraint_upper_bounds()[row];
1361 if ( val > rhs + feastol )
1388 lpi->
solver->ClearStateForNextSolve();
1400 SCIPdebugMessage(
"status=%s obj=%f iter=%ld.\n", GetProblemStatusString(lpi->
solver->GetProblemStatus()).c_str(),
1401 lpi->
solver->GetObjectiveValue(), lpi->
solver->GetNumberOfIterations());
1403 const ProblemStatus status = lpi->
solver->GetProblemStatus();
1404 if ( (status == ProblemStatus::PRIMAL_FEASIBLE || status == ProblemStatus::OPTIMAL) && lpi->
parameters->use_scaling() )
1408 SCIPdebugMessage(
"Solution not feasible w.r.t. absolute tolerance %g -> reoptimize.\n", lpi->
parameters->primal_feasibility_tolerance());
1418 SCIPdebugMessage(
"Solution still not feasible after turning off scaling.\n");
1442 lpi->
parameters->set_use_dual_simplex(
false);
1511 ProblemStatus status
1514 return status == ProblemStatus::OPTIMAL || status == ProblemStatus::DUAL_FEASIBLE || status == ProblemStatus::DUAL_UNBOUNDED;
1544 const Fractional lb = lpi->
scaled_lp->variable_lower_bounds()[col];
1545 const Fractional ub = lpi->
scaled_lp->variable_upper_bounds()[col];
1546 const double value =
psol * lpi->
scaler->VariableScalingFactor(col);
1554 const Fractional
eps = lpi->
parameters->primal_feasibility_tolerance();
1560 if (
newub >= lb - 0.5 )
1571 lpi->
solver->GetObjectiveValue(), (
int) lpi->
solver->GetProblemStatus(), lpi->
solver->GetNumberOfIterations());
1591 if (
newlb <= ub + 0.5 )
1598 *
up = lpi->
solver->GetObjectiveValue();
1602 lpi->
solver->GetObjectiveValue(), (
int) lpi->
solver->GetProblemStatus(), lpi->
solver->GetNumberOfIterations());
1621 lpi->
scaled_lp->SetVariableBounds(col, lb, ub);
1778 SCIP_Bool* primalfeasible,
1779 SCIP_Bool* dualfeasible
1787 const ProblemStatus status = lpi->
solver->GetProblemStatus();
1788 *primalfeasible = (status == ProblemStatus::OPTIMAL || status == ProblemStatus::PRIMAL_FEASIBLE);
1789 *dualfeasible = (status == ProblemStatus::OPTIMAL || status == ProblemStatus::DUAL_FEASIBLE);
1791 SCIPdebugMessage(
"SCIPlpiGetSolFeasibility primal:%u dual:%u\n", *primalfeasible, *dualfeasible);
1806 return lpi->
solver->GetProblemStatus() == ProblemStatus::PRIMAL_UNBOUNDED;
1819 return lpi->
solver->GetProblemStatus() == ProblemStatus::PRIMAL_UNBOUNDED;
1830 return lpi->
solver->GetProblemStatus() == ProblemStatus::PRIMAL_UNBOUNDED;
1841 const ProblemStatus status = lpi->
solver->GetProblemStatus();
1843 return status == ProblemStatus::DUAL_UNBOUNDED || status == ProblemStatus::PRIMAL_INFEASIBLE;
1854 const ProblemStatus status = lpi->
solver->GetProblemStatus();
1856 return status == ProblemStatus::PRIMAL_FEASIBLE || status == ProblemStatus::OPTIMAL;
1869 const ProblemStatus status = lpi->
solver->GetProblemStatus();
1871 return status == ProblemStatus::DUAL_UNBOUNDED;
1884 const ProblemStatus status = lpi->
solver->GetProblemStatus();
1886 return status == ProblemStatus::DUAL_UNBOUNDED;
1897 const ProblemStatus status = lpi->
solver->GetProblemStatus();
1898 return status == ProblemStatus::DUAL_UNBOUNDED;
1909 const ProblemStatus status = lpi->
solver->GetProblemStatus();
1910 return status == ProblemStatus::PRIMAL_UNBOUNDED || status == ProblemStatus::DUAL_INFEASIBLE;
1921 const ProblemStatus status = lpi->
solver->GetProblemStatus();
1923 return status == ProblemStatus::DUAL_FEASIBLE || status == ProblemStatus::OPTIMAL;
1934 return lpi->
solver->GetProblemStatus() == ProblemStatus::OPTIMAL;
1954 const ProblemStatus status = lpi->
solver->GetProblemStatus();
1955 if ( (status == ProblemStatus::PRIMAL_FEASIBLE || status == ProblemStatus::DUAL_FEASIBLE) &&
1962 if ( status == ProblemStatus::ABNORMAL || status == ProblemStatus::INVALID_PROBLEM || status == ProblemStatus::IMPRECISE )
1992 return lpi->
solver->objective_limit_reached();
2004 int maxiter = (int) lpi->
parameters->max_number_of_iterations();
2005 return maxiter >= 0 && lpi->
niterations >= maxiter;
2027 return static_cast<int>(lpi->
solver->GetProblemStatus());
2070 SCIP_Real* activity,
2082 for (ColIndex col(0); col <
num_cols; ++col)
2084 int i = col.value();
2089 if ( redcost !=
NULL )
2090 redcost[
i] = lpi->
scaler->UnscaleReducedCost(col, lpi->
solver->GetReducedCost(col));
2096 int j = row.value();
2098 if ( dualsol !=
NULL )
2099 dualsol[
j] = lpi->
scaler->UnscaleDualValue(row, lpi->
solver->GetDualValue(row));
2101 if ( activity !=
NULL )
2102 activity[
j] = lpi->
scaler->UnscaleConstraintActivity(row, lpi->
solver->GetConstraintActivity(row));
2122 for (ColIndex col(0); col <
num_cols; ++col)
2131 SCIP_Real* dualfarkas
2143 dualfarkas[row.value()] = -lpi->
scaler->UnscaleDualValue(row,
dual_ray[row]);
2183 *
quality = lpi->
solver->GetBasisFactorization().ComputeInfinityNormConditionNumber();
2187 *
quality = lpi->
solver->GetBasisFactorization().ComputeInfinityNormConditionNumberUpperBound();
2213 VariableStatus status,
2219 case VariableStatus::BASIC:
2221 case VariableStatus::AT_UPPER_BOUND:
2223 case VariableStatus::AT_LOWER_BOUND:
2225 case VariableStatus::FREE:
2227 case VariableStatus::FIXED_VALUE:
2238 ConstraintStatus status,
2244 case ConstraintStatus::BASIC:
2246 case ConstraintStatus::AT_UPPER_BOUND:
2248 case ConstraintStatus::AT_LOWER_BOUND:
2250 case ConstraintStatus::FREE:
2252 case ConstraintStatus::FIXED_VALUE:
2269 return VariableStatus::BASIC;
2271 return VariableStatus::AT_UPPER_BOUND;
2273 return VariableStatus::AT_LOWER_BOUND;
2275 return VariableStatus::FREE;
2294 return VariableStatus::BASIC;
2296 return VariableStatus::AT_LOWER_BOUND;
2298 return VariableStatus::AT_UPPER_BOUND;
2300 return VariableStatus::FREE;
2316 assert( lpi->
solver->GetProblemStatus() == ProblemStatus::OPTIMAL );
2318 if ( cstat !=
NULL )
2321 for (ColIndex col(0); col <
num_cols; ++col)
2323 int i = col.value();
2328 if ( rstat !=
NULL )
2333 int i = row.value();
2363 for (ColIndex col(0); col <
num_cols; ++col)
2369 lpi->
solver->LoadStateForNextSolve(state);
2392 const ColIndex col = lpi->
solver->GetBasis(row);
2394 bind[row.value()] = col.value();
2426 lpi->
solver->GetBasisFactorization().LeftSolveForUnitRow(ColIndex(
r), lpi->
tmp_row);
2429 const ColIndex size = lpi->
tmp_row->values.size();
2438 if ( ! lpi->
tmp_row->non_zeros.empty() )
2440 ScatteredRowIterator
end = lpi->
tmp_row->end();
2441 for (ScatteredRowIterator iter = lpi->
tmp_row->begin(); iter !=
end; ++iter)
2443 int idx = (*iter).column().value();
2445 coef[idx] = (*iter).coefficient();
2446 inds[(*ninds)++] = idx;
2452 const Fractional
eps = lpi->
parameters->primal_feasibility_tolerance();
2453 for (ColIndex col(0); col < size; ++col)
2455 SCIP_Real val = (*lpi->
tmp_row)[col];
2458 coef[col.value()] = val;
2459 inds[(*ninds)++] = col.value();
2467 for (ColIndex col(0); col < size; ++col)
2468 coef[col.value()] = (*lpi->
tmp_row)[col];
2502 const ColIndex col(
c);
2508 const Fractional
eps = lpi->
parameters->primal_feasibility_tolerance();
2511 for (
int row = 0; row <
num_rows; ++row)
2513 lpi->
solver->GetBasisFactorization().LeftSolveForUnitRow(ColIndex(row), lpi->
tmp_row);
2516 SCIP_Real val = (*lpi->
tmp_row)[col];
2520 inds[(*ninds)++] = row;
2527 for (
int row = 0; row <
num_rows; ++row)
2529 lpi->
solver->GetBasisFactorization().LeftSolveForUnitRow(ColIndex(row), lpi->
tmp_row);
2531 coef[row] = (*lpi->
tmp_row)[col];
2563 lpi->
solver->GetBasisFactorization().LeftSolveForUnitRow(ColIndex(
r), lpi->
tmp_row);
2571 const Fractional
eps = lpi->
parameters->primal_feasibility_tolerance();
2574 for (ColIndex col(0); col <
num_cols; ++col)
2576 SCIP_Real val = operations_research::glop::ScalarProduct(lpi->
tmp_row->values, lpi->
linear_program->GetSparseColumn(col));
2579 coef[col.value()] = val;
2580 inds[(*ninds)++] = col.value();
2587 for (ColIndex col(0); col <
num_cols; ++col)
2588 coef[col.value()] = operations_research::glop::ScalarProduct(lpi->
tmp_row->values, lpi->
linear_program->GetSparseColumn(col));
2617 lpi->
solver->GetBasisFactorization().RightSolveForProblemColumn(ColIndex(
c), lpi->
tmp_column);
2631 for (ScatteredColumnIterator iter = lpi->
tmp_column->begin(); iter !=
end; ++iter)
2633 int idx = (*iter).row().value();
2635 coef[idx] = (*iter).coefficient();
2636 inds[(*ninds)++] = idx;
2642 const Fractional
eps = lpi->
parameters->primal_feasibility_tolerance();
2648 coef[row.value()] = val;
2649 inds[(*ninds)++] = row.value();
2714 lpi->
solver->LoadStateForNextSolve(*lpistate);
2727 lpi->
solver->ClearStateForNextSolve();
2758 return lpistate !=
NULL;
2945 (
void) google::SetVLOGLevel(
"*", google::GLOG_INFO);
2950 (
void) google::SetVLOGLevel(
"*", google::GLOG_ERROR);
2972 lpi->
parameters->set_feasibility_rule(operations_research::glop::GlopParameters_PricingRule_STEEPEST_EDGE);
2976 lpi->
parameters->set_feasibility_rule(operations_research::glop::GlopParameters_PricingRule_DANTZIG);
2979 lpi->
parameters->set_feasibility_rule(operations_research::glop::GlopParameters_PricingRule_DEVEX);
3059#ifdef SCIP_DISABLED_CODE
3111#ifdef SCIP_DISABLED_CODE
3155 return std::numeric_limits<SCIP_Real>::infinity();
3166 return val == std::numeric_limits<SCIP_Real>::infinity();
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)
static void deleteRowsAndUpdateCurrentBasis(SCIP_LPI *lpi, const DenseBooleanColumn &rows_to_delete)
SCIP_RETCODE SCIPlpiSetRealpar(SCIP_LPI *lpi, SCIP_LPPARAM type, SCIP_Real dval)
SCIP_RETCODE SCIPlpiStrongbranchFrac(SCIP_LPI *lpi, int col_index, 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
static SCIP_BASESTAT ConvertGlopConstraintStatus(ConstraintStatus status, Fractional dual)
static SCIP_BASESTAT ConvertGlopVariableStatus(VariableStatus status, Fractional rc)
static VariableStatus ConvertSCIPConstraintStatusToSlackStatus(int status)
static bool IsDualBoundValid(ProblemStatus status)
static SCIP_RETCODE strongbranch(SCIP_LPI *lpi, int col_index, SCIP_Real psol, int itlim, SCIP_Real *down, SCIP_Real *up, SCIP_Bool *downvalid, SCIP_Bool *upvalid, int *iter)
static SCIP_RETCODE SolveInternal(SCIP_LPI *lpi, bool recursive, std::unique_ptr< TimeLimit > &time_limit)
static void updateScaledLP(SCIP_LPI *lpi)
static bool checkUnscaledPrimalFeasibility(SCIP_LPI *lpi)
static VariableStatus ConvertSCIPVariableStatus(int status)
#define BMSfreeMemory(ptr)
#define BMSallocMemoryArray(ptr, num)
#define BMSfreeMemoryArray(ptr)
struct BMS_BlkMem BMS_BLKMEM
#define BMSallocMemory(ptr)
public methods for message output
ScatteredColumn * tmp_column
operations_research::glop::LinearProgram * linear_program
operations_research::glop::LinearProgram * scaled_lp
operations_research::glop::GlopParameters * parameters
bool lp_time_limit_was_reached
bool lp_modified_since_last_solve
operations_research::glop::LpScalingHelper * scaler
operations_research::glop::RevisedSimplex * solver
@ SCIP_PRICING_STEEPQSTART
@ SCIP_PRICING_LPIDEFAULT
enum SCIP_Pricing SCIP_PRICING
enum SCIP_LPParam SCIP_LPPARAM
@ SCIP_LPSOLQUALITY_EXACTCONDITION
@ SCIP_LPSOLQUALITY_ESTIMCONDITION
@ SCIP_LPPAR_CONDITIONLIMIT
enum SCIP_LPSolQuality SCIP_LPSOLQUALITY
enum SCIP_ObjSen SCIP_OBJSEN
enum SCIP_BaseStat SCIP_BASESTAT
enum SCIP_Retcode SCIP_RETCODE