Mercurial > hg > CbC > CbC_gcc

view gcc/testsuite/g++.dg/torture/pr36826.C @ 131:84e7813d76e9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc-8.2
author mir3636
date Thu, 25 Oct 2018 07:37:49 +0900
parents 04ced10e8804
children
line wrap: on
line source

#if __cplusplus > 201402L
template <class T> T CoinMax(const T x1, const T x2); 
template <class T> T CoinMin(const T x1, const T x2);
#else
template <class T> T CoinMax(register const T x1, register const T x2); 
template <class T> T CoinMin(register const T x1, register const T x2);
#endif
class CoinIndexedVector;
class ClpModel {
protected:
    double objectiveScale_;
    double rhsScale_;
    int numberRows_;
    int numberColumns_;
    double * rowActivity_;
    double * columnActivity_;
    double * dual_;
    double * reducedCost_;
    double* rowLower_;
    double* rowUpper_;
    double * rowObjective_;
    double * columnLower_;
    double * columnUpper_;
    double * rowScale_;
    double * columnScale_;
    double * inverseRowScale_;
    double * inverseColumnScale_;
    int problemStatus_;
    int secondaryStatus_;
};
class ClpSimplex : public ClpModel {
    void deleteRim(int getRidOfFactorizationData=2);
    double upperOut_;
    double dualTolerance_;
    double primalTolerance_;
    double * rowLowerWork_;
    double * columnLowerWork_;
    double * rowUpperWork_;
    double * columnUpperWork_;
    double * rowObjectiveWork_;
    CoinIndexedVector * columnArray_[6];
    double * reducedCostWork_;
    double * rowActivityWork_;
    double * columnActivityWork_;
    ClpSimplex * auxiliaryModel_;
};
class CoinIndexedVector {
public:
    void clear();
};
void ClpSimplex::deleteRim(int getRidOfFactorizationData)
{
  int numberRows=numberRows_;
  int numberColumns=numberColumns_;
  int i;
  int numberPrimalScaled=0;
  int numberPrimalUnscaled=0;
  int numberDualScaled=0;
  int numberDualUnscaled=0;
  double scaleC = 1.0/objectiveScale_;
  double scaleR = 1.0/rhsScale_;
  if (!inverseColumnScale_) {
      for (i=0; i<numberColumns; i++)
	{
	  double scaleFactor = columnScale_[i];
	  double valueScaled = columnActivityWork_[i];
	  double lowerScaled = columnLowerWork_[i];
	  double upperScaled = columnUpperWork_[i];
	  if (lowerScaled>-1.0e20||upperScaled<1.0e20) {
	      if (valueScaled<lowerScaled-primalTolerance_||   valueScaled>upperScaled+primalTolerance_)
		numberPrimalScaled++;
	      else
		upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled));
	  }
	  columnActivity_[i] = valueScaled*scaleFactor*scaleR;
	  double value = columnActivity_[i];
	  if (value<columnLower_[i]-primalTolerance_)
	    numberPrimalUnscaled++;
	  else if (value>columnUpper_[i]+primalTolerance_)
	    numberPrimalUnscaled++;
	  double valueScaledDual = reducedCostWork_[i];
	  if (valueScaled>columnLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_)
	    numberDualScaled++;
	  if (valueScaled<columnUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_)
	    numberDualScaled++;
	  reducedCost_[i] = (valueScaledDual*scaleC)/scaleFactor;
	  double valueDual = reducedCost_[i];
	  if (value>columnLower_[i]+primalTolerance_&&valueDual>dualTolerance_)
	    numberDualUnscaled++;
	  if (value<columnUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_)
	    numberDualUnscaled++;
	}
      for (i=0; i<numberRows; i++)
	{
	  double scaleFactor = rowScale_[i];
	  double valueScaled = rowActivityWork_[i];
	  double lowerScaled = rowLowerWork_[i];
	  double upperScaled = rowUpperWork_[i];
	  if (lowerScaled>-1.0e20||upperScaled<1.0e20) {      if (valueScaled<lowerScaled-primalTolerance_||   valueScaled>upperScaled+primalTolerance_)        numberPrimalScaled++;      else        upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled));    }
	  rowActivity_[i] = (valueScaled*scaleR)/scaleFactor;
	  double value = rowActivity_[i];
	  if (value<rowLower_[i]-primalTolerance_)      numberPrimalUnscaled++;
	  else if (value>rowUpper_[i]+primalTolerance_)      numberPrimalUnscaled++;
	  double valueScaledDual = dual_[i]+rowObjectiveWork_[i];
	  ;
	  if (valueScaled>rowLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_)      numberDualScaled++;
	  if (valueScaled<rowUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_)      numberDualScaled++;
	  dual_[i] *= scaleFactor*scaleC;
	  double valueDual = dual_[i];
	  if (rowObjective_)      valueDual += rowObjective_[i];
	  if (value>rowLower_[i]+primalTolerance_&&valueDual>dualTolerance_)      numberDualUnscaled++;
	  if (value<rowUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_)      numberDualUnscaled++;
	}
  }
  const double * inverseScale = inverseColumnScale_;
  for (i=0; i<numberColumns; i++)
    {
      double scaleFactor = columnScale_[i];
      double valueScaled = columnActivityWork_[i];
      double lowerScaled = columnLowerWork_[i];
      double upperScaled = columnUpperWork_[i];
      if (lowerScaled>-1.0e20||upperScaled<1.0e20) {      if (valueScaled<lowerScaled-primalTolerance_||   valueScaled>upperScaled+primalTolerance_)        numberPrimalScaled++;      else        upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled));    }
      columnActivity_[i] = valueScaled*scaleFactor*scaleR;
      double value = columnActivity_[i];
      if (value<columnLower_[i]-primalTolerance_)      numberPrimalUnscaled++;
      else if (value>columnUpper_[i]+primalTolerance_)      numberPrimalUnscaled++;
      double valueScaledDual = reducedCostWork_[i];
      if (valueScaled>columnLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_)      numberDualScaled++;
      if (valueScaled<columnUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_)      numberDualScaled++;
      reducedCost_[i] = (valueScaledDual*scaleC)*inverseScale[i];
      double valueDual = reducedCost_[i];
      if (value>columnLower_[i]+primalTolerance_&&valueDual>dualTolerance_)      numberDualUnscaled++;
      if (value<columnUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_)      numberDualUnscaled++;
    }
  inverseScale = inverseRowScale_;
  for (i=0; i<numberRows; i++)
    {
      double scaleFactor = rowScale_[i];
      double valueScaled = rowActivityWork_[i];
      double lowerScaled = rowLowerWork_[i];
      double upperScaled = rowUpperWork_[i];
      if (lowerScaled>-1.0e20||upperScaled<1.0e20) {      if (valueScaled<lowerScaled-primalTolerance_||   valueScaled>upperScaled+primalTolerance_)        numberPrimalScaled++;      else        upperOut_ = CoinMax(upperOut_,CoinMin(valueScaled-lowerScaled,upperScaled-valueScaled));    }
      rowActivity_[i] = (valueScaled*scaleR)*inverseScale[i];
      double value = rowActivity_[i];
      if (value<rowLower_[i]-primalTolerance_)      numberPrimalUnscaled++;
      else if (value>rowUpper_[i]+primalTolerance_)      numberPrimalUnscaled++;
      double valueScaledDual = dual_[i]+rowObjectiveWork_[i];
      ;
      if (valueScaled>rowLowerWork_[i]+primalTolerance_&&valueScaledDual>dualTolerance_)      numberDualScaled++;
      if (valueScaled<rowUpperWork_[i]-primalTolerance_&&valueScaledDual<-dualTolerance_)      numberDualScaled++;
      dual_[i] *= scaleFactor*scaleC;
      double valueDual = dual_[i];
      if (rowObjective_)      valueDual += rowObjective_[i];
      if (value>rowLower_[i]+primalTolerance_&&valueDual>dualTolerance_)      numberDualUnscaled++;
      if (value<rowUpper_[i]-primalTolerance_&&valueDual<-dualTolerance_)      numberDualUnscaled++;
    }
  if (numberPrimalUnscaled) {
      if (numberDualUnscaled) 
	secondaryStatus_=4;
      else
	secondaryStatus_=2;
  }
  if (numberDualUnscaled)
    secondaryStatus_=3;
  int iRow,iColumn;
  for (iRow=0; iRow<4; iRow++)
    ;
  for (iColumn=0; iColumn<2; iColumn++)
    if (columnArray_[iColumn])
      columnArray_[iColumn]->clear();
}