1 #if __cplusplus > 201402L
2 template <class T> T CoinMax(const T x1, const T x2);
3 template <class T> T CoinMin(const T x1, const T x2);
4 #else
5 template <class T> T CoinMax(register const T x1, register const T x2);
6 template <class T> T CoinMin(register const T x1, register const T x2);
7 #endif
8 class CoinIndexedVector;
9 class ClpModel {
10 protected:
11 double objectiveScale_;
12 double rhsScale_;
13 int numberRows_;
14 int numberColumns_;
15 double * rowActivity_;
16 double * columnActivity_;
17 double * dual_;
18 double * reducedCost_;
19 double* rowLower_;
20 double* rowUpper_;
21 double * rowObjective_;
22 double * columnLower_;
23 double * columnUpper_;
24 double * rowScale_;
25 double * columnScale_;
26 double * inverseRowScale_;
27 double * inverseColumnScale_;
28 int problemStatus_;
29 int secondaryStatus_;
30 };
31 class ClpSimplex : public ClpModel {
32 void deleteRim(int getRidOfFactorizationData=2);
33 double upperOut_;
34 double dualTolerance_;
35 double primalTolerance_;
36 double * rowLowerWork_;
37 double * columnLowerWork_;
38 double * rowUpperWork_;
39 double * columnUpperWork_;
40 double * rowObjectiveWork_;
41 CoinIndexedVector * columnArray_[6];
42 double * reducedCostWork_;
43 double * rowActivityWork_;
44 double * columnActivityWork_;
45 ClpSimplex * auxiliaryModel_;
46 };
47 class CoinIndexedVector {
48 public:
49 void clear();
50 };
deleteRim(int getRidOfFactorizationData)51 void ClpSimplex::deleteRim(int getRidOfFactorizationData)
52 {
53 int numberRows=numberRows_;
54 int numberColumns=numberColumns_;
55 int i;
56 int numberPrimalScaled=0;
57 int numberPrimalUnscaled=0;
58 int numberDualScaled=0;
59 int numberDualUnscaled=0;
60 double scaleC = 1.0/objectiveScale_;
61 double scaleR = 1.0/rhsScale_;
62 if (!inverseColumnScale_) {
63 for (i=0; i<numberColumns; i++)
64 {
65 double scaleFactor = columnScale_[i];
66 double valueScaled = columnActivityWork_[i];
67 double lowerScaled = columnLowerWork_[i];
68 double upperScaled = columnUpperWork_[i];
69 if (lowerScaled>-1.0e20||upperScaled<1.0e20) {
70 if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_)
71 numberPrimalScaled++;
72 else
73 upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled));
74 }
75 columnActivity_[i] = valueScaled*scaleFactor*scaleR;
76 double value = columnActivity_[i];
77 if (value<columnLower_[i]-primalTolerance_)
78 numberPrimalUnscaled++;
79 else if (value>columnUpper_[i]+primalTolerance_)
80 numberPrimalUnscaled++;
81 double valueScaledDual = reducedCostWork_[i];
82 if (valueScaled>columnLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_)
83 numberDualScaled++;
84 if (valueScaled<columnUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_)
85 numberDualScaled++;
86 reducedCost_[i] = (valueScaledDual*scaleC)/scaleFactor;
87 double valueDual = reducedCost_[i];
88 if (value>columnLower_[i]+primalTolerance_&&valueDual>dualTolerance_)
89 numberDualUnscaled++;
90 if (value<columnUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_)
91 numberDualUnscaled++;
92 }
93 for (i=0; i<numberRows; i++)
94 {
95 double scaleFactor = rowScale_[i];
96 double valueScaled = rowActivityWork_[i];
97 double lowerScaled = rowLowerWork_[i];
98 double upperScaled = rowUpperWork_[i];
99 if (lowerScaled>-1.0e20||upperScaled<1.0e20) { if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_) numberPrimalScaled++; else upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled)); }
100 rowActivity_[i] = (valueScaled*scaleR)/scaleFactor;
101 double value = rowActivity_[i];
102 if (value<rowLower_[i]-primalTolerance_) numberPrimalUnscaled++;
103 else if (value>rowUpper_[i]+primalTolerance_) numberPrimalUnscaled++;
104 double valueScaledDual = dual_[i]+rowObjectiveWork_[i];
105 ;
106 if (valueScaled>rowLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_) numberDualScaled++;
107 if (valueScaled<rowUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_) numberDualScaled++;
108 dual_[i] *= scaleFactor*scaleC;
109 double valueDual = dual_[i];
110 if (rowObjective_) valueDual += rowObjective_[i];
111 if (value>rowLower_[i]+primalTolerance_&&valueDual>dualTolerance_) numberDualUnscaled++;
112 if (value<rowUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_) numberDualUnscaled++;
113 }
114 }
115 const double * inverseScale = inverseColumnScale_;
116 for (i=0; i<numberColumns; i++)
117 {
118 double scaleFactor = columnScale_[i];
119 double valueScaled = columnActivityWork_[i];
120 double lowerScaled = columnLowerWork_[i];
121 double upperScaled = columnUpperWork_[i];
122 if (lowerScaled>-1.0e20||upperScaled<1.0e20) { if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_) numberPrimalScaled++; else upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled)); }
123 columnActivity_[i] = valueScaled*scaleFactor*scaleR;
124 double value = columnActivity_[i];
125 if (value<columnLower_[i]-primalTolerance_) numberPrimalUnscaled++;
126 else if (value>columnUpper_[i]+primalTolerance_) numberPrimalUnscaled++;
127 double valueScaledDual = reducedCostWork_[i];
128 if (valueScaled>columnLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_) numberDualScaled++;
129 if (valueScaled<columnUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_) numberDualScaled++;
130 reducedCost_[i] = (valueScaledDual*scaleC)*inverseScale[i];
131 double valueDual = reducedCost_[i];
132 if (value>columnLower_[i]+primalTolerance_&&valueDual>dualTolerance_) numberDualUnscaled++;
133 if (value<columnUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_) numberDualUnscaled++;
134 }
135 inverseScale = inverseRowScale_;
136 for (i=0; i<numberRows; i++)
137 {
138 double scaleFactor = rowScale_[i];
139 double valueScaled = rowActivityWork_[i];
140 double lowerScaled = rowLowerWork_[i];
141 double upperScaled = rowUpperWork_[i];
142 if (lowerScaled>-1.0e20||upperScaled<1.0e20) { if (valueScaled<lowerScaled-primalTolerance_|| valueScaled>upperScaled+primalTolerance_) numberPrimalScaled++; else upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled)); }
143 rowActivity_[i] = (valueScaled*scaleR)*inverseScale[i];
144 double value = rowActivity_[i];
145 if (value<rowLower_[i]-primalTolerance_) numberPrimalUnscaled++;
146 else if (value>rowUpper_[i]+primalTolerance_) numberPrimalUnscaled++;
147 double valueScaledDual = dual_[i]+rowObjectiveWork_[i];
148 ;
149 if (valueScaled>rowLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_) numberDualScaled++;
150 if (valueScaled<rowUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_) numberDualScaled++;
151 dual_[i] *= scaleFactor*scaleC;
152 double valueDual = dual_[i];
153 if (rowObjective_) valueDual += rowObjective_[i];
154 if (value>rowLower_[i]+primalTolerance_&&valueDual>dualTolerance_) numberDualUnscaled++;
155 if (value<rowUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_) numberDualUnscaled++;
156 }
157 if (numberPrimalUnscaled) {
158 if (numberDualUnscaled)
159 secondaryStatus_=4;
160 else
161 secondaryStatus_=2;
162 }
163 if (numberDualUnscaled)
164 secondaryStatus_=3;
165 int iRow,iColumn;
166 for (iRow=0; iRow<4; iRow++)
167 ;
168 for (iColumn=0; iColumn<2; iColumn++)
169 if (columnArray_[iColumn])
170 columnArray_[iColumn]->clear();
171 }
172