Changeset 2326 for trunk


Ignore:
Timestamp:
Apr 30, 2018 6:27:59 AM (18 months ago)
Author:
forrest
Message:

various things when slight inaccuracy

Location:
trunk/Clp/src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/ClpSimplex.cpp

    r2323 r2326  
    41884188
    41894189     if (what == 63) {
    4190           if (newArrays) {
    4191                // get some arrays
    4192                int iRow, iColumn;
    4193                // these are "indexed" arrays so we always know where nonzeros are
    4194                /**********************************************************
     4190          // Safer to get new arrays anyway so test on newArrays removed
     4191          // get some arrays
     4192          int iRow, iColumn;
     4193          // these are "indexed" arrays so we always know where nonzeros are
     4194          /**********************************************************
    41954195               rowArray_[3] is long enough for rows+columns (2 also maybe)
    41964196               rowArray_[1] is long enough for max(rows,columns)
    4197                *********************************************************/
    4198                for (iRow = 0; iRow < 4; iRow++) {
    4199                     int length = numberRows2 + factorization_->maximumPivots();
    4200                     if (iRow > SHORT_REGION || objective_->type() > 1)
    4201                          length += numberColumns_;
    4202                     else if (iRow == 1)
    4203                          length = CoinMax(length, numberColumns_);
    4204                     if ((specialOptions_ & 65536) == 0 || !rowArray_[iRow]) {
    4205                          delete rowArray_[iRow];
    4206                          rowArray_[iRow] = new CoinIndexedVector();
    4207                     }
    4208                     rowArray_[iRow]->reserve(length);
    4209                }
    4210 
    4211                for (iColumn = 0; iColumn < SHORT_REGION; iColumn++) {
    4212                     if ((specialOptions_ & 65536) == 0 || !columnArray_[iColumn]) {
    4213                          delete columnArray_[iColumn];
    4214                          columnArray_[iColumn] = new CoinIndexedVector();
    4215                     }
    4216                     columnArray_[iColumn]->reserve(numberColumns_+numberRows2);
    4217                }
    4218           } else {
    4219                int iRow, iColumn;
    4220                for (iRow = 0; iRow < 4; iRow++) {
    4221                     int length = numberRows2 + factorization_->maximumPivots();
    4222                     if (iRow > SHORT_REGION || objective_->type() > 1)
    4223                          length += numberColumns_;
    4224                     if(rowArray_[iRow]->capacity() >= length) {
    4225                          rowArray_[iRow]->clear();
    4226                     } else {
    4227                          // model size or maxinv changed
    4228                          rowArray_[iRow]->reserve(length);
    4229                     }
    4230 #ifndef NDEBUG
    4231                     rowArray_[iRow]->checkClear();
    4232 #endif
    4233                }
    4234 
    4235                for (iColumn = 0; iColumn < SHORT_REGION; iColumn++) {
    4236                     int length = numberColumns_;
    4237                     if (iColumn)
    4238                          length = CoinMax(numberRows2, numberColumns_);
    4239                     if(columnArray_[iColumn]->capacity() >= length) {
    4240                          columnArray_[iColumn]->clear();
    4241                     } else {
    4242                          // model size or maxinv changed
    4243                          columnArray_[iColumn]->reserve(length);
    4244                     }
    4245 #ifndef NDEBUG
    4246                     columnArray_[iColumn]->checkClear();
    4247 #endif
    4248                }
    4249           }
     4197          *********************************************************/
     4198          for (iRow = 0; iRow < 4; iRow++) {
     4199            int length = numberRows2 + factorization_->maximumPivots();
     4200            if (iRow > SHORT_REGION || objective_->type() > 1)
     4201              length += numberColumns_;
     4202            else if (iRow == 1)
     4203              length = CoinMax(length, numberColumns_);
     4204            if ((specialOptions_ & 65536) == 0 || !rowArray_[iRow]) {
     4205              delete rowArray_[iRow];
     4206              rowArray_[iRow] = new CoinIndexedVector();
     4207            }
     4208            rowArray_[iRow]->reserve(length);
     4209          }
     4210         
     4211          for (iColumn = 0; iColumn < SHORT_REGION; iColumn++) {
     4212            if ((specialOptions_ & 65536) == 0 || !columnArray_[iColumn]) {
     4213              delete columnArray_[iColumn];
     4214              columnArray_[iColumn] = new CoinIndexedVector();
     4215            }
     4216            columnArray_[iColumn]->reserve(numberColumns_+numberRows2);
     4217          }
    42504218     }
    42514219     if (problemStatus_ == 10) {
     
    58875855     }
    58885856#endif
     5857     // massage infeasibilities
     5858     if (!problemStatus_) {
     5859       if (handler_->logLevel()==63) {
     5860         if (numberPrimalInfeasibilities_||numberDualInfeasibilities_)
     5861           printf("minor inaccuracy primal sum %g (%d) error %g, dual %g (%d) %g\n",
     5862                  sumPrimalInfeasibilities_,numberPrimalInfeasibilities_,
     5863                  largestPrimalError_,
     5864                  sumDualInfeasibilities_,numberDualInfeasibilities_,
     5865                  largestDualError_);
     5866       }
     5867       if (numberPrimalInfeasibilities_) {
     5868         numberPrimalInfeasibilities_=0;
     5869         sumPrimalInfeasibilities_=0.0;
     5870         if (secondaryStatus_==0)
     5871           secondaryStatus_=2;
     5872         else if (secondaryStatus_==3)
     5873           secondaryStatus_=4;
     5874       }
     5875       if (numberDualInfeasibilities_) {
     5876         numberDualInfeasibilities_=0;
     5877         sumDualInfeasibilities_=0.0;
     5878         if (secondaryStatus_==0)
     5879           secondaryStatus_=3;
     5880         else if (secondaryStatus_==2)
     5881           secondaryStatus_=4;
     5882       }
     5883     }
    58895884     return returnCode;
    58905885}
     
    61436138     //factorization_->pivotTolerance(savedPivotTolerance);
    61446139     onStopped(); // set secondary status if stopped
     6140     // massage infeasibilities
     6141     if (!problemStatus_) {
     6142       if (handler_->logLevel()==63) {
     6143         if (numberPrimalInfeasibilities_||numberDualInfeasibilities_)
     6144           printf("minor inaccuracy primal sum %g (%d) error %g, dual %g (%d) %g\n",
     6145                  sumPrimalInfeasibilities_,numberPrimalInfeasibilities_,
     6146                  largestPrimalError_,
     6147                  sumDualInfeasibilities_,numberDualInfeasibilities_,
     6148                  largestDualError_);
     6149       }
     6150       if (numberPrimalInfeasibilities_) {
     6151         numberPrimalInfeasibilities_=0;
     6152         sumPrimalInfeasibilities_=0.0;
     6153         if (secondaryStatus_==0)
     6154           secondaryStatus_=2;
     6155         else if (secondaryStatus_==3)
     6156           secondaryStatus_=4;
     6157       }
     6158       if (numberDualInfeasibilities_) {
     6159         numberDualInfeasibilities_=0;
     6160         sumDualInfeasibilities_=0.0;
     6161         if (secondaryStatus_==0)
     6162           secondaryStatus_=3;
     6163         else if (secondaryStatus_==2)
     6164           secondaryStatus_=4;
     6165       }
     6166     }
    61456167     //if (problemStatus_==1&&lastAlgorithm==1)
    61466168     //returnCode=10; // so will do primal after postsolve
  • trunk/Clp/src/ClpSimplexDual.cpp

    r2322 r2326  
    500500              (moreSpecialOptions_&256)==0 &&
    501501              ((progress_.lastObjective(0)<-1.0e10 &&
    502 -               progress_.lastObjective(1)>-1.0e5)||sumPrimalInfeasibilities_>1.0e10*smallestPrimalInfeasibility)) {
     502-               progress_.lastObjective(1)>-1.0e5)||sumPrimalInfeasibilities_>1.0e10*smallestPrimalInfeasibility)&&problemStatus_<0) {
    503503            // problems - try primal
    504504            problemStatus_=10;
     
    526526          }
    527527
    528           // Say good factorization
     528          // Say good factorization 
    529529          factorType = 1;
    530530          if (data.sparseThreshold_) {
     
    24232423               if (iStatus) {
    24242424                    double value = reducedCost[iSequence] - theta * alphaI;
    2425                     assert (iStatus>0);
     2425                    // NO - can have free assert (iStatus>0);
    24262426                    reducedCost[iSequence] = value;
    24272427                    double mult = multiplier[iStatus-1];
     
    31223122                    break;
    31233123               case atUpperBound:
    3124                     if (fabs(value - upperValue) > primalTolerance_)
    3125                          numberInfeasibilities++;
     3124                    if (fabs(value - upperValue) > primalTolerance_) {
     3125                      if(fabs(dj_[iSequence])>1.0e-9) {
     3126                         numberInfeasibilities++;
     3127                      } else {
     3128                        setStatus(iSequence,superBasic);
     3129                        moreSpecialOptions_ &= ~8;
     3130                      }
     3131                    }
    31263132                    break;
    31273133               case atLowerBound:
    3128                     if (fabs(value - lowerValue) > primalTolerance_)
    3129                          numberInfeasibilities++;
     3134                    if (fabs(value - lowerValue) > primalTolerance_) {
     3135                      if(fabs(dj_[iSequence])>1.0e-9) {
     3136                         numberInfeasibilities++;
     3137                      } else {
     3138                        setStatus(iSequence,superBasic);
     3139                        moreSpecialOptions_ &= ~8;
     3140                      }
     3141                    }
    31303142                    break;
    31313143               }
     
    31533165                              newLowerValue = CoinMax(lowerValue, newUpperValue - newBound);
    31543166                         }
    3155                          lower_[iSequence] = newLowerValue;
    3156                          upper_[iSequence] = newUpperValue;
    31573167                         if (newLowerValue > lowerValue) {
    31583168                              if (newUpperValue < upperValue) {
    31593169                                   setFakeBound(iSequence, ClpSimplexDual::bothFake);
    3160 #ifdef CLP_INVESTIGATE
    3161                                    abort(); // No idea what should happen here - I have never got here
    3162 #endif
     3170                                   // redo
     3171                                   if (status == atLowerBound) {
     3172                                     newLowerValue = value;
     3173                                     newUpperValue = CoinMin(upperValue, newLowerValue + newBound);
     3174                                   } else {
     3175                                     newUpperValue = value;
     3176                                     newLowerValue = CoinMax(lowerValue, newUpperValue - newBound);
     3177                                   }
    31633178                                   numberFake_++;
    31643179                              } else {
     
    31723187                              }
    31733188                         }
     3189                         lower_[iSequence] = newLowerValue;
     3190                         upper_[iSequence] = newUpperValue;
    31743191                         if (status == atUpperBound)
    31753192                              solution_[iSequence] = newUpperValue;
     
    31963213          int iSequence;
    31973214          if (initialize == 3) {
    3198                for (iSequence = 0; iSequence < numberRows_ + numberColumns_; iSequence++) {
    3199                     setFakeBound(iSequence, ClpSimplexDual::noFake);
    3200                }
     3215            if (columnScale_) {
     3216              for (iSequence = 0; iSequence < numberColumns_; iSequence++) {
     3217                if (getFakeBound(iSequence) != ClpSimplexDual::noFake) {
     3218                  double multiplier = rhsScale_ * inverseColumnScale_[iSequence];
     3219                  // lower
     3220                  double value = columnLower_[iSequence];
     3221                  if (value > -1.0e30) {
     3222                    value *= multiplier;
     3223                  }
     3224                  lower_[iSequence] = value;
     3225                  // upper
     3226                  value = columnUpper_[iSequence];
     3227                  if (value < 1.0e30) {
     3228                    value *= multiplier;
     3229                  }
     3230                  upper_[iSequence] = value;
     3231                  setFakeBound(iSequence, ClpSimplexDual::noFake);
     3232                }
     3233              }
     3234              for (iSequence = 0; iSequence < numberRows_; iSequence++) {
     3235                // lower
     3236                double multiplier = rhsScale_ * rowScale_[iSequence];
     3237                double value = rowLower_[iSequence];
     3238                if (value > -1.0e30) {
     3239                  value *= multiplier;
     3240                }
     3241                lower_[iSequence+numberColumns_] = value;
     3242                // upper
     3243                value = rowUpper_[iSequence];
     3244                if (value < 1.0e30) {
     3245                  value *= multiplier;
     3246                }
     3247                upper_[iSequence+numberColumns_] = value;
     3248                setFakeBound(iSequence+numberColumns_, ClpSimplexDual::noFake);
     3249              }
     3250            } else {
     3251              for (iSequence = 0; iSequence < numberColumns_; iSequence++) {
     3252                if (getFakeBound(iSequence) != ClpSimplexDual::noFake) {
     3253                  lower_[iSequence] = columnLower_[iSequence];
     3254                  upper_[iSequence] = columnUpper_[iSequence];
     3255                  setFakeBound(iSequence, ClpSimplexDual::noFake);
     3256                }
     3257              }
     3258              for (iSequence = 0; iSequence < numberRows_; iSequence++) {
     3259                if (getFakeBound(iSequence+numberColumns_) != ClpSimplexDual::noFake) {
     3260                  lower_[iSequence+numberColumns_] = rowLower_[iSequence];
     3261                  upper_[iSequence+numberColumns_] = rowUpper_[iSequence];
     3262                  setFakeBound(iSequence+numberColumns_, ClpSimplexDual::noFake);
     3263                }
     3264              }
     3265            }
    32013266          }
    32023267          double testBound = 0.999999 * dualBound_;
  • trunk/Clp/src/ClpSimplexPrimal.cpp

    r2323 r2326  
    571571     progress_.initialWeight_ = 0.0;
    572572     if (problemStatus_ == 1 && secondaryStatus_ != 6) {
     573#ifndef WANT_INFEASIBLE_DUALS
    573574          infeasibilityCost_ = 0.0;
    574575          createRim(1 + 4);
     576#else
     577          infeasibilityCost_ = 1.0;
     578          createRim(1);
     579          memset(cost_,0,(numberRows_+numberColumns_)*sizeof(double));
     580#endif
    575581          delete nonLinearCost_;
    576582          nonLinearCost_ = new ClpNonLinearCost(this);
Note: See TracChangeset for help on using the changeset viewer.