Changeset 40 for branches


Ignore:
Timestamp:
Oct 10, 2002 5:28:55 PM (17 years ago)
Author:
forrest
Message:

Still trying to harden presolve

Location:
branches/devel-1
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • branches/devel-1/ClpModel.cpp

    r35 r40  
    362362    objective_ = ClpCopyOfArray ( rhs.objective_, numberColumns_ );
    363363    rowObjective_ = ClpCopyOfArray ( rhs.rowObjective_, numberRows_ );
    364     if (rhs.status_)
    365       status_ = ClpCopyOfArray( rhs.status_,numberColumns_+numberRows_);
    366     else
    367       status_ = NULL;
     364    status_ = ClpCopyOfArray( rhs.status_,numberColumns_+numberRows_);
    368365    ray_ = NULL;
    369366    if (problemStatus_==1)
  • branches/devel-1/ClpPrimalColumnSteepest.cpp

    r35 r40  
    629629        memcpy(weights_,savedWeights_,(numberRows+numberColumns)*
    630630               sizeof(double));
    631         pivotSequence_= savedPivotSequence_;
    632         model_->setSequenceOut(savedSequenceOut_);
     631        // was - but I think should not be
     632        //pivotSequence_= savedPivotSequence_;
     633        //model_->setSequenceOut(savedSequenceOut_);
     634        pivotSequence_= -1;
     635        model_->setSequenceOut(-1);
    633636      }
    634637    }
  • branches/devel-1/ClpSimplex.cpp

    r35 r40  
    13831383    delete primalColumnPivot_;
    13841384    primalColumnPivot_ = NULL;
    1385     delete [] status_;
    1386     status_=NULL;
    13871385  } else {
    13881386    // delete any size information in methods
  • branches/devel-1/Presolve.cpp

    r39 r40  
    4949Presolve::~Presolve()
    5050{
    51   const PresolveAction *paction = paction_;
     51  gutsOfDestroy();
     52}
     53// Gets rid of presolve actions (e.g.when infeasible)
     54void
     55Presolve::gutsOfDestroy()
     56{
     57 const PresolveAction *paction = paction_;
    5258  while (paction) {
    5359    const PresolveAction *next = paction->next;
     
    5561    paction = next;
    5662  }
    57   delete originalColumn_;
     63  delete [] originalColumn_;
     64  paction_=NULL;
     65  originalColumn_=NULL;
    5866}
    5967
     
    215223    paction_ = presolve(&prob);
    216224
    217     result =0; // do infeasible later
     225    result =0;
     226
     227    if (prob.status_==0&&paction_) {
     228      // feasible
    218229   
    219     prob.update_model(*presolvedModel_, nrows_, ncols_, nelems_);
    220     // copy status and solution
    221     memcpy(presolvedModel_->primalColumnSolution(),
    222            prob.sol_,prob.ncols_*sizeof(double));
    223     memcpy(presolvedModel_->primalRowSolution(),
    224       prob.acts_,prob.nrows_*sizeof(double));
    225     memcpy(presolvedModel_->statusArray(),
    226       prob.colstat_,prob.ncols_*sizeof(unsigned char));
    227     memcpy(presolvedModel_->statusArray()+prob.ncols_,
    228       prob.rowstat_,prob.nrows_*sizeof(unsigned char));
    229     delete [] prob.sol_;
    230     delete [] prob.acts_;
    231     delete [] prob.colstat_;
    232     prob.sol_=NULL;
    233     prob.acts_=NULL;
    234     prob.colstat_=NULL;
    235 
    236     int ncolsNow = presolvedModel_->getNumCols();
    237     memcpy(originalColumn_,prob.originalColumn_,ncolsNow*sizeof(int));
    238     // now clean up integer variables.  This can modify original
    239     int i;
    240     const char * information = presolvedModel_->integerInformation();
    241     if (information) {
    242       int numberChanges=0;
    243       double * lower0 = originalModel_->columnLower();
    244       double * upper0 = originalModel_->columnUpper();
    245       double * lower = presolvedModel_->columnLower();
    246       double * upper = presolvedModel_->columnUpper();
    247       for (i=0;i<ncolsNow;i++) {
    248         if (!information[i])
    249           continue;
    250         int iOriginal = originalColumn_[i];
    251         double lowerValue0 = lower0[iOriginal];
    252         double upperValue0 = upper0[iOriginal];
    253         double lowerValue = ceil(lower[i]-1.0e-5);
    254         double upperValue = floor(upper[i]+1.0e-5);
    255         lower[i]=lowerValue;
    256         upper[i]=upperValue;
    257         if (lowerValue>upperValue) {
    258           numberChanges++;
    259           presolvedModel_->messageHandler()->message(CLP_PRESOLVE_COLINFEAS,
    260                                              presolvedModel_->messages())
    261                                                <<iOriginal
    262                                                <<lowerValue
    263                                                <<upperValue
    264                                                <<CoinMessageEol;
    265           result=1;
    266         } else {
    267           if (lowerValue>lowerValue0+1.0e-8) {
    268             lower0[iOriginal] = lowerValue;
     230      prob.update_model(*presolvedModel_, nrows_, ncols_, nelems_);
     231      // copy status and solution
     232      memcpy(presolvedModel_->primalColumnSolution(),
     233             prob.sol_,prob.ncols_*sizeof(double));
     234      memcpy(presolvedModel_->primalRowSolution(),
     235             prob.acts_,prob.nrows_*sizeof(double));
     236      memcpy(presolvedModel_->statusArray(),
     237             prob.colstat_,prob.ncols_*sizeof(unsigned char));
     238      memcpy(presolvedModel_->statusArray()+prob.ncols_,
     239             prob.rowstat_,prob.nrows_*sizeof(unsigned char));
     240      delete [] prob.sol_;
     241      delete [] prob.acts_;
     242      delete [] prob.colstat_;
     243      prob.sol_=NULL;
     244      prob.acts_=NULL;
     245      prob.colstat_=NULL;
     246     
     247      int ncolsNow = presolvedModel_->getNumCols();
     248      memcpy(originalColumn_,prob.originalColumn_,ncolsNow*sizeof(int));
     249      // now clean up integer variables.  This can modify original
     250      int i;
     251      const char * information = presolvedModel_->integerInformation();
     252      if (information) {
     253        int numberChanges=0;
     254        double * lower0 = originalModel_->columnLower();
     255        double * upper0 = originalModel_->columnUpper();
     256        double * lower = presolvedModel_->columnLower();
     257        double * upper = presolvedModel_->columnUpper();
     258        for (i=0;i<ncolsNow;i++) {
     259          if (!information[i])
     260            continue;
     261          int iOriginal = originalColumn_[i];
     262          double lowerValue0 = lower0[iOriginal];
     263          double upperValue0 = upper0[iOriginal];
     264          double lowerValue = ceil(lower[i]-1.0e-5);
     265          double upperValue = floor(upper[i]+1.0e-5);
     266          lower[i]=lowerValue;
     267          upper[i]=upperValue;
     268          if (lowerValue>upperValue) {
    269269            numberChanges++;
     270            presolvedModel_->messageHandler()->message(CLP_PRESOLVE_COLINFEAS,
     271                                                       presolvedModel_->messages())
     272                                                         <<iOriginal
     273                                                         <<lowerValue
     274                                                         <<upperValue
     275                                                         <<CoinMessageEol;
     276            result=1;
     277          } else {
     278            if (lowerValue>lowerValue0+1.0e-8) {
     279              lower0[iOriginal] = lowerValue;
     280              numberChanges++;
     281            }
     282            if (upperValue<upperValue0-1.0e-8) {
     283              upper0[iOriginal] = upperValue;
     284              numberChanges++;
     285            }
     286          }       
     287        }
     288        if (numberChanges) {
     289          presolvedModel_->messageHandler()->message(CLP_PRESOLVE_INTEGERMODS,
     290                                                     presolvedModel_->messages())
     291                                                       <<numberChanges
     292                                                       <<CoinMessageEol;
     293          if (!result) {
     294            result = -1; // round again
    270295          }
    271           if (upperValue<upperValue0-1.0e-8) {
    272             upper0[iOriginal] = upperValue;
    273             numberChanges++;
    274           }
    275         }         
     296        }
    276297      }
    277       if (numberChanges) {
    278           presolvedModel_->messageHandler()->message(CLP_PRESOLVE_INTEGERMODS,
    279                                              presolvedModel_->messages())
    280                                                <<numberChanges
    281                                                <<CoinMessageEol;
    282         if (!result) {
    283           result = -1; // round again
    284         }
    285       }
     298    } else {
     299      // infeasible
     300      delete [] prob.sol_;
     301      delete [] prob.acts_;
     302      delete [] prob.colstat_;
     303      result=1;
    286304    }
    287305  }
    288   int nrowsAfter = presolvedModel_->getNumRows();
    289   int ncolsAfter = presolvedModel_->getNumCols();
    290   int nelsAfter = presolvedModel_->getNumElements();
    291   presolvedModel_->messageHandler()->message(CLP_PRESOLVE_STATS,
    292                                      presolvedModel_->messages())
    293                                        <<nrowsAfter<< -(nrows_ - nrowsAfter)
    294                                        << ncolsAfter<< -(ncols_ - ncolsAfter)
    295                                        <<nelsAfter<< -(nelems_ - nelsAfter)
    296                                        <<CoinMessageEol;
    297 
     306  if (!result) {
     307    int nrowsAfter = presolvedModel_->getNumRows();
     308    int ncolsAfter = presolvedModel_->getNumCols();
     309    int nelsAfter = presolvedModel_->getNumElements();
     310    presolvedModel_->messageHandler()->message(CLP_PRESOLVE_STATS,
     311                                               presolvedModel_->messages())
     312                                                 <<nrowsAfter<< -(nrows_ - nrowsAfter)
     313                                                 << ncolsAfter<< -(ncols_ - ncolsAfter)
     314                                                 <<nelsAfter<< -(nelems_ - nelsAfter)
     315                                                 <<CoinMessageEol;
     316  } else {
     317    gutsOfDestroy();
     318    delete presolvedModel_;
     319    presolvedModel_=NULL;
     320  }
    298321  return presolvedModel_;
    299322}
     
    395418}
    396419
     420#ifdef  DEBUG_PRESOLVE
     421void check_sol(PresolveMatrix *prob)
     422{
     423  double *colels        = prob->colels_;
     424  int *hrow             = prob->hrow_;
     425  int *mcstrt           = prob->mcstrt_;
     426  int *hincol           = prob->hincol_;
     427  int ncols             = prob->ncols_;
     428
     429
     430  double * csol = prob->sol_;
     431  double * clo = prob->clo_;
     432  double * cup = prob->cup_;
     433  int nrows = prob->nrows_;
     434  double * rlo = prob->rlo_;
     435  double * rup = prob->rup_;
     436
     437  int colx;
     438
     439  double * rsol = new double[nrows];
     440  memset(rsol,0,nrows*sizeof(double));
     441
     442  for (colx = 0; colx < ncols; ++colx) {
     443    if (1) {
     444      int k = mcstrt[colx];
     445      int nx = hincol[colx];
     446      double solutionValue = csol[colx];
     447      for (int i=0; i<nx; ++i) {
     448        int row = hrow[k];
     449        double coeff = colels[k];
     450        k++;
     451        rsol[row] += solutionValue*coeff;
     452      }
     453      if (csol[colx]<clo[colx]-1.0e-4) {
     454        printf("low CSOL:  %d  - %g %g %g\n",
     455                   colx, clo[colx], csol[colx], cup[colx]);
     456      } else if (csol[colx]>cup[colx]+1.0e-4) {
     457        printf("high CSOL:  %d  - %g %g %g\n",
     458                   colx, clo[colx], csol[colx], cup[colx]);
     459      }
     460    }
     461  }
     462  int rowx;
     463  for (rowx = 0; rowx < nrows; ++rowx) {
     464    if (1) {
     465      if (rsol[rowx]<rlo[rowx]-1.0e-4) {
     466        printf("low RSOL:  %d - %g %g %g\n",
     467                   rowx,  rlo[rowx], rsol[rowx], rup[rowx]);
     468      } else if (rsol[rowx]>rup[rowx]+1.0e-4) {
     469        printf("high RSOL:  %d - %g %g %g\n",
     470                   rowx,  rlo[rowx], rsol[rowx], rup[rowx]);
     471      }
     472    }
     473  }
     474  delete [] rsol;
     475}
     476#endif
    397477// This is the presolve loop.
    398478// It is a separate virtual function so that it can be easily
     
    479559       
    480560       
     561#if     DEBUG_PRESOLVE
     562        check_sol(prob);
     563#endif
     564
    481565#if     CHECK_CONSISTENCY
    482566        presolve_links_ok(prob->rlink_, prob->mrstrt_, prob->hinrow_,
     
    604688                                             presolvedModel_->messages())
    605689                                               <<CoinMessageEol;
    606     delete paction_;
    607     paction_=NULL;
     690    // get rid of data
     691    gutsOfDestroy();
    608692  }
    609693  return (paction_);
  • branches/devel-1/PresolveForcing.cpp

    r39 r40  
    485485                                double *ilbound, double *iubound)
    486486{
    487   const double tol = ZTOLDP;
     487  const double tol = prob->feasibilityTolerance_;
    488488
    489489  for (int irow=0; irow<nrows; irow++) {
  • branches/devel-1/PresolveImpliedFree.cpp

    r39 r40  
    7272  const char *integerType = prob->integerType_;
    7373
    74   const double tol = ZTOLDP;
     74  const double tol = prob->feasibilityTolerance_;
    7575
    7676  int nbounds = 0;
     
    331331  delete[]tcup;
    332332
    333   if (isolated_row != -1)
    334     next = isolated_constraint_action::presolve(prob, isolated_row, next);
     333  if (isolated_row != -1) {
     334    const PresolveAction *nextX = isolated_constraint_action::presolve(prob,
     335                                                isolated_row, next);
     336    if (nextX)
     337      next = nextX; // may fail
     338  }
    335339
    336340  // try more complex ones
  • branches/devel-1/PresolveIsolated.cpp

    r29 r40  
    4747#endif
    4848
    49   if (rlo[irow] != 0.0 || rup[irow] != 0.0)
    50     DIE("can't handle non-trivial isolated constraints for now\n");
    51 
     49  if (rlo[irow] != 0.0 || rup[irow] != 0.0) {
     50#if     DEBUG_PRESOLVE
     51    printf("can't handle non-trivial isolated constraints for now\n");
     52#endif
     53    return NULL;
     54  }
    5255  for (int k = krs; k<kre; ++k) {
    5356    int jcol = hcol[k];
    54     if (clo[jcol] != 0.0 && cup[jcol] != 0.0)
    55       DIE("can't handle non-trivial isolated constraints for now\n");
     57    if (clo[jcol] != 0.0 && cup[jcol] != 0.0) {
     58#if     DEBUG_PRESOLVE
     59      printf("can't handle non-trivial isolated constraints for now\n");
     60#endif
     61    return NULL;
     62    }
    5663  }
    5764
  • branches/devel-1/PresolveSubst.cpp

    r39 r40  
    470470  presolvehlink *rlink = prob->rlink_;
    471471
    472   const double tol = ZTOLDP;
     472  const double tol = prob->feasibilityTolerance_;
    473473
    474474  action *actions       = new action [ncols];
     
    11251125    double coeffy=0.0;
    11261126
    1127     double rloy;
     1127    double rloy=1.0e50;
    11281128    {
    11291129      int nel = 0;
     
    11391139          coeffy = coeffxs[i];
    11401140          rloy = rlo[row];
     1141
    11411142        }
    11421143        nel += ninrowxs[i];
  • branches/devel-1/include/Presolve.hpp

    r39 r40  
    132132  /// while debugging new presolve techniques.
    133133  virtual void postsolve(PostsolveMatrix &prob);
     134  /// Gets rid of presolve actions (e.g.when infeasible)
     135  void gutsOfDestroy();
    134136};
    135137#endif
Note: See TracChangeset for help on using the changeset viewer.