Ignore:
Timestamp:
Jun 9, 2006 10:05:41 PM (14 years ago)
Author:
ladanyi
Message:

finishing conversion to svn

File:
1 edited

Legend:

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

    r355 r356  
    6464#include "CglMixedIntegerRounding2.hpp"
    6565#include "CglTwomir.hpp"
     66#include "CglDuplicateRow.hpp"
    6667
    6768#include "CbcModel.hpp"
     
    8485static double totalTime=0.0;
    8586static void statistics(ClpSimplex * originalModel, ClpSimplex * model);
    86 static bool maskMatches(std::string & mask, std::string & check);
     87static bool maskMatches(const int * starts, char ** masks,
     88                        std::string & check);
     89static void generateCode(const char * fileName,int type,int preProcess);
    8790//#############################################################################
    8891
     
    402405  }
    403406}
     407static int outDupRow(OsiSolverInterface * solver)
     408{
     409  CglDuplicateRow dupCuts(solver);
     410  CglTreeInfo info;
     411  info.level = 0;
     412  info.pass = 0;
     413  int numberRows = solver->getNumRows();
     414  info.formulation_rows = numberRows;
     415  info.inTree = false;
     416  info.strengthenRow= NULL;
     417  info.pass = 0;
     418  OsiCuts cs;
     419  dupCuts.generateCuts(*solver,cs,info);
     420  const int * duplicate = dupCuts.duplicate();
     421  // Get rid of duplicate rows
     422  int * which = new int[numberRows];
     423  int numberDrop=0;
     424  for (int iRow=0;iRow<numberRows;iRow++) {
     425    if (duplicate[iRow]==-2||duplicate[iRow]>=0)
     426      which[numberDrop++]=iRow;
     427  }
     428  if (numberDrop) {
     429    solver->deleteRows(numberDrop,which);
     430  }
     431  delete [] which;
     432  // see if we have any column cuts
     433  int numberColumnCuts = cs.sizeColCuts() ;
     434  const double * columnLower = solver->getColLower();
     435  const double * columnUpper = solver->getColUpper();
     436  for (int k = 0;k<numberColumnCuts;k++) {
     437    OsiColCut * thisCut = cs.colCutPtr(k) ;
     438    const CoinPackedVector & lbs = thisCut->lbs() ;
     439    const CoinPackedVector & ubs = thisCut->ubs() ;
     440    int j ;
     441    int n ;
     442    const int * which ;
     443    const double * values ;
     444    n = lbs.getNumElements() ;
     445    which = lbs.getIndices() ;
     446    values = lbs.getElements() ;
     447    for (j = 0;j<n;j++) {
     448      int iColumn = which[j] ;
     449      if (values[j]>columnLower[iColumn])
     450        solver->setColLower(iColumn,values[j]) ;
     451    }
     452    n = ubs.getNumElements() ;
     453    which = ubs.getIndices() ;
     454    values = ubs.getElements() ;
     455    for (j = 0;j<n;j++) {
     456      int iColumn = which[j] ;
     457      if (values[j]<columnUpper[iColumn])
     458        solver->setColUpper(iColumn,values[j]) ;
     459    }
     460  }
     461  return numberDrop;
     462}
    404463int main (int argc, const char *argv[])
    405464{
     
    430489    double * pseudoDown=NULL;
    431490    double * pseudoUp=NULL;
     491    double * solutionIn = NULL;
     492    int * prioritiesIn = NULL;
    432493#ifdef CBC_AMPL
    433494    ampl_info info;
     
    495556    int outputFormat=2;
    496557    int slpValue=-1;
     558    int cppValue=-1;
    497559    int printOptions=0;
    498560    int printMode=0;
     
    506568    int preSolve=5;
    507569    int preProcess=4;
     570    bool useStrategy=false;
    508571    bool preSolveFile=false;
    509572   
     
    581644    parameters[whichParam(CUTSSTRATEGY,numberParameters,parameters)].setCurrentOption("on");
    582645    parameters[whichParam(HEURISTICSTRATEGY,numberParameters,parameters)].setCurrentOption("on");
     646    int doSOS=1;
    583647    int verbose=0;
    584648    CglGomory gomoryGen;
     
    655719    bool useLocalTree=false;
    656720    parameters[whichParam(COSTSTRATEGY,numberParameters,parameters)].setCurrentOption("off");
    657     bool useCosts=false;
     721    int useCosts=0;
     722    // don't use input solution
     723    int useSolution=0;
    658724   
    659725    // total number of commands read
     
    746812        }
    747813        if (type==GENERALQUERY) {
     814          bool evenHidden=false;
     815          if ((verbose&8)!=0) {
     816            // even hidden
     817            evenHidden = true;
     818            verbose &= ~8;
     819          }
    748820#ifdef CBC_AMPL
    749821          if (verbose<4&&usingAmpl)
     
    787859            for ( iParam=0; iParam<numberParameters; iParam++ ) {
    788860              int type = parameters[iParam].type();
    789               if (parameters[iParam].displayThis()&&type>=limits[iType]
     861              if ((parameters[iParam].displayThis()||evenHidden)&&
     862                  type>=limits[iType]
    790863                  &&type<limits[iType+1]) {
    791864                // but skip if not useful for ampl (and in ampl mode)
     
    903976              else if (parameters[iParam].type()==SLPVALUE)
    904977                slpValue = value;
     978              else if (parameters[iParam].type()==CPP)
     979                cppValue = value;
    905980              else if (parameters[iParam].type()==PRESOLVEOPTIONS)
    906981                presolveOptions = value;
     
    10611136              crossover=action;
    10621137              break;
     1138            case SOS:
     1139              doSOS=action;
     1140              break;
    10631141            case GOMORYCUTS:
    10641142              defaultSettings=false; // user knows what she is doing
     
    11461224              break;
    11471225            case COSTSTRATEGY:
    1148               if (action!=1&&action!=0) {
    1149                 printf("Pseudo costs not implemented yet\n");
    1150               } else {
    1151                 useCosts=action;
    1152               }
     1226              useCosts=action;
    11531227              break;
    11541228            case PREPROCESS:
    11551229              preProcess = action;
     1230              break;
     1231            case USESOLUTION:
     1232              useSolution = action;
    11561233              break;
    11571234            default:
     
    14511528            }
    14521529            break;
     1530          case OUTDUPROWS:
     1531            if (goodModel) {
     1532              int nOut = outDupRow(clpSolver);
     1533              if (nOut&&!noPrinting)
     1534                printf("%d rows eliminated\n",nOut);
     1535            } else {
     1536              std::cout<<"** Current model not valid"<<std::endl;
     1537            }
     1538            break;
    14531539          case NETWORK:
    14541540            if (goodModel) {
     
    14971583                si->setSpecialOptions(0x40000000);
    14981584              }
    1499               if (!miplib)
     1585              if (!miplib) {
    15001586                model.initialSolve();
     1587                OsiSolverInterface * solver = model.solver();
     1588                OsiClpSolverInterface * si =
     1589                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
     1590                if (si->getModelPtr()->tightenPrimalBounds()!=0) {
     1591                  std::cout<<"Problem is infeasible - tightenPrimalBounds!"<<std::endl;
     1592                  exit(1);
     1593                }
     1594                si->getModelPtr()->dual();  // clean up
     1595              }
    15011596              // If user made settings then use them
    15021597              if (!defaultSettings) {
     
    15841679              time1 = time2;
    15851680              double timeLeft = babModel->getMaximumSeconds();
     1681              int numberOriginalColumns = babModel->solver()->getNumCols();
     1682#ifdef CBC_AMPL
     1683              if (usingAmpl&&info.numberSos&&doSOS) {
     1684                // SOS
     1685                assert (!preProcess); // do later
     1686                int numberSOS = info.numberSos;
     1687                int numberIntegers = babModel->numberIntegers();
     1688                int numberColumns = babModel->getNumCols();
     1689                /* model may not have created objects
     1690                   If none then create
     1691                */
     1692                if (!numberIntegers||!babModel->numberObjects()) {
     1693                  int type = (pseudoUp) ? 1 : 0;
     1694                  babModel->findIntegers(true,type);
     1695                  numberIntegers = babModel->numberIntegers();
     1696                }
     1697                // Do sets and priorities
     1698                CbcObject ** objects = new CbcObject * [numberSOS];
     1699                const int * starts = info.sosStart;
     1700                const int * which = info.sosIndices;
     1701                const char * type = info.sosType;
     1702                const double * weight = info.sosReference;
     1703                // see if any priorities
     1704                int i;
     1705                bool gotPriorities=false;
     1706                int * priorities=info.priorities;
     1707                if (priorities) {
     1708                  for (i=0;i<numberColumns;i++) {
     1709                    if (priorities[i]) {
     1710                      gotPriorities=true;
     1711                      break;
     1712                    }
     1713                  }
     1714                }
     1715                priorities=info.sosPriority;
     1716                if (priorities) {
     1717                  for (i=0;i<numberSOS;i++) {
     1718                    if (priorities[i]) {
     1719                      gotPriorities=true;
     1720                      break;
     1721                    }
     1722                  }
     1723                }
     1724                int iSOS;
     1725                for (iSOS =0;iSOS<numberSOS;iSOS++) {
     1726                  int iStart = starts[iSOS];
     1727                  int n=starts[iSOS+1]-iStart;
     1728                  objects[iSOS] = new CbcSOS(babModel,n,which+iStart,weight+iStart,
     1729                                             iSOS,type[iSOS]);
     1730                  // higher for set
     1731                  objects[iSOS]->setPriority(10);
     1732                  if (gotPriorities&&info.sosPriority&&info.sosPriority[iSOS])
     1733                    objects[iSOS]->setPriority(info.sosPriority[iSOS]);
     1734                }
     1735                babModel->addObjects(numberSOS,objects);
     1736                for (iSOS=0;iSOS<numberSOS;iSOS++)
     1737                  delete objects[iSOS];
     1738                delete [] objects;
     1739              }
     1740#endif
     1741              if (preProcess==6) {
     1742                // use strategy instead
     1743                preProcess=0;
     1744                useStrategy=true;
     1745              }
    15861746              if (preProcess&&type==BAB) {
    15871747                saveSolver=babModel->solver()->clone();
     
    16791839                  if (babModel->isInteger(iColumn)) {
    16801840                    sort[n]=n;
    1681                     dsort[n++]=-objective[iColumn];
     1841                    if (useCosts==1)
     1842                      dsort[n++]=-objective[iColumn];
     1843                    else
     1844                      dsort[n++]=iColumn;
    16821845                  }
    16831846                }
     
    18792042                  pseudoDown=info.pseudoDown;
    18802043                  pseudoUp=info.pseudoUp;
     2044                  solutionIn=info.primalSolution;
     2045                  prioritiesIn = info.priorities;
    18812046                }
    18822047#endif               
    1883                 const int * originalColumns = NULL;
    1884                 if (preProcess)
    1885                   originalColumns = process.originalColumns();
     2048                const int * originalColumns = preProcess ? process.originalColumns() : NULL;
     2049                if (solutionIn&&useSolution) {
     2050                  if (preProcess) {
     2051                    int numberColumns = babModel->getNumCols();
     2052                    // extend arrays in case SOS
     2053                    int n = originalColumns[numberColumns-1]+1;
     2054                    int nSmaller = CoinMin(n,numberOriginalColumns);
     2055                    double * solutionIn2 = new double [n];
     2056                    int * prioritiesIn2 = new int[n];
     2057                    int i;
     2058                    for (i=0;i<nSmaller;i++) {
     2059                      solutionIn2[i]=solutionIn[i];
     2060                      prioritiesIn2[i]=prioritiesIn[i];
     2061                    }
     2062                    for (;i<n;i++) {
     2063                      solutionIn2[i]=0.0;
     2064                      prioritiesIn2[i]=1000000;
     2065                    }
     2066                    int iLast=-1;
     2067                    for (i=0;i<numberColumns;i++) {
     2068                      int iColumn = originalColumns[i];
     2069                      assert (iColumn>iLast);
     2070                      iLast=iColumn;
     2071                      solutionIn2[i]=solutionIn2[iColumn];
     2072                      if (prioritiesIn)
     2073                        prioritiesIn2[i]=prioritiesIn2[iColumn];
     2074                    }
     2075                    babModel->setHotstartSolution(solutionIn2,prioritiesIn2);
     2076                    delete [] solutionIn2;
     2077                    delete [] prioritiesIn2;
     2078                  } else {
     2079                    babModel->setHotstartSolution(solutionIn,prioritiesIn);
     2080                  }
     2081                }
    18862082                if (preProcess&&process.numberSOS()) {
    18872083                  int numberSOS = process.numberSOS();
     
    19052101                    int iColumn = oldObjects[iObj]->columnNumber();
    19062102                    assert (iColumn>=0);
     2103                    if (iColumn>=numberOriginalColumns)
     2104                      continue;
    19072105                    if (originalColumns)
    19082106                      iColumn = originalColumns[iColumn];
     
    19132111                        dynamic_cast <CbcSimpleIntegerPseudoCost *>(oldObjects[iObj]) ;
    19142112                      assert (obj1a);
    1915                       obj1a->setDownPseudoCost(pseudoDown[iColumn]);
    1916                       obj1a->setUpPseudoCost(pseudoUp[iColumn]);
     2113                      if (pseudoDown[iColumn]>0.0)
     2114                        obj1a->setDownPseudoCost(pseudoDown[iColumn]);
     2115                      if (pseudoUp[iColumn]>0.0)
     2116                        obj1a->setUpPseudoCost(pseudoUp[iColumn]);
    19172117                    }
    19182118                  }
     
    19472147                  int numberObjects = babModel->numberObjects();
    19482148                  for (int iObj = 0;iObj<numberObjects;iObj++) {
     2149                    // skip sos
     2150                    CbcSOS * objSOS =
     2151                      dynamic_cast <CbcSOS *>(objects[iObj]) ;
     2152                    if (objSOS)
     2153                      continue;
    19492154                    int iColumn = objects[iObj]->columnNumber();
    19502155                    assert (iColumn>=0);
     
    19622167                        dynamic_cast <CbcSimpleIntegerPseudoCost *>(objects[iObj]) ;
    19632168                      assert (obj1a);
    1964                       obj1a->setDownPseudoCost(pseudoDown[iColumn]);
    1965                       obj1a->setUpPseudoCost(pseudoUp[iColumn]);
     2169                      if (pseudoDown[iColumn]>0.0)
     2170                        obj1a->setDownPseudoCost(pseudoDown[iColumn]);
     2171                      if (pseudoUp[iColumn]>0.0)
     2172                        obj1a->setUpPseudoCost(pseudoUp[iColumn]);
    19662173                    }
    19672174                  }
    19682175                }
     2176                int statistics = (printOptions>0) ? printOptions: 0;
    19692177#ifdef CBC_AMPL
    19702178                if (!usingAmpl) {
     
    19782186                  free(pseudoUp);
    19792187                  pseudoUp=NULL;
     2188                  free(solutionIn);
     2189                  solutionIn=NULL;
     2190                  free(prioritiesIn);
     2191                  prioritiesIn=NULL;
    19802192#ifdef CBC_AMPL
    19812193                }
    19822194#endif               
    1983                 int statistics = (printOptions>0) ? printOptions: 0;
     2195                if (cppValue>=0) {
     2196                  int prepro = useStrategy ? -1 : preProcess;
     2197                  // generate code
     2198                  FILE * fp = fopen("user_driver.cpp","w");
     2199                  if (fp) {
     2200                    // generate enough to do BAB
     2201                    babModel->generateCpp(fp,1);
     2202                    OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     2203                    // Make general so do factorization
     2204                    int factor = osiclp->getModelPtr()->factorizationFrequency();
     2205                    osiclp->getModelPtr()->setFactorizationFrequency(200);
     2206                    osiclp->generateCpp(fp);
     2207                    osiclp->getModelPtr()->setFactorizationFrequency(factor);
     2208                    //solveOptions.generateCpp(fp);
     2209                    fclose(fp);
     2210                    // now call generate code
     2211                    generateCode("user_driver.cpp",cppValue,prepro);
     2212                  } else {
     2213                    std::cout<<"Unable to open file user_driver.cpp"<<std::endl;
     2214                  }
     2215                }
     2216                if (useStrategy) {
     2217                  CbcStrategyDefault strategy(true,5,5);
     2218                  strategy.setupPreProcessing(1);
     2219                  babModel->setStrategy(strategy);
     2220                }
    19842221                babModel->branchAndBound(statistics);
    19852222              } else if (type==MIPLIB) {
     
    21472384                free(pseudoUp);
    21482385                pseudoUp=NULL;
     2386                free(solutionIn);
     2387                solutionIn=NULL;
     2388                free(prioritiesIn);
     2389                prioritiesIn=NULL;
    21492390#ifdef CBC_AMPL
    21502391              }
     
    24812722              if (fp) {
    24822723                // can open - lets go for it
    2483                 std::string headings[]={"name","number","direction","priority","up","down"};
    2484                 int order[]={-1,-1,-1,-1,-1,-1};
     2724                std::string headings[]={"name","number","direction","priority","up","down",
     2725                                        "solution","priin"};
     2726                int got[]={-1,-1,-1,-1,-1,-1,-1,-1};
     2727                int order[8];
     2728                assert(sizeof(got)==sizeof(order));
    24852729                int nAcross=0;
    24862730                char line[1000];
     
    24962740                      put++;
    24972741                    }
     2742                    pos++;
    24982743                  }
    24992744                  *put='\0';
     
    25052750                    if (comma)
    25062751                      *comma='\0';
    2507                     for (i=0;i<(int) (sizeof(order)/sizeof(int));i++) {
     2752                    for (i=0;i<(int) (sizeof(got)/sizeof(int));i++) {
    25082753                      if (headings[i]==pos) {
    2509                         if (order[i]<0) {
    2510                           order[i]=nAcross++;
     2754                        if (got[i]<0) {
     2755                          order[nAcross]=i;
     2756                          got[i]=nAcross++;
    25112757                        } else {
    25122758                          // duplicate
     
    25162762                      }
    25172763                    }
    2518                     if (i==(int) (sizeof(order)/sizeof(int)))
     2764                    if (i==(int) (sizeof(got)/sizeof(int)))
    25192765                      good=false;
    25202766                    if (comma) {
     
    25252771                    }
    25262772                  }
    2527                   if (order[0]<0&&order[1]<0)
     2773                  if (got[0]<0&&got[1]<0)
    25282774                    good=false;
    2529                   if (order[0]>=0&&order[1]>=0)
     2775                  if (got[0]>=0&&got[1]>=0)
    25302776                    good=false;
    2531                   if (order[0]>=0&&!lpSolver->lengthNames())
     2777                  if (got[0]>=0&&!lpSolver->lengthNames())
    25322778                    good=false;
    25332779                  if (good) {
     
    25372783                    branchDirection = (int *) malloc(numberColumns*sizeof(int));
    25382784                    priorities= (int *) malloc(numberColumns*sizeof(int));
     2785                    free(solutionIn);
     2786                    solutionIn=NULL;
     2787                    free(prioritiesIn);
     2788                    prioritiesIn=NULL;
    25392789                    int iColumn;
     2790                    if (got[6]>=0) {
     2791                      solutionIn = (double *) malloc(numberColumns*sizeof(double));
     2792                      CoinZeroN(solutionIn,numberColumns);
     2793                    }
     2794                    if (got[7]>=0) {
     2795                      prioritiesIn = (int *) malloc(numberColumns*sizeof(int));
     2796                      for (iColumn=0;iColumn<numberColumns;iColumn++)
     2797                        prioritiesIn[iColumn]=10000;
     2798                    }
    25402799                    for (iColumn=0;iColumn<numberColumns;iColumn++) {
    25412800                      columnNames[iColumn] =
     
    25592818                      int pri=0;
    25602819                      int dir=0;
     2820                      double solValue=COIN_DBL_MAX;
     2821                      int priValue=1000000;
    25612822                      char * pos = line;
    25622823                      char * put = line;
     
    25662827                          put++;
    25672828                        }
     2829                        pos++;
    25682830                      }
    25692831                      *put='\0';
     
    26222884                          down = atof(pos);
    26232885                          break;
     2886                          // sol value
     2887                        case 6:
     2888                          solValue = atof(pos);
     2889                          break;
     2890                          // priority in value
     2891                        case 7:
     2892                          priValue = atoi(pos);
     2893                          break;
    26242894                        }
    26252895                        if (comma) {
     
    26532923                        branchDirection[iColumn]=dir;
    26542924                        priorities[iColumn]=pri;
     2925                        if (solValue!=COIN_DBL_MAX) {
     2926                          assert (solutionIn);
     2927                          solutionIn[iColumn]=solValue;
     2928                        }
     2929                        if (priValue!=1000000) {
     2930                          assert (prioritiesIn);
     2931                          prioritiesIn[iColumn]=priValue;
     2932                        }
    26552933                      } else {
    26562934                        nBadName++;
     
    30793357            }
    30803358            break;
     3359          case USERCLP:
     3360            // Replace the sample code by whatever you want
     3361            if (goodModel) {
     3362              printf("Dummy user clp code - model has %d rows and %d columns\n",
     3363                     lpSolver->numberRows(),lpSolver->numberColumns());
     3364            }
     3365            break;
     3366          case USERCBC:
     3367            // Replace the sample code by whatever you want
     3368            if (goodModel) {
     3369              printf("Dummy user cbc code - model has %d rows and %d columns\n",
     3370                     model.getNumRows(),model.getNumCols());
     3371  // Reduce printout
     3372  //solver1.setHintParam(OsiDoReducePrint,true,OsiHintTry);
     3373  OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (model.solver());
     3374  // go faster stripes
     3375  if (osiclp&&0) {
     3376    // Turn this off if you get problems
     3377    // Used to be automatically set
     3378    osiclp->setSpecialOptions(128);
     3379    if(osiclp->getNumRows()<300&&osiclp->getNumCols()<500) {
     3380      //osiclp->setupForRepeatedUse(2,0);
     3381      osiclp->setupForRepeatedUse(0,0);
     3382    }
     3383  }
     3384  // Allow rounding heuristic
     3385
     3386  CbcRounding heuristic1(model);
     3387  model.addHeuristic(&heuristic1);
     3388
     3389  // Do initial solve to continuous
     3390  ClpPrimalColumnSteepest steepest(5);
     3391  osiclp->getModelPtr()->setPrimalColumnPivotAlgorithm(steepest);
     3392  osiclp->getModelPtr()->setPerturbation(50);
     3393  osiclp->getModelPtr()->setInfeasibilityCost(1.0e9);
     3394  osiclp->setHintParam(OsiDoPresolveInInitial,false,OsiHintTry);
     3395  osiclp->setHintParam(OsiDoDualInInitial,false,OsiHintTry);
     3396  //osiclp->setHintParam(OsiDoDualInResolve,false,OsiHintTry);
     3397  model.setSpecialOptions(model.specialOptions()|4);
     3398  osiclp->getModelPtr()->defaultFactorizationFrequency();
     3399  {
     3400    ClpSimplex * clp = osiclp->getModelPtr();
     3401    // fix integers to 1
     3402    int numberColumns = clp->numberColumns();
     3403    double * lower = clp->columnLower();
     3404    int i;
     3405    for (i=0;i<numberColumns;i++) {
     3406      if (osiclp->isInteger(i))
     3407        lower[i]=1.0;
     3408    }
     3409    clp->primal();
     3410    double objValue = clp->objectiveValue();
     3411    osiclp->setDblParam(OsiDualObjectiveLimit,objValue+1.0e-4);
     3412    // unfix integers
     3413    for (i=0;i<numberColumns;i++) {
     3414      if (osiclp->isInteger(i))
     3415        lower[i]=0.0;
     3416    }
     3417    clp->primal();
     3418    //clp->dual();
     3419    int nArt=0;
     3420    int nFixed0=0,nFixed1=0;
     3421    double gap=objValue-clp->objectiveValue();
     3422    // for those at one fix anyway
     3423    double gap2=1.0;
     3424    const double * solution = clp->primalColumnSolution();
     3425    const double * dj = clp->dualColumnSolution();
     3426    const double * objective = clp->objective();
     3427    double * upper = clp->columnUpper();
     3428    for (i=0;i<numberColumns;i++) {
     3429      if (objective[i]>1.0e5&&solution[i]>1.0e-8)
     3430        nArt++;
     3431      if (osiclp->isInteger(i)) {
     3432        if(dj[i]>gap+1.0e-4) {
     3433          nFixed0++;
     3434          upper[i]=0.0;
     3435        }
     3436        if(-dj[i]>gap2+1.0e-4) {
     3437          nFixed1++;
     3438        lower[i]=1.0;
     3439        }
     3440      }
     3441    }
     3442    printf("%d artificials, %d fixed to 0, %d fixed to 1\n",nArt,nFixed0,nFixed1);
     3443    //osiclp->getModelPtr()->setPerturbation(100);
     3444    osiclp->setWarmStart(NULL); // set basis in osiclp
     3445  }
     3446  osiclp->initialSolve();
     3447
     3448  // Switch off strong branching if wanted
     3449  // model.setNumberStrong(0);
     3450  // Do more strong branching if small
     3451  model.setNumberStrong(0);
     3452  model.setNumberBeforeTrust(0);
     3453
     3454  // TEMP - set gap - better to see if no improvement in last few nodes
     3455  model.setAllowableGap(600.0);
     3456  // message levels
     3457  model.messageHandler()->setLogLevel(2);
     3458  model.solver()->messageHandler()->setLogLevel(2);
     3459  // Do complete search
     3460 
     3461  model.branchAndBound();
     3462            }
     3463            break;
    30813464          case HELP:
    30823465            std::cout<<"Coin Solver version "<<CBCVERSION
     
    31463529                sprintf(format,"%%-%ds",CoinMax(lengthName,8));
    31473530                bool doMask = (printMask!=""&&lengthName);
     3531                int * maskStarts=NULL;
     3532                int maxMasks=0;
     3533                char ** masks =NULL;
     3534                if (doMask) {
     3535                  int nAst =0;
     3536                  const char * pMask2 = printMask.c_str();
     3537                  char pMask[100];
     3538                  int iChar;
     3539                  int lengthMask = strlen(pMask2);
     3540                  assert (lengthMask<100);
     3541                  if (*pMask2=='"') {
     3542                    if (pMask2[lengthMask-1]!='"') {
     3543                      printf("mismatched \" in mask %s\n",pMask2);
     3544                      break;
     3545                    } else {
     3546                      strcpy(pMask,pMask2+1);
     3547                      *strchr(pMask,'"')='\0';
     3548                    }
     3549                  } else if (*pMask2=='\'') {
     3550                    if (pMask2[lengthMask-1]!='\'') {
     3551                      printf("mismatched ' in mask %s\n",pMask2);
     3552                      break;
     3553                    } else {
     3554                      strcpy(pMask,pMask2+1);
     3555                      *strchr(pMask,'\'')='\0';
     3556                    }
     3557                  } else {
     3558                    strcpy(pMask,pMask2);
     3559                  }
     3560                  if (lengthMask>lengthName) {
     3561                    printf("mask %s too long - skipping\n",pMask);
     3562                    break;
     3563                  }
     3564                  maxMasks = 1;
     3565                  for (iChar=0;iChar<lengthMask;iChar++) {
     3566                    if (pMask[iChar]=='*') {
     3567                      nAst++;
     3568                      maxMasks *= (lengthName+1);
     3569                    }
     3570                  }
     3571                  int nEntries = 1;
     3572                  maskStarts = new int[lengthName+2];
     3573                  masks = new char * [maxMasks];
     3574                  char ** newMasks = new char * [maxMasks];
     3575                  int i;
     3576                  for (i=0;i<maxMasks;i++) {
     3577                    masks[i] = new char[lengthName+1];
     3578                    newMasks[i] = new char[lengthName+1];
     3579                  }
     3580                  strcpy(masks[0],pMask);
     3581                  for (int iAst=0;iAst<nAst;iAst++) {
     3582                    int nOldEntries = nEntries;
     3583                    nEntries=0;
     3584                    for (int iEntry = 0;iEntry<nOldEntries;iEntry++) {
     3585                      char * oldMask = masks[iEntry];
     3586                      char * ast = strchr(oldMask,'*');
     3587                      assert (ast);
     3588                      int length = strlen(oldMask)-1;
     3589                      int nBefore = ast-oldMask;
     3590                      int nAfter = length-nBefore;
     3591                      // and add null
     3592                      nAfter++;
     3593                      for (int i=0;i<=lengthName-length;i++) {
     3594                        char * maskOut = newMasks[nEntries];
     3595                        memcpy(maskOut,oldMask,nBefore);
     3596                        for (int k=0;k<i;k++)
     3597                          maskOut[k+nBefore]='?';
     3598                        memcpy(maskOut+nBefore+i,ast+1,nAfter);
     3599                        nEntries++;
     3600                        assert (nEntries<=maxMasks);
     3601                      }
     3602                    }
     3603                    char ** temp = masks;
     3604                    masks = newMasks;
     3605                    newMasks = temp;
     3606                  }
     3607                  // Now extend and sort
     3608                  int * sort = new int[nEntries];
     3609                  for (i=0;i<nEntries;i++) {
     3610                    char * maskThis = masks[i];
     3611                    int length = strlen(maskThis);
     3612                    while (maskThis[length-1]==' ')
     3613                      length--;
     3614                    maskThis[length]='\0';
     3615                    sort[i]=length;
     3616                  }
     3617                  CoinSort_2(sort,sort+nEntries,masks);
     3618                  int lastLength=-1;
     3619                  for (i=0;i<nEntries;i++) {
     3620                    int length = sort[i];
     3621                    while (length>lastLength)
     3622                      maskStarts[++lastLength] = i;
     3623                  }
     3624                  maskStarts[++lastLength]=nEntries;
     3625                  delete [] sort;
     3626                  for (i=0;i<maxMasks;i++)
     3627                    delete [] newMasks[i];
     3628                  delete [] newMasks;
     3629                }
    31483630                if (printMode>2) {
    31493631                  for (iRow=0;iRow<numberRows;iRow++) {
     
    31583640                      type=3;
    31593641                    }
    3160                     if (doMask&&!maskMatches(printMask,rowNames[iRow]))
     3642                    if (doMask&&!maskMatches(maskStarts,masks,rowNames[iRow]))
    31613643                      type =0;
    31623644                    if (type) {
     
    31933675                         &&printMode==1)
    31943676                      type=0;
    3195                     if (doMask&&!maskMatches(printMask,columnNames[iColumn]))
     3677                    if (doMask&&!maskMatches(maskStarts,masks,
     3678                                             columnNames[iColumn]))
    31963679                      type =0;
    31973680                    if (type) {
     
    32523735                if (fp!=stdout)
    32533736                  fclose(fp);
     3737                if (masks) {
     3738                  delete [] maskStarts;
     3739                  for (int i=0;i<maxMasks;i++)
     3740                    delete [] masks[i];
     3741                  delete [] masks;
     3742                }
    32543743              } else {
    32553744                std::cout<<"Unable to open file "<<fileName<<std::endl;
     
    36384127  breakdown("Objective",numberColumns,objective);
    36394128}
    3640 static bool maskMatches(std::string & mask, std::string & check)
     4129static bool maskMatches(const int * starts, char ** masks,
     4130                        std::string & check)
    36414131{
    36424132  // back to char as I am old fashioned
    3643   const char * maskC = mask.c_str();
    36444133  const char * checkC = check.c_str();
    3645   int length = strlen(maskC);
    3646   int lengthCheck;
    3647   for (lengthCheck=length-1;lengthCheck>=0;lengthCheck--) {
    3648     if (maskC[lengthCheck]!='*')
    3649       break;
     4134  int length = strlen(checkC);
     4135  while (checkC[length-1]==' ')
     4136    length--;
     4137  for (int i=starts[length];i<starts[length+1];i++) {
     4138    char * thisMask = masks[i];
     4139    int k;
     4140    for ( k=0;k<length;k++) {
     4141      if (thisMask[k]!='?'&&thisMask[k]!=checkC[k])
     4142        break;
     4143    }
     4144    if (k==length)
     4145      return true;
    36504146  }
    3651   lengthCheck++;
    3652   int lengthC = strlen(checkC);
    3653   if (lengthC>length)
    3654     return false; // can't be true
    3655   if (lengthC<lengthCheck) {
    3656     // last lot must be blank for match
    3657     for (int i=lengthC;i<lengthCheck;i++) {
    3658       if (maskC[i]!=' ')
    3659         return false;
     4147  return false;
     4148}
     4149static void clean(char * temp)
     4150{
     4151  char * put = temp;
     4152  while (*put>=' ')
     4153    put++;
     4154  *put='\0';
     4155}
     4156static void generateCode(const char * fileName,int type,int preProcess)
     4157{
     4158  // options on code generation
     4159  bool sizecode = (type&4)!=0;
     4160  type &= 3;
     4161  FILE * fp = fopen(fileName,"r");
     4162  assert (fp);
     4163  int numberLines=0;
     4164#define MAXLINES 5000
     4165#define MAXONELINE 200
     4166  char line[MAXLINES][MAXONELINE];
     4167  strcpy(line[numberLines++],"0#if defined(_MSC_VER)");
     4168  strcpy(line[numberLines++],"0// Turn off compiler warning about long names");
     4169  strcpy(line[numberLines++],"0#  pragma warning(disable:4786)");
     4170  strcpy(line[numberLines++],"0#endif\n");
     4171  strcpy(line[numberLines++],"0#include <cassert>");
     4172  strcpy(line[numberLines++],"0#include <iomanip>");
     4173  strcpy(line[numberLines++],"0#include \"OsiClpSolverInterface.hpp\"");
     4174  strcpy(line[numberLines++],"0#include \"CbcModel.hpp\"");
     4175  strcpy(line[numberLines++],"0#include \"CbcCutGenerator.hpp\"");
     4176  strcpy(line[numberLines++],"0#include \"CbcStrategy.hpp\"");
     4177  strcpy(line[numberLines++],"0#include \"CglPreProcess.hpp\"");
     4178  strcpy(line[numberLines++],"0#include \"CoinTime.hpp\"");
     4179  while (fgets(line[numberLines],MAXONELINE,fp)) {
     4180    assert (numberLines<MAXLINES);
     4181    clean(line[numberLines]);
     4182    numberLines++;
     4183  }
     4184  fclose(fp);
     4185  strcpy(line[numberLines++],"0\nint main (int argc, const char *argv[])\n{");
     4186  strcpy(line[numberLines++],"0  OsiClpSolverInterface solver1;");
     4187  strcpy(line[numberLines++],"0  int status=1;");
     4188  strcpy(line[numberLines++],"0  if (argc<2)");
     4189  strcpy(line[numberLines++],"0    std::cout<<\"Please give file name\"<<std::endl;");
     4190  strcpy(line[numberLines++],"0  else");
     4191  strcpy(line[numberLines++],"0    status=solver1.readMps(argv[1],\"\");");
     4192  strcpy(line[numberLines++],"0  if (status) {");
     4193  strcpy(line[numberLines++],"0    std::cout<<\"Bad readMps \"<<argv[1]<<std::endl;");
     4194  strcpy(line[numberLines++],"0    exit(1);");
     4195  strcpy(line[numberLines++],"0  }\n");
     4196  strcpy(line[numberLines++],"0  double time1 = CoinCpuTime();");
     4197  strcpy(line[numberLines++],"0  CbcModel model(solver1);");
     4198  strcpy(line[numberLines++],"0  // Now do requested saves and modifications");
     4199  strcpy(line[numberLines++],"0  CbcModel * cbcModel = & model;");
     4200  strcpy(line[numberLines++],"0  OsiSolverInterface * osiModel = model.solver();");
     4201  strcpy(line[numberLines++],"0  OsiClpSolverInterface * osiclpModel = dynamic_cast< OsiClpSolverInterface*> (osiModel);");
     4202  strcpy(line[numberLines++],"0  ClpSimplex * clpModel = osiclpModel->getModelPtr();");
     4203  // add in comments about messages
     4204  strcpy(line[numberLines++],"3  // You can save some time by switching off message building");
     4205  strcpy(line[numberLines++],"3  // clpModel->messagesPointer()->setDetailMessages(100,10000,(int *) NULL);");
     4206  strcpy(line[numberLines++],"5  cbcModel->initialSolve();");
     4207  strcpy(line[numberLines++],"5  if (clpModel->tightenPrimalBounds()!=0) {");
     4208  strcpy(line[numberLines++],"5    std::cout<<\"Problem is infeasible - tightenPrimalBounds!\"<<std::endl;");
     4209  strcpy(line[numberLines++],"5    exit(1);");
     4210  strcpy(line[numberLines++],"5  }");
     4211  strcpy(line[numberLines++],"5  clpModel->dual();  // clean up");
     4212  if (sizecode) {
     4213    // override some settings
     4214    strcpy(line[numberLines++],"5  // compute some things using problem size");
     4215    strcpy(line[numberLines++],"5  cbcModel->setMinimumDrop(min(5.0e-2,");
     4216    strcpy(line[numberLines++],"5       fabs(cbcModel->getMinimizationObjValue())*1.0e-3+1.0e-4));");
     4217    strcpy(line[numberLines++],"5  if (cbcModel->getNumCols()<500)");
     4218    strcpy(line[numberLines++],"5    cbcModel->setMaximumCutPassesAtRoot(-100); // always do 100 if possible");
     4219    strcpy(line[numberLines++],"5  else if (cbcModel->getNumCols()<5000)");
     4220    strcpy(line[numberLines++],"5    cbcModel->setMaximumCutPassesAtRoot(100); // use minimum drop");
     4221    strcpy(line[numberLines++],"5  else");
     4222    strcpy(line[numberLines++],"5    cbcModel->setMaximumCutPassesAtRoot(20);");
     4223    strcpy(line[numberLines++],"5  cbcModel->setMaximumCutPasses(1);");
     4224  }
     4225  if (preProcess<=0) {
     4226    // no preprocessing or strategy
     4227    if (preProcess) {
     4228      strcpy(line[numberLines++],"5  // Preprocessing using CbcStrategy");
     4229      strcpy(line[numberLines++],"5  CbcStrategyDefault strategy(true,5,5);");
     4230      strcpy(line[numberLines++],"5  strategy.setupPreProcessing(1);");
     4231      strcpy(line[numberLines++],"5  cbcModel->setStrategy(strategy);");
     4232    }
     4233  } else {
     4234    int translate[]={9999,0,0,-1,2,3};
     4235    strcpy(line[numberLines++],"5  // Hand coded preprocessing");
     4236    strcpy(line[numberLines++],"5  CglPreProcess process;");
     4237    strcpy(line[numberLines++],"5  OsiSolverInterface * saveSolver=cbcModel->solver()->clone();");
     4238    strcpy(line[numberLines++],"5  // Tell solver we are in Branch and Cut");
     4239    strcpy(line[numberLines++],"5  saveSolver->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo) ;");
     4240    strcpy(line[numberLines++],"5  // Default set of cut generators");
     4241    strcpy(line[numberLines++],"5  CglProbing generator1;");
     4242    strcpy(line[numberLines++],"5  generator1.setUsingObjective(true);");
     4243    strcpy(line[numberLines++],"5  generator1.setMaxPass(3);");
     4244    strcpy(line[numberLines++],"5  generator1.setMaxProbeRoot(saveSolver->getNumCols());");
     4245    strcpy(line[numberLines++],"5  generator1.setMaxElements(100);");
     4246    strcpy(line[numberLines++],"5  generator1.setMaxLookRoot(50);");
     4247    strcpy(line[numberLines++],"5  generator1.setRowCuts(3);");
     4248    strcpy(line[numberLines++],"5  // Add in generators");
     4249    strcpy(line[numberLines++],"5  process.addCutGenerator(&generator1);");
     4250    strcpy(line[numberLines++],"5  process.messageHandler()->setLogLevel(cbcModel->logLevel());");
     4251    strcpy(line[numberLines++],"5  OsiSolverInterface * solver2 = ");
     4252    sprintf(line[numberLines++],"5    process.preProcessNonDefault(*saveSolver,%d,10);",translate[preProcess]);
     4253    strcpy(line[numberLines++],"5  // Tell solver we are not in Branch and Cut");
     4254    strcpy(line[numberLines++],"5  saveSolver->setHintParam(OsiDoInBranchAndCut,false,OsiHintDo) ;");
     4255    strcpy(line[numberLines++],"5  if (solver2)");
     4256    strcpy(line[numberLines++],"5    solver2->setHintParam(OsiDoInBranchAndCut,false,OsiHintDo) ;");
     4257    strcpy(line[numberLines++],"5  if (!solver2) {");
     4258    strcpy(line[numberLines++],"5    std::cout<<\"Pre-processing says infeasible!\"<<std::endl;");
     4259    strcpy(line[numberLines++],"5    exit(1);");
     4260    strcpy(line[numberLines++],"5  } else {");
     4261    strcpy(line[numberLines++],"5    std::cout<<\"processed model has \"<<solver2->getNumRows()");
     4262    strcpy(line[numberLines++],"5            <<\" rows, \"<<solver2->getNumCols()");
     4263    strcpy(line[numberLines++],"5            <<\" and \"<<solver2->getNumElements()<<std::endl;");
     4264    strcpy(line[numberLines++],"5  }");
     4265    strcpy(line[numberLines++],"5  // we have to keep solver2 so pass clone");
     4266    strcpy(line[numberLines++],"5  solver2 = solver2->clone();");
     4267    strcpy(line[numberLines++],"5  cbcModel->assignSolver(solver2);");
     4268    strcpy(line[numberLines++],"5  cbcModel->initialSolve();");
     4269  }
     4270  // add in actual solve
     4271  strcpy(line[numberLines++],"5  cbcModel->branchAndBound();");
     4272  strcpy(line[numberLines++],"8  std::cout<<argv[1]<<\" took \"<<CoinCpuTime()-time1<<\" seconds, \"");
     4273  strcpy(line[numberLines++],"8    <<cbcModel->getNodeCount()<<\" nodes with objective \"");
     4274  strcpy(line[numberLines++],"8    <<cbcModel->getObjValue()");
     4275  strcpy(line[numberLines++],"8    <<(!cbcModel->status() ? \" Finished\" : \" Not finished\")");
     4276  strcpy(line[numberLines++],"8    <<std::endl;");
     4277  strcpy(line[numberLines++],"5  // For best solution");
     4278  strcpy(line[numberLines++],"5  int numberColumns = solver1.getNumCols();");
     4279  strcpy(line[numberLines++],"5  if (cbcModel->getMinimizationObjValue()<1.0e50) {");
     4280  if (preProcess>0) {
     4281    strcpy(line[numberLines++],"5    // post process");
     4282    strcpy(line[numberLines++],"5    process.postProcess(*cbcModel->solver());");
     4283    strcpy(line[numberLines++],"5    // Solution now back in saveSolver");
     4284    strcpy(line[numberLines++],"5    cbcModel->assignSolver(saveSolver);");
     4285    strcpy(line[numberLines++],"5    memcpy(cbcModel->bestSolution(),cbcModel->solver()->getColSolution(),");
     4286    strcpy(line[numberLines++],"5          numberColumns*sizeof(double));");
     4287  }
     4288  strcpy(line[numberLines++],"5    // put back in original solver");
     4289  strcpy(line[numberLines++],"5    solver1.setColSolution(cbcModel->bestSolution());");
     4290  strcpy(line[numberLines++],"5    const double * solution = solver1.getColSolution();");
     4291  strcpy(line[numberLines++],"8  \n  // Now you would use solution etc etc\n");
     4292  strcpy(line[numberLines++],"5");
     4293  strcpy(line[numberLines++],"5    // Get names from solver1 (as OsiSolverInterface may lose)");
     4294  strcpy(line[numberLines++],"5    std::vector<std::string> columnNames = *solver1.getModelPtr()->columnNames();");
     4295  strcpy(line[numberLines++],"5    ");
     4296  strcpy(line[numberLines++],"5    int iColumn;");
     4297  strcpy(line[numberLines++],"5    std::cout<<std::setiosflags(std::ios::fixed|std::ios::showpoint)<<std::setw(14);");
     4298  strcpy(line[numberLines++],"5    ");
     4299  strcpy(line[numberLines++],"5    std::cout<<\"--------------------------------------\"<<std::endl;");
     4300  strcpy(line[numberLines++],"5    for (iColumn=0;iColumn<numberColumns;iColumn++) {");
     4301  strcpy(line[numberLines++],"5      double value=solution[iColumn];");
     4302  strcpy(line[numberLines++],"5      if (fabs(value)>1.0e-7&&solver1.isInteger(iColumn)) ");
     4303  strcpy(line[numberLines++],"5 std::cout<<std::setw(6)<<iColumn<<\" \"");
     4304  strcpy(line[numberLines++],"5                 <<columnNames[iColumn]<<\" \"");
     4305  strcpy(line[numberLines++],"5                 <<value<<std::endl;");
     4306  strcpy(line[numberLines++],"5    }");
     4307  strcpy(line[numberLines++],"5    std::cout<<\"--------------------------------------\"<<std::endl;");
     4308  strcpy(line[numberLines++],"5  ");
     4309  strcpy(line[numberLines++],"5    std::cout<<std::resetiosflags(std::ios::fixed|std::ios::showpoint|std::ios::scientific);");
     4310  strcpy(line[numberLines++],"5  }");
     4311  strcpy(line[numberLines++],"8  return 0;\n}");
     4312  fp = fopen(fileName,"w");
     4313  assert (fp);
     4314
     4315  int wanted[9];
     4316  memset(wanted,0,sizeof(wanted));
     4317  wanted[0]=wanted[3]=wanted[5]=wanted[8]=1;
     4318  if (type>0)
     4319    wanted[1]=wanted[6]=1;
     4320  if (type>1)
     4321    wanted[2]=wanted[4]=wanted[7]=1;
     4322  std::string header[9]=
     4323  { "","Save values","Redundant save of default values","Set changed values",
     4324    "Redundant set default values","Solve","Restore values","Redundant restore values","Add to model"};
     4325  for (int iType=0;iType<9;iType++) {
     4326    if (!wanted[iType])
     4327      continue;
     4328    int n=0;
     4329    int iLine;
     4330    for (iLine=0;iLine<numberLines;iLine++) {
     4331      if (line[iLine][0]=='0'+iType) {
     4332        if (!n&&header[iType]!="")
     4333          fprintf(fp,"\n  // %s\n\n",header[iType].c_str());
     4334        n++;
     4335        // skip save and clp as cloned
     4336        if (!strstr(line[iLine],"save")||(!strstr(line[iLine],"clpMo")&&
     4337                                          !strstr(line[iLine],"_Osi")))
     4338          fprintf(fp,"%s\n",line[iLine]+1);
     4339      }
    36604340    }
    36614341  }
    3662   // need only check this much
    3663   lengthC = CoinMin(lengthC,lengthCheck);
    3664   for (int i=0;i<lengthC;i++) {
    3665     if (maskC[i]!='*'&&maskC[i]!=checkC[i])
    3666       return false;
    3667   }
    3668   return true; // matches
     4342  fclose(fp);
     4343  printf("C++ file written to %s\n",fileName);
    36694344}
    36704345/*
Note: See TracChangeset for help on using the changeset viewer.