gcc/testsuite/g++.dg/torture/pr36826.C

   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 };
  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 }