Cbc  2.9.9
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
ClpNonLinearCost.hpp
Go to the documentation of this file.
1 /* $Id: ClpNonLinearCost.hpp 1769 2011-07-26 09:31:51Z forrest $ */
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 ClpNonLinearCost_H
7 #define ClpNonLinearCost_H
8 
9 
10 #include "CoinPragma.hpp"
11 
12 class ClpSimplex;
13 class CoinIndexedVector;
14 
32 /* status has original status and current status
33  0 - below lower so stored is upper
34  1 - in range
35  2 - above upper so stored is lower
36  4 - (for current) - same as original
37 */
38 #define CLP_BELOW_LOWER 0
39 #define CLP_FEASIBLE 1
40 #define CLP_ABOVE_UPPER 2
41 #define CLP_SAME 4
42 inline int originalStatus(unsigned char status)
43 {
44  return (status & 15);
45 }
46 inline int currentStatus(unsigned char status)
47 {
48  return (status >> 4);
49 }
50 inline void setOriginalStatus(unsigned char & status, int value)
51 {
52  status = static_cast<unsigned char>(status & ~15);
53  status = static_cast<unsigned char>(status | value);
54 }
55 inline void setCurrentStatus(unsigned char &status, int value)
56 {
57  status = static_cast<unsigned char>(status & ~(15 << 4));
58  status = static_cast<unsigned char>(status | (value << 4));
59 }
60 inline void setInitialStatus(unsigned char &status)
61 {
62  status = static_cast<unsigned char>(CLP_FEASIBLE | (CLP_SAME << 4));
63 }
64 inline void setSameStatus(unsigned char &status)
65 {
66  status = static_cast<unsigned char>(status & ~(15 << 4));
67  status = static_cast<unsigned char>(status | (CLP_SAME << 4));
68 }
69 // Use second version to get more speed
70 //#define FAST_CLPNON
71 #ifndef FAST_CLPNON
72 #define CLP_METHOD1 ((method_&1)!=0)
73 #define CLP_METHOD2 ((method_&2)!=0)
74 #else
75 #define CLP_METHOD1 (false)
76 #define CLP_METHOD2 (true)
77 #endif
79 
80 public:
81 
82 public:
83 
92  ClpNonLinearCost(ClpSimplex * model, int method = 1);
98  ClpNonLinearCost(ClpSimplex * model, const int * starts,
99  const double * lower, const double * cost);
102  // Copy
104  // Assignment
107 
108 
115  void checkInfeasibilities(double oldTolerance = 0.0);
119  void checkInfeasibilities(int numberInArray, const int * index);
126  void checkChanged(int numberInArray, CoinIndexedVector * update);
133  void goThru(int numberInArray, double multiplier,
134  const int * index, const double * work,
135  double * rhs);
138  void goBack(int numberInArray, const int * index,
139  double * rhs);
145  void goBackAll(const CoinIndexedVector * update);
147  void zapCosts();
149  void refreshCosts(const double * columnCosts);
151  void feasibleBounds();
153  void refresh();
157  double setOne(int sequence, double solutionValue);
160  void setOne(int sequence, double solutionValue, double lowerValue, double upperValue,
161  double costValue = 0.0);
165  int setOneOutgoing(int sequence, double &solutionValue);
167  double nearest(int sequence, double solutionValue);
171  inline double changeInCost(int sequence, double alpha) const {
172  double returnValue = 0.0;
173  if (CLP_METHOD1) {
174  int iRange = whichRange_[sequence] + offset_[sequence];
175  if (alpha > 0.0)
176  returnValue = cost_[iRange] - cost_[iRange-1];
177  else
178  returnValue = cost_[iRange] - cost_[iRange+1];
179  }
180  if (CLP_METHOD2) {
181  returnValue = (alpha > 0.0) ? infeasibilityWeight_ : -infeasibilityWeight_;
182  }
183  return returnValue;
184  }
185  inline double changeUpInCost(int sequence) const {
186  double returnValue = 0.0;
187  if (CLP_METHOD1) {
188  int iRange = whichRange_[sequence] + offset_[sequence];
189  if (iRange + 1 != start_[sequence+1] && !infeasible(iRange + 1))
190  returnValue = cost_[iRange] - cost_[iRange+1];
191  else
192  returnValue = -1.0e100;
193  }
194  if (CLP_METHOD2) {
195  returnValue = -infeasibilityWeight_;
196  }
197  return returnValue;
198  }
199  inline double changeDownInCost(int sequence) const {
200  double returnValue = 0.0;
201  if (CLP_METHOD1) {
202  int iRange = whichRange_[sequence] + offset_[sequence];
203  if (iRange != start_[sequence] && !infeasible(iRange - 1))
204  returnValue = cost_[iRange] - cost_[iRange-1];
205  else
206  returnValue = 1.0e100;
207  }
208  if (CLP_METHOD2) {
209  returnValue = infeasibilityWeight_;
210  }
211  return returnValue;
212  }
214  inline double changeInCost(int sequence, double alpha, double &rhs) {
215  double returnValue = 0.0;
216 #ifdef NONLIN_DEBUG
217  double saveRhs = rhs;
218 #endif
219  if (CLP_METHOD1) {
220  int iRange = whichRange_[sequence] + offset_[sequence];
221  if (alpha > 0.0) {
222  assert(iRange - 1 >= start_[sequence]);
223  offset_[sequence]--;
224  rhs += lower_[iRange] - lower_[iRange-1];
225  returnValue = alpha * (cost_[iRange] - cost_[iRange-1]);
226  } else {
227  assert(iRange + 1 < start_[sequence+1] - 1);
228  offset_[sequence]++;
229  rhs += lower_[iRange+2] - lower_[iRange+1];
230  returnValue = alpha * (cost_[iRange] - cost_[iRange+1]);
231  }
232  }
233  if (CLP_METHOD2) {
234 #ifdef NONLIN_DEBUG
235  double saveRhs1 = rhs;
236  rhs = saveRhs;
237 #endif
238  unsigned char iStatus = status_[sequence];
239  int iWhere = currentStatus(iStatus);
240  if (iWhere == CLP_SAME)
241  iWhere = originalStatus(iStatus);
242  // rhs always increases
243  if (iWhere == CLP_FEASIBLE) {
244  if (alpha > 0.0) {
245  // going below
246  iWhere = CLP_BELOW_LOWER;
247  rhs = COIN_DBL_MAX;
248  } else {
249  // going above
250  iWhere = CLP_ABOVE_UPPER;
251  rhs = COIN_DBL_MAX;
252  }
253  } else if (iWhere == CLP_BELOW_LOWER) {
254  assert (alpha < 0);
255  // going feasible
256  iWhere = CLP_FEASIBLE;
257  rhs += bound_[sequence] - model_->upperRegion()[sequence];
258  } else {
259  assert (iWhere == CLP_ABOVE_UPPER);
260  // going feasible
261  iWhere = CLP_FEASIBLE;
262  rhs += model_->lowerRegion()[sequence] - bound_[sequence];
263  }
264  setCurrentStatus(status_[sequence], iWhere);
265 #ifdef NONLIN_DEBUG
266  assert(saveRhs1 == rhs);
267 #endif
268  returnValue = fabs(alpha) * infeasibilityWeight_;
269  }
270  return returnValue;
271  }
273  inline double lower(int sequence) const {
274  return lower_[whichRange_[sequence] + offset_[sequence]];
275  }
277  inline double upper(int sequence) const {
278  return lower_[whichRange_[sequence] + offset_[sequence] + 1];
279  }
281  inline double cost(int sequence) const {
282  return cost_[whichRange_[sequence] + offset_[sequence]];
283  }
285 
286 
289  inline int numberInfeasibilities() const {
291  return numberInfeasibilities_;
292  }
294  inline double changeInCost() const {
295  return changeCost_;
296  }
298  inline double feasibleCost() const {
299  return feasibleCost_;
300  }
302  double feasibleReportCost() const;
304  inline double sumInfeasibilities() const {
305  return sumInfeasibilities_;
306  }
308  inline double largestInfeasibility() const {
309  return largestInfeasibility_;
310  }
312  inline double averageTheta() const {
313  return averageTheta_;
314  }
315  inline void setAverageTheta(double value) {
316  averageTheta_ = value;
317  }
318  inline void setChangeInCost(double value) {
319  changeCost_ = value;
320  }
321  inline void setMethod(int value) {
322  method_ = value;
323  }
325  inline bool lookBothWays() const {
326  return bothWays_;
327  }
329  inline bool infeasible(int i) const {
331  return ((infeasible_[i>>5] >> (i & 31)) & 1) != 0;
332  }
333  inline void setInfeasible(int i, bool trueFalse) {
334  unsigned int & value = infeasible_[i>>5];
335  int bit = i & 31;
336  if (trueFalse)
337  value |= (1 << bit);
338  else
339  value &= ~(1 << bit);
340  }
341  inline unsigned char * statusArray() const {
342  return status_;
343  }
345  void validate();
347 
348 private:
351  double changeCost_;
368  int * start_;
370  int * whichRange_;
372  int * offset_;
376  double * lower_;
378  double * cost_;
381  // Array to say which regions are infeasible
382  unsigned int * infeasible_;
385  // new stuff
387  unsigned char * status_;
389  double * bound_;
391  double * cost2_;
393  int method_;
395  bool convex_;
397  bool bothWays_;
399 };
400 
401 #endif
ClpSimplex * model_
Model.
ClpNonLinearCost()
Default constructor.
double * cost2_
Feasible cost array.
void refreshCosts(const double *columnCosts)
Refreshes costs always makes row costs zero.
double sumInfeasibilities_
Sum of infeasibilities.
~ClpNonLinearCost()
Destructor.
void setMethod(int value)
ClpNonLinearCost & operator=(const ClpNonLinearCost &)
unsigned char * status_
Contains status at beginning and current.
double * cost_
Cost for each range.
void refresh()
Refresh - assuming regions OK.
double cost(int sequence) const
Returns current cost.
int setOneOutgoing(int sequence, double &solutionValue)
Sets bounds and cost for outgoing variable may change value Returns direction.
void checkInfeasibilities(double oldTolerance=0.0)
Changes infeasible costs and computes number and cost of infeas Puts all non-basic (non free) variabl...
double changeCost_
Change in cost because of infeasibilities.
int numberColumns_
Number of columns (mainly for checking and copy)
double largestInfeasibility_
Largest infeasibility.
void setCurrentStatus(unsigned char &status, int value)
double largestInfeasibility() const
Largest infeasibility.
double changeInCost(int sequence, double alpha) const
Returns change in cost - one down if alpha &gt;0.0, up if &lt;0.0 Value is current - new.
double changeDownInCost(int sequence) const
double * lower_
Lower bound for each range (upper bound is next lower).
double changeInCost(int sequence, double alpha, double &rhs)
This also updates next bound.
double upper(int sequence) const
Returns current upper bound.
unsigned char * statusArray() const
void goThru(int numberInArray, double multiplier, const int *index, const double *work, double *rhs)
Goes through one bound for each variable.
#define CLP_METHOD1
double changeUpInCost(int sequence) const
void goBackAll(const CoinIndexedVector *update)
Puts back correct infeasible costs for each variable The input indices are row indices and need conve...
double changeInCost() const
Change in cost.
int method_
Method 1 old, 2 new, 3 both!
int * start_
Starts for each entry (columns then rows)
int numberInfeasibilities() const
Number of infeasibilities.
double averageTheta_
Average theta - kept here as only for primal.
This solves LPs using the simplex method.
Definition: ClpSimplex.hpp:70
bool bothWays_
If we should look both ways for djs.
void setChangeInCost(double value)
Indexed Vector.
#define CLP_BELOW_LOWER
Trivial class to deal with non linear costs.
#define CLP_FEASIBLE
double sumInfeasibilities() const
Sum of infeasibilities.
double feasibleReportCost() const
Feasible cost with offset and direction (i.e. for reporting)
void goBack(int numberInArray, const int *index, double *rhs)
Takes off last iteration (i.e.
#define CLP_ABOVE_UPPER
int currentStatus(unsigned char status)
int originalStatus(unsigned char status)
void validate()
For debug.
int * whichRange_
Range for each entry (columns then rows)
void zapCosts()
Temporary zeroing of feasible costs.
double infeasibilityWeight_
Current infeasibility weight.
void setSameStatus(unsigned char &status)
void feasibleBounds()
Puts feasible bounds into lower and upper.
void setAverageTheta(double value)
bool infeasible(int i) const
void setOriginalStatus(unsigned char &status, int value)
double * lowerRegion(int section) const
double lower(int sequence) const
Returns current lower bound.
double nearest(int sequence, double solutionValue)
Returns nearest bound.
void setInfeasible(int i, bool trueFalse)
#define CLP_METHOD2
bool lookBothWays() const
See if may want to look both ways.
double * upperRegion(int section) const
int numberInfeasibilities_
Number of infeasibilities found.
void setInitialStatus(unsigned char &status)
const double COIN_DBL_MAX
Definition: CoinFinite.hpp:18
double feasibleCost() const
Feasible cost.
#define CLP_SAME
double * bound_
Bound which has been replaced in lower_ or upper_.
int numberRows_
Number of rows (mainly for checking and copy)
double feasibleCost_
Feasible cost.
double averageTheta() const
Average theta.
int * offset_
Temporary range offset for each entry (columns then rows)
void checkChanged(int numberInArray, CoinIndexedVector *update)
Puts back correct infeasible costs for each variable The input indices are row indices and need conve...
unsigned int * infeasible_
bool convex_
If all non-linear costs convex.
double setOne(int sequence, double solutionValue)
Sets bounds and cost for one variable Returns change in cost May need to be inline for speed...