Ignore:
Timestamp:
Mar 16, 2009 6:30:25 AM (10 years ago)
Author:
forrest
Message:

chnages to try and make faster

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/unitTestClp.cpp

    r1121 r1132  
    283283    OsiClpSolverInterface * si =
    284284      dynamic_cast<OsiClpSolverInterface *>(model->solver()) ;
    285     assert (si != NULL);
    286     // get clp itself
    287     ClpSimplex * modelC = si->getModelPtr();
    288     if (stuff&&stuff[9]) {
    289       // vector matrix!
    290       ClpMatrixBase * matrix = modelC->clpMatrix();
    291       if (dynamic_cast< ClpPackedMatrix*>(matrix)) {
    292         ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
    293         clpMatrix->makeSpecialColumnCopy();
    294       }
    295     }
    296     modelC->tightenPrimalBounds(0.0,0,true);
    297     model->initialSolve();
    298     if (modelC->dualBound()==1.0e10) {
    299       // user did not set - so modify
    300       // get largest scaled away from bound
    301       ClpSimplex temp=*modelC;
    302       temp.dual(0,7);
    303       double largestScaled=1.0e-12;
    304       double largest=1.0e-12;
    305       int numberRows = temp.numberRows();
    306       const double * rowPrimal = temp.primalRowSolution();
    307       const double * rowLower = temp.rowLower();
    308       const double * rowUpper = temp.rowUpper();
    309       const double * rowScale = temp.rowScale();
    310       int iRow;
    311       for (iRow=0;iRow<numberRows;iRow++) {
    312         double value = rowPrimal[iRow];
    313         double above = value-rowLower[iRow];
    314         double below = rowUpper[iRow]-value;
    315         if (above<1.0e12) {
    316           largest = CoinMax(largest,above);
     285    ClpSimplex * modelC = NULL;
     286    if (si) {
     287      // get clp itself
     288      modelC = si->getModelPtr();
     289      if (stuff&&stuff[9]) {
     290        // vector matrix!
     291        ClpMatrixBase * matrix = modelC->clpMatrix();
     292        if (dynamic_cast< ClpPackedMatrix*>(matrix)) {
     293          ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
     294          clpMatrix->makeSpecialColumnCopy();
    317295        }
    318         if (below<1.0e12) {
    319           largest = CoinMax(largest,below);
     296      }
     297      modelC->tightenPrimalBounds(0.0,0,true);
     298      model->initialSolve();
     299      if (modelC->dualBound()==1.0e10) {
     300        // user did not set - so modify
     301        // get largest scaled away from bound
     302        ClpSimplex temp=*modelC;
     303        temp.dual(0,7);
     304        double largestScaled=1.0e-12;
     305        double largest=1.0e-12;
     306        int numberRows = temp.numberRows();
     307        const double * rowPrimal = temp.primalRowSolution();
     308        const double * rowLower = temp.rowLower();
     309        const double * rowUpper = temp.rowUpper();
     310        const double * rowScale = temp.rowScale();
     311        int iRow;
     312        for (iRow=0;iRow<numberRows;iRow++) {
     313          double value = rowPrimal[iRow];
     314          double above = value-rowLower[iRow];
     315          double below = rowUpper[iRow]-value;
     316          if (above<1.0e12) {
     317            largest = CoinMax(largest,above);
     318          }
     319          if (below<1.0e12) {
     320            largest = CoinMax(largest,below);
     321          }
     322          if (rowScale) {
     323            double multiplier = rowScale[iRow];
     324            above *= multiplier;
     325            below *= multiplier;
     326          }
     327          if (above<1.0e12) {
     328            largestScaled = CoinMax(largestScaled,above);
     329          }
     330          if (below<1.0e12) {
     331            largestScaled = CoinMax(largestScaled,below);
     332          }
    320333        }
    321         if (rowScale) {
    322           double multiplier = rowScale[iRow];
    323           above *= multiplier;
    324           below *= multiplier;
     334       
     335        int numberColumns = temp.numberColumns();
     336        const double * columnPrimal = temp.primalColumnSolution();
     337        const double * columnLower = temp.columnLower();
     338        const double * columnUpper = temp.columnUpper();
     339        const double * columnScale = temp.columnScale();
     340        int iColumn;
     341        for (iColumn=0;iColumn<numberColumns;iColumn++) {
     342          double value = columnPrimal[iColumn];
     343          double above = value-columnLower[iColumn];
     344          double below = columnUpper[iColumn]-value;
     345          if (above<1.0e12) {
     346            largest = CoinMax(largest,above);
     347          }
     348          if (below<1.0e12) {
     349            largest = CoinMax(largest,below);
     350          }
     351          if (columnScale) {
     352            double multiplier = 1.0/columnScale[iColumn];
     353            above *= multiplier;
     354            below *= multiplier;
     355          }
     356          if (above<1.0e12) {
     357            largestScaled = CoinMax(largestScaled,above);
     358          }
     359          if (below<1.0e12) {
     360            largestScaled = CoinMax(largestScaled,below);
     361          }
    325362        }
    326         if (above<1.0e12) {
    327           largestScaled = CoinMax(largestScaled,above);
    328         }
    329         if (below<1.0e12) {
    330           largestScaled = CoinMax(largestScaled,below);
    331         }
    332       }
    333      
    334       int numberColumns = temp.numberColumns();
    335       const double * columnPrimal = temp.primalColumnSolution();
    336       const double * columnLower = temp.columnLower();
    337       const double * columnUpper = temp.columnUpper();
    338       const double * columnScale = temp.columnScale();
    339       int iColumn;
    340       for (iColumn=0;iColumn<numberColumns;iColumn++) {
    341         double value = columnPrimal[iColumn];
    342         double above = value-columnLower[iColumn];
    343         double below = columnUpper[iColumn]-value;
    344         if (above<1.0e12) {
    345           largest = CoinMax(largest,above);
    346         }
    347         if (below<1.0e12) {
    348           largest = CoinMax(largest,below);
    349         }
    350         if (columnScale) {
    351           double multiplier = 1.0/columnScale[iColumn];
    352           above *= multiplier;
    353           below *= multiplier;
    354         }
    355         if (above<1.0e12) {
    356           largestScaled = CoinMax(largestScaled,above);
    357         }
    358         if (below<1.0e12) {
    359           largestScaled = CoinMax(largestScaled,below);
    360         }
    361       }
    362       std::cout<<"Largest (scaled) away from bound "<<largestScaled
    363                <<" unscaled "<<largest<<std::endl;
     363        std::cout<<"Largest (scaled) away from bound "<<largestScaled
     364                 <<" unscaled "<<largest<<std::endl;
    364365#if 1
    365       modelC->setDualBound(CoinMax(1.0001e8,
    366                                    CoinMin(1000.0*largestScaled,1.00001e10)));
     366        modelC->setDualBound(CoinMax(1.0001e8,
     367                                     CoinMin(1000.0*largestScaled,1.00001e10)));
    367368#else
    368       modelC->setDualBound(CoinMax(1.0001e9,
    369                                    CoinMin(1000.0*largestScaled,1.e10)));
    370 #endif
     369        modelC->setDualBound(CoinMax(1.0001e9,
     370                                     CoinMin(1000.0*largestScaled,1.e10)));
     371#endif
     372      }
    371373    }
    372374    model->setMinimumDrop(CoinMin(5.0e-2,
     
    444446      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
    445447    }
     448    if (model->getNumCols()==-10724) {
     449      // mitre
     450      std::string problemName ;
     451      model->solver()->getStrParam(OsiProbName,problemName) ;
     452      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
     453    }
    446454    if (model->getNumCols()==-1224) {
    447455      //PUSH_MPS("gesa2",1392,1224,25779856.372,25476489.678,7);
     
    451459      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
    452460    }
     461    if (model->getNumCols()==-282) {
     462      //PUSH_MPS("p0282",241,282,258411,176867.50,7);
     463      // p0282
     464      std::string problemName ;
     465      model->solver()->getStrParam(OsiProbName,problemName) ;
     466      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
     467    }
    453468    if (model->getNumCols()==-141) {
    454469      // egout
     
    482497    }
    483498    setCutAndHeuristicOptions(*model);
     499    if (si) {
    484500#ifdef CLP_MULTIPLE_FACTORIZATIONS   
    485     int denseCode = stuff ? static_cast<int> (stuff[4]) : -1;
    486     int smallCode = stuff ? static_cast<int> (stuff[10]) : -1;
    487     if (stuff&&stuff[8]>=1) {
    488       if (denseCode<0)
    489         denseCode=40;
    490       if (smallCode<0)
    491         smallCode=40;
    492     }
    493     if (denseCode>0)
    494       modelC->factorization()->setGoDenseThreshold(denseCode);
    495     if (smallCode>0)
    496       modelC->factorization()->setGoSmallThreshold(smallCode);
    497     if (denseCode>=modelC->numberRows()) {
    498       printf("problem going dense\n");
    499       //modelC->factorization()->goDenseOrSmall(modelC->numberRows());
    500     }
    501 #endif
    502     if (stuff&&stuff[8]>=1) {
    503       if (modelC->numberColumns()+modelC->numberRows()<=500&&
    504           model->fastNodeDepth()==-1)
    505         model->setFastNodeDepth(-9);
     501      int denseCode = stuff ? static_cast<int> (stuff[4]) : -1;
     502      int smallCode = stuff ? static_cast<int> (stuff[10]) : -1;
     503      if (stuff&&stuff[8]>=1) {
     504        if (denseCode<0)
     505          denseCode=40;
     506        if (smallCode<0)
     507          smallCode=40;
     508      }
     509      if (denseCode>0)
     510        modelC->factorization()->setGoDenseThreshold(denseCode);
     511      if (smallCode>0)
     512        modelC->factorization()->setGoSmallThreshold(smallCode);
     513      if (denseCode>=modelC->numberRows()) {
     514        //printf("problem going dense\n");
     515        //modelC->factorization()->goDenseOrSmall(modelC->numberRows());
     516      }
     517#endif
     518      if (stuff&&stuff[8]>=1) {
     519        if (modelC->numberColumns()+modelC->numberRows()<=500&&
     520            model->fastNodeDepth()==-1)
     521          model->setFastNodeDepth(-12);
     522      }
    506523    }
    507524    //OsiObject * obj = new CbcBranchToFixLots(model,0.3,0.0,3,3000003);
Note: See TracChangeset for help on using the changeset viewer.