/home/coin/SVN-release/CoinAll-1.1.0/Clp/src/ClpPresolve.hpp

Go to the documentation of this file.

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.

#ifndef ClpPresolve_H
#define ClpPresolve_H
#include "ClpSimplex.hpp"

class CoinPresolveAction;
#include "CoinPresolveMatrix.hpp"
class ClpPresolve {
public:

  ClpPresolve();

  virtual ~ClpPresolve();

  ClpSimplex * presolvedModel(ClpSimplex & si,
                              double feasibilityTolerance=0.0,
                              bool keepIntegers=true,
                              int numberPasses=5,
                              bool dropNames=false,
                              bool doRowObjective=false);
#ifndef CLP_NO_STD

  int presolvedModelToFile(ClpSimplex &si,std::string fileName,
                           double feasibilityTolerance=0.0,
                           bool keepIntegers=true,
                           int numberPasses=5,
                           bool doRowObjective=false);
#endif

  ClpSimplex * model() const;
  ClpSimplex * originalModel() const;
  void setOriginalModel(ClpSimplex * model);
    
  const int * originalColumns() const;
  const int * originalRows() const;
  inline void setNonLinearValue(double value)
  { nonLinearValue_ = value;}
  inline double nonLinearValue() const
    { return nonLinearValue_;}
  inline bool doDual() const
  { return (presolveActions_&1)==0;}
  inline void setDoDual(bool doDual)
  { if (doDual) presolveActions_  &= ~1; else presolveActions_ |= 1;}
  inline bool doSingleton() const
  { return (presolveActions_&2)==0;}
  inline void setDoSingleton(bool doSingleton)
  { if (doSingleton) presolveActions_  &= ~2; else presolveActions_ |= 2;}
  inline bool doDoubleton() const
  { return (presolveActions_&4)==0;}
  inline void setDoDoubleton(bool doDoubleton)
  { if (doDoubleton) presolveActions_  &= ~4; else presolveActions_ |= 4;}
  inline bool doTripleton() const
  { return (presolveActions_&8)==0;}
  inline void setDoTripleton(bool doTripleton)
  { if (doTripleton) presolveActions_  &= ~8; else presolveActions_ |= 8;}
  inline bool doTighten() const
  { return (presolveActions_&16)==0;}
  inline void setDoTighten(bool doTighten)
  { if (doTighten) presolveActions_  &= ~16; else presolveActions_ |= 16;}
  inline bool doForcing() const
  { return (presolveActions_&32)==0;}
  inline void setDoForcing(bool doForcing)
  { if (doForcing) presolveActions_  &= ~32; else presolveActions_ |= 32;}
  inline bool doImpliedFree() const
  { return (presolveActions_&64)==0;}
  inline void setDoImpliedFree(bool doImpliedfree)
  { if (doImpliedfree) presolveActions_  &= ~64; else presolveActions_ |= 64;}
  inline bool doDupcol() const
  { return (presolveActions_&128)==0;}
  inline void setDoDupcol(bool doDupcol)
  { if (doDupcol) presolveActions_  &= ~128; else presolveActions_ |= 128;}
  inline bool doDuprow() const
  { return (presolveActions_&256)==0;}
  inline void setDoDuprow(bool doDuprow)
  { if (doDuprow) presolveActions_  &= ~256; else presolveActions_ |= 256;}
  inline bool doSingletonColumn() const
  { return (presolveActions_&512)==0;}
  inline void setDoSingletonColumn(bool doSingleton)
  { if (doSingleton) presolveActions_  &= ~512; else presolveActions_ |= 512;}
  inline int presolveActions() const
  { return presolveActions_&0xffff;}
  inline void setPresolveActions(int action)
  { presolveActions_  = (presolveActions_&0xffff0000)|(action&0xffff);}
  inline void setSubstitution(int value)
  { substitution_=value;}
  inline void statistics()
  { presolveActions_ |= 0x80000000;}

  virtual void postsolve(bool updateStatus=true);

  void destroyPresolve();

private:
  ClpSimplex * originalModel_;

  ClpSimplex * presolvedModel_;
  double nonLinearValue_;
  int * originalColumn_;
  int * originalRow_;
  double * rowObjective_;
  const CoinPresolveAction *paction_;

  int ncols_;
  int nrows_;
  CoinBigIndex nelems_;
  int numberPasses_;
  int substitution_;
#ifndef CLP_NO_STD
  std::string saveFile_;
#endif

  int presolveActions_;
protected:
  virtual const CoinPresolveAction *presolve(CoinPresolveMatrix *prob);

  virtual void postsolve(CoinPostsolveMatrix &prob);
  virtual ClpSimplex * gutsOfPresolvedModel(ClpSimplex * originalModel,
                                            double feasibilityTolerance,
                                            bool keepIntegers,
                                            int numberPasses,
                                            bool dropNames,
                                            bool doRowObjective);
};
#endif

---