Changeset 207 for branches


Ignore:
Timestamp:
Sep 8, 2003 3:04:34 PM (16 years ago)
Author:
forrest
Message:

Fixes

Location:
branches/pre
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • branches/pre/ClpFactorization.cpp

    r203 r207  
    211211            ftranAverageAfterR_ = max(ftranCountAfterR_/ftranCountAfterL_,1.0);
    212212            ftranAverageAfterU_ = max(ftranCountAfterU_/ftranCountAfterR_,1.0);
    213             if (btranCountInput_) {
     213            assert (ftranCountInput_&&ftranCountAfterL_&&ftranCountAfterR_);
     214            if (btranCountInput_&&btranCountAfterU_&&btranCountAfterR_) {
    214215              btranAverageAfterU_ = max(btranCountAfterU_/btranCountInput_,1.0);
    215216              btranAverageAfterR_ = max(btranCountAfterR_/btranCountAfterU_,1.0);
    216217              btranAverageAfterL_ = max(btranCountAfterL_/btranCountAfterR_,1.0);
    217218            } else {
    218               // odd - we have not done any btrans
     219              // we have not done any useful btrans (values pass?)
    219220              btranAverageAfterU_ = 1.0;
    220221              btranAverageAfterR_ = 1.0;
  • branches/pre/ClpNetworkMatrix.cpp

    r180 r207  
    818818  abort();
    819819}
     820/* Given positive integer weights for each row fills in sum of weights
     821   for each column (and slack).
     822   Returns weights vector
     823*/
     824CoinBigIndex *
     825ClpNetworkMatrix::dubiousWeights(const ClpSimplex * model,int * inputWeights) const
     826{
     827  int numberRows = model->numberRows();
     828  int numberColumns =model->numberColumns();
     829  int number = numberRows+numberColumns;
     830  CoinBigIndex * weights = new CoinBigIndex[number];
     831  int i;
     832  for (i=0;i<numberColumns;i++) {
     833    CoinBigIndex j=i<<1;
     834    CoinBigIndex count=0;
     835    int iRowM = indices_[j];
     836    int iRowP = indices_[j+1];
     837    if (iRowM>=0) {
     838      count += inputWeights[iRowM];
     839    }
     840    if (iRowP>=0) {
     841      count += inputWeights[iRowP];
     842    }
     843    weights[i]=count;
     844  }
     845  for (i=0;i<numberRows;i++) {
     846    weights[i+numberColumns]=inputWeights[i];
     847  }
     848  return weights;
     849}
  • branches/pre/ClpPlusMinusOneMatrix.cpp

    r180 r207  
    508508          value -= pi[iRow];
    509509        }
    510         value += scalar;
     510        value *= scalar;
    511511        if (fabs(value)>zeroTolerance) {
    512512          index[numberNonZero++]=iColumn;
     
    11401140  numberColumns_=numberColumns;
    11411141}
     1142/* Given positive integer weights for each row fills in sum of weights
     1143   for each column (and slack).
     1144   Returns weights vector
     1145*/
     1146CoinBigIndex *
     1147ClpPlusMinusOneMatrix::dubiousWeights(const ClpSimplex * model,int * inputWeights) const
     1148{
     1149  int numberRows = model->numberRows();
     1150  int numberColumns =model->numberColumns();
     1151  int number = numberRows+numberColumns;
     1152  CoinBigIndex * weights = new CoinBigIndex[number];
     1153  int i;
     1154  for (i=0;i<numberColumns;i++) {
     1155    CoinBigIndex j;
     1156    CoinBigIndex count=0;
     1157    for (j=startPositive_[i];j<startPositive_[i+1];j++) {
     1158      int iRow=indices_[j];
     1159      count += inputWeights[iRow];
     1160    }
     1161    weights[i]=count;
     1162  }
     1163  for (i=0;i<numberRows;i++) {
     1164    weights[i+numberColumns]=inputWeights[i];
     1165  }
     1166  return weights;
     1167}
  • branches/pre/ClpSimplexPrimal.cpp

    r206 r207  
    277277ClpSimplexPrimal::whileIterating()
    278278{
    279 
    280279  // Say if values pass
    281280  int ifValuesPass=(firstFree_>=0) ? 1 : 0;
     
    345344        pivotRow_=-1; // say no weights update
    346345        returnCode=-4;
     346        // Clean up
     347        int i;
     348        for (i=0;i<numberRows_+numberColumns_;i++) {
     349          if (getColumnStatus(i)==atLowerBound||getColumnStatus(i)==isFixed)
     350            solution_[i]=lower_[i];
     351          else if (getColumnStatus(i)==atUpperBound)
     352            solution_[i]=upper_[i];
     353        }
    347354        break;
    348355      } else {
     
    857864    printf("trouble\n");
    858865#endif
    859 
    860866  for (iIndex=0;iIndex<number;iIndex++) {
    861867
     
    878884     
    879885    double value = oldValue-tentativeTheta*fabs(alpha);
    880     assert (oldValue>=-primalTolerance_*1.0001);
     886    assert (oldValue>=-primalTolerance_*1.002);
    881887    if (value<-primalTolerance_) {
    882888      // add to list
     
    889895    }
    890896  }
    891 
     897#if 0
     898  if (numberIterations_>17701)
     899    handler_->setLogLevel(63);
     900  if (!valuesPass&&fabs(dualIn_-saveDj)>1.0e-1*(1.0+fabs(saveDj))) {
     901    double d=0.0;
     902    for (iIndex=0;iIndex<number;iIndex++) {
     903     
     904      int iRow = which[iIndex];
     905      double alpha = work[iRow];
     906      int iPivot=pivotVariable_[iRow];
     907      double value = alpha*cost(iPivot);
     908      d -= value;
     909      if (value>1.0e7)
     910        printf("%d %g\n",iRow,value);
     911    }
     912  }
     913#endif
    892914  // we need to keep where rhs non-zeros are
    893915  int numberInRhs=numberRemaining;
     
    10921114#endif
    10931115    double largestInfeasibility = primalTolerance_;
    1094     if (theta_<minimumTheta&&(specialOptions_&4)==0) {
     1116    if (theta_<minimumTheta&&(specialOptions_&4)==0&&!valuesPass) {
    10951117      theta_=minimumTheta;
    10961118      for (iIndex=0;iIndex<numberSwapped;iIndex++) {
     
    14911513      }
    14921514    }
     1515    double checkValue=1.0e-2;
     1516    if (largestDualError_>1.0e-5)
     1517      checkValue=1.0e-1;
    14931518    if (solveType_==1&&((saveDj*dualIn_<1.0e-20&&!ifValuesPass)||
    1494         fabs(saveDj-dualIn_)>1.0e-3*(1.0+fabs(saveDj)))) {
     1519        fabs(saveDj-dualIn_)>checkValue*(1.0+fabs(saveDj)))) {
    14951520      handler_->message(CLP_PRIMAL_DJ,messages_)
    14961521        <<saveDj<<dualIn_
     
    15101535        // take on more relaxed criterion
    15111536        if (saveDj*dualIn_<1.0e-20||
    1512             fabs(saveDj-dualIn_)>1.0e-1*(1.0+fabs(dualIn_))) {
     1537            fabs(saveDj-dualIn_)>2.0e-1*(1.0+fabs(dualIn_))) {
    15131538          // need to reject something
    15141539          char x = isColumn(sequenceIn_) ? 'C' :'R';
  • branches/pre/Test/ClpMain.cpp

    r206 r207  
    12231223                    if (numberRows>2000&&numberColumns>2*numberRows) {
    12241224                      ClpPackedMatrix* clpMatrix =
    1225                         dynamic_cast< ClpPackedMatrix*>(saveMatrix);
     1225                        dynamic_cast< ClpPackedMatrix*>(model2->clpMatrix());
    12261226                      if (clpMatrix) {
    12271227                        ClpPlusMinusOneMatrix * newMatrix = new ClpPlusMinusOneMatrix(*(clpMatrix->matrix()));
     
    12461246                      } else {
    12471247                        ClpPlusMinusOneMatrix* clpMatrix =
    1248                           dynamic_cast< ClpPlusMinusOneMatrix*>(saveMatrix);
     1248                          dynamic_cast< ClpPlusMinusOneMatrix*>(model2->clpMatrix());
    12491249                        if (clpMatrix) {
    12501250                          int nPasses = 10+numberColumns/1000;
     
    12931293#endif
    12941294                models[iModel].checkSolution();
    1295                 if (!finalStatus&&finalStatus!=3) {
     1295                if (finalStatus&&finalStatus!=3) {
    12961296                  printf("Resolving from postsolved model\n");
    12971297                 
  • branches/pre/include/ClpNetworkMatrix.hpp

    r180 r207  
    7070                                 int * row, int * column,
    7171                                 double * element) const ;
     72  /** Given positive integer weights for each row fills in sum of weights
     73      for each column (and slack).
     74      Returns weights vector
     75  */
     76  virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model,int * inputWeights) const;
    7277  /** Unpacks a column into an CoinIndexedvector
    7378   */
  • branches/pre/include/ClpPlusMinusOneMatrix.hpp

    r180 r207  
    6868                                 int * row, int * column,
    6969                                 double * element) const ;
     70  /** Given positive integer weights for each row fills in sum of weights
     71      for each column (and slack).
     72      Returns weights vector
     73  */
     74  virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model,int * inputWeights) const;
    7075  /** Unpacks a column into an CoinIndexedvector
    7176   */
Note: See TracChangeset for help on using the changeset viewer.