ClpPESimplex.hpp

Go to the documentation of this file.

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
/*
   Authors
 
   Jeremy Omer
 
   Last update: june 10, 2014
 
 */
 
#ifndef ClpPESimplex_H
#define ClpPESimplex_H
 
#include "ClpSimplex.hpp"
#include "CoinIndexedVector.hpp"
#include "ClpPackedMatrix.hpp"
#include "CoinTime.hpp"
 
#include <iostream>
#include <fstream>
 
// #define PE_DEBUG 0
 
double PEdot(CoinIndexedVector &v1, const double *v2);
 
double PEdot(CoinIndexedVector &v1, CoinIndexedVector &v2);
 
void PEtransposeTimesSubsetAll(ClpSimplex *model, int number, const int *which,
  const double *COIN_RESTRICT x, double *COIN_RESTRICT y,
  const double *COIN_RESTRICT rowScale,
  const double *COIN_RESTRICT columnScale);
 
class ClpPESimplex {
 
public:
  ClpPESimplex(ClpSimplex *model);
 
  ~ClpPESimplex();
 
public:
  inline int coPrimalDegenerates() { return coPrimalDegenerates_; }
  inline int coDualDegenerates() { return coDualDegenerates_; }
  inline int coCompatibleCols() { return coCompatibleCols_; }
  inline int coCompatibleRows() { return coCompatibleRows_; }
 
  inline bool isCompatibleCol(int sequence) { return isCompatibleCol_[sequence]; }
  inline bool isCompatibleRow(int row)
  {
    assert(row >= 0 && row < numberRows_);
    return isCompatibleRow_[row];
  }
 
  inline ClpSimplex *clpModel() { return model_; }
  // check seems to be same model - returns false if size changed
  bool checkSize();
public:
  void updatePrimalDegenerates();
 
  void updateDualDegenerates();
 
  void identifyCompatibleCols(int number, const int *which,
    CoinIndexedVector *spareRow2,
    CoinIndexedVector *wPrimal);
 
  void identifyCompatibleRows(CoinIndexedVector *spare,
    CoinIndexedVector *wDual);
 
  void updateCompatibleRows(int sequence);
 
public:
#if PE_DEBUG >= 1
 
  void printPrimalDegenerates();
 
  void printCompatibleCols();
 
  bool checkCompatibilityCol(int sequence, CoinIndexedVector *spareRow2);
#endif
 
  bool checkCompatibilityRow(int pivotRow);
 
  inline double lastObjectiveValue() { return lastObjectiveValue_; }
  inline void updateLastObjectiveValue() { lastObjectiveValue_ = model_->objectiveValue(); }
  inline bool isDegeneratePivot() { return fabs(model_->objectiveValue() - lastObjectiveValue_) < model_->dualTolerance(); }
  inline bool isLastPivotCompatible() { return isLastPivotCompatible_; }
  inline void isLastPivotCompatible(bool yesOrNo) { isLastPivotCompatible_ = yesOrNo; }
 
  inline void startTimer() { timeTmp_ = CoinCpuTime(); }
  inline void stopTimer() { timeCompatibility_ += CoinCpuTime() - timeTmp_; }
  void printTimer(std::ostream &out);
  inline double timeMultRandom() { return timeMultRandom_; }
  inline double timeLinearSystem() { return timeLinearSystem_; }
  inline double timeCompatibility() { return timeCompatibility_; }
 
  inline void addDegeneratePivot() { coDegeneratePivots_++; }
  inline int coDegeneratePivots() { return coDegeneratePivots_; }
  inline void addDegeneratePivotConsecutive() { coDegeneratePivotsConsecutive_++; }
  inline void resetDegeneratePivotsConsecutive() { coDegeneratePivotsConsecutive_ = 0; }
  inline int coDegeneratePivotsConsecutive() { return coDegeneratePivotsConsecutive_; }
  void updateDualDegeneratesAvg(int coPivots);
  inline double coDualDegeneratesAvg() { return coDualDegeneratesAvg_; }
  void updatePrimalDegeneratesAvg(int coPivots);
  inline double coPrimalDegeneratesAvg() { return coPrimalDegeneratesAvg_; }
  inline double coCompatibleRowsAvg() { return coCompatibleRowsAvg_; }
  void updateCompatibleRowsAvg(int coPivots);
  inline double coCompatibleColsAvg() { return coCompatibleColsAvg_; }
  void updateCompatibleColsAvg(int coPivots);
  inline int coCompatiblePivots() { return coCompatiblePivots_; }
  inline void addCompatiblePivot() { coCompatiblePivots_++; }
  inline int coDegenerateCompatiblePivots() { return coDegenerateCompatiblePivots_; }
  inline void addDegenerateCompatiblePivot() { coDegenerateCompatiblePivots_++; }
 
  /* Get and update the number of compatible pivots that were done because of the priority factor */
  inline void addPriorityPivot() { coPriorityPivots_++; }
  inline int coPriorityPivots() { return coPriorityPivots_; }
  inline int doStatistics() const
  {
    return doStatistics_;
  }
  inline void setDoStatistics(int value)
  {
    doStatistics_ = value;
  }
 
protected:
  int coPrimalDegenerates_;
  int *primalDegenerates_;
  bool *isPrimalDegenerate_;
 
  int coDualDegenerates_;
  int *dualDegenerates_;
  bool *isDualDegenerate_;
 
  int coCompatibleCols_;
  double *compatibilityCol_;
  bool *isCompatibleCol_;
 
  int coCompatibleRows_;
  double *compatibilityRow_;
  bool *isCompatibleRow_;
 
private:
  ClpSimplex *model_;
 
  double epsDegeneracy_;
  double epsCompatibility_;
 
  int numberRows_;
  int numberColumns_;
 
  // now passed in CoinIndexedVector *wPrimal_;
  // now passed in CoinIndexedVector *wDual_;
 
  // not usedCoinIndexedVector *tempColumn_;
  double *tempRandom_;
 
  int coPrimalDegeneratesAvg_;
  int coDualDegeneratesAvg_;
  int coCompatibleColsAvg_;
  int coCompatibleRowsAvg_;
  int coUpdateDegenerates_;
  //int coIdentifyCompatibles_;
  int coDegeneratePivots_;
  int coCompatiblePivots_;
  int coDegenerateCompatiblePivots_;
  int coDegeneratePivotsConsecutive_;
 
  int coPriorityPivots_;
  int doStatistics_;
 
  double lastObjectiveValue_;
  bool isLastPivotCompatible_;
 
  double timeCompatibility_;
  double timeMultRandom_;
  double timeLinearSystem_;
  double timeTmp_;
};
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/