85 PostStep(
const char* p_name,
int nR = 0,
int nC = 0)
184 , m_old_i(lp.
nRows()-1)
185 , m_row(lp.rowVector(_i))
186 , m_row_obj(lp.rowObj(_i))
192 , m_old_i(old.m_old_i)
194 , m_row_obj(old.m_row_obj)
234 , m_old_i(lp.
nRows()-1)
235 , m_row_obj(lp.rowObj(_i))
241 , m_old_i(old.m_old_i)
242 , m_row_obj(old.m_row_obj)
294 , m_old_i(lp.
nRows()-1)
298 , m_strictLo(strictLo)
299 , m_strictUp(strictUp)
300 , m_maxSense(lp.spxSense() ==
SPxLP::MAXIMIZE)
301 , m_obj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
302 , m_col(lp.colVector(_j))
307 , m_row_obj(lp.rowObj(_i))
313 , m_old_i(old.m_old_i)
317 , m_strictLo(old.m_strictLo)
318 , m_strictUp(old.m_strictUp)
319 , m_maxSense(old.m_maxSense)
322 , m_newLo(old.m_newLo)
323 , m_newUp(old.m_newUp)
324 , m_oldLo(old.m_oldLo)
325 , m_oldUp(old.m_oldUp)
326 , m_row_obj(old.m_row_obj)
375 , m_old_i(lp.
nRows()-1)
376 , m_lRhs(lhsFixed ? lp.lhs(_i) : lp.rhs(_i))
377 , m_row(lp.rowVector(_i))
378 , m_objs(lp.rowVector(_i).size())
380 , m_cols(lp.rowVector(_i).size())
381 , m_lhsFixed(lhsFixed)
382 , m_maxSense(lp.spxSense() ==
SPxLP::MAXIMIZE)
387 , m_rowobj(lp.rowObj(_i))
389 for(
int k = 0; k < m_row.
size(); ++k)
399 , m_old_i(old.m_old_i)
403 , m_fixed(old.m_fixed)
405 , m_lhsFixed(old.m_lhsFixed)
406 , m_maxSense(old.m_maxSense)
407 , m_oldLowers(old.m_oldLowers)
408 , m_oldUppers(old.m_oldUppers)
411 , m_rowobj(old.m_rowobj)
459 , m_old_j(lp.
nCols()-1)
461 , m_obj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
462 , m_lower(lp.lower(_j))
463 , m_upper(lp.upper(_j))
464 , m_correctIdx(correctIdx)
465 , m_col(lp.colVector(_j))
473 , m_old_j(old.m_old_j)
476 , m_lower(old.m_lower)
477 , m_upper(old.m_upper)
478 , m_correctIdx(old.m_correctIdx)
534 , m_status(old.m_status)
581 , m_old_j(lp.
nCols()-1)
582 , m_old_i(lp.
nRows()-1)
583 , m_bnd(loFree ? lp.upper(_j) : lp.lower(_j))
584 , m_col(col_idx_sorted)
585 , m_lRhs(lp.colVector(_j).size())
586 , m_rowObj(lp.colVector(_j).size())
587 , m_rows(lp.colVector(_j).size())
590 for(
int k = 0; k < m_col.
size(); ++k)
594 int r = m_col.
index(k);
595 if ((m_loFree && m_col.
value(k) > 0) ||
596 (!m_loFree && m_col.
value(k) < 0))
609 , m_old_j(old.m_old_j)
610 , m_old_i(old.m_old_i)
614 , m_rowObj(old.m_rowObj)
616 , m_loFree(old.m_loFree)
665 , m_old_j(lp.
nCols()-1)
668 , m_lower(lp.lower(_j))
669 , m_upper(lp.upper(_j))
670 , m_row(lp.rowVector(_i))
677 , m_old_j(old.m_old_j)
680 , m_lower(old.m_lower)
681 , m_upper(old.m_upper)
729 , m_old_j(lp.
nCols()-1)
730 , m_old_i(lp.
nRows()-1)
731 , m_obj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
733 , m_onLhs(
EQ(slackVal, lp.lhs(_i)))
734 , m_eqCons(
EQ(lp.lhs(_i), lp.rhs(_i)))
735 , m_row(lp.rowVector(_i))
737 assert(m_row[m_j] != 0.0);
745 , m_old_j(old.m_old_j)
746 , m_old_i(old.m_old_i)
749 , m_onLhs(old.m_onLhs)
750 , m_eqCons(old.m_eqCons)
809 , m_maxSense(lp.spxSense() ==
SPxLP::MAXIMIZE)
810 , m_jFixed(
EQ(lp.lower(_j), lp.upper(_j)))
811 , m_jObj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
812 , m_kObj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_k) : -lp.obj(_k))
813 , m_aij(lp.colVector(_j).value(0))
814 , m_strictLo(lp.lower(_k) > oldLo)
815 , m_strictUp(lp.upper(_k) < oldUp)
816 , m_newLo(lp.lower(_k))
817 , m_newUp(lp.upper(_k))
820 , m_Lo_j(lp.lower(_j))
821 , m_Up_j(lp.upper(_j))
824 , m_col(lp.colVector(_k))
832 , m_maxSense(old.m_maxSense)
833 , m_jFixed(old.m_jFixed)
837 , m_strictLo(old.m_strictLo)
838 , m_strictUp(old.m_strictUp)
839 , m_newLo(old.m_newLo)
840 , m_newUp(old.m_newUp)
841 , m_oldLo(old.m_oldLo)
842 , m_oldUp(old.m_oldUp)
895 int maxLhsIdx,
int minRhsIdx,
const DSVector& dupRows,
897 bool isTheLast,
bool isFixedRow,
bool isFirst =
false)
900 , m_i_rowObj(lp.rowObj(_i))
901 , m_maxLhsIdx((maxLhsIdx == -1) ? -1 : maxLhsIdx)
902 , m_minRhsIdx((minRhsIdx == -1) ? -1 : minRhsIdx)
903 , m_maxSense(lp.spxSense() ==
SPxLP::MAXIMIZE)
905 , m_isLast(isTheLast)
906 , m_fixed(isFixedRow)
907 , m_nCols(lp.
nCols())
908 , m_scale(dupRows.size())
909 , m_rowObj(dupRows.size())
910 , m_rIdxLocalOld(dupRows.size())
912 , m_isLhsEqualRhs(isLhsEqualRhs)
914 Real rowScale = scale[_i];
916 for(
int k = 0; k < dupRows.
size(); ++k)
918 m_scale.
add(dupRows.
index(k), rowScale / scale[dupRows.
index(k)]);
920 m_rIdxLocalOld[k] = dupRows.
index(k);
927 , m_i_rowObj(old.m_i_rowObj)
928 , m_maxLhsIdx(old.m_maxLhsIdx)
929 , m_minRhsIdx(old.m_minRhsIdx)
930 , m_maxSense(old.m_maxSense)
931 , m_isFirst(old.m_isFirst)
932 , m_isLast(old.m_isLast)
933 , m_fixed(old.m_fixed)
934 , m_nCols(old.m_nCols)
935 , m_scale(old.m_scale)
936 , m_rowObj(old.m_rowObj)
937 , m_rIdxLocalOld(old.m_rIdxLocalOld)
939 , m_isLhsEqualRhs(old.m_isLhsEqualRhs)
989 , m_loJ(lp.lower(_j))
990 , m_upJ(lp.upper(_j))
991 , m_loK(lp.lower(_k))
992 , m_upK(lp.upper(_k))
995 , m_isLast(isTheLast)
1007 , m_scale (old.m_scale)
1008 , m_isFirst(old.m_isFirst)
1009 , m_isLast(old.m_isLast)
1010 , m_perm(old.m_perm)
1058 , m_old_j(lp.
nCols()-1)
1059 , m_old_i(lp.
nRows()-1)
1060 , m_upper(lp.upper(_j))
1061 , m_lower(lp.lower(_j))
1062 , m_obj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
1064 , m_onLhs(
EQ(constant, lp.lhs(_i)))
1065 , m_eqCons(
EQ(lp.lhs(_i), lp.rhs(_i)))
1066 , m_row(lp.rowVector(_i))
1067 , m_col(lp.colVector(_j))
1069 assert(m_row[m_j] != 0.0);
1077 , m_old_j(old.m_old_j)
1078 , m_old_i(old.m_old_i)
1079 , m_upper(old.m_upper)
1080 , m_lower(old.m_lower)
1082 , m_const(old.m_const)
1083 , m_onLhs(old.m_onLhs)
1084 , m_eqCons(old.m_eqCons)
1127 , m_origupper(origupper)
1128 , m_origlower(origlower)
1135 , m_origupper(old.m_origupper)
1136 , m_origlower(old.m_origlower)
1280 m_rIdx[i] = m_rIdx[lp.
nRows()-1];
1286 m_cIdx[j] = m_cIdx[lp.
nCols()-1];
1329 , m_thesense(
SPxLP::MAXIMIZE)
1330 , m_keepbounds(false)
1339 , m_prim(old.m_prim)
1340 , m_slack(old.m_slack)
1341 , m_dual(old.m_dual)
1342 , m_redCost(old.m_redCost)
1343 , m_cBasisStat(old.m_cBasisStat)
1344 , m_rBasisStat(old.m_rBasisStat)
1345 , m_cIdx(old.m_cIdx)
1346 , m_rIdx(old.m_rIdx)
1347 , m_postsolved(old.m_postsolved)
1348 , m_epsilon(old.m_epsilon)
1349 , m_feastol(old.m_feastol)
1350 , m_opttol(old.m_opttol)
1351 , m_stat(old.m_stat)
1352 , m_thesense(old.m_thesense)
1353 , m_keepbounds(old.m_keepbounds)
1354 , m_addedcols(old.m_addedcols)
1355 , m_result(old.m_result)
1356 , m_cutoffbound(old.m_cutoffbound)
1357 , m_pseudoobj(old.m_pseudoobj)
1361 for(
int k = 0; k < old.
m_hist.size(); ++k)
1396 for(
int k = 0; k < m_hist.
size(); ++k)
1398 m_hist[k]->~PostStep();
1405 for(
int k = 0; k < rhs.
m_hist.size(); ++k)
1420 for(
int k = 0; k < m_hist.
size(); ++k)
1422 if( m_hist[k] != 0 )
1424 m_hist[k]->~PostStep();
1442 return simplify(lp, eps, delta, delta);
1465 assert(m_postsolved);
1471 assert(m_postsolved);
1477 assert(m_postsolved);
1483 assert(m_postsolved);
1489 assert(m_postsolved);
1490 return m_rBasisStat[i];
1495 assert(m_postsolved);
1496 return m_cBasisStat[j];
1501 assert(m_postsolved);
1502 assert(rowsSize < 0 || rowsSize >= m_rBasisStat.
size());
1503 assert(colsSize < 0 || colsSize >= m_cBasisStat.
size());
1505 for(
int i = 0; i < m_rBasisStat.
size(); ++i)
1506 rows[i] = m_rBasisStat[i];
1508 for(
int j = 0; j < m_cBasisStat.
size(); ++j)
1509 cols[j] = m_cBasisStat[j];
1553 #endif // _SPXMAINSM_H_
const VectorBase< R > & rhs() const
Returns right hand side vector.
DVector m_prim
unsimplified primal solution vector.
bool isNotZero(Real a, Real eps=Param::epsilon())
returns true iff |a| > eps
Real m_opttol
dual feasibility tolerance.
virtual bool isUnsimplified() const
specifies whether an optimal solution has already been unsimplified.
DataArray< PostStep * > m_hist
vector of presolve history.
Postsolves multi aggregation.
Exception class for things that should NEVER happen.This class is derived from the SoPlex exception b...
RowObjPS & operator=(const RowObjPS &rhs)
assignment operator
virtual void removeRow(int i)
Removes i 'th row.
MultiAggregationPS(const MultiAggregationPS &old)
copy constructor
free variable fixed to zero.
friend class FreeConstraintPS
Result removeRowSingleton(SPxLP &lp, const SVector &row, int &i)
remove row singletons.
DataArray< int > m_stat
preprocessing history.
EmptyConstraintPS(const SPxLP &lp, int _i)
ZeroObjColSingletonPS & operator=(const ZeroObjColSingletonPS &rhs)
assignment operator
PostStep & operator=(const PostStep &)
assignment operator
SPxMainSM(Timer::TYPE ttype=Timer::USER_TIME)
default constructor.
const VectorBase< R > & upper() const
Returns upper bound vector.
#define DEFAULT_BND_VIOL
default allowed bound violation
Real m_epsilon
epsilon zero.
THREADLOCAL const Real infinity
Postsolves variable bound fixing.
Result
Result of the simplification.
Postsolves duplicate rows.
int size() const
Number of used indices.
const char * m_name
name of the simplifier
DataArray< int > m_rIdxLocalOld
FixVariablePS(const FixVariablePS &old)
copy constructor
void computeMinMaxResidualActivity(SPxLP &lp, int rowNumber, int colNumber, Real &minAct, Real &maxAct)
computes the minimum and maximum residual activity for a given row and column. If colNumber is set to...
Real m_feastol
primal feasibility tolerance.
virtual PostStep * clone() const
clone function for polymorphism
DataArray< SPxSolver::VarStatus > m_rBasisStat
basis status of rows.
Exception classes for SoPlex.
SPxMainSM & operator=(const SPxMainSM &rhs)
assignment operator
virtual PostStep * clone() const
clone function for polymorphism
FreeZeroObjVariablePS(const SPxLP &lp, int _j, bool loFree, SVector col_idx_sorted)
SPxLP::SPxSense m_thesense
optimization sense.
virtual void execute(DVector &x, DVector &y, DVector &s, DVector &r, DataArray< SPxSolver::VarStatus > &cBasis, DataArray< SPxSolver::VarStatus > &rBasis, bool isOptimal) const =0
executes the postsolving.
Safe arrays of arbitrary types.Class Array provides safe arrays of arbitrary type. Array elements are accessed just like ordinary C++ array elements by means of the index operator[](). Safety is provided by.
virtual Result simplify(SPxLP &lp, Real eps, Real delta)
simplify SPxLP lp with identical primal and dual feasibility tolerance.
friend class DuplicateRowsPS
PostStep(const PostStep &old)
copy constructor.
FixVariablePS(const SPxLP &lp, SPxMainSM &simplifier, int _j, const Real val, bool correctIdx=true)
int cIdx(int j) const
returns for a given column index of the (reduced) LP the corresponding column index in the unsimplifi...
void clear()
remove all elements.
FixBoundsPS & operator=(const FixBoundsPS &rhs)
assignment operator
variable fixed to identical bounds.
RowSingletonPS & operator=(const RowSingletonPS &rhs)
assignment operator
Base class for postsolving operations.Class PostStep is an abstract base class providing the interfac...
DVector m_dual
unsimplified dual solution vector.
virtual const Vector & unsimplifiedDual()
returns a reference to the unsimplified dual solution.
FreeConstraintPS(const FreeConstraintPS &old)
copy constructor
virtual void removeCol(int i)
Removes i 'th column.
R & value(int n)
Reference to value of n 'th nonzero.
DuplicateRowsPS & operator=(const DuplicateRowsPS &rhs)
assignment operator
Postsolves empty constraints.
DataArray< Real > m_oldLowers
PostStep(const char *p_name, int nR=0, int nC=0)
constructor.
FreeColSingletonPS(const FreeColSingletonPS &old)
copy constructor
void handleExtremes(SPxLP &lp)
handles extreme values by setting them to zero or infinity.
bool m_postsolved
status of postsolving.
virtual SPxSolver::VarStatus getBasisRowStatus(int i) const
gets basis status for a single row.
int rIdx(int i) const
returns for a given row index of the (reduced) LP the corresponding row index in the unsimplified LP...
virtual void unsimplify(const Vector &x, const Vector &y, const Vector &s, const Vector &r, const SPxSolver::VarStatus rows[], const SPxSolver::VarStatus cols[], bool isOptimal=true)
reconstructs an optimal solution for the unsimplified LP.
virtual PostStep * clone() const
clone function for polymorphism
FreeColSingletonPS(const SPxLP &lp, SPxMainSM &simplifier, int _j, int _i, Real slackVal)
DataArray< Real > m_oldUppers
ZeroObjColSingletonPS(const SPxLP &lp, const SPxMainSM &, int _j, int _i)
int idx
Index of nonzero element.
LP simplification base class.
void fixColumn(SPxLP &lp, int i, bool correctIdx=true)
handles the fixing of a variable. correctIdx is true iff the index mapping has to be updated...
FreeZeroObjVariablePS & operator=(const FreeZeroObjVariablePS &rhs)
assignment operator
virtual void addObjoffset(const Real val)
add objective offset.
int nRows() const
Returns number of rows in LP.
void add(const SVectorBase< S > &vec)
Append nonzeros of sv.
void spx_alloc(T &p, int n=1)
Allocate memory.
simplification could be done
DataArray< bool > m_fixed
virtual PostStep * clone() const
clone function for polymorphism
MultiAggregationPS(const SPxLP &lp, SPxMainSM &simplifier, int _i, int _j, Real constant)
Postsolves the case when constraints are removed due to a variable with zero objective that is free i...
virtual const char * getName() const
get name of simplifying step.
virtual PostStep * clone() const
clone function for polymorphism
friend class RowSingletonPS
EmptyConstraintPS(const EmptyConstraintPS &old)
copy constructor
SPxSimplifier & operator=(const SPxSimplifier &rhs)
assignment operator
SPxSense
Optimization sense.
TightenBoundsPS & operator=(const TightenBoundsPS &rhs)
assignment operator
virtual ~PostStep()
destructor.
virtual PostStep * clone() const
clone function for polymorphism
virtual PostStep * clone() const
clone function for polymorphism
SPxSolver::VarStatus m_status
Array< DSVector > m_classSetCols
stores parallel classes with non-zero row entry
RowSingletonPS(const RowSingletonPS &old)
copy constructor
FreeConstraintPS(const SPxLP &lp, int _i)
Result duplicateCols(SPxLP &lp, bool &again)
removes duplicate columns
void removeCol(SPxLP &lp, int j)
removes a column in the LP.
TightenBoundsPS(const SPxLP &lp, int j, Real origupper, Real origlower)
SPxSense spxSense() const
Returns the optimization sense.
int & index(int n)
Reference to index of n 'th nonzero.
Postsolves row singletons.
MultiAggregationPS & operator=(const MultiAggregationPS &rhs)
assignment operator
virtual PostStep * clone() const
clone function for polymorphism
Result simplifyRows(SPxLP &lp, bool &again)
performs simplification steps on the rows of the LP.
virtual void getBasis(SPxSolver::VarStatus rows[], SPxSolver::VarStatus cols[], const int rowsSize=-1, const int colsSize=-1) const
get optimal basis.
DuplicateColsPS & operator=(const DuplicateColsPS &rhs)
assignment operator
LP simplification abstract base class.Instances of classes derived from SPxSimplifier may be loaded t...
bool checkSolution(SPxLP &lp, DVector sol)
checks a solution for feasibility
virtual PostStep * clone() const
clone function for polymorphism
DuplicateColsPS(const SPxLP &lp, int _j, int _k, Real scale, DataArray< int > perm, bool isFirst=false, bool isTheLast=false)
void append(const T &t)
append element t.
friend class DoubletonEquationPS
SPxMainSM(const SPxMainSM &old)
copy constructor.
FixVariablePS & operator=(const FixVariablePS &rhs)
assignment operator
ForceConstraintPS(const SPxLP &lp, int _i, bool lhsFixed, DataArray< bool > &fixCols, DataArray< Real > &lo, DataArray< Real > &up)
Postsolves doubleton equations combined with a column singleton.
Postsolves free column singletons.
ForceConstraintPS & operator=(const ForceConstraintPS &rhs)
assignment operator
#define DEFAULT_EPS_ZERO
default allowed additive zero: 1.0 + EPS_ZERO == 1.0
comparator for class SVector::Element: compare nonzeros according to value
R obj(int i) const
Returns objective value of column i.
virtual PostStep * clone() const
clone function for polymorphism
const VectorBase< R > & lhs() const
Returns left hand side vector.
DataArray< int > m_cIdx
column index vector in original LP.
Result m_result
result of the simplification.
FixBoundsPS(const FixBoundsPS &old)
copy constructor
DuplicateColsPS(const DuplicateColsPS &old)
copy constructor
virtual Result result() const
returns result status of the simplification
variable set to its upper bound.
DoubletonEquationPS(const SPxLP &lp, int _j, int _k, int _i, Real oldLo, Real oldUp)
virtual PostStep * clone() const
clone function for polymorphism
DuplicateRowsPS(const DuplicateRowsPS &old)
copy constructor
DoubletonEquationPS(const DoubletonEquationPS &old)
copy constructor
variable set to its lower bound.
Array< DSVector > m_dupCols
arrange duplicate columns w.r.t. their pClass values
virtual PostStep * clone() const =0
clone function for polymorphism
Debugging, floating point type and parameter definitions.
Postsolves row objectives.
bool EQ(Real a, Real b, Real eps=Param::epsilon())
returns true iff |a-b| <= eps
DataArray< int > m_rIdx
row index vector in original LP.
Postsolves column singletons with zero objective.
TightenBoundsPS(const TightenBoundsPS &old)
copy constructor
bool m_keepbounds
keep some bounds (for boundflipping)
Everything should be within this namespace.
bool EQrel(Real a, Real b, Real eps=Param::epsilon())
returns true iff |relDiff(a,b)| <= eps
virtual bool checkBasisDim(DataArray< SPxSolver::VarStatus > rows, DataArray< SPxSolver::VarStatus > cols) const
friend class ForceConstraintPS
void handleRowObjectives(SPxLP &lp)
handle row objectives
RowSingletonPS(const SPxLP &lp, int _i, int _j, bool strictLo, bool strictUp, Real newLo, Real newUp, Real oldLo, Real oldUp)
DuplicateRowsPS(const SPxLP &lp, int _i, int maxLhsIdx, int minRhsIdx, const DSVector &dupRows, const DataArray< Real > scale, const DataArray< int > perm, const DataArray< bool > isLhsEqualRhs, bool isTheLast, bool isFixedRow, bool isFirst=false)
virtual ~SPxMainSM()
destructor.
Result duplicateRows(SPxLP &lp, bool &again)
removes duplicate rows.
Real m_cutoffbound
the cutoff bound that is found by heuristics
DSVector m_col
does the index mapping have to be updated in postsolving?
Result multiaggregation(SPxLP &lp, bool &again)
performs multi-aggregations of variable based upon constraint activitu.
Save arrays of arbitrary types.
friend class DuplicateColsPS
FreeZeroObjVariablePS(const FreeZeroObjVariablePS &old)
copy constructor
const SVectorBase< R > & rowVector(int i) const
Gets row vector of row i.
comparator for class SVector::Element: compare nonzeros according to index
virtual const Vector & unsimplifiedPrimal()
returns a reference to the unsimplified primal solution.
FreeColSingletonPS & operator=(const FreeColSingletonPS &rhs)
assignment operator
virtual const Vector & unsimplifiedRedCost()
returns a reference to the unsimplified reduced costs.
void trivialHeuristic(SPxLP &lp)
tries to find good lower bound solutions by applying some trivial heuristics
int m_j
slack column index
virtual PostStep * clone() const
clone function for polymorphism
Postsolves duplicate columns.
DataArray< bool > m_isLhsEqualRhs
virtual SPxSimplifier * clone() const
clone function for polymorphism
SimpleStep
Different simplification steps.
Result removeEmpty(SPxLP &lp)
removed empty rows and empty columns.
int size() const
return nr. of elements.
Postsolves forcing constraints.
virtual PostStep * clone() const
clone function for polymorphism
FixBoundsPS(const SPxLP &lp, int j, Real val)
Result simplifyDual(SPxLP &lp, bool &again)
performs simplification steps on the LP based on dual concepts.
Postsolves unconstraint constraints.
R val
Value of nonzero element.
Postsolves variable bound tightening from pseudo objective propagation.
const SVectorBase< R > & colVector(int i) const
Returns column vector of column i.
Postsolves variable fixing.
int nCols() const
Returns number of columns in LP.
friend class FreeColSingletonPS
Real m_pseudoobj
the pseudo objective function value
friend class FreeZeroObjVariablePS
void computeMinMaxValues(SPxLP &lp, Real side, Real val, Real minRes, Real maxRes, Real &minVal, Real &maxVal)
calculate min/max value for the multi aggregated variables
virtual PostStep * clone() const
clone function for polymorphism
int m_addedcols
columns added by handleRowObjectives()
virtual const Vector & unsimplifiedSlacks()
returns a reference to the unsimplified slack values.
friend class ZeroObjColSingletonPS
int operator()(const SVector::Element &e1, const SVector::Element &e2) const
void removeRow(SPxLP &lp, int i)
removes a row in the LP.
friend class EmptyConstraintPS
FreeConstraintPS & operator=(const FreeConstraintPS &rhs)
assignment operator
RowObjPS(const RowObjPS &old)
copy constructor
RowObjPS(const SPxLP &lp, int _i, int _j)
Result simplifyCols(SPxLP &lp, bool &again)
performs simplification steps on the columns of the LP.
Array< DSVector > m_dupRows
arrange duplicate rows using bucket sort w.r.t. their pClass values
EmptyConstraintPS & operator=(const EmptyConstraintPS &rhs)
assignment operator
void reSize(int newsize)
reset size to newsize.
ZeroObjColSingletonPS(const ZeroObjColSingletonPS &old)
copy constructor
DVector m_slack
unsimplified slack vector.
const VectorBase< R > & lower() const
Returns (internal and possibly scaled) lower bound vector.
void spx_free(T &p)
Release memory.
virtual SPxSolver::VarStatus getBasisColStatus(int j) const
gets basis status for a single column.
DoubletonEquationPS & operator=(const DoubletonEquationPS &rhs)
assignment operator
DataArray< SPxSolver::VarStatus > m_cBasisStat
basis status of columns.
void propagatePseudoobj(SPxLP &lp)
tightens variable bounds by propagating the pseudo objective function value.
LP simplifier for removing uneccessary row/columns.This SPxSimplifier is mainly based on the paper "P...
Array< DSVector > m_classSetRows
stores parallel classes with non-zero colum entry
friend class FixVariablePS
int operator()(const SVector::Element &e1, const SVector::Element &e2) const
DVector m_redCost
unsimplified reduced cost vector.
ForceConstraintPS(const ForceConstraintPS &old)
copy constructor
virtual PostStep * clone() const
clone function for polymorphism