Cbc  2.10.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ClpPrimalColumnSteepest.hpp
Go to the documentation of this file.
1 /* $Id: ClpPrimalColumnSteepest.hpp 2385 2019-01-06 19:43:06Z unxusr $ */
2 // Copyright (C) 2002, International Business Machines
3 // Corporation and others. All Rights Reserved.
4 // This code is licensed under the terms of the Eclipse Public License (EPL).
5 
6 #ifndef ClpPrimalColumnSteepest_H
7 #define ClpPrimalColumnSteepest_H
8 
10 #include <bitset>
11 
12 //#############################################################################
13 class CoinIndexedVector;
14 
22 
23 public:
25 
26 
34  virtual int pivotColumn(CoinIndexedVector *updates,
35  CoinIndexedVector *spareRow1,
36  CoinIndexedVector *spareRow2,
37  CoinIndexedVector *spareColumn1,
38  CoinIndexedVector *spareColumn2);
41  CoinIndexedVector *spareRow1,
42  CoinIndexedVector *spareRow2,
43  CoinIndexedVector *spareColumn1,
44  CoinIndexedVector *spareColumn2);
46  void justDjs(CoinIndexedVector *updates,
47  CoinIndexedVector *spareRow2,
48  CoinIndexedVector *spareColumn1,
49  CoinIndexedVector *spareColumn2);
51  int partialPricing(CoinIndexedVector *updates,
52  CoinIndexedVector *spareRow2,
53  int numberWanted,
54  int numberLook);
56  void djsAndDevex(CoinIndexedVector *updates,
57  CoinIndexedVector *spareRow2,
58  CoinIndexedVector *spareColumn1,
59  CoinIndexedVector *spareColumn2);
62  void djsAndSteepest(CoinIndexedVector *updates,
63  CoinIndexedVector *spareRow2,
64  CoinIndexedVector *spareColumn1,
65  CoinIndexedVector *spareColumn2);
67  void djsAndDevex2(CoinIndexedVector *updates,
68  CoinIndexedVector *spareRow2,
69  CoinIndexedVector *spareColumn1,
70  CoinIndexedVector *spareColumn2);
72  void djsAndSteepest2(CoinIndexedVector *updates,
73  CoinIndexedVector *spareRow2,
74  CoinIndexedVector *spareColumn1,
75  CoinIndexedVector *spareColumn2);
77  void justDevex(CoinIndexedVector *updates,
78  CoinIndexedVector *spareRow2,
79  CoinIndexedVector *spareColumn1,
80  CoinIndexedVector *spareColumn2);
82  void justSteepest(CoinIndexedVector *updates,
83  CoinIndexedVector *spareRow2,
84  CoinIndexedVector *spareColumn1,
85  CoinIndexedVector *spareColumn2);
88  const CoinIndexedVector *pi2, CoinIndexedVector *dj2,
89  CoinIndexedVector *spare, double scaleFactor);
90 
92  virtual void updateWeights(CoinIndexedVector *input);
93 
95  void checkAccuracy(int sequence, double relativeTolerance,
96  CoinIndexedVector *rowArray1,
97  CoinIndexedVector *rowArray2);
98 
100  void initializeWeights();
101 
110  virtual void saveWeights(ClpSimplex *model, int mode);
112  void redoInfeasibilities();
114  virtual void unrollWeights();
116  virtual void clearArrays();
118  virtual bool looksOptimal() const;
120  virtual void maximumPivotsChanged();
122 
125  inline int mode() const
127  {
128  return mode_;
129  }
131  inline void setMode(int mode)
132  {
133  mode_ = mode;
134  }
137  {
138  return infeasible_;
139  }
141  inline const double *weights() const
142  {
143  return weights_;
144  }
147  {
148  return alternateWeights_;
149  }
153  virtual int numberSprintColumns(int &numberIterations) const;
155  virtual void switchOffSprint();
156 
158 
161  enum Persistence {
162  normal = 0x00, // create (if necessary) and destroy
163  keep = 0x01 // create (if necessary) and leave
164  };
165 
167 
168 
176  ClpPrimalColumnSteepest(int mode = 3);
177 
180 
183 
185  virtual ~ClpPrimalColumnSteepest();
186 
188  virtual ClpPrimalColumnPivot *clone(bool copyData = true) const;
189 
191 
193 
196  inline bool reference(int i) const
197  {
198  return ((reference_[i >> 5] >> (i & 31)) & 1) != 0;
199  }
200  inline void setReference(int i, bool trueFalse)
201  {
202  unsigned int &value = reference_[i >> 5];
203  int bit = i & 31;
204  if (trueFalse)
205  value |= (1 << bit);
206  else
207  value &= ~(1 << bit);
208  }
210  inline void setPersistence(Persistence life)
211  {
212  persistence_ = life;
213  }
214  inline Persistence persistence() const
215  {
216  return persistence_;
217  }
218 
220  //---------------------------------------------------------------------------
221 
222 protected:
224  // Update weight
225  double devex_;
227  double *weights_;
233  double *savedWeights_;
234  // Array for exact devex to say what is in reference framework
235  unsigned int *reference_;
241  int state_;
254  int mode_;
255  /* Infeasibility state i.e. array of infeasibilities and sequenceIn-
256  0 - correct
257  1 - needs correcting
258  2 - not known but column sequence has been chosen
259  */
265  // This is pivot row (or pivot sequence round re-factorization)
267  // This is saved pivot sequence
269  // This is saved outgoing variable
271  // Iteration when last rectified
273  // Size of factorization at invert (used to decide algorithm)
276 };
277 
278 #endif
279 
280 /* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
281 */
virtual bool looksOptimal() const
Returns true if would not find any column.
void djsAndDevex(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update djs, weights for Devex using djs.
int transposeTimes2(const CoinIndexedVector *pi1, CoinIndexedVector *dj1, const CoinIndexedVector *pi2, CoinIndexedVector *dj2, CoinIndexedVector *spare, double scaleFactor)
Updates two arrays for steepest.
virtual void saveWeights(ClpSimplex *model, int mode)
Save weights - this may initialize weights as well mode is - 1) before factorization 2) after factori...
int mode_
0 is exact devex, 1 full steepest, 2 is partial exact devex 3 switches between 0 and 2 depending on f...
Primal Column Pivot Abstract Base Class.
int partialPricing(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, int numberWanted, int numberLook)
Update djs doing partial pricing (dantzig)
void justSteepest(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update weights for Steepest.
double * savedWeights_
save weight array (so we can use checkpoint)
void djsAndDevex2(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update djs, weights for Devex using pivot row.
Primal Column Pivot Steepest Edge Algorithm Class.
void initializeWeights()
Initialize weights.
CoinIndexedVector * infeasible_
square of infeasibility array (just for infeasible columns)
void setPersistence(Persistence life)
Set/ get persistence.
void redoInfeasibilities()
redo infeasibilities
virtual ClpPrimalColumnPivot * clone(bool copyData=true) const
Clone.
void checkAccuracy(int sequence, double relativeTolerance, CoinIndexedVector *rowArray1, CoinIndexedVector *rowArray2)
Checks accuracy - just for debug.
bool reference(int i) const
reference would be faster using ClpSimplex&#39;s status_, but I prefer to keep modularity.
void justDjs(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Just update djs.
int pivotColumnOldMethod(CoinIndexedVector *updates, CoinIndexedVector *spareRow1, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
For quadratic or funny nonlinearities.
virtual int numberSprintColumns(int &numberIterations) const
Returns number of extra columns for sprint algorithm - 0 means off.
virtual void switchOffSprint()
Switch off sprint idea.
This solves LPs using the simplex method.
Definition: ClpSimplex.hpp:106
Indexed Vector.
void djsAndSteepest2(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update djs, weights for Steepest using pivot row.
ClpPrimalColumnSteepest & operator=(const ClpPrimalColumnSteepest &rhs)
Assignment operator.
CoinIndexedVector * alternateWeights() const
alternate weight array
void justDevex(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update weights for Devex.
virtual void clearArrays()
Gets rid of all arrays.
ClpSimplex * model()
Returns model.
virtual void unrollWeights()
Gets rid of last update.
virtual void updateWeights(CoinIndexedVector *input)
Updates weights - part 1 - also checks accuracy.
Persistence persistence_
Life of weights.
void setReference(int i, bool trueFalse)
const double * weights() const
Weights.
CoinIndexedVector * alternateWeights_
alternate weight array (so we can unroll)
CoinIndexedVector * infeasible() const
square of infeasibility array (just for infeasible columns)
Persistence
enums for persistence
virtual void maximumPivotsChanged()
Called when maximum pivots changes.
int state_
Status 0) Normal -1) Needs initialization 1) Weights are stored by sequence number.
void djsAndSteepest(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update djs, weights for Steepest using djs sets best sequence (possibly)
ClpPrimalColumnSteepest(int mode=3)
Default Constructor 0 is exact devex, 1 full steepest, 2 is partial exact devex 3 switches between 0 ...
void setMode(int mode)
Set mode.
virtual ~ClpPrimalColumnSteepest()
Destructor.
int numberSwitched_
Number of times switched from partial dantzig to 0/2.
virtual int pivotColumn(CoinIndexedVector *updates, CoinIndexedVector *spareRow1, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Returns pivot column, -1 if none.