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

Go to the documentation of this file.

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

/* 
   Authors
   
   John Forrest

 */
#ifndef ClpSolve_H
#define ClpSolve_H

class ClpSolve  {

public:

  enum SolveType {
    useDual=0,
    usePrimal,
    usePrimalorSprint,
    useBarrier,
    useBarrierNoCross,
    automatic,
    notImplemented
  };
  enum PresolveType {
    presolveOn=0,
    presolveOff,
    presolveNumber,
    presolveNumberCost
  };


  ClpSolve (  );
  ClpSolve ( SolveType method, PresolveType presolveType,
             int numberPasses, int options[6],
             int extraInfo[6], int independentOptions[3]);
  void generateCpp(FILE * fp);
  ClpSolve(const ClpSolve &);
    ClpSolve & operator=(const ClpSolve & rhs);
   ~ClpSolve (  );

  void setSpecialOption(int which,int value,int extraInfo=-1);
  int getSpecialOption(int which) const;

  void setSolveType(SolveType method, int extraInfo=-1);
  SolveType getSolveType();

  // Presolve types
  void setPresolveType(PresolveType amount, int extraInfo=-1);
  PresolveType getPresolveType();
  int getPresolvePasses() const;
  int getExtraInfo(int which) const;
  void setInfeasibleReturn(bool trueFalse);
  inline bool infeasibleReturn() const
  { return independentOptions_[0]!=0;}
  inline bool doDual() const
  { return (independentOptions_[1]&1)==0;}
  inline void setDoDual(bool doDual)
  { if (doDual) independentOptions_[1]  &= ~1; else independentOptions_[1] |= 1;}
  inline bool doSingleton() const
  { return (independentOptions_[1]&2)==0;}
  inline void setDoSingleton(bool doSingleton)
  { if (doSingleton) independentOptions_[1]  &= ~2; else independentOptions_[1] |= 2;}
  inline bool doDoubleton() const
  { return (independentOptions_[1]&4)==0;}
  inline void setDoDoubleton(bool doDoubleton)
  { if (doDoubleton) independentOptions_[1]  &= ~4; else independentOptions_[1] |= 4;}
  inline bool doTripleton() const
  { return (independentOptions_[1]&8)==0;}
  inline void setDoTripleton(bool doTripleton)
  { if (doTripleton) independentOptions_[1]  &= ~8; else independentOptions_[1] |= 8;}
  inline bool doTighten() const
  { return (independentOptions_[1]&16)==0;}
  inline void setDoTighten(bool doTighten)
  { if (doTighten) independentOptions_[1]  &= ~16; else independentOptions_[1] |= 16;}
  inline bool doForcing() const
  { return (independentOptions_[1]&32)==0;}
  inline void setDoForcing(bool doForcing)
  { if (doForcing) independentOptions_[1]  &= ~32; else independentOptions_[1] |= 32;}
  inline bool doImpliedFree() const
  { return (independentOptions_[1]&64)==0;}
  inline void setDoImpliedFree(bool doImpliedfree)
  { if (doImpliedfree) independentOptions_[1]  &= ~64; else independentOptions_[1] |= 64;}
  inline bool doDupcol() const
  { return (independentOptions_[1]&128)==0;}
  inline void setDoDupcol(bool doDupcol)
  { if (doDupcol) independentOptions_[1]  &= ~128; else independentOptions_[1] |= 128;}
  inline bool doDuprow() const
  { return (independentOptions_[1]&256)==0;}
  inline void setDoDuprow(bool doDuprow)
  { if (doDuprow) independentOptions_[1]  &= ~256; else independentOptions_[1] |= 256;}
  inline bool doSingletonColumn() const
  { return (independentOptions_[1]&512)==0;}
  inline void setDoSingletonColumn(bool doSingleton)
  { if (doSingleton) independentOptions_[1]  &= ~512; else independentOptions_[1] |= 512;}
  inline int presolveActions() const
  { return independentOptions_[1]&0xffff;}
  inline void setPresolveActions(int action)
  { independentOptions_[1]  = (independentOptions_[1]&0xffff0000)|(action&0xffff);}
  inline int substitution() const
  { return independentOptions_[2];}
  inline void setSubstitution(int value)
  { independentOptions_[2] = value;}

private:


  SolveType method_;
  PresolveType presolveType_;
  int numberPasses_;
  int options_[7];
  int extraInfo_[7];
  int independentOptions_[3];
};

class ClpSimplexProgress {

public:



    ClpSimplexProgress (  );

    ClpSimplexProgress ( ClpSimplex * model );

  ClpSimplexProgress(const ClpSimplexProgress &);

    ClpSimplexProgress & operator=(const ClpSimplexProgress & rhs);
   ~ClpSimplexProgress (  );
   void reset();
    void fillFromModel ( ClpSimplex * model );


    int looping (  );
  void startCheck();
  int cycle(int in, int out,int wayIn,int wayOut); 

  double lastObjective(int back=1) const;
  void setInfeasibility(double value);
  double lastInfeasibility(int back=1) const;
  void modifyObjective(double value);
  int lastIterationNumber(int back=1) const;
  void clearIterationNumbers();
  inline void newOddState()
  { oddState_= - oddState_-1;}
  inline void endOddState()
  { oddState_=abs(oddState_);}
  inline void clearOddState() 
  { oddState_=0;}
  inline int oddState() const
  { return oddState_;}
  inline int badTimes() const
  { return numberBadTimes_;}
  inline void clearBadTimes()
  { numberBadTimes_=0;}


#define CLP_PROGRESS 5
  //#define CLP_PROGRESS_WEIGHT 10

  double objective_[CLP_PROGRESS];
  double infeasibility_[CLP_PROGRESS];
  double realInfeasibility_[CLP_PROGRESS];
#ifdef CLP_PROGRESS_WEIGHT
  double objectiveWeight_[CLP_PROGRESS_WEIGHT];
  double infeasibilityWeight_[CLP_PROGRESS_WEIGHT];
  double realInfeasibilityWeight_[CLP_PROGRESS_WEIGHT];
  double drop_;
  double best_;
#endif
  double initialWeight_;
#define CLP_CYCLE 12
  //double obj_[CLP_CYCLE];
  int in_[CLP_CYCLE];
  int out_[CLP_CYCLE];
  char way_[CLP_CYCLE];
  ClpSimplex * model_;
  int numberInfeasibilities_[CLP_PROGRESS];
  int iterationNumber_[CLP_PROGRESS];
#ifdef CLP_PROGRESS_WEIGHT
  int numberInfeasibilitiesWeight_[CLP_PROGRESS_WEIGHT];
  int iterationNumberWeight_[CLP_PROGRESS_WEIGHT];
#endif
  int numberTimes_;
  int numberBadTimes_;
  int oddState_;

};
#endif

---