Ignore:
Timestamp:
Jan 6, 2019 2:43:06 PM (4 months ago)
Author:
unxusr
Message:

formatting

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/ClpSolve.hpp

    r2259 r2385  
    1818*/
    1919
    20 class ClpSolve  {
     20class ClpSolve {
    2121
    2222public:
    23 
    24      /** enums for solve function */
    25      enum SolveType {
    26           useDual = 0,
    27           usePrimal,
    28           usePrimalorSprint,
    29           useBarrier,
    30           useBarrierNoCross,
    31           automatic,
    32           tryDantzigWolfe,
    33           tryBenders,
    34           notImplemented
    35      };
    36      enum PresolveType {
    37           presolveOn = 0,
    38           presolveOff,
    39           presolveNumber,
    40           presolveNumberCost
    41      };
    42 
    43      /**@name Constructors and destructor and copy */
    44      //@{
    45      /// Default constructor
    46      ClpSolve (  );
    47      /// Constructor when you really know what you are doing
    48      ClpSolve ( SolveType method, PresolveType presolveType,
    49                 int numberPasses, int options[6],
    50                 int extraInfo[6], int independentOptions[3]);
    51      /// Generates code for above constructor
    52      void generateCpp(FILE * fp);
    53      /// Copy constructor.
    54      ClpSolve(const ClpSolve &);
    55      /// Assignment operator. This copies the data
    56      ClpSolve & operator=(const ClpSolve & rhs);
    57      /// Destructor
    58      ~ClpSolve (  );
    59      //@}
    60 
    61      /**@name Functions most useful to user */
    62      //@{
    63      /** Special options - bits
     23  /** enums for solve function */
     24  enum SolveType {
     25    useDual = 0,
     26    usePrimal,
     27    usePrimalorSprint,
     28    useBarrier,
     29    useBarrierNoCross,
     30    automatic,
     31    tryDantzigWolfe,
     32    tryBenders,
     33    notImplemented
     34  };
     35  enum PresolveType {
     36    presolveOn = 0,
     37    presolveOff,
     38    presolveNumber,
     39    presolveNumberCost
     40  };
     41
     42  /**@name Constructors and destructor and copy */
     43  //@{
     44  /// Default constructor
     45  ClpSolve();
     46  /// Constructor when you really know what you are doing
     47  ClpSolve(SolveType method, PresolveType presolveType,
     48    int numberPasses, int options[6],
     49    int extraInfo[6], int independentOptions[3]);
     50  /// Generates code for above constructor
     51  void generateCpp(FILE *fp);
     52  /// Copy constructor.
     53  ClpSolve(const ClpSolve &);
     54  /// Assignment operator. This copies the data
     55  ClpSolve &operator=(const ClpSolve &rhs);
     56  /// Destructor
     57  ~ClpSolve();
     58  //@}
     59
     60  /**@name Functions most useful to user */
     61  //@{
     62  /** Special options - bits
    6463     0      4 - use crash (default allslack in dual, idiot in primal)
    6564         8 - all slack basis in primal
     
    6867         64 - do not use sprint even if problem looks good
    6968      */
    70      /** which translation is:
     69  /** which translation is:
    7170         which:
    7271         0 - startup in Dual  (nothing if basis exists).:
     
    103102                     
    104103     */
    105      void setSpecialOption(int which, int value, int extraInfo = -1);
    106      int getSpecialOption(int which) const;
    107 
    108      /// Solve types
    109      void setSolveType(SolveType method, int extraInfo = -1);
    110      SolveType getSolveType();
    111 
    112      // Presolve types
    113      void setPresolveType(PresolveType amount, int extraInfo = -1);
    114      PresolveType getPresolveType();
    115      int getPresolvePasses() const;
    116      /// Extra info for idiot (or sprint)
    117      int getExtraInfo(int which) const;
    118      /** Say to return at once if infeasible,
     104  void setSpecialOption(int which, int value, int extraInfo = -1);
     105  int getSpecialOption(int which) const;
     106
     107  /// Solve types
     108  void setSolveType(SolveType method, int extraInfo = -1);
     109  SolveType getSolveType();
     110
     111  // Presolve types
     112  void setPresolveType(PresolveType amount, int extraInfo = -1);
     113  PresolveType getPresolveType();
     114  int getPresolvePasses() const;
     115  /// Extra info for idiot (or sprint)
     116  int getExtraInfo(int which) const;
     117  /** Say to return at once if infeasible,
    119118         default is to solve */
    120      void setInfeasibleReturn(bool trueFalse);
    121      inline bool infeasibleReturn() const {
    122           return independentOptions_[0] != 0;
    123      }
    124      /// Whether we want to do dual part of presolve
    125      inline bool doDual() const {
    126           return (independentOptions_[1] & 1) == 0;
    127      }
    128      inline void setDoDual(bool doDual_) {
    129           if (doDual_) independentOptions_[1]  &= ~1;
    130           else independentOptions_[1] |= 1;
    131      }
    132      /// Whether we want to do singleton part of presolve
    133      inline bool doSingleton() const {
    134           return (independentOptions_[1] & 2) == 0;
    135      }
    136      inline void setDoSingleton(bool doSingleton_) {
    137           if (doSingleton_) independentOptions_[1]  &= ~2;
    138           else independentOptions_[1] |= 2;
    139      }
    140      /// Whether we want to do doubleton part of presolve
    141      inline bool doDoubleton() const {
    142           return (independentOptions_[1] & 4) == 0;
    143      }
    144      inline void setDoDoubleton(bool doDoubleton_) {
    145           if (doDoubleton_) independentOptions_[1]  &= ~4;
    146           else independentOptions_[1] |= 4;
    147      }
    148      /// Whether we want to do tripleton part of presolve
    149      inline bool doTripleton() const {
    150           return (independentOptions_[1] & 8) == 0;
    151      }
    152      inline void setDoTripleton(bool doTripleton_) {
    153           if (doTripleton_) independentOptions_[1]  &= ~8;
    154           else independentOptions_[1] |= 8;
    155      }
    156      /// Whether we want to do tighten part of presolve
    157      inline bool doTighten() const {
    158           return (independentOptions_[1] & 16) == 0;
    159      }
    160      inline void setDoTighten(bool doTighten_) {
    161           if (doTighten_) independentOptions_[1]  &= ~16;
    162           else independentOptions_[1] |= 16;
    163      }
    164      /// Whether we want to do forcing part of presolve
    165      inline bool doForcing() const {
    166           return (independentOptions_[1] & 32) == 0;
    167      }
    168      inline void setDoForcing(bool doForcing_) {
    169           if (doForcing_) independentOptions_[1]  &= ~32;
    170           else independentOptions_[1] |= 32;
    171      }
    172      /// Whether we want to do impliedfree part of presolve
    173      inline bool doImpliedFree() const {
    174           return (independentOptions_[1] & 64) == 0;
    175      }
    176      inline void setDoImpliedFree(bool doImpliedfree) {
    177           if (doImpliedfree) independentOptions_[1]  &= ~64;
    178           else independentOptions_[1] |= 64;
    179      }
    180      /// Whether we want to do dupcol part of presolve
    181      inline bool doDupcol() const {
    182           return (independentOptions_[1] & 128) == 0;
    183      }
    184      inline void setDoDupcol(bool doDupcol_) {
    185           if (doDupcol_) independentOptions_[1]  &= ~128;
    186           else independentOptions_[1] |= 128;
    187      }
    188      /// Whether we want to do duprow part of presolve
    189      inline bool doDuprow() const {
    190           return (independentOptions_[1] & 256) == 0;
    191      }
    192      inline void setDoDuprow(bool doDuprow_) {
    193           if (doDuprow_) independentOptions_[1]  &= ~256;
    194           else independentOptions_[1] |= 256;
    195      }
    196      /// Whether we want to do singleton column part of presolve
    197      inline bool doSingletonColumn() const {
    198           return (independentOptions_[1] & 512) == 0;
    199      }
    200      inline void setDoSingletonColumn(bool doSingleton_) {
    201           if (doSingleton_) independentOptions_[1]  &= ~512;
    202           else independentOptions_[1] |= 512;
    203      }
    204      /// Whether we want to kill small substitutions
    205      inline bool doKillSmall() const {
    206           return (independentOptions_[1] & 8192) == 0;
    207      }
    208      inline void setDoKillSmall(bool doKill) {
    209           if (doKill) independentOptions_[1]  &= ~8192;
    210           else independentOptions_[1] |= 8192;
    211      }
    212      /// Set whole group
    213      inline int presolveActions() const {
    214           return independentOptions_[1] & 0xffffff;
    215      }
    216      inline void setPresolveActions(int action) {
    217           independentOptions_[1]  = (independentOptions_[1] & 0xff000000) | (action & 0xffffff);
    218      }
    219      /// Largest column for substitution (normally 3)
    220      inline int substitution() const {
    221           return independentOptions_[2];
    222      }
    223      inline void setSubstitution(int value) {
    224           independentOptions_[2] = value;
    225      }
    226      inline void setIndependentOption(int type,int value) {
    227           independentOptions_[type]  = value;
    228      }
    229      inline int independentOption(int type) const {
    230           return independentOptions_[type];
    231      }
    232      //@}
    233 
    234 ////////////////// data //////////////////
     119  void setInfeasibleReturn(bool trueFalse);
     120  inline bool infeasibleReturn() const
     121  {
     122    return independentOptions_[0] != 0;
     123  }
     124  /// Whether we want to do dual part of presolve
     125  inline bool doDual() const
     126  {
     127    return (independentOptions_[1] & 1) == 0;
     128  }
     129  inline void setDoDual(bool doDual_)
     130  {
     131    if (doDual_)
     132      independentOptions_[1] &= ~1;
     133    else
     134      independentOptions_[1] |= 1;
     135  }
     136  /// Whether we want to do singleton part of presolve
     137  inline bool doSingleton() const
     138  {
     139    return (independentOptions_[1] & 2) == 0;
     140  }
     141  inline void setDoSingleton(bool doSingleton_)
     142  {
     143    if (doSingleton_)
     144      independentOptions_[1] &= ~2;
     145    else
     146      independentOptions_[1] |= 2;
     147  }
     148  /// Whether we want to do doubleton part of presolve
     149  inline bool doDoubleton() const
     150  {
     151    return (independentOptions_[1] & 4) == 0;
     152  }
     153  inline void setDoDoubleton(bool doDoubleton_)
     154  {
     155    if (doDoubleton_)
     156      independentOptions_[1] &= ~4;
     157    else
     158      independentOptions_[1] |= 4;
     159  }
     160  /// Whether we want to do tripleton part of presolve
     161  inline bool doTripleton() const
     162  {
     163    return (independentOptions_[1] & 8) == 0;
     164  }
     165  inline void setDoTripleton(bool doTripleton_)
     166  {
     167    if (doTripleton_)
     168      independentOptions_[1] &= ~8;
     169    else
     170      independentOptions_[1] |= 8;
     171  }
     172  /// Whether we want to do tighten part of presolve
     173  inline bool doTighten() const
     174  {
     175    return (independentOptions_[1] & 16) == 0;
     176  }
     177  inline void setDoTighten(bool doTighten_)
     178  {
     179    if (doTighten_)
     180      independentOptions_[1] &= ~16;
     181    else
     182      independentOptions_[1] |= 16;
     183  }
     184  /// Whether we want to do forcing part of presolve
     185  inline bool doForcing() const
     186  {
     187    return (independentOptions_[1] & 32) == 0;
     188  }
     189  inline void setDoForcing(bool doForcing_)
     190  {
     191    if (doForcing_)
     192      independentOptions_[1] &= ~32;
     193    else
     194      independentOptions_[1] |= 32;
     195  }
     196  /// Whether we want to do impliedfree part of presolve
     197  inline bool doImpliedFree() const
     198  {
     199    return (independentOptions_[1] & 64) == 0;
     200  }
     201  inline void setDoImpliedFree(bool doImpliedfree)
     202  {
     203    if (doImpliedfree)
     204      independentOptions_[1] &= ~64;
     205    else
     206      independentOptions_[1] |= 64;
     207  }
     208  /// Whether we want to do dupcol part of presolve
     209  inline bool doDupcol() const
     210  {
     211    return (independentOptions_[1] & 128) == 0;
     212  }
     213  inline void setDoDupcol(bool doDupcol_)
     214  {
     215    if (doDupcol_)
     216      independentOptions_[1] &= ~128;
     217    else
     218      independentOptions_[1] |= 128;
     219  }
     220  /// Whether we want to do duprow part of presolve
     221  inline bool doDuprow() const
     222  {
     223    return (independentOptions_[1] & 256) == 0;
     224  }
     225  inline void setDoDuprow(bool doDuprow_)
     226  {
     227    if (doDuprow_)
     228      independentOptions_[1] &= ~256;
     229    else
     230      independentOptions_[1] |= 256;
     231  }
     232  /// Whether we want to do singleton column part of presolve
     233  inline bool doSingletonColumn() const
     234  {
     235    return (independentOptions_[1] & 512) == 0;
     236  }
     237  inline void setDoSingletonColumn(bool doSingleton_)
     238  {
     239    if (doSingleton_)
     240      independentOptions_[1] &= ~512;
     241    else
     242      independentOptions_[1] |= 512;
     243  }
     244  /// Whether we want to kill small substitutions
     245  inline bool doKillSmall() const
     246  {
     247    return (independentOptions_[1] & 8192) == 0;
     248  }
     249  inline void setDoKillSmall(bool doKill)
     250  {
     251    if (doKill)
     252      independentOptions_[1] &= ~8192;
     253    else
     254      independentOptions_[1] |= 8192;
     255  }
     256  /// Set whole group
     257  inline int presolveActions() const
     258  {
     259    return independentOptions_[1] & 0xffffff;
     260  }
     261  inline void setPresolveActions(int action)
     262  {
     263    independentOptions_[1] = (independentOptions_[1] & 0xff000000) | (action & 0xffffff);
     264  }
     265  /// Largest column for substitution (normally 3)
     266  inline int substitution() const
     267  {
     268    return independentOptions_[2];
     269  }
     270  inline void setSubstitution(int value)
     271  {
     272    independentOptions_[2] = value;
     273  }
     274  inline void setIndependentOption(int type, int value)
     275  {
     276    independentOptions_[type] = value;
     277  }
     278  inline int independentOption(int type) const
     279  {
     280    return independentOptions_[type];
     281  }
     282  //@}
     283
     284  ////////////////// data //////////////////
    235285private:
    236 
    237      /**@name data.
     286  /**@name data.
    238287     */
    239      //@{
    240      /// Solve type
    241      SolveType method_;
    242      /// Presolve type
    243      PresolveType presolveType_;
    244      /// Amount of presolve
    245      int numberPasses_;
    246      /// Options - last is switch for OsiClp
    247      int options_[7];
    248      /// Extra information
    249      int extraInfo_[7];
    250      /** Extra algorithm dependent options
     288  //@{
     289  /// Solve type
     290  SolveType method_;
     291  /// Presolve type
     292  PresolveType presolveType_;
     293  /// Amount of presolve
     294  int numberPasses_;
     295  /// Options - last is switch for OsiClp
     296  int options_[7];
     297  /// Extra information
     298  int extraInfo_[7];
     299  /** Extra algorithm dependent options
    251300         0 - if set return from clpsolve if infeasible
    252301         1 - To be copied over to presolve options
     
    254303         If Dantzig Wolfe/benders 0 is number blocks, 2 is #passes (notional)
    255304     */
    256      int independentOptions_[3];
    257      //@}
     305  int independentOptions_[3];
     306  //@}
    258307};
    259308
     
    262311
    263312public:
    264 
    265 
    266      /**@name Constructors and destructor and copy */
    267      //@{
    268      /// Default constructor
    269      ClpSimplexProgress (  );
    270 
    271      /// Constructor from model
    272      ClpSimplexProgress ( ClpSimplex * model );
    273 
    274      /// Copy constructor.
    275      ClpSimplexProgress(const ClpSimplexProgress &);
    276 
    277      /// Assignment operator. This copies the data
    278      ClpSimplexProgress & operator=(const ClpSimplexProgress & rhs);
    279      /// Destructor
    280      ~ClpSimplexProgress (  );
    281      /// Resets as much as possible
    282      void reset();
    283      /// Fill from model
    284      void fillFromModel ( ClpSimplex * model );
    285 
    286      //@}
    287 
    288      /**@name Check progress */
    289      //@{
    290      /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken,
     313  /**@name Constructors and destructor and copy */
     314  //@{
     315  /// Default constructor
     316  ClpSimplexProgress();
     317
     318  /// Constructor from model
     319  ClpSimplexProgress(ClpSimplex *model);
     320
     321  /// Copy constructor.
     322  ClpSimplexProgress(const ClpSimplexProgress &);
     323
     324  /// Assignment operator. This copies the data
     325  ClpSimplexProgress &operator=(const ClpSimplexProgress &rhs);
     326  /// Destructor
     327  ~ClpSimplexProgress();
     328  /// Resets as much as possible
     329  void reset();
     330  /// Fill from model
     331  void fillFromModel(ClpSimplex *model);
     332
     333  //@}
     334
     335  /**@name Check progress */
     336  //@{
     337  /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken,
    291338         >=0 if give up and use as problem status
    292339     */
    293      int looping (  );
    294      /// Start check at beginning of whileIterating
    295      void startCheck();
    296      /// Returns cycle length in whileIterating
    297      int cycle(int in, int out, int wayIn, int wayOut);
    298 
    299      /// Returns previous objective (if -1) - current if (0)
    300      double lastObjective(int back = 1) const;
    301      /// Set real primal infeasibility and move back
    302      void setInfeasibility(double value);
    303      /// Returns real primal infeasibility (if -1) - current if (0)
    304      double lastInfeasibility(int back = 1) const;
    305      /// Returns number of primal infeasibilities (if -1) - current if (0)
    306      int numberInfeasibilities(int back = 1) const;
    307      /// Modify objective e.g. if dual infeasible in dual
    308      void modifyObjective(double value);
    309      /// Returns previous iteration number (if -1) - current if (0)
    310      int lastIterationNumber(int back = 1) const;
    311      /// clears all iteration numbers (to switch off panic)
    312      void clearIterationNumbers();
    313      /// Odd state
    314      inline void newOddState() {
    315           oddState_ = - oddState_ - 1;
    316      }
    317      inline void endOddState() {
    318           oddState_ = abs(oddState_);
    319      }
    320      inline void clearOddState() {
    321           oddState_ = 0;
    322      }
    323      inline int oddState() const {
    324           return oddState_;
    325      }
    326      /// number of bad times
    327      inline int badTimes() const {
    328           return numberBadTimes_;
    329      }
    330      inline void clearBadTimes() {
    331           numberBadTimes_ = 0;
    332      }
    333      /// number of really bad times
    334      inline int reallyBadTimes() const {
    335           return numberReallyBadTimes_;
    336      }
    337      inline void incrementReallyBadTimes() {
    338           numberReallyBadTimes_++;
    339      }
    340      /// number of times flagged
    341      inline int timesFlagged() const {
    342           return numberTimesFlagged_;
    343      }
    344      inline void clearTimesFlagged() {
    345           numberTimesFlagged_ = 0;
    346      }
    347      inline void incrementTimesFlagged() {
    348           numberTimesFlagged_++;
    349      }
    350 
    351      //@}
    352      /**@name Data  */
     340  int looping();
     341  /// Start check at beginning of whileIterating
     342  void startCheck();
     343  /// Returns cycle length in whileIterating
     344  int cycle(int in, int out, int wayIn, int wayOut);
     345
     346  /// Returns previous objective (if -1) - current if (0)
     347  double lastObjective(int back = 1) const;
     348  /// Set real primal infeasibility and move back
     349  void setInfeasibility(double value);
     350  /// Returns real primal infeasibility (if -1) - current if (0)
     351  double lastInfeasibility(int back = 1) const;
     352  /// Returns number of primal infeasibilities (if -1) - current if (0)
     353  int numberInfeasibilities(int back = 1) const;
     354  /// Modify objective e.g. if dual infeasible in dual
     355  void modifyObjective(double value);
     356  /// Returns previous iteration number (if -1) - current if (0)
     357  int lastIterationNumber(int back = 1) const;
     358  /// clears all iteration numbers (to switch off panic)
     359  void clearIterationNumbers();
     360  /// Odd state
     361  inline void newOddState()
     362  {
     363    oddState_ = -oddState_ - 1;
     364  }
     365  inline void endOddState()
     366  {
     367    oddState_ = abs(oddState_);
     368  }
     369  inline void clearOddState()
     370  {
     371    oddState_ = 0;
     372  }
     373  inline int oddState() const
     374  {
     375    return oddState_;
     376  }
     377  /// number of bad times
     378  inline int badTimes() const
     379  {
     380    return numberBadTimes_;
     381  }
     382  inline void clearBadTimes()
     383  {
     384    numberBadTimes_ = 0;
     385  }
     386  /// number of really bad times
     387  inline int reallyBadTimes() const
     388  {
     389    return numberReallyBadTimes_;
     390  }
     391  inline void incrementReallyBadTimes()
     392  {
     393    numberReallyBadTimes_++;
     394  }
     395  /// number of times flagged
     396  inline int timesFlagged() const
     397  {
     398    return numberTimesFlagged_;
     399  }
     400  inline void clearTimesFlagged()
     401  {
     402    numberTimesFlagged_ = 0;
     403  }
     404  inline void incrementTimesFlagged()
     405  {
     406    numberTimesFlagged_++;
     407  }
     408
     409  //@}
     410  /**@name Data  */
    353411#define CLP_PROGRESS 5
    354      //#define CLP_PROGRESS_WEIGHT 10
    355      //@{
    356      /// Objective values
    357      double objective_[CLP_PROGRESS];
    358      /// Sum of infeasibilities for algorithm
    359      double infeasibility_[CLP_PROGRESS];
    360      /// Sum of real primal infeasibilities for primal
    361      double realInfeasibility_[CLP_PROGRESS];
     412  //#define CLP_PROGRESS_WEIGHT 10
     413  //@{
     414  /// Objective values
     415  double objective_[CLP_PROGRESS];
     416  /// Sum of infeasibilities for algorithm
     417  double infeasibility_[CLP_PROGRESS];
     418  /// Sum of real primal infeasibilities for primal
     419  double realInfeasibility_[CLP_PROGRESS];
    362420#ifdef CLP_PROGRESS_WEIGHT
    363      /// Objective values for weights
    364      double objectiveWeight_[CLP_PROGRESS_WEIGHT];
    365      /// Sum of infeasibilities for algorithm for weights
    366      double infeasibilityWeight_[CLP_PROGRESS_WEIGHT];
    367      /// Sum of real primal infeasibilities for primal for weights
    368      double realInfeasibilityWeight_[CLP_PROGRESS_WEIGHT];
    369      /// Drop  for weights
    370      double drop_;
    371      /// Best? for weights
    372      double best_;
     421  /// Objective values for weights
     422  double objectiveWeight_[CLP_PROGRESS_WEIGHT];
     423  /// Sum of infeasibilities for algorithm for weights
     424  double infeasibilityWeight_[CLP_PROGRESS_WEIGHT];
     425  /// Sum of real primal infeasibilities for primal for weights
     426  double realInfeasibilityWeight_[CLP_PROGRESS_WEIGHT];
     427  /// Drop  for weights
     428  double drop_;
     429  /// Best? for weights
     430  double best_;
    373431#endif
    374      /// Initial weight for weights
    375      double initialWeight_;
     432  /// Initial weight for weights
     433  double initialWeight_;
    376434#define CLP_CYCLE 12
    377      /// For cycle checking
    378      //double obj_[CLP_CYCLE];
    379      int in_[CLP_CYCLE];
    380      int out_[CLP_CYCLE];
    381      char way_[CLP_CYCLE];
    382      /// Pointer back to model so we can get information
    383      ClpSimplex * model_;
    384      /// Number of infeasibilities
    385      int numberInfeasibilities_[CLP_PROGRESS];
    386      /// Iteration number at which occurred
    387      int iterationNumber_[CLP_PROGRESS];
     435  /// For cycle checking
     436  //double obj_[CLP_CYCLE];
     437  int in_[CLP_CYCLE];
     438  int out_[CLP_CYCLE];
     439  char way_[CLP_CYCLE];
     440  /// Pointer back to model so we can get information
     441  ClpSimplex *model_;
     442  /// Number of infeasibilities
     443  int numberInfeasibilities_[CLP_PROGRESS];
     444  /// Iteration number at which occurred
     445  int iterationNumber_[CLP_PROGRESS];
    388446#ifdef CLP_PROGRESS_WEIGHT
    389      /// Number of infeasibilities for weights
    390      int numberInfeasibilitiesWeight_[CLP_PROGRESS_WEIGHT];
    391      /// Iteration number at which occurred for weights
    392      int iterationNumberWeight_[CLP_PROGRESS_WEIGHT];
     447  /// Number of infeasibilities for weights
     448  int numberInfeasibilitiesWeight_[CLP_PROGRESS_WEIGHT];
     449  /// Iteration number at which occurred for weights
     450  int iterationNumberWeight_[CLP_PROGRESS_WEIGHT];
    393451#endif
    394      /// Number of times checked (so won't stop too early)
    395      int numberTimes_;
    396      /// Number of times it looked like loop
    397      int numberBadTimes_;
    398      /// Number really bad times
    399      int numberReallyBadTimes_;
    400      /// Number of times no iterations as flagged
    401      int numberTimesFlagged_;
    402      /// If things are in an odd state
    403      int oddState_;
    404      //@}
     452  /// Number of times checked (so won't stop too early)
     453  int numberTimes_;
     454  /// Number of times it looked like loop
     455  int numberBadTimes_;
     456  /// Number really bad times
     457  int numberReallyBadTimes_;
     458  /// Number of times no iterations as flagged
     459  int numberTimesFlagged_;
     460  /// If things are in an odd state
     461  int oddState_;
     462  //@}
    405463};
    406464
     
    412470
    413471public:
    414 
    415 
    416      /**@name Constructors and destructor and copy */
    417      //@{
    418      /// Default constructor
    419      AbcSimplexProgress (  );
    420 
    421      /// Constructor from model
    422      AbcSimplexProgress ( ClpSimplex * model );
    423 
    424      /// Copy constructor.
    425      AbcSimplexProgress(const AbcSimplexProgress &);
    426 
    427      /// Assignment operator. This copies the data
    428      AbcSimplexProgress & operator=(const AbcSimplexProgress & rhs);
    429      /// Destructor
    430      ~AbcSimplexProgress (  );
    431 
    432      //@}
    433 
    434      /**@name Check progress */
    435      //@{
    436      /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken,
     472  /**@name Constructors and destructor and copy */
     473  //@{
     474  /// Default constructor
     475  AbcSimplexProgress();
     476
     477  /// Constructor from model
     478  AbcSimplexProgress(ClpSimplex *model);
     479
     480  /// Copy constructor.
     481  AbcSimplexProgress(const AbcSimplexProgress &);
     482
     483  /// Assignment operator. This copies the data
     484  AbcSimplexProgress &operator=(const AbcSimplexProgress &rhs);
     485  /// Destructor
     486  ~AbcSimplexProgress();
     487
     488  //@}
     489
     490  /**@name Check progress */
     491  //@{
     492  /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken,
    437493         >=0 if give up and use as problem status
    438494     */
    439      int looping (  );
    440 
    441      //@}
    442      /**@name Data  */
    443      //@}
     495  int looping();
     496
     497  //@}
     498  /**@name Data  */
     499  //@}
    444500};
    445501#endif
    446502#endif
     503
     504/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
     505*/
Note: See TracChangeset for help on using the changeset viewer.