Changeset 85


Ignore:
Timestamp:
Jan 7, 2003 2:02:44 PM (17 years ago)
Author:
forrest
Message:

Still trying

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/ClpDualRowSteepest.cpp

    r63 r85  
    128128  const int * pivotVariable =model_->pivotVariable();
    129129  int chosenRow=-1;
     130  int lastPivotRow = model_->pivotRow();
    130131  double tolerance=model_->currentPrimalTolerance();
    131132  // we can't really trust infeasibilities if there is primal error
     
    133134    tolerance *= model_->largestPrimalError()/1.0e-8;
    134135  tolerance *= tolerance; // as we are using squares
     136  double * solution = model_->solutionRegion();
     137  double * lower = model_->lowerRegion();
     138  double * upper = model_->upperRegion();
     139  // do last pivot row one here
     140  if (lastPivotRow>=0) {
     141    int iPivot=model_->sequenceIn();
     142    if (iPivot>=0) {
     143      double value = solution[iPivot];
     144      double lower = model_->lower(iPivot);
     145      double upper = model_->upper(iPivot);
     146      if (value>upper+tolerance) {
     147        // store square in list
     148        if (infeas[lastPivotRow])
     149          infeas[lastPivotRow] = (value-upper)*(value-upper); // already there
     150        else
     151          infeasible_->quickAdd(lastPivotRow,(value-upper)*(value-upper));
     152      } else if (value<lower-tolerance) {
     153        // store square in list
     154        if (infeas[lastPivotRow])
     155          infeas[lastPivotRow] = (value-lower)*(value-lower); // already there
     156        else
     157          infeasible_->add(lastPivotRow,(value-lower)*(value-lower));
     158      } else {
     159        // feasible - was it infeasible - if so set tiny
     160        if (infeas[lastPivotRow])
     161          infeas[lastPivotRow] = 1.0e-100;
     162      }
     163    }
     164  }
    135165  for (i=0;i<number;i++) {
    136166    iRow = index[i];
    137167    double value = infeas[iRow];
    138168    if (value>largest*weights_[iRow]&&value>tolerance) {
     169      // make last pivot row last resort choice
     170      if (iRow==lastPivotRow) {
     171        if (value*1.0e-10<largest*weights_[iRow])
     172          continue;
     173        else
     174          value *= 1.0e-10;
     175      }
    139176      int iSequence = pivotVariable[iRow];
    140177      if (!model_->flagged(iSequence)) {
    141         chosenRow=iRow;
    142         largest=value/weights_[iRow];
     178        //#define CLP_DEBUG 1
     179#ifdef CLP_DEBUG
     180        double value2=0.0;
     181        if (solution[iSequence]>upper[iSequence]+tolerance)
     182          value2=solution[iSequence]-upper[iSequence];
     183        else if (solution[iSequence]<lower[iSequence]-tolerance)
     184          value2=solution[iSequence]-lower[iSequence];
     185        assert(fabs(value2*value2-infeas[iRow])<1.0e-8*min(value2*value2,infeas[iRow]));
     186#endif
     187        if (solution[iSequence]>upper[iSequence]+tolerance||
     188            solution[iSequence]<lower[iSequence]-tolerance) {
     189          chosenRow=iRow;
     190          largest=value/weights_[iRow];
     191        }
    143192      }
    144193    }
     
    287336    double upper = model_->upper(iPivot);
    288337    // But if pivot row then use value of incoming
     338    // Although it is safer to recompute before next selection
     339    // in case something odd happens
    289340    if (iRow==pivotRow) {
    290341      iPivot = model_->sequenceIn();
    291       // make last resort choice
    292       lower = 1.0e-6*model_->lower(iPivot);
    293       upper = 1.0e-6*model_->upper(iPivot);
    294       value = 1.0e-6*model_->valueIncomingDual();
     342      lower = model_->lower(iPivot);
     343      upper = model_->upper(iPivot);
     344      value = model_->valueIncomingDual();
    295345    }
    296346    if (value>upper+tolerance) {
  • trunk/ClpSimplex.cpp

    r84 r85  
    21102110            // problem is infeasible - exit at once
    21112111            numberInfeasible++;
     2112            if (handler_->logLevel()>3)
     2113              printf("a %g %g %g %g\n",maximumUp,rowLower_[iRow],
     2114                     maximumDown,rowUpper_[iRow]);
    21122115            break;
    21132116          }
     
    21292132                    // check infeasible (relaxed)
    21302133                    if (columnUpper_[iColumn] - columnLower_[iColumn] <
    2131                         -100.0*tolerance)
     2134                        -100.0*tolerance) {
    21322135                      numberInfeasible++;
     2136                      if (handler_->logLevel()>3)
     2137                        printf("b %g %g \n",columnLower_[iColumn],columnUpper_[iColumn]);
     2138                    }
    21332139                    infiniteLower=1; // skip looking at other bound
    21342140                  }
     
    21462152                    // check infeasible (relaxed)
    21472153                    if (columnUpper_[iColumn] - columnLower_[iColumn] <
    2148                         -100.0*tolerance)
     2154                        -100.0*tolerance) {
    21492155                      numberInfeasible++;
     2156                      if (handler_->logLevel()>3)
     2157                        printf("c %g %g \n",columnLower_[iColumn],columnUpper_[iColumn]);
     2158                    }
    21502159                    infiniteLower=1; // skip looking at other bound
    21512160                  }
     
    21722181                    // check infeasible (relaxed)
    21732182                    if (columnUpper_[iColumn] - columnLower_[iColumn] <
    2174                         -100.0*tolerance)
     2183                        -100.0*tolerance) {
    21752184                      numberInfeasible++;
     2185                      if (handler_->logLevel()>3)
     2186                        printf("d %g %g \n",columnLower_[iColumn],columnUpper_[iColumn]);
     2187                    }
    21762188                  }
    21772189                }
     
    21882200                    // check infeasible (relaxed)
    21892201                    if (columnUpper_[iColumn] - columnLower_[iColumn] <
    2190                         -100.0*tolerance)
     2202                        -100.0*tolerance) {
    21912203                      numberInfeasible++;
     2204                      if (handler_->logLevel()>3)
     2205                        printf("e %g %g \n",columnLower_[iColumn],columnUpper_[iColumn]);
     2206                    }
    21922207                  }
    21932208                }
  • trunk/ClpSimplexDual.cpp

    r82 r85  
    263263    // number of times we have declared optimality
    264264    numberTimesOptimal_=0;
    265    
     265
    266266    // Progress indicator
    267267    ClpSimplexProgress progress(this);
     
    542542          }
    543543        }
     544        assert(fabs(dualOut_)<1.0e30);
    544545        // if stable replace in basis
    545546        int updateStatus = factorization_->replaceColumn(rowArray_[2],
     
    876877      directionOut_ = -1;
    877878      dualOut_ = valueOut_ - upperOut_;
    878     } else {
     879    } else if (valueOut_<lowerOut_) {
    879880      directionOut_ = 1;
    880881      dualOut_ = lowerOut_ - valueOut_;
     882    } else {
     883      // odd - it's feasible - go to nearest
     884      if (valueOut_-lowerOut_<upperOut_-valueOut_) {
     885        directionOut_ = 1;
     886        dualOut_ = lowerOut_ - valueOut_;
     887      } else {
     888        directionOut_ = -1;
     889        dualOut_ = valueOut_ - upperOut_;
     890      }
    881891    }
    882892#ifdef CLP_DEBUG
     
    17591769        for (i=0;i<4;i++)
    17601770          rowArray_[i]->clear();
     1771        // need to reject something
     1772        char x = isColumn(sequenceOut_) ? 'C' :'R';
     1773        handler_->message(CLP_SIMPLEX_FLAG,messages_)
     1774          <<x<<sequenceWithin(sequenceOut_)
     1775          <<CoinMessageEol;
     1776        setFlagged(sequenceOut_);
     1777       
    17611778        forceFactorization_=1; // a bit drastic but ..
    17621779        type = 2;
     
    18311848  while (problemStatus_<=-3) {
    18321849    bool cleanDuals=situationChanged;
     1850    situationChanged=false;
    18331851    int numberChangedBounds=0;
    18341852    int doOriginalTolerance=0;
     
    20132031    dualRowPivot_->saveWeights(this,3);
    20142032  // unflag all variables (we may want to wait a bit?)
    2015   int iRow;
    2016   for (iRow=0;iRow<numberRows_;iRow++) {
    2017     int iPivot=pivotVariable_[iRow];
    2018     clearFlagged(iPivot);
     2033  if (tentativeStatus!=-2) {
     2034    int iRow;
     2035    for (iRow=0;iRow<numberRows_;iRow++) {
     2036      int iPivot=pivotVariable_[iRow];
     2037      clearFlagged(iPivot);
     2038    }
     2039  }
     2040  // see if cutoff reached
     2041  double limit = 0.0;
     2042  getDblParam(ClpDualObjectiveLimit, limit);
     2043  if(fabs(limit)<1.0e30&&objectiveValue()*optimizationDirection_>
     2044           optimizationDirection_*limit&&
     2045           !numberAtFakeBound()) {
     2046    problemStatus_=1;
    20192047  }
    20202048  if (problemStatus_<0&&!changeMade_) {
Note: See TracChangeset for help on using the changeset viewer.