Ignore:
Timestamp:
Jul 27, 2008 9:56:20 PM (12 years ago)
Author:
ladanyi
Message:

Updated stable/1.8 to match trunk

File:
1 edited

Legend:

Unmodified
Added
Removed
  • stable/1.8/Clp/src/ClpSimplex.cpp

    r1212 r1249  
    16731673    handler_->message()<<CoinMessageEol;
    16741674  }
     1675  //#define COMPUTE_INT_INFEAS
     1676#ifdef COMPUTE_INT_INFEAS
     1677  if (userPointer_) {
     1678    if (algorithm_>0&&integerType_&&!nonLinearCost_->numberInfeasibilities()) {
     1679      if (fabs(theta_)>1.0e-6||!numberIterations_) {
     1680        // For saving solutions
     1681        typedef struct {
     1682          int numberSolutions;
     1683          int maximumSolutions;
     1684          int numberColumns;
     1685          double ** solution;
     1686          int * numberUnsatisfied;
     1687        } clpSolution;
     1688        clpSolution * solution = (clpSolution *) userPointer_;
     1689        if (solution->numberSolutions==solution->maximumSolutions) {
     1690          int n =  solution->maximumSolutions;
     1691          int n2 = (n*3)/2+10;
     1692          solution->maximumSolutions=n2;
     1693          double ** temp = new double * [n2];
     1694          for (int i=0;i<n;i++)
     1695            temp[i]=solution->solution[i];
     1696          delete [] solution->solution;
     1697          solution->solution=temp;
     1698          int * tempN = new int [n2];
     1699          for (int i=0;i<n;i++)
     1700            tempN[i] = solution->numberUnsatisfied[i];
     1701          delete [] solution->numberUnsatisfied;
     1702          solution->numberUnsatisfied = tempN;
     1703        }
     1704        assert (numberColumns_==solution->numberColumns);
     1705        double * sol = new double [numberColumns_];
     1706        solution->solution[solution->numberSolutions]=sol;
     1707        int numberFixed=0;
     1708        int numberUnsat=0;
     1709        int numberSat=0;
     1710        double sumUnsat=0.0;
     1711        double tolerance = 10.0*primalTolerance_;
     1712        double mostAway=0.0;
     1713        int iAway=-1;
     1714        for (int i=0;i<numberColumns_;i++) {
     1715          // Save anyway
     1716          sol[i] = columnScale_ ? solution_[i]*columnScale_[i] : solution_[i];
     1717          // rest is optional
     1718          if (upper_[i]>lower_[i]) {
     1719            double value = solution_[i];
     1720            if (value>lower_[i]+tolerance&&
     1721                value<upper_[i]-tolerance&&integerType_[i]) {
     1722              // may have to modify value if scaled
     1723              if (columnScale_)
     1724                value *= columnScale_[i];
     1725              double closest = floor(value+0.5);
     1726              // problem may be perturbed so relax test
     1727              if (fabs(value-closest)>1.0e-4) {
     1728                numberUnsat++;
     1729                sumUnsat += fabs(value-closest);
     1730                if (mostAway<fabs(value-closest)) {
     1731                  mostAway=fabs(value-closest);
     1732                  iAway=i;
     1733                }
     1734              } else {
     1735                numberSat++;
     1736              }
     1737            } else {
     1738              numberSat++;
     1739            }
     1740          } else {
     1741            numberFixed++;
     1742          }
     1743        }
     1744        solution->numberUnsatisfied[solution->numberSolutions++]=numberUnsat;
     1745        printf("iteration %d, %d unsatisfied (%g,%g), %d fixed, %d satisfied\n",
     1746               numberIterations_,numberUnsat,sumUnsat,mostAway,numberFixed,numberSat);
     1747      }
     1748    }
     1749  }
     1750#endif
    16751751  if (hitMaximumIterations())
    16761752    return 2;
     
    53695445    // Allow for catastrophe
    53705446    int saveMax = intParam_[ClpMaxNumIteration];
    5371     if (intParam_[ClpMaxNumIteration]>100000+numberIterations_)
    5372       intParam_[ClpMaxNumIteration] = numberIterations_ + 1000 + 2*numberRows_+numberColumns_;
     5447    if (numberIterations_) {
     5448      // normal
     5449      if (intParam_[ClpMaxNumIteration]>100000+numberIterations_)
     5450        intParam_[ClpMaxNumIteration]
     5451          = numberIterations_ + 1000 + 2*numberRows_+numberColumns_;
     5452    } else {
     5453      // Not normal allow more
     5454      baseIteration_ += 2*(numberRows_+numberColumns_);
     5455    }
    53735456    // check which algorithms allowed
    53745457    int dummy;
Note: See TracChangeset for help on using the changeset viewer.