Idiot.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).
 
// "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;
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, bool doCrossover = true);
  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;
  }
  // minor iterations for first time
  inline int getMinorIterations0() const
  {
    return maxIts_;
  }
  inline void setMinorIterations0(int value)
  {
    maxIts_ = 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;
  }
  inline void setModel(OsiSolverInterface *model)
  {
    model_ = model;
  };
 
private:
  // allow public!
public:
  void solve2(CoinMessageHandler *handler, const CoinMessages *messages);
 
private:
  IdiotResult IdiSolve(
    int nrows, int ncols, double *rowsol, double *colsol,
    double *pi, double *djs, const double *origcost,
    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,
    CoinThreadRandom *randomNumberGenerator);
  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);
  // Deals with whenUsed and slacks
  int cleanIteration(int iteration, int ordinaryStart, int ordinaryEnd,
    double *colsol, const double *lower, const double *upper,
    const double *rowLower, const double *rowUpper,
    const double *cost, const double *element, double fixTolerance, double &objChange,
    double &infChange, double &maxInfeasibility);
 
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)
                  8192 - always do a presolve in crossover
                 16384 - costed slacks found - so whenUsed_ longer 
                 32768 - experimental 1
                 65536 - experimental 2
                 131072 - experimental 3 
                 262144 - just values pass etc 
                 524288 - don't treat structural slacks as slacks */
 
  int lightWeight_; // 0 - normal, 1 lightweight
};
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/