ClpSolve.hpp

Go to the documentation of this file.

/* $Id: ClpSolve.hpp 2078 2015-01-05 12:39:49Z forrest $ */
// 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] & 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;
     }
     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