Clp 1.17.5
Loading...
Searching...
No Matches
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//#############################################################################
13class CoinIndexedVector;
14
22
23public:
25
26
34 virtual int pivotColumn(CoinIndexedVector *updates,
35 CoinIndexedVector *spareRow1,
36 CoinIndexedVector *spareRow2,
37 CoinIndexedVector *spareColumn1,
38 CoinIndexedVector *spareColumn2);
40 int pivotColumnOldMethod(CoinIndexedVector *updates,
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);
87 int transposeTimes2(const CoinIndexedVector *pi1, CoinIndexedVector *dj1,
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
101
110 virtual void saveWeights(ClpSimplex *model, int mode);
114 virtual void unrollWeights();
116 virtual void clearArrays();
118 virtual bool looksOptimal() const;
120 virtual void maximumPivotsChanged();
122
126 inline int mode() const
127 {
128 return mode_;
129 }
131 inline void setMode(int mode)
132 {
133 mode_ = mode;
134 }
136 inline CoinIndexedVector *infeasible() const
137 {
138 return infeasible_;
139 }
141 inline const double *weights() const
142 {
143 return weights_;
144 }
146 inline CoinIndexedVector *alternateWeights() const
147 {
148 return alternateWeights_;
149 }
153 virtual int numberSprintColumns(int &numberIterations) const;
155 virtual void switchOffSprint();
156
158
162 normal = 0x00, // create (if necessary) and destroy
163 keep = 0x01 // create (if necessary) and leave
164 };
165
167
168
177
180
183
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 }
215 {
216 return persistence_;
217 }
218
220 //---------------------------------------------------------------------------
221
222protected:
224 // Update weight
225 double devex_;
227 double *weights_;
229 CoinIndexedVector *infeasible_;
231 CoinIndexedVector *alternateWeights_;
234 // Array for exact devex to say what is in reference framework
235 unsigned int *reference_;
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*/
Primal Column Pivot Abstract Base Class.
ClpSimplex * model()
Returns model.
Primal Column Pivot Steepest Edge Algorithm Class.
int pivotColumnOldMethod(CoinIndexedVector *updates, CoinIndexedVector *spareRow1, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
For quadratic or funny nonlinearities.
CoinIndexedVector * alternateWeights_
alternate weight array (so we can unroll)
virtual void updateWeights(CoinIndexedVector *input)
Updates weights - part 1 - also checks accuracy.
virtual ClpPrimalColumnPivot * clone(bool copyData=true) const
Clone.
bool reference(int i) const
reference would be faster using ClpSimplex's status_, but I prefer to keep modularity.
ClpPrimalColumnSteepest & operator=(const ClpPrimalColumnSteepest &rhs)
Assignment operator.
void justDevex(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update weights for Devex.
virtual bool looksOptimal() const
Returns true if would not find any column.
virtual ~ClpPrimalColumnSteepest()
Destructor.
virtual void clearArrays()
Gets rid of all arrays.
void djsAndSteepest(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update djs, weights for Steepest using djs sets best sequence (possibly)
int numberSwitched_
Number of times switched from partial dantzig to 0/2.
int mode_
0 is exact devex, 1 full steepest, 2 is partial exact devex 3 switches between 0 and 2 depending on f...
void justDjs(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Just update djs.
virtual int numberSprintColumns(int &numberIterations) const
Returns number of extra columns for sprint algorithm - 0 means off.
CoinIndexedVector * infeasible() const
square of infeasibility array (just for infeasible columns)
CoinIndexedVector * alternateWeights() const
alternate weight array
void justSteepest(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update weights for Steepest.
int transposeTimes2(const CoinIndexedVector *pi1, CoinIndexedVector *dj1, const CoinIndexedVector *pi2, CoinIndexedVector *dj2, CoinIndexedVector *spare, double scaleFactor)
Updates two arrays for steepest.
virtual void switchOffSprint()
Switch off sprint idea.
virtual void saveWeights(ClpSimplex *model, int mode)
Save weights - this may initialize weights as well mode is - 1) before factorization 2) after factori...
void djsAndDevex2(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update djs, weights for Devex using pivot row.
void setPersistence(Persistence life)
Set/ get persistence.
void setMode(int mode)
Set mode.
virtual void maximumPivotsChanged()
Called when maximum pivots changes.
ClpPrimalColumnSteepest(int mode=3)
Default Constructor 0 is exact devex, 1 full steepest, 2 is partial exact devex 3 switches between 0 ...
double * savedWeights_
save weight array (so we can use checkpoint)
void djsAndSteepest2(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update djs, weights for Steepest using pivot row.
void setReference(int i, bool trueFalse)
int state_
Status 0) Normal -1) Needs initialization 1) Weights are stored by sequence number.
Persistence persistence_
Life of weights.
const double * weights() const
Weights.
CoinIndexedVector * infeasible_
square of infeasibility array (just for infeasible columns)
void initializeWeights()
Initialize weights.
int partialPricing(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, int numberWanted, int numberLook)
Update djs doing partial pricing (dantzig)
void redoInfeasibilities()
redo infeasibilities
void checkAccuracy(int sequence, double relativeTolerance, CoinIndexedVector *rowArray1, CoinIndexedVector *rowArray2)
Checks accuracy - just for debug.
virtual void unrollWeights()
Gets rid of last update.
ClpPrimalColumnSteepest(const ClpPrimalColumnSteepest &rhs)
Copy constructor.
virtual int pivotColumn(CoinIndexedVector *updates, CoinIndexedVector *spareRow1, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Returns pivot column, -1 if none.
void djsAndDevex(CoinIndexedVector *updates, CoinIndexedVector *spareRow2, CoinIndexedVector *spareColumn1, CoinIndexedVector *spareColumn2)
Update djs, weights for Devex using djs.
This solves LPs using the simplex method.