source: branches/devel-1/include/ClpSimplex.hpp @ 19

Last change on this file since 19 was 19, checked in by ladanyi, 17 years ago

reordering Clp

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 23.6 KB
Line 
1// Copyright (C) 2002, International Business Machines
2// Corporation and others.  All Rights Reserved.
3
4/*
5   Authors
6   
7   John Forrest
8
9 */
10#ifndef ClpSimplex_H
11#define ClpSimplex_H
12
13#include <iostream>
14#include <cfloat>
15#include "ClpModel.hpp"
16#include "ClpMatrixBase.hpp"
17class ClpDualRowPivot;
18class ClpPrimalColumnPivot;
19class ClpFactorization;
20class CoinWarmStartBasis;
21class CoinIndexedVector;
22class ClpNonLinearCost;
23
24/** This solves LPs using the simplex method
25
26    It inherits from ClpModel and all its arrays are created at
27    algorithm time. Originally I tried to work with model arrays
28    but for simplicity of coding I changed to single arrays with
29    structural variables then row variables.  Some coding is still
30    based on old style and needs cleaning up.
31
32    For a description of algorithms:
33
34    for dual see ClpSimplexDual.hpp and at top of ClpSimplexDual.cpp
35    for primal see ClpSimplexPrimal.hpp and at top of ClpSimplexPrimal.cpp
36
37    There is an algorithm data member.  + for primal variations
38    and - for dual variations
39
40*/
41
42class ClpSimplex : public ClpModel {
43   friend void ClpSimplexUnitTest(const std::string & mpsDir,
44                                  const std::string & netlibDir);
45
46public:
47
48  /// enums for status of various sorts (matches CoinWarmStartBasis)
49  enum Status {
50    isFree = 0x00,
51    basic = 0x01,
52    atUpperBound = 0x02,
53    atLowerBound = 0x03,
54    superBasic = 0x04
55  };
56
57  enum FakeBound {
58    noFake = 0x00,
59    bothFake = 0x01,
60    upperFake = 0x02,
61    lowerFake = 0x03
62  };
63
64  /**@name Constructors and destructor and copy */
65  //@{
66  /// Default constructor
67    ClpSimplex (  );
68
69  /// Copy constructor.
70  ClpSimplex(const ClpSimplex &);
71  /// Copy constructor from model.
72  ClpSimplex(const ClpModel &);
73  /// Assignment operator. This copies the data
74    ClpSimplex & operator=(const ClpSimplex & rhs);
75  /// Destructor
76   ~ClpSimplex (  );
77  /** Borrow model.  This is so we dont have to copy large amounts
78      of data around.  It assumes a derived class wants to overwrite
79      an empty model with a real one - while it does an algorithm.
80      This is same as ClpModel one, but sets scaling on etc. */
81  void borrowModel(ClpModel & otherModel);
82  //@}
83
84  /**@name Functions most useful to user */
85  //@{
86  /** Dual algorithm - see ClpSimplexDual.hpp for method */
87  int dual();
88  /** Primal algorithm - see ClpSimplexPrimal.hpp for method */
89  int primal(int ifValuesPass=0);
90  /// Sets up working basis as a copy of input
91  void setBasis( const CoinWarmStartBasis & basis);
92  /// Passes in factorization
93  void setFactorization( ClpFactorization & factorization);
94  /// Sets or unsets scaling, 0 -off, 1 on, 2 dynamic(later)
95  void scaling(int mode=1);
96  /// Gets scalingFlag
97  inline int scalingFlag() const {return scalingFlag_;};
98  /** Tightens primal bounds to make dual faster.  Unless
99      fixed, bounds are slightly looser than they could be.
100      This is to make dual go faster and is probably not needed
101      with a presolve.  Returns non-zero if problem infeasible
102  */
103  int tightenPrimalBounds();
104  /// Sets row pivot choice algorithm in dual
105  void setDualRowPivotAlgorithm(ClpDualRowPivot & choice);
106  /// Sets column pivot choice algorithm in primal
107  void setPrimalColumnPivotAlgorithm(ClpPrimalColumnPivot & choice);
108  /** For strong branching.  On input lower and upper are new bounds
109      while on output they are change in objective function values
110      (>1.0e50 infeasible).
111      Return code is 0 if nothing interesting, -1 if infeasible both
112      ways and +1 if infeasible one way (check values to see which one(s))
113  */
114  int strongBranching(int numberVariables,const int * variables,
115                      double * newLower, double * newUpper,
116                      bool stopOnFirstInfeasible=true,
117                      bool alwaysFinish=false);
118  //@}
119
120  /**@name most useful gets and sets */
121  //@{
122  /// If problem is primal feasible
123  inline bool primalFeasible() const
124         { return (numberPrimalInfeasibilities_==0);};
125  /// If problem is dual feasible
126  inline bool dualFeasible() const
127         { return (numberDualInfeasibilities_==0);};
128  /// factorization
129  inline ClpFactorization * factorization() const 
130          { return factorization_;};
131  /// Sparsity on or off
132  bool sparseFactorization() const;
133  void setSparseFactorization(bool value);
134  /// Dual bound
135  inline double dualBound() const
136          { return dualBound_;};
137  void setDualBound(double value);
138  /// Infeasibility cost
139  inline double infeasibilityCost() const
140          { return infeasibilityCost_;};
141  void setInfeasibilityCost(double value);
142  /** Amount of print out:
143      0 - none
144      1 - just final
145      2 - just factorizations
146      3 - as 2 plus a bit more
147      4 - verbose
148      above that 8,16,32 etc just for selective debug
149  */
150  /** Perturbation:
151      -50 to +50 - perturb by this power of ten (-6 sounds good)
152      100 - auto perturb if takes too long (1.0e-6 largest nonzero)
153      101 - we are perturbed
154      102 - don't try perturbing again
155      default is 100
156  */
157  inline int perturbation() const
158    { return perturbation_;};
159  void setPerturbation(int value);
160  /// Current (or last) algorithm
161  inline int algorithm() const 
162  {return algorithm_; } ;
163  /// Sum of dual infeasibilities
164  inline double sumDualInfeasibilities() const 
165          { return sumDualInfeasibilities_;} ;
166  /// Number of dual infeasibilities
167  inline int numberDualInfeasibilities() const 
168          { return numberDualInfeasibilities_;} ;
169  /// Sum of primal infeasibilities
170  inline double sumPrimalInfeasibilities() const 
171          { return sumPrimalInfeasibilities_;} ;
172  /// Number of primal infeasibilities
173  inline int numberPrimalInfeasibilities() const 
174          { return numberPrimalInfeasibilities_;} ;
175  /// Warm start
176  CoinWarmStartBasis getBasis() const;
177  /** Save model to file, returns 0 if success.  This is designed for
178      use outside algorithms so does not save iterating arrays etc.
179  It does not save any messaging information.
180  Does not save scaling values.
181  It does not know about all types of virtual functions.
182  */
183  int saveModel(const char * fileName);
184  /** Restore model from file, returns 0 if success,
185      deletes current model */
186  int restoreModel(const char * fileName);
187 
188  //@}
189
190  /******************** End of most useful part **************/
191  /**@name Functions less likely to be useful to casual user */
192  //@{
193  /** Given an existing factorization computes and checks
194      primal and dual solutions.  Uses input arrays for variables at
195      bounds.  Returns feasibility states */
196  int getSolution (  const double * rowActivities,
197                     const double * columnActivities);
198  /** Given an existing factorization computes and checks
199      primal and dual solutions.  Uses current problem arrays for
200      bounds.  Returns feasibility states */
201  int getSolution ();
202  /** Factorizes using current basis. 
203      solveType - 1 iterating, 0 initial, -1 external
204      If 10 added then in primal values pass
205      Return codes are as from ClpFactorization unless initial factorization
206      when total number of singularities is returned
207  */
208  int internalFactorize(int solveType);
209  /// Factorizes using current basis. For external use
210  int factorize();
211  /// Computes duals from scratch
212  void computeDuals();
213  /// Computes primals from scratch
214  void computePrimals (  const double * rowActivities,
215                     const double * columnActivities);
216  /**
217     Unpacks one column of the matrix into indexed array
218     Uses sequenceIn_
219     Also applies scaling if needed
220  */
221  void unpack(CoinIndexedVector * rowArray);
222  /**
223     Unpacks one column of the matrix into indexed array
224     Slack if sequence>= numberColumns
225     Also applies scaling if needed
226  */
227  void unpack(CoinIndexedVector * rowArray,int sequence);
228 
229  /**
230      This does basis housekeeping and does values for in/out variables.
231      Can also decide to re-factorize
232  */
233  int housekeeping(double objectiveChange);
234  /** This sets largest infeasibility and most infeasible and sum
235      and number of infeasibilities (Primal) */
236  void checkPrimalSolution(const double * rowActivities=NULL,
237                           const double * columnActivies=NULL);
238  /** This sets largest infeasibility and most infeasible and sum
239      and number of infeasibilities (Dual) */
240  void checkDualSolution();
241  //@}
242  /**@name Matrix times vector methods
243     They can be faster if scalar is +- 1
244     These are covers so user need not worry about scaling
245     Also for simplex I am not using basic/non-basic split */
246  //@{
247    /** Return <code>y + A * x * scalar</code> in <code>y</code>.
248        @precond <code>x<code> must be of size <code>numColumns()</code>
249        @precond <code>y<code> must be of size <code>numRows()</code> */
250   void times(double scalar,
251                       const double * x, double * y) const;
252    /** Return <code>y + x * scalar * A</code> in <code>y</code>.
253        @precond <code>x<code> must be of size <code>numRows()</code>
254        @precond <code>y<code> must be of size <code>numColumns()</code> */
255    void transposeTimes(double scalar,
256                                const double * x, double * y) const ;
257  //@}
258
259  /**@name most useful gets and sets */
260  //@{
261  /// Worst column primal infeasibility
262  inline double columnPrimalInfeasibility() const 
263          { return columnPrimalInfeasibility_;} ;
264  /// Sequence of worst (-1 if feasible)
265  inline int columnPrimalSequence() const 
266          { return columnPrimalSequence_;} ;
267  /// Worst row primal infeasibility
268  inline double rowPrimalInfeasibility() const 
269          { return rowPrimalInfeasibility_;} ;
270  /// Sequence of worst (-1 if feasible)
271  inline int rowPrimalSequence() const 
272          { return rowPrimalSequence_;} ;
273  /** Worst column dual infeasibility (note - these may not be as meaningful
274      if the problem is primal infeasible */
275  inline double columnDualInfeasibility() const 
276          { return columnDualInfeasibility_;} ;
277  /// Sequence of worst (-1 if feasible)
278  inline int columnDualSequence() const 
279          { return columnDualSequence_;} ;
280  /// Worst row dual infeasibility
281  inline double rowDualInfeasibility() const 
282          { return rowDualInfeasibility_;} ;
283  /// Sequence of worst (-1 if feasible)
284  inline int rowDualSequence() const 
285          { return rowDualSequence_;} ;
286  /// Primal tolerance needed to make dual feasible (<largeTolerance)
287  inline double primalToleranceToGetOptimal() const 
288          { return primalToleranceToGetOptimal_;} ;
289  /// Remaining largest dual infeasibility
290  inline double remainingDualInfeasibility() const 
291          { return remainingDualInfeasibility_;} ;
292  /// Large bound value (for complementarity etc)
293  inline double largeValue() const 
294          { return largeValue_;} ;
295  void setLargeValue( double value) ;
296  /// Largest error on Ax-b
297  inline double largestPrimalError() const
298          { return largestPrimalError_;} ;
299  /// Largest error on basic duals
300  inline double largestDualError() const
301          { return largestDualError_;} ;
302  /// Largest difference between input primal solution and computed
303  inline double largestSolutionError() const
304          { return largestSolutionError_;} ;
305  /// Basic variables pivoting on which rows
306  inline const int * pivotVariable() const
307          { return pivotVariable_;};
308  /// Current dual tolerance
309  inline double currentDualTolerance() const 
310          { return dualTolerance_;} ;
311  /// Current primal tolerance
312  inline double currentPrimalTolerance() const 
313          { return primalTolerance_;} ;
314  /// How many iterative refinements to do
315  inline int numberRefinements() const 
316          { return numberRefinements_;} ;
317  void setnumberRefinements( int value) ;
318  /// Alpha (pivot element) for use by classes e.g. steepestedge
319  inline double alpha() const { return alpha_;};
320  /// Reduced cost of last incoming for use by classes e.g. steepestedge
321  inline double dualIn() const { return dualIn_;};
322  /// Pivot Row for use by classes e.g. steepestedge
323  inline int pivotRow() const{ return pivotRow_;};
324  /// value of incoming variable (in Dual)
325  double valueIncomingDual() const;
326  //@}
327
328  protected:
329  /**@name protected methods */
330  //@{
331  /// May change basis and then returns number changed
332  int gutsOfSolution ( const double * rowActivities,
333                       const double * columnActivities,
334                       bool valuesPass=false);
335  /// Does most of deletion (0 = all, 1 = most)
336  void gutsOfDelete(int type);
337  /// Does most of copying
338  void gutsOfCopy(const ClpSimplex & rhs);
339  /** puts in format I like (rowLower,rowUpper) also see StandardMatrix
340      1 bit does rows, 2 bit does column bounds, 4 bit does objective(s).
341      8 bit does solution scaling in
342      16 bit does rowArray and columnArray indexed vectors
343      and makes row copy if wanted, also sets columnStart_ etc
344      Also creates scaling arrays if needed.  It does scaling if needed.
345      16 also moves solutions etc in to work arrays
346  */
347  void createRim(int what,bool makeRowCopy=false);
348  /// releases above arrays and does solution scaling out
349  void deleteRim();
350  //@}
351  public:
352  /**@name public methods */
353  //@{
354  /** Return row or column sections - not as much needed as it
355      once was.  These just map into single arrays */
356  inline double * solutionRegion(int section)
357  { if (!section) return rowActivityWork_; else return columnActivityWork_;};
358  inline double * djRegion(int section)
359  { if (!section) return rowReducedCost_; else return reducedCostWork_;};
360  inline double * lowerRegion(int section)
361  { if (!section) return rowLowerWork_; else return columnLowerWork_;};
362  inline double * upperRegion(int section)
363  { if (!section) return rowUpperWork_; else return columnUpperWork_;};
364  inline double * costRegion(int section)
365  { if (!section) return rowObjectiveWork_; else return objectiveWork_;};
366  /// Return region as single array
367  inline double * solutionRegion()
368  { return solution_;};
369  inline double * djRegion()
370  { return dj_;};
371  inline double * lowerRegion()
372  { return lower_;};
373  inline double * upperRegion()
374  { return upper_;};
375  inline double * costRegion()
376  { return cost_;};
377  inline Status getStatus(int sequence) const
378  {return static_cast<Status> (status_[sequence]&7);};
379  inline void setStatus(int sequence, Status status)
380  {
381    unsigned char & st_byte = status_[sequence];
382    st_byte &= ~7;
383    st_byte |= status;
384  };
385  /** Return sequence In or Out */
386  inline int sequenceIn() const
387  {return sequenceIn_;};
388  inline int sequenceOut() const
389  {return sequenceOut_;};
390  /** Set sequenceIn or Out */
391  inline void  setSequenceIn(int sequence)
392  { sequenceIn_=sequence;};
393  inline void  setSequenceOut(int sequence)
394  { sequenceOut_=sequence;};
395  /// Returns 1 if sequence indicates column
396  inline int isColumn(int sequence) const
397  { return sequence<numberColumns_ ? 1 : 0;};
398  /// Returns sequence number within section
399  inline int sequenceWithin(int sequence) const
400  { return sequence<numberColumns_ ? sequence : sequence-numberColumns_;};
401  /// Return row or column values
402  inline double solution(int sequence)
403  { return solution_[sequence];};
404  /// Return address of row or column values
405  inline double & solutionAddress(int sequence)
406  { return solution_[sequence];};
407  inline double reducedCost(int sequence)
408   { return dj_[sequence];};
409  inline double & reducedCostAddress(int sequence)
410   { return dj_[sequence];};
411  inline double lower(int sequence)
412  { return lower_[sequence];};
413  /// Return address of row or column lower bound
414  inline double & lowerAddress(int sequence)
415  { return lower_[sequence];};
416  inline double upper(int sequence)
417  { return upper_[sequence];};
418  /// Return address of row or column upper bound
419  inline double & upperAddress(int sequence)
420  { return upper_[sequence];};
421  inline double cost(int sequence)
422  { return cost_[sequence];};
423  /// Return address of row or column cost
424  inline double & costAddress(int sequence)
425  { return cost_[sequence];};
426  /// Scaling
427  const double * rowScale() const {return rowScale_;};
428  const double * columnScale() const {return columnScale_;};
429  void setRowScale(double * scale) { rowScale_ = scale;};
430  void setColumnScale(double * scale) { columnScale_ = scale;};
431  //@}
432  /**@name status methods */
433  //@{
434  inline void setFakeBound(int sequence, FakeBound fakeBound)
435  {
436    unsigned char & st_byte = status_[sequence];
437    st_byte &= ~24;
438    st_byte |= fakeBound<<3;
439  };
440  inline FakeBound getFakeBound(int sequence) const
441  {return static_cast<FakeBound> ((status_[sequence]>>3)&3);};
442  inline void setRowStatus(int sequence, Status status)
443  {
444    unsigned char & st_byte = status_[sequence+numberColumns_];
445    st_byte &= ~7;
446    st_byte |= status;
447  };
448  inline Status getRowStatus(int sequence) const
449  {return static_cast<Status> (status_[sequence+numberColumns_]&7);};
450  inline void setColumnStatus(int sequence, Status status)
451  {
452    unsigned char & st_byte = status_[sequence];
453    st_byte &= ~7;
454    st_byte |= status;
455  };
456  inline Status getColumnStatus(int sequence) const
457  {return static_cast<Status> (status_[sequence]&7);};
458  inline void setFixed( int sequence)
459  { status_[sequence] |= 32;};
460  inline void clearFixed( int sequence)
461  { status_[sequence] &= ~32; };
462  inline bool fixed(int sequence) const
463  {return (((status_[sequence]>>5)&1)!=0);};
464  inline void setFlagged( int sequence)
465  {
466    status_[sequence] |= 64;
467  };
468  inline void clearFlagged( int sequence)
469  {
470    status_[sequence] &= ~64;
471  };
472  inline bool flagged(int sequence) const
473  {return (((status_[sequence]>>6)&1)!=0);};
474  /// So we know when to be cautious
475  inline int lastBadIteration() const
476  {return lastBadIteration_;};
477  //@}
478
479////////////////// data //////////////////
480protected:
481
482  /**@name data.  Many arrays have a row part and a column part.
483   There is a single array with both - columns then rows and
484   then normally two arrays pointing to rows and columns.  The
485   single array is the owner of memory
486  */
487  //@{
488  /// Worst column primal infeasibility
489  double columnPrimalInfeasibility_;
490  /// Sequence of worst (-1 if feasible)
491  int columnPrimalSequence_;
492  /// Worst row primal infeasibility
493  double rowPrimalInfeasibility_;
494  /// Sequence of worst (-1 if feasible)
495  int rowPrimalSequence_;
496  /// Worst column dual infeasibility
497  double columnDualInfeasibility_;
498  /// Sequence of worst (-1 if feasible)
499  int columnDualSequence_;
500  /// Worst row dual infeasibility
501  double rowDualInfeasibility_;
502  /// Sequence of worst (-1 if feasible)
503  int rowDualSequence_;
504  /// Primal tolerance needed to make dual feasible (<largeTolerance)
505  double primalToleranceToGetOptimal_;
506  /// Remaining largest dual infeasibility
507  double remainingDualInfeasibility_;
508  /// Large bound value (for complementarity etc)
509  double largeValue_;
510  /// Largest error on Ax-b
511  double largestPrimalError_;
512  /// Largest error on basic duals
513  double largestDualError_;
514  /// Largest difference between input primal solution and computed
515  double largestSolutionError_;
516  /// Dual bound
517  double dualBound_;
518  /// Working copy of lower bounds (Owner of arrays below)
519  double * lower_;
520  /// Row lower bounds - working copy
521  double * rowLowerWork_;
522  /// Column lower bounds - working copy
523  double * columnLowerWork_;
524  /// Working copy of upper bounds (Owner of arrays below)
525  double * upper_;
526  /// Row upper bounds - working copy
527  double * rowUpperWork_;
528  /// Column upper bounds - working copy
529  double * columnUpperWork_;
530  /// Working copy of objective (Owner of arrays below)
531  double * cost_;
532  /// Row objective - working copy
533  double * rowObjectiveWork_;
534  /// Column objective - working copy
535  double * objectiveWork_;
536  /// Useful row length arrays
537  CoinIndexedVector * rowArray_[6];
538  /// Useful column length arrays
539  CoinIndexedVector * columnArray_[6];
540  /// Alpha (pivot element)
541  double alpha_;
542  /// Theta (pivot change)
543  double theta_;
544  /// Lower Bound on In variable
545  double lowerIn_;
546  /// Value of In variable
547  double valueIn_;
548  /// Upper Bound on In variable
549  double upperIn_;
550  /// Reduced cost of In variable
551  double dualIn_;
552  /// Sequence of In variable
553  int sequenceIn_;
554  /// Direction of In, 1 going up, -1 going down, 0 not a clude
555  int directionIn_;
556  /// Lower Bound on Out variable
557  double lowerOut_;
558  /// Value of Out variable
559  double valueOut_;
560  /// Upper Bound on Out variable
561  double upperOut_;
562  /// Infeasibility (dual) or ? (primal) of Out variable
563  double dualOut_;
564  /// Sequence of Out variable
565  int sequenceOut_;
566  /// Direction of Out, 1 to upper bound, -1 to lower bound, 0 - superbasic
567  int directionOut_;
568  /// Pivot Row
569  int pivotRow_;
570  /// Status Region (Owner of array below)
571  unsigned char * status_;
572  /// Working copy of reduced costs (Owner of arrays below)
573  double * dj_;
574  /// Reduced costs of slacks not same as duals (or - duals)
575  double * rowReducedCost_;
576  /// Possible scaled reduced costs
577  double * reducedCostWork_;
578  /// Working copy of primal solution (Owner of arrays below)
579  double * solution_;
580  /// Row activities - working copy
581  double * rowActivityWork_;
582  /// Column activities - working copy
583  double * columnActivityWork_;
584  /// Current dual tolerance for algorithm
585  double dualTolerance_;
586  /// Current primal tolerance for algorithm
587  double primalTolerance_;
588  /// Sum of dual infeasibilities
589  double sumDualInfeasibilities_;
590  /// Number of dual infeasibilities
591  int numberDualInfeasibilities_;
592  /// Number of dual infeasibilities (without free)
593  int numberDualInfeasibilitiesWithoutFree_;
594  /// Sum of primal infeasibilities
595  double sumPrimalInfeasibilities_;
596  /// Number of primal infeasibilities
597  int numberPrimalInfeasibilities_;
598  /// dual row pivot choice
599  ClpDualRowPivot * dualRowPivot_;
600  /// primal column pivot choice
601  ClpPrimalColumnPivot * primalColumnPivot_;
602  /// Basic variables pivoting on which rows
603  int * pivotVariable_;
604  /// factorization
605  ClpFactorization * factorization_;
606  /// How many iterative refinements to do
607  int numberRefinements_;
608  /// Row scale factors for matrix
609  // ****** get working simply then make coding more efficient
610  // on full matrix operations
611  double * rowScale_;
612  /// Saved version of solution
613  double * savedSolution_;
614  /// Column scale factors
615  double * columnScale_;
616  /// Scale flag, 0 none, 1 normal, 2 dynamic
617  int scalingFlag_;
618  /// Number of times code has tentatively thought optimal
619  int numberTimesOptimal_;
620  /// If change has been made (first attempt at stopping looping)
621  int changeMade_;
622  /// Algorithm >0 == Primal, <0 == Dual
623  int algorithm_;
624  /** Now for some reliability aids
625      This forces re-factorization early */
626  int forceFactorization_;
627  /// Saved status regions
628  unsigned char * saveStatus_;
629  /** Perturbation:
630      -50 to +50 - perturb by this power of ten (-6 sounds good)
631      100 - auto perturb if takes too long (1.0e-6 largest nonzero)
632      101 - we are perturbed
633      102 - don't try perturbing again
634      default is 100
635  */
636  int perturbation_;
637  /// Weight assigned to being infeasible in primal
638  double infeasibilityCost_;
639  /** Very wasteful way of dealing with infeasibilities in primal.
640      However it will allow non-linearities and use of dual
641      analysis.  If it doesn't work it can easily be replaced.
642  */
643  ClpNonLinearCost * nonLinearCost_;
644  /// For advanced options
645  unsigned int specialOptions_;
646  /// So we know when to be cautious
647  int lastBadIteration_;
648  /// Can be used for count of fake bounds (dual) or fake costs (primal)
649  int numberFake_;
650  //@}
651};
652//#############################################################################
653/** A function that tests the methods in the ClpSimplex class. The
654    only reason for it not to be a member method is that this way it doesn't
655    have to be compiled into the library. And that's a gain, because the
656    library should be compiled with optimization on, but this method should be
657    compiled with debugging.
658
659    It also does some testing of ClpFactorization class
660 */
661void
662ClpSimplexUnitTest(const std::string & mpsDir,
663                   const std::string & netlibDir);
664#endif
Note: See TracBrowser for help on using the repository browser.