ClpPresolve.hpp

Go to the documentation of this file.

/* $Id$ */
// 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 doTransfer() const
  {
    return (presolveActions_ & 65536) != 0;
  }
  inline void setDoTransfer(bool doTransfer)
  {
    if (doTransfer)
      presolveActions_ |= 65536;
    else
      presolveActions_ &= ~65536;
  }

  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_ & 0xffffff;
  }
  inline void setPresolveActions(int action)
  {
    presolveActions_ = (presolveActions_ & 0xff000000) | (action & 0xffffff);
  }

  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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/