85 PostStep(
const char* p_name,
int nR = 0,
int nC = 0)
191 , m_old_i(lp.
nRows()-1)
192 , m_row(lp.rowVector(_i))
193 , m_row_obj(lp.rowObj(_i))
199 , m_old_i(old.m_old_i)
201 , m_row_obj(old.m_row_obj)
241 , m_old_i(lp.
nRows()-1)
242 , m_row_obj(lp.rowObj(_i))
248 , m_old_i(old.m_old_i)
249 , m_row_obj(old.m_row_obj)
301 , m_old_i(lp.
nRows()-1)
305 , m_strictLo(strictLo)
306 , m_strictUp(strictUp)
307 , m_maxSense(lp.spxSense() ==
SPxLP::MAXIMIZE)
308 , m_obj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
309 , m_col(lp.colVector(_j))
314 , m_row_obj(lp.rowObj(_i))
320 , m_old_i(old.m_old_i)
324 , m_strictLo(old.m_strictLo)
325 , m_strictUp(old.m_strictUp)
326 , m_maxSense(old.m_maxSense)
329 , m_newLo(old.m_newLo)
330 , m_newUp(old.m_newUp)
331 , m_oldLo(old.m_oldLo)
332 , m_oldUp(old.m_oldUp)
333 , m_row_obj(old.m_row_obj)
382 , m_old_i(lp.
nRows()-1)
383 , m_lRhs(lhsFixed ? lp.lhs(_i) : lp.rhs(_i))
384 , m_row(lp.rowVector(_i))
385 , m_objs(lp.rowVector(_i).size())
387 , m_cols(lp.rowVector(_i).size())
388 , m_lhsFixed(lhsFixed)
389 , m_maxSense(lp.spxSense() ==
SPxLP::MAXIMIZE)
394 , m_rowobj(lp.rowObj(_i))
396 for(
int k = 0; k < m_row.
size(); ++k)
406 , m_old_i(old.m_old_i)
410 , m_fixed(old.m_fixed)
412 , m_lhsFixed(old.m_lhsFixed)
413 , m_maxSense(old.m_maxSense)
414 , m_oldLowers(old.m_oldLowers)
415 , m_oldUppers(old.m_oldUppers)
418 , m_rowobj(old.m_rowobj)
466 , m_old_j(lp.
nCols()-1)
468 , m_obj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
469 , m_lower(lp.lower(_j))
470 , m_upper(lp.upper(_j))
471 , m_correctIdx(correctIdx)
472 , m_col(lp.colVector(_j))
480 , m_old_j(old.m_old_j)
483 , m_lower(old.m_lower)
484 , m_upper(old.m_upper)
485 , m_correctIdx(old.m_correctIdx)
541 , m_status(old.m_status)
588 , m_old_j(lp.
nCols()-1)
589 , m_old_i(lp.
nRows()-1)
590 , m_bnd(loFree ? lp.upper(_j) : lp.lower(_j))
591 , m_col(col_idx_sorted)
592 , m_lRhs(lp.colVector(_j).size())
593 , m_rowObj(lp.colVector(_j).size())
594 , m_rows(lp.colVector(_j).size())
597 for(
int k = 0; k < m_col.
size(); ++k)
601 int r = m_col.
index(k);
602 if ((m_loFree && m_col.
value(k) > 0) ||
603 (!m_loFree && m_col.
value(k) < 0))
616 , m_old_j(old.m_old_j)
617 , m_old_i(old.m_old_i)
621 , m_rowObj(old.m_rowObj)
623 , m_loFree(old.m_loFree)
672 , m_old_j(lp.
nCols()-1)
675 , m_lower(lp.lower(_j))
676 , m_upper(lp.upper(_j))
677 , m_row(lp.rowVector(_i))
684 , m_old_j(old.m_old_j)
687 , m_lower(old.m_lower)
688 , m_upper(old.m_upper)
736 , m_old_j(lp.
nCols()-1)
737 , m_old_i(lp.
nRows()-1)
738 , m_obj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
740 , m_onLhs(
EQ(slackVal, lp.lhs(_i)))
741 , m_eqCons(
EQ(lp.lhs(_i), lp.rhs(_i)))
742 , m_row(lp.rowVector(_i))
744 assert(m_row[m_j] != 0.0);
752 , m_old_j(old.m_old_j)
753 , m_old_i(old.m_old_i)
756 , m_onLhs(old.m_onLhs)
757 , m_eqCons(old.m_eqCons)
816 , m_maxSense(lp.spxSense() ==
SPxLP::MAXIMIZE)
817 , m_jFixed(
EQ(lp.lower(_j), lp.upper(_j)))
818 , m_jObj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
819 , m_kObj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_k) : -lp.obj(_k))
820 , m_aij(lp.colVector(_j).value(0))
821 , m_strictLo(lp.lower(_k) > oldLo)
822 , m_strictUp(lp.upper(_k) < oldUp)
823 , m_newLo(lp.lower(_k))
824 , m_newUp(lp.upper(_k))
827 , m_Lo_j(lp.lower(_j))
828 , m_Up_j(lp.upper(_j))
831 , m_col(lp.colVector(_k))
839 , m_maxSense(old.m_maxSense)
840 , m_jFixed(old.m_jFixed)
844 , m_strictLo(old.m_strictLo)
845 , m_strictUp(old.m_strictUp)
846 , m_newLo(old.m_newLo)
847 , m_newUp(old.m_newUp)
848 , m_oldLo(old.m_oldLo)
849 , m_oldUp(old.m_oldUp)
902 int maxLhsIdx,
int minRhsIdx,
const DSVector& dupRows,
904 bool isTheLast,
bool isFixedRow,
bool isFirst =
false)
907 , m_i_rowObj(lp.rowObj(_i))
908 , m_maxLhsIdx((maxLhsIdx == -1) ? -1 : maxLhsIdx)
909 , m_minRhsIdx((minRhsIdx == -1) ? -1 : minRhsIdx)
910 , m_maxSense(lp.spxSense() ==
SPxLP::MAXIMIZE)
912 , m_isLast(isTheLast)
913 , m_fixed(isFixedRow)
914 , m_nCols(lp.
nCols())
915 , m_scale(dupRows.size())
916 , m_rowObj(dupRows.size())
917 , m_rIdxLocalOld(dupRows.size())
919 , m_isLhsEqualRhs(isLhsEqualRhs)
921 Real rowScale = scale[_i];
923 for(
int k = 0; k < dupRows.
size(); ++k)
925 m_scale.
add(dupRows.
index(k), rowScale / scale[dupRows.
index(k)]);
927 m_rIdxLocalOld[k] = dupRows.
index(k);
934 , m_i_rowObj(old.m_i_rowObj)
935 , m_maxLhsIdx(old.m_maxLhsIdx)
936 , m_minRhsIdx(old.m_minRhsIdx)
937 , m_maxSense(old.m_maxSense)
938 , m_isFirst(old.m_isFirst)
939 , m_isLast(old.m_isLast)
940 , m_fixed(old.m_fixed)
941 , m_nCols(old.m_nCols)
942 , m_scale(old.m_scale)
943 , m_rowObj(old.m_rowObj)
944 , m_rIdxLocalOld(old.m_rIdxLocalOld)
946 , m_isLhsEqualRhs(old.m_isLhsEqualRhs)
996 , m_loJ(lp.lower(_j))
997 , m_upJ(lp.upper(_j))
998 , m_loK(lp.lower(_k))
999 , m_upK(lp.upper(_k))
1001 , m_isFirst(isFirst)
1002 , m_isLast(isTheLast)
1014 , m_scale (old.m_scale)
1015 , m_isFirst(old.m_isFirst)
1016 , m_isLast(old.m_isLast)
1017 , m_perm(old.m_perm)
1065 , m_old_j(lp.
nCols()-1)
1066 , m_old_i(lp.
nRows()-1)
1067 , m_upper(lp.upper(_j))
1068 , m_lower(lp.lower(_j))
1069 , m_obj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
1070 , m_oldupper(oldupper)
1071 , m_oldlower(oldlower)
1073 , m_row(lp.rowVector(_i))
1074 , m_col(lp.colVector(_j))
1076 assert(m_row[m_j] != 0.0);
1083 , m_old_j(old.m_old_j)
1084 , m_old_i(old.m_old_i)
1085 , m_upper(old.m_upper)
1086 , m_lower(old.m_lower)
1088 , m_oldupper(old.m_oldupper)
1089 , m_oldlower(old.m_oldlower)
1144 , m_old_j(lp.
nCols()-1)
1145 , m_old_i(lp.
nRows()-1)
1146 , m_upper(lp.upper(_j))
1147 , m_lower(lp.lower(_j))
1148 , m_obj(lp.spxSense() ==
SPxLP::MINIMIZE ? lp.obj(_j) : -lp.obj(_j))
1150 , m_onLhs(
EQ(constant, lp.lhs(_i)))
1151 , m_eqCons(
EQ(lp.lhs(_i), lp.rhs(_i)))
1152 , m_row(lp.rowVector(_i))
1153 , m_col(lp.colVector(_j))
1155 assert(m_row[m_j] != 0.0);
1163 , m_old_j(old.m_old_j)
1164 , m_old_i(old.m_old_i)
1165 , m_upper(old.m_upper)
1166 , m_lower(old.m_lower)
1168 , m_const(old.m_const)
1169 , m_onLhs(old.m_onLhs)
1170 , m_eqCons(old.m_eqCons)
1213 , m_origupper(origupper)
1214 , m_origlower(origlower)
1221 , m_origupper(old.m_origupper)
1222 , m_origlower(old.m_origlower)
1371 m_rIdx[i] = m_rIdx[lp.
nRows()-1];
1377 m_cIdx[j] = m_cIdx[lp.
nCols()-1];
1423 , m_thesense(
SPxLP::MAXIMIZE)
1424 , m_keepbounds(false)
1433 , m_prim(old.m_prim)
1434 , m_slack(old.m_slack)
1435 , m_dual(old.m_dual)
1436 , m_redCost(old.m_redCost)
1437 , m_cBasisStat(old.m_cBasisStat)
1438 , m_rBasisStat(old.m_rBasisStat)
1439 , m_cIdx(old.m_cIdx)
1440 , m_rIdx(old.m_rIdx)
1441 , m_postsolved(old.m_postsolved)
1442 , m_epsilon(old.m_epsilon)
1443 , m_feastol(old.m_feastol)
1444 , m_opttol(old.m_opttol)
1445 , m_stat(old.m_stat)
1446 , m_thesense(old.m_thesense)
1447 , m_keepbounds(old.m_keepbounds)
1448 , m_addedcols(old.m_addedcols)
1449 , m_result(old.m_result)
1450 , m_cutoffbound(old.m_cutoffbound)
1451 , m_pseudoobj(old.m_pseudoobj)
1455 for(
int k = 0; k < old.
m_hist.size(); ++k)
1490 for(
int k = 0; k < m_hist.
size(); ++k)
1492 m_hist[k]->~PostStep();
1499 for(
int k = 0; k < rhs.
m_hist.size(); ++k)
1514 for(
int k = 0; k < m_hist.
size(); ++k)
1516 if( m_hist[k] != 0 )
1518 m_hist[k]->~PostStep();
1536 return simplify(lp, eps, delta, delta);
1559 assert(m_postsolved);
1565 assert(m_postsolved);
1571 assert(m_postsolved);
1577 assert(m_postsolved);
1583 assert(m_postsolved);
1584 return m_rBasisStat[i];
1589 assert(m_postsolved);
1590 return m_cBasisStat[j];
1595 assert(m_postsolved);
1596 assert(rowsSize < 0 || rowsSize >= m_rBasisStat.
size());
1597 assert(colsSize < 0 || colsSize >= m_cBasisStat.
size());
1599 for(
int i = 0; i < m_rBasisStat.
size(); ++i)
1600 rows[i] = m_rBasisStat[i];
1602 for(
int j = 0; j < m_cBasisStat.
size(); ++j)
1603 cols[j] = m_cBasisStat[j];
1647 #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.
AggregationPS & operator=(const AggregationPS &rhs)
assignment operator
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 PostStep * clone() const
clone function for polymorphism
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.
AggregationPS(const SPxLP &lp, int _i, int _j, Real rhs, Real oldupper, Real oldlower)
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.
AggregationPS(const AggregationPS &old)
copy constructor
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 aggregateVars(SPxLP &lp, const SVector &row, int &i)
aggregate two variables that appear in an equation.
Result duplicateRows(SPxLP &lp, bool &again)
removes duplicate rows.
Real m_cutoffbound
the cutoff bound that is found by heuristics
friend class AggregationPS
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