ClpSolve.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
/*
   Authors
 
   John Forrest
 
 */
#ifndef ClpSolve_H
#define ClpSolve_H
 
class ClpSolve {
 
public:
  enum SolveType {
    useDual = 0,
    usePrimal,
    usePrimalorSprint,
    useBarrier,
    useBarrierNoCross,
    automatic,
    tryDantzigWolfe,
    tryBenders,
    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 bool doKillSmall() const
  {
    return (independentOptions_[1] & 8192) == 0;
  }
  inline void setDoKillSmall(bool doKill)
  {
    if (doKill)
      independentOptions_[1] &= ~8192;
    else
      independentOptions_[1] |= 8192;
  }
  inline int presolveActions() const
  {
    return independentOptions_[1] & 0xffffff;
  }
  inline void setPresolveActions(int action)
  {
    independentOptions_[1] = (independentOptions_[1] & 0xff000000) | (action & 0xffffff);
  }
  inline int substitution() const
  {
    return independentOptions_[2];
  }
  inline void setSubstitution(int value)
  {
    independentOptions_[2] = value;
  }
  inline void setIndependentOption(int type, int value)
  {
    independentOptions_[type] = value;
  }
  inline int independentOption(int type) const
  {
    return independentOptions_[type];
  }
 
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;
  int numberInfeasibilities(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;
  }
  inline int reallyBadTimes() const
  {
    return numberReallyBadTimes_;
  }
  inline void incrementReallyBadTimes()
  {
    numberReallyBadTimes_++;
  }
  inline int timesFlagged() const
  {
    return numberTimesFlagged_;
  }
  inline void clearTimesFlagged()
  {
    numberTimesFlagged_ = 0;
  }
  inline void incrementTimesFlagged()
  {
    numberTimesFlagged_++;
  }
 
 
#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 numberReallyBadTimes_;
  int numberTimesFlagged_;
  int oddState_;
};
 
#include "ClpConfig.h"
#if CLP_HAS_ABC
#include "AbcCommon.hpp"
class AbcSimplexProgress : public ClpSimplexProgress {
 
public:
  AbcSimplexProgress();
 
  AbcSimplexProgress(ClpSimplex *model);
 
  AbcSimplexProgress(const AbcSimplexProgress &);
 
  AbcSimplexProgress &operator=(const AbcSimplexProgress &rhs);
  ~AbcSimplexProgress();
 
 
  int looping();
 
 
};
#endif
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/