Changeset 104


Ignore:
Timestamp:
Jan 24, 2003 3:33:41 PM (17 years ago)
Author:
forrest
Message:

Changes for free variables and unbounded

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpSimplex.cpp

    r102 r104  
    671671        // all slack basis
    672672        int numberBasic=0;
    673         // changed to put free variables in basis
    674673        if (!status_) {
    675674          createStatus();
     
    680679          if (lower>-largeValue_||upper<largeValue_) {
    681680            if (fabs(lower)<=fabs(upper)) {
    682               setRowStatus(iRow,atLowerBound);
    683681              rowActivityWork_[iRow]=lower;
    684682            } else {
    685               setRowStatus(iRow,atUpperBound);
    686683              rowActivityWork_[iRow]=upper;
    687684            }
    688685          } else {
    689             setRowStatus(iRow,isFree);
    690686            rowActivityWork_[iRow]=0.0;
    691687          }
     
    708704            setColumnStatus(iColumn,isFree);
    709705            columnActivityWork_[iColumn]=0.0;
    710           }
    711         }
    712         assert(numberBasic<=numberRows_); // problems if too many free
    713         if (!numberBasic) {
    714           // might as well do all slack basis
    715           for (iRow=0;iRow<numberRows_;iRow++) {
    716             setRowStatus(iRow,basic);
    717706          }
    718707        }
     
    997986    }
    998987  }
     988  if (upper_[sequenceIn_]>1.0e20&&lower_[sequenceIn_]<-1.0e20)
     989    progressFlag_ |= 2; // making real progress
    999990  if (algorithm_<0)
    1000991    objectiveChange += cost*(value-valueIn_);
     
    15501541    if (getColumnStatus(iColumn) != basic) {
    15511542      // not basic
    1552       double value = reducedCostWork_[iColumn];
    15531543      double distanceUp = columnUpperWork_[iColumn]-
    15541544        columnActivityWork_[iColumn];
     
    15561546        columnLowerWork_[iColumn];
    15571547      if (distanceUp>primalTolerance_) {
     1548        double value = reducedCostWork_[iColumn];
    15581549        // Check if "free"
    15591550        if (firstFree_<0&&distanceDown>primalTolerance_) {
     
    16031594      }
    16041595      if (distanceDown>primalTolerance_) {
     1596        double value = reducedCostWork_[iColumn];
    16051597        // should not be positive
    16061598        if (value>0.0) {
     
    16281620    if (getRowStatus(iRow) != basic) {
    16291621      // not basic
    1630       double value = rowReducedCost_[iRow];
    16311622      double distanceUp = rowUpperWork_[iRow]-rowActivityWork_[iRow];
    16321623      double distanceDown = rowActivityWork_[iRow] -rowLowerWork_[iRow];
    16331624      if (distanceUp>primalTolerance_) {
     1625        double value = rowReducedCost_[iRow];
    16341626        // Check if "free"
    16351627        if (firstFree_<0&&distanceDown>primalTolerance_) {
     
    16691661      }
    16701662      if (distanceDown>primalTolerance_) {
     1663        double value = rowReducedCost_[iRow];
    16711664        // should not be positive
    16721665        if (value>0.0) {
  • trunk/ClpSimplexDual.cpp

    r98 r104  
    668668      if (!factorization_->pivots()) {
    669669        // may have crept through - so may be optimal
    670         //problemStatus_=-5; //say looks unbounded
    671         problemStatus_=0;
    672670        // check any flagged variables
    673671        int iRow;
     
    681679          std::cerr<<"Flagged variables at end - infeasible?"<<std::endl;
    682680#endif
    683           problemStatus_=-4; //say looks infeasible
    684           // create ray anyway
    685           delete [] ray_;
    686           ray_ = new double [ numberRows_];
    687           ClpDisjointCopyN(rowArray_[0]->denseVector(),numberRows_,ray_);
    688         }
     681        }
     682        if (numberFake_||numberDualInfeasibilities_) {
     683          // may be dual infeasible
     684          problemStatus_=-5;
     685        } else {
     686          problemStatus_=0;
     687        }
     688      } else {
     689        problemStatus_=-3;
    689690      }
    690691      returnCode=0;
     
    882883{
    883884  // get pivot row using whichever method it is
    884 #if 0
     885#if 1
    885886  // Doesnt seem to help - think harder about free variables
    886887  // first see if any free variables and put them in basis
     
    12481249      case superBasic:
    12491250        if (oldValue>dualTolerance_) {
    1250           if (value<-newTolerance)
    1251             keep = 2;
     1251          keep = 2;
    12521252        } else if (oldValue<-dualTolerance_) {
    1253           if (value>newTolerance)
    1254             keep = 2;
     1253          keep = 2;
    12551254        } else {
    12561255          if (fabs(alpha)>10.0*acceptablePivot)
     
    18601859  // Check if looping
    18611860  int loop = progress.looping();
    1862   bool situationChanged=false;
     1861  int situationChanged=0;
    18631862  if (loop>=0) {
    18641863    problemStatus_ = loop; //exit if in loop
     
    18721871    // something may have changed
    18731872    gutsOfSolution(rowActivityWork_,columnActivityWork_);
    1874     situationChanged=true;
     1873    situationChanged=1;
     1874  }
     1875  // really for free variables in
     1876  if((progressFlag_&2)!=0) {
     1877    situationChanged=2;
    18751878  }
    18761879  progressFlag_ = 0; //reset progress flag
     
    19161919  //double saveDualBound = dualBound_;
    19171920  while (problemStatus_<=-3) {
    1918     bool cleanDuals=situationChanged;
    1919     situationChanged=false;
     1921    bool cleanDuals=situationChanged!=0;
    19201922    int numberChangedBounds=0;
    19211923    int doOriginalTolerance=0;
     
    19721974          if (doOriginalTolerance==1) {
    19731975            // check unbounded
    1974             problemStatus_ = checkUnbounded(rowArray_[0],rowArray_[1],
    1975                                             changeCost);
     1976            // find a variable with bad dj
     1977            int iSequence;
     1978            int iChosen=-1;
     1979            double largest = 100.0*primalTolerance_;
     1980            for (iSequence=0;iSequence<numberRows_+numberColumns_;
     1981                 iSequence++) {
     1982              double djValue = dj_[iSequence];
     1983              double originalLo = originalLower(iSequence);
     1984              double originalUp = originalUpper(iSequence);
     1985              if (fabs(djValue)>fabs(largest)) {
     1986                if (getStatus(iSequence)!=basic) {
     1987                  if (djValue>0&&originalLo<-1.0e20) {
     1988                    if (djValue>fabs(largest)) {
     1989                      largest=djValue;
     1990                      iChosen=iSequence;
     1991                    }
     1992                  } else if (djValue<0&&originalUp>1.0e20) {
     1993                    if (-djValue>fabs(largest)) {
     1994                      largest=djValue;
     1995                      iChosen=iSequence;
     1996                    }
     1997                  }
     1998                }
     1999              }
     2000            }
     2001            if (iChosen>=0) {
     2002              int iSave=sequenceIn_;
     2003              sequenceIn_=iChosen;
     2004              unpack(rowArray_[1]);
     2005              sequenceIn_ = iSave;
     2006              problemStatus_ = checkUnbounded(rowArray_[0],rowArray_[1],
     2007                                              changeCost);
     2008              rowArray_[1]->clear();
     2009            } else {
     2010              problemStatus_=-3;
     2011            }
    19762012            if (problemStatus_==2&&perturbation_==101) {
    19772013              perturbation_=102; // stop any perturbations
     
    20632099        gutsOfSolution(rowActivityWork_,columnActivityWork_);
    20642100        //assert(numberDualInfeasibilitiesWithoutFree_==0);
    2065         if (numberDualInfeasibilities_) {
    2066           // bad free variables
    2067           if (primalFeasible()) {
    2068 #ifdef DEBUG
    2069             std::cerr<<"Free variable problem?"<<std::endl;
    2070 #endif
    2071             //abort(); // what now
    2072           }
     2101        if (numberDualInfeasibilities_||situationChanged==2) {
    20732102          problemStatus_=-1; // carry on as normal
    20742103        }
  • trunk/ClpSimplexPrimal.cpp

    r92 r104  
    708708    gutsOfSolution(rowActivityWork_, columnActivityWork_);
    709709  }
     710  // really for free variables in
     711  //if((progressFlag_&2)!=0)
     712  //problemStatus_=-1;;
    710713  progressFlag_ = 0; //reset progress flag
    711714
  • trunk/PresolveEmpty.cpp

    r94 r104  
    297297          if (rlo[i]<=prob->feasibilityTolerance_ &&
    298298              rup[i]>=-prob->feasibilityTolerance_) {
    299             rlo[i]=min(0.0,rlo[i]);
    300             rup[i]=max(0.0,rup[i]);
     299            rlo[i]=0.0;
     300            rup[i]=0.0;
    301301          } else {
    302302            prob->status_|= 1;
  • trunk/include/ClpSimplex.hpp

    r95 r104  
    494494  inline double & costAddress(int sequence)
    495495  { return cost_[sequence];};
     496  /// Return original lower bound
     497  inline double originalLower(int iSequence) const
     498  { if (iSequence<numberColumns_) return columnLower_[iSequence]; else
     499    return rowLower_[iSequence-numberColumns_];};
     500  /// Return original lower bound
     501  inline double originalUpper(int iSequence) const
     502  { if (iSequence<numberColumns_) return columnUpper_[iSequence]; else
     503    return rowUpper_[iSequence-numberColumns_];};
    496504  /// Scaling
    497505  const double * rowScale() const {return rowScale_;};
     
    726734  /// Can be used for count of fake bounds (dual) or fake costs (primal)
    727735  int numberFake_;
    728   /// Progress flag - at present 0 bit says artificials out
     736  /// Progress flag - at present 0 bit says artificials out, 1 free in
    729737  int progressFlag_;
    730738  /// First free/super-basic variable (-1 if none)
Note: See TracChangeset for help on using the changeset viewer.