Idiot.hpp

// Copyright (C) 2002, International Business Machines
// Corporation and others.  All Rights Reserved.
// "Idiot" as the name of this algorithm is copylefted.  If you want to change
// the name then it should be something equally stupid (but not "Stupid") or
// even better something witty.

#ifndef Idiot_H
#define Idiot_H
#ifndef OSI_IDIOT
#include "ClpSimplex.hpp"
#define OsiSolverInterface ClpSimplex
#else
#include "OsiSolverInterface.hpp"
typedef int CoinBigIndex;
#endif
class CoinMessageHandler;
class CoinMessages;
// for use internally
typedef struct {
  double infeas;
  double objval;
  double dropThis;
  double weighted;
  double sumSquared;
  double djAtBeginning;
  double djAtEnd;
  int iteration;
} IdiotResult;
class Idiot {

public:


    Idiot (  );
    Idiot ( OsiSolverInterface & model );

    Idiot(const Idiot &);
    Idiot & operator=(const Idiot & rhs);
    ~Idiot (  );



  void solve();
  void crash(int numberPass,CoinMessageHandler * handler ,const CoinMessages * messages);
  void crossOver(int mode);


  inline double getStartingWeight() const
  { return mu_;};
  inline void setStartingWeight(double value)
  { mu_ = value;};
  inline double getWeightFactor() const
  { return muFactor_;};
  inline void setWeightFactor(double value)
  { muFactor_ = value;};
  inline double getFeasibilityTolerance() const
  { return smallInfeas_;};
  inline void setFeasibilityTolerance(double value)
  { smallInfeas_ = value;};
  inline double getReasonablyFeasible() const
  { return reasonableInfeas_;};
  inline void setReasonablyFeasible(double value)
  { reasonableInfeas_ = value;};
  inline double getExitInfeasibility() const
  { return exitFeasibility_;};
  inline void setExitInfeasibility(double value)
  { exitFeasibility_ = value;};
  inline int getMajorIterations() const
  { return majorIterations_;};
  inline void setMajorIterations(int value)
  { majorIterations_ = value;};
  inline int getMinorIterations() const
  { return maxIts2_;};
  inline void setMinorIterations(int value)
  { maxIts2_ = value;};
  inline int getReduceIterations() const
  { return maxBigIts_;};
  inline void setReduceIterations(int value)
  { maxBigIts_ = value;};
  inline int getLogLevel() const
  { return logLevel_;};
  inline void setLogLevel(int value)
  { logLevel_ = value;};
  inline int getLightweight() const
  { return lightWeight_;};
  inline void setLightweight(int value)
  { lightWeight_ = value;};
  inline int getStrategy() const
  { return strategy_;};
  inline void setStrategy(int value)
  { strategy_ = value;};
  inline double getDropEnoughFeasibility() const
  { return dropEnoughFeasibility_;};
  inline void setDropEnoughFeasibility(double value)
  { dropEnoughFeasibility_=value;};
  inline double getDropEnoughWeighted() const
  { return dropEnoughWeighted_;};
  inline void setDropEnoughWeighted(double value)
  { dropEnoughWeighted_=value;};


private:

  void solve2(CoinMessageHandler * handler,const CoinMessages *messages);
IdiotResult IdiSolve(
                     int nrows, int ncols, double * rowsol , double * colsol,
                     double * pi, double * djs, const double * origcost , 
                     const double * rowlower,
                     double * rowupper, const double * lower,
                     const double * upper, const double * element, 
                     const int * row, const CoinBigIndex * colcc,
                     const int * length, double * lambda,
                     int maxIts,double mu,double drop,
                     double maxmin, double offset,
                     int strategy,double djTol,double djExit,double djFlag);
int dropping(IdiotResult result,
             double tolerance,
             double small,
             int *nbad);
IdiotResult objval(int nrows, int ncols, double * rowsol , double * colsol,
                   double * pi, double * djs, const double * cost , 
                   const double * rowlower,
                   const double * rowupper, const double * lower,
                   const double * upper, const double * elemnt, 
                   const int * row, const CoinBigIndex * columnStart,
                   const int * length, int extraBlock, int * rowExtra,
                   double * solExtra, double * elemExtra, double * upperExtra,
                   double * costExtra,double weight);

private:
  OsiSolverInterface * model_;

  double djTolerance_;
  double mu_;  /* starting mu */
  double drop_; /* exit if drop over 5 checks less than this */
  double muFactor_; /* reduce mu by this */
  double stopMu_; /* exit if mu gets smaller than this */
  double smallInfeas_; /* feasibility tolerance */
  double reasonableInfeas_; /* use lambdas if feasibility less than this */
  double exitDrop_; /* candidate for stopping after a major iteration */
  double muAtExit_; /* mu on exit */
  double exitFeasibility_; /* exit if infeasibility less than this */
  double dropEnoughFeasibility_; /* okay if feasibility drop this factor */
  double dropEnoughWeighted_; /* okay if weighted obj drop this factor */
  int * whenUsed_; /* array to say what was used */
  int maxBigIts_; /* always reduce mu after this */
  int maxIts_; /* do this many iterations on first go */
  int majorIterations_;
  int logLevel_;
  int logFreq_;
  int checkFrequency_; /* can exit after 5 * this iterations (on drop) */
  int lambdaIterations_; /* do at least this many lambda iterations */ 
  int maxIts2_; /* do this many iterations on subsequent goes */
  int strategy_;   /* 0 - default strategy
                     1 - do accelerator step but be cautious
                     2 - do not do accelerator step 
                     4 - drop, exitDrop and djTolerance all relative
                     8 - keep accelerator step to theta=10.0

                    32 - Scale
                   512 - crossover 
                  2048 - keep lambda across mu change
                  4096 - return best solution (not last found) */
  int lightWeight_; // 0 - normal, 1 lightweight
};
#endif

---