Ignore:
Timestamp:
Oct 2, 2003 1:21:02 PM (17 years ago)
Author:
forrest
Message:

lots of stuff

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/pre/ClpSimplex.cpp

    r210 r212  
    9393  savedSolution_(NULL),
    9494  columnScale_(NULL),
    95   scalingFlag_(1),
     95  scalingFlag_(3),
    9696  numberTimesOptimal_(0),
    9797  changeMade_(1),
     
    196196  savedSolution_(NULL),
    197197  columnScale_(NULL),
    198   scalingFlag_(1),
     198  scalingFlag_(3),
    199199  numberTimesOptimal_(0),
    200200  changeMade_(1),
     
    692692
    693693  return status;
     694}
     695// Clean up status
     696void
     697ClpSimplex::cleanStatus()
     698{
     699  int iRow,iColumn;
     700  int numberBasic=0;
     701  // make row activities correct
     702  memset(rowActivityWork_,0,numberRows_*sizeof(double));
     703  times(1.0,columnActivityWork_,rowActivityWork_);
     704  if (!status_)
     705    createStatus();
     706  for (iRow=0;iRow<numberRows_;iRow++) {
     707    if (getRowStatus(iRow)==basic)
     708      numberBasic++;
     709    else {
     710      setRowStatus(iRow,superBasic);
     711      // but put to bound if close
     712      if (fabs(rowActivityWork_[iRow]-rowLowerWork_[iRow])
     713          <=primalTolerance_) {
     714        rowActivityWork_[iRow]=rowLowerWork_[iRow];
     715        setRowStatus(iRow,atLowerBound);
     716      } else if (fabs(rowActivityWork_[iRow]-rowUpperWork_[iRow])
     717                 <=primalTolerance_) {
     718        rowActivityWork_[iRow]=rowUpperWork_[iRow];
     719        setRowStatus(iRow,atUpperBound);
     720      }
     721    }
     722  }
     723  for (iColumn=0;iColumn<numberColumns_;iColumn++) {
     724    if (getColumnStatus(iColumn)==basic) {
     725      if (numberBasic==numberRows_) {
     726        // take out of basis
     727        setColumnStatus(iColumn,superBasic);
     728        // but put to bound if close
     729        if (fabs(columnActivityWork_[iColumn]-columnLowerWork_[iColumn])
     730            <=primalTolerance_) {
     731          columnActivityWork_[iColumn]=columnLowerWork_[iColumn];
     732          setColumnStatus(iColumn,atLowerBound);
     733        } else if (fabs(columnActivityWork_[iColumn]
     734                        -columnUpperWork_[iColumn])
     735                   <=primalTolerance_) {
     736          columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
     737          setColumnStatus(iColumn,atUpperBound);
     738        }
     739      } else
     740        numberBasic++;
     741    } else {
     742      setColumnStatus(iColumn,superBasic);
     743      // but put to bound if close
     744      if (fabs(columnActivityWork_[iColumn]-columnLowerWork_[iColumn])
     745          <=primalTolerance_) {
     746        columnActivityWork_[iColumn]=columnLowerWork_[iColumn];
     747        setColumnStatus(iColumn,atLowerBound);
     748      } else if (fabs(columnActivityWork_[iColumn]
     749                      -columnUpperWork_[iColumn])
     750                 <=primalTolerance_) {
     751        columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
     752        setColumnStatus(iColumn,atUpperBound);
     753      }
     754    }
     755  }
    694756}
    695757
     
    9771039    } else {
    9781040      // values pass has less coding
    979       // make row activities correct
    980       memset(rowActivityWork_,0,numberRows_*sizeof(double));
    981       times(1.0,columnActivityWork_,rowActivityWork_);
     1041      // make row activities correct and clean basis a bit
     1042      cleanStatus();
    9821043      if (status_) {
    983         // set values from warm start (if sensible)
    9841044        int numberBasic=0;
    9851045        for (iRow=0;iRow<numberRows_;iRow++) {
    9861046          if (getRowStatus(iRow)==basic)
    9871047            numberBasic++;
    988           else {
    989             setRowStatus(iRow,superBasic);
    990             // but put to bound if close
    991             if (fabs(rowActivityWork_[iRow]-rowLowerWork_[iRow])
    992                 <=primalTolerance_) {
    993               rowActivityWork_[iRow]=rowLowerWork_[iRow];
    994               setRowStatus(iRow,atLowerBound);
    995             } else if (fabs(rowActivityWork_[iRow]-rowUpperWork_[iRow])
    996                        <=primalTolerance_) {
    997               rowActivityWork_[iRow]=rowUpperWork_[iRow];
    998               setRowStatus(iRow,atUpperBound);
    999             }
    1000           }
    1001          
    10021048        }
    10031049        totalSlacks=numberBasic;
    10041050        for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    1005           if (getColumnStatus(iColumn)==basic) {
    1006             if (numberBasic==numberRows_) {
    1007               // take out of basis
    1008               setColumnStatus(iColumn,superBasic);
    1009               // but put to bound if close
    1010               if (fabs(columnActivityWork_[iColumn]-columnLowerWork_[iColumn])
    1011                   <=primalTolerance_) {
    1012                 columnActivityWork_[iColumn]=columnLowerWork_[iColumn];
    1013                 setColumnStatus(iColumn,atLowerBound);
    1014               } else if (fabs(columnActivityWork_[iColumn]
    1015                             -columnUpperWork_[iColumn])
    1016                          <=primalTolerance_) {
    1017                 columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
    1018                 setColumnStatus(iColumn,atUpperBound);
    1019               }
    1020             } else
    1021               numberBasic++;
    1022           } else {
    1023             setColumnStatus(iColumn,superBasic);
    1024             // but put to bound if close
    1025             if (fabs(columnActivityWork_[iColumn]-columnLowerWork_[iColumn])
    1026                 <=primalTolerance_) {
    1027               columnActivityWork_[iColumn]=columnLowerWork_[iColumn];
    1028               setColumnStatus(iColumn,atLowerBound);
    1029             } else if (fabs(columnActivityWork_[iColumn]
    1030                           -columnUpperWork_[iColumn])
    1031                        <=primalTolerance_) {
    1032               columnActivityWork_[iColumn]=columnUpperWork_[iColumn];
    1033               setColumnStatus(iColumn,atUpperBound);
    1034             }
    1035           }
     1051          if (getColumnStatus(iColumn)==basic)
     1052            numberBasic++;
    10361053        }
    10371054      } else {
     
    12831300  savedSolution_(NULL),
    12841301  columnScale_(NULL),
    1285   scalingFlag_(1),
     1302  scalingFlag_(3),
    12861303  numberTimesOptimal_(0),
    12871304  changeMade_(1),
     
    13801397  savedSolution_(NULL),
    13811398  columnScale_(NULL),
    1382   scalingFlag_(1),
     1399  scalingFlag_(3),
    13831400  numberTimesOptimal_(0),
    13841401  changeMade_(1),
     
    22522269ClpSimplex::scaling(int mode)
    22532270{
    2254   if (mode>0&&mode<3) {
     2271  if (mode>0&&mode<4) {
    22552272    scalingFlag_=mode;
    22562273  } else if (!mode) {
     
    25942611      <<CoinMessageEol;
    25952612    // Set bounds slightly loose
     2613    double useTolerance = 1.0e-3;
    25962614    for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    2597       if (saveUpper[iColumn]>saveLower[iColumn]+tolerance) {
    2598         if (columnUpper_[iColumn]-columnLower_[iColumn]<tolerance+1.0e8) {
     2615      if (saveUpper[iColumn]>saveLower[iColumn]+useTolerance) {
     2616        if (columnUpper_[iColumn]-columnLower_[iColumn]<useTolerance+1.0e8) {
    25992617          // relax enough so will have correct dj
    26002618#if 1
    26012619          columnLower_[iColumn]=max(saveLower[iColumn],
    2602                                     columnLower_[iColumn]-100.0*tolerance);
     2620                                    columnLower_[iColumn]-100.0*useTolerance);
    26032621          columnUpper_[iColumn]=min(saveUpper[iColumn],
    2604                                     columnUpper_[iColumn]+100.0*tolerance);
     2622                                    columnUpper_[iColumn]+100.0*useTolerance);
    26052623#else
    26062624          if (fabs(columnUpper_[iColumn])<fabs(columnLower_[iColumn])) {
    2607             if (columnUpper_[iColumn]- 100.0*tolerance>saveLower[iColumn]) {
    2608               columnLower_[iColumn]=columnUpper_[iColumn]-100.0*tolerance;
     2625            if (columnUpper_[iColumn]- 100.0*useTolerance>saveLower[iColumn]) {
     2626              columnLower_[iColumn]=columnUpper_[iColumn]-100.0*useTolerance;
    26092627            } else {
    26102628              columnLower_[iColumn]=saveLower[iColumn];
    26112629              columnUpper_[iColumn]=min(saveUpper[iColumn],
    2612                                         saveLower[iColumn]+100.0*tolerance);
     2630                                        saveLower[iColumn]+100.0*useTolerance);
    26132631            }
    26142632          } else {
    2615             if (columnLower_[iColumn]+100.0*tolerance<saveUpper[iColumn]) {
    2616               columnUpper_[iColumn]=columnLower_[iColumn]+100.0*tolerance;
     2633            if (columnLower_[iColumn]+100.0*useTolerance<saveUpper[iColumn]) {
     2634              columnUpper_[iColumn]=columnLower_[iColumn]+100.0*useTolerance;
    26172635            } else {
    26182636              columnUpper_[iColumn]=saveUpper[iColumn];
    26192637              columnLower_[iColumn]=max(saveLower[iColumn],
    2620                                         saveUpper[iColumn]-100.0*tolerance);
     2638                                        saveUpper[iColumn]-100.0*useTolerance);
    26212639            }
    26222640          }
     
    26252643          if (columnUpper_[iColumn]<saveUpper[iColumn]) {
    26262644            // relax a bit
    2627             columnUpper_[iColumn] = min(columnUpper_[iColumn]+100.0*tolerance,
     2645            columnUpper_[iColumn] = min(columnUpper_[iColumn]+100.0*useTolerance,
    26282646                                        saveUpper[iColumn]);
    26292647          }
    26302648          if (columnLower_[iColumn]>saveLower[iColumn]) {
    26312649            // relax a bit
    2632             columnLower_[iColumn] = max(columnLower_[iColumn]-100.0*tolerance,
     2650            columnLower_[iColumn] = max(columnLower_[iColumn]-100.0*useTolerance,
    26332651                                        saveLower[iColumn]);
    26342652          }
     
    26582676    int savePerturbation = perturbation_;
    26592677    perturbation_=100;
     2678    bool denseFactorization = initialDenseFactorization();
     2679    // It will be safe to allow dense
     2680    setInitialDenseFactorization(true);
    26602681    returnCode = ((ClpSimplexPrimal *) this)->primal(1);
     2682    setInitialDenseFactorization(denseFactorization);
    26612683    perturbation_=savePerturbation;
    26622684  }
     
    26712693    int savePerturbation = perturbation_;
    26722694    perturbation_=100;
     2695    bool denseFactorization = initialDenseFactorization();
     2696    // It will be safe to allow dense
     2697    setInitialDenseFactorization(true);
    26732698    returnCode = ((ClpSimplexDual *) this)->dual(0);
     2699    setInitialDenseFactorization(denseFactorization);
    26742700    perturbation_=savePerturbation;
    26752701  }
     
    39053931  }
    39063932}
    3907 int
    3908 ClpSimplex::nextSuperBasic()
    3909 {
    3910   if (firstFree_>=0) {
    3911     int returnValue=firstFree_;
    3912     int iColumn=firstFree_+1;
    3913     if (algorithm_>0) {
    3914       // primal
    3915       for (;iColumn<numberRows_+numberColumns_;iColumn++) {
    3916         if (getStatus(iColumn)==superBasic) {
    3917           if (fabs(solution_[iColumn]-lower_[iColumn])<=primalTolerance_) {
    3918             solution_[iColumn]=lower_[iColumn];
    3919             setStatus(iColumn,atLowerBound);
    3920           } else if (fabs(solution_[iColumn]-upper_[iColumn])
    3921                      <=primalTolerance_) {
    3922             solution_[iColumn]=upper_[iColumn];
    3923             setStatus(iColumn,atUpperBound);
    3924           } else if (lower_[iColumn]<-1.0e20&&upper_[iColumn]>1.0e20) {
    3925             setStatus(iColumn,isFree);
    3926             break;
    3927           } else {
    3928             break;
    3929           }
    3930         }
    3931       }
    3932     } else {
    3933       // dual
    3934       for (;iColumn<numberRows_+numberColumns_;iColumn++) {
    3935         if (getStatus(iColumn)==isFree)
    3936           if (fabs(dj_[iColumn])>1.0e2*dualTolerance_)
    3937             break;
    3938       }
    3939     }
    3940     firstFree_ = iColumn;
    3941     if (firstFree_==numberRows_+numberColumns_)
    3942       firstFree_=-1;
    3943     return returnValue;
    3944   } else {
    3945     return -1;
    3946   }
    3947 }
    39483933/* Pivot in a variable and out a variable.  Returns 0 if okay,
    39493934   1 if inaccuracy forced re-factorization, -1 if would be singular.
Note: See TracChangeset for help on using the changeset viewer.