ClpPresolve.hpp

Go to the documentation of this file.

/* $Id: ClpPresolve.hpp 2134 2015-03-22 16:40:43Z forrest $ */
// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#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,
                                 const char * prohibitedRows=NULL,
                                 const char * prohibitedColumns=NULL);
#ifndef CLP_NO_STD
     int presolvedModelToFile(ClpSimplex &si, std::string fileName,
                              double feasibilityTolerance = 0.0,
                              bool keepIntegers = true,
                              int numberPasses = 5,
                              bool dropNames = false,
                              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 doDependency() const {
          return (presolveActions_ & 32768) != 0;
     }
     inline void setDoDependency(bool doDependency) {
          if (doDependency) presolveActions_  |= 32768;
          else presolveActions_ &= ~32768;
     }
     inline bool doSingletonColumn() const {
          return (presolveActions_ & 512) == 0;
     }
     inline void setDoSingletonColumn(bool doSingleton) {
          if (doSingleton) presolveActions_  &= ~512;
          else presolveActions_ |= 512;
     }
     inline bool doGubrow() const {
          return (presolveActions_ & 1024) == 0;
     }
     inline void setDoGubrow(bool doGubrow) {
          if (doGubrow) presolveActions_  &= ~1024;
          else presolveActions_ |= 1024;
     }
     inline bool doTwoxTwo() const {
          return (presolveActions_ & 2048) != 0;
     }
     inline void setDoTwoxtwo(bool doTwoxTwo) {
          if (!doTwoxTwo) presolveActions_  &= ~2048;
          else presolveActions_ |= 2048;
     }
     inline bool doIntersection() const {
          return (presolveActions_ & 4096) != 0;
     }
     inline void setDoIntersection(bool doIntersection) {
          if (doIntersection) presolveActions_  &= ~4096;
          else presolveActions_ |= 4096;
     }
     inline int zeroSmall() const {
          return (presolveActions_&(8192|16384))>>13;
     }
     inline void setZeroSmall(int value) {
         presolveActions_  &= ~(8192|16384);
         presolveActions_ |= value<<13;
     }
     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;
     }
     int presolveStatus() const;
 
     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,
                                               const char * prohibitedRows=NULL,
                                               const char * prohibitedColumns=NULL);
};
#endif