Ignore:
Timestamp:
Jan 11, 2011 2:04:34 PM (9 years ago)
Author:
forrest
Message:

add some more heuristics

File:
1 edited

Legend:

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

    r1573 r1585  
    35883588                                        process.setOptions(1);
    35893589                                    // Add in generators
    3590                                     process.addCutGenerator(&generator1);
     3590                                    if ((model_.moreSpecialOptions()&65536)==0)
     3591                                      process.addCutGenerator(&generator1);
    35913592                                    int translate[] = {9999, 0, 0, -3, 2, 3, -2, 9999, 4, 5};
    35923593                                    process.passInMessageHandler(babModel_->messageHandler());
     
    36913692                                            osiclp->getModelPtr()->setPerturbation(52); // try less
    36923693#endif
     3694                                        if ((model_.moreSpecialOptions()&65536)!=0)
     3695                                          process.setOptions(2+4+8); // no cuts
    36933696                                        solver2 = process.preProcessNonDefault(*saveSolver, translate[preProcess], numberPasses,
    36943697                                                                               tunePreProcess);
     
    75057508                            // get next field
    75067509                            field = CoinReadGetString(argc, argv);
     7510                            bool append = false;
     7511                            if (field == "append$") {
     7512                              field = "$";
     7513                              append = true;
     7514                            }
    75077515                            if (field == "$") {
    75087516                                field = parameters_[iParam].stringValue();
     
    75477555                                    fileName = directory + field;
    75487556                                }
    7549                                 fp = fopen(fileName.c_str(), "w");
     7557                                if (!append)
     7558                                  fp = fopen(fileName.c_str(), "w");
     7559                                else
     7560                                  fp = fopen(fileName.c_str(), "a");
    75507561                            }
    75517562                            if (fp) {
    75527563#ifndef CBC_OTHER_SOLVER
    7553                                 if (printMode != 5) {
     7564                                if (printMode < 5) {
    75547565                                    // Write solution header (suggested by Luigi Poderico)
    75557566                                    lpSolver->computeObjectiveValue(false);
     
    77067717                                    delete [] newMasks;
    77077718                                }
     7719                                if (printMode > 5) {
     7720                                  ClpSimplex * solver = clpSolver->getModelPtr();
     7721                                  int numberColumns = solver->numberColumns();
     7722                                  // column length unless rhs ranging
     7723                                  int number = numberColumns;
     7724                                  switch (printMode) {
     7725                                    // bound ranging
     7726                                  case 6:
     7727                                    fprintf(fp,"Bound ranging");
     7728                                    break;
     7729                                    // rhs ranging
     7730                                  case 7:
     7731                                    fprintf(fp,"Rhs ranging");
     7732                                    number = numberRows;
     7733                                    break;
     7734                                    // objective ranging
     7735                                  case 8:
     7736                                    fprintf(fp,"Objective ranging");
     7737                                    break;
     7738                                  }
     7739                                  if (lengthName)
     7740                                    fprintf(fp,",name");
     7741                                  fprintf(fp,",increase,variable,decrease,variable\n");
     7742                                  int * which = new int [ number];
     7743                                  if (printMode != 7) {
     7744                                    if (!doMask) {
     7745                                      for (int i = 0; i < number;i ++)
     7746                                        which[i]=i;
     7747                                    } else {
     7748                                      int n = 0;
     7749                                      for (int i = 0; i < number;i ++) {
     7750                                        if (maskMatches(maskStarts,masks,columnNames[i]))
     7751                                          which[n++]=i;
     7752                                      }
     7753                                      if (n) {
     7754                                        number=n;
     7755                                      } else {
     7756                                        printf("No names match - doing all\n");
     7757                                        for (int i = 0; i < number;i ++)
     7758                                          which[i]=i;
     7759                                      }
     7760                                    }
     7761                                  } else {
     7762                                    if (!doMask) {
     7763                                    for (int i = 0; i < number;i ++)
     7764                                      which[i]=i+numberColumns;
     7765                                    } else {
     7766                                      int n = 0;
     7767                                      for (int i = 0; i < number;i ++) {
     7768                                        if (maskMatches(maskStarts,masks,rowNames[i]))
     7769                                          which[n++]=i+numberColumns;
     7770                                      }
     7771                                      if (n) {
     7772                                        number=n;
     7773                                      } else {
     7774                                        printf("No names match - doing all\n");
     7775                                        for (int i = 0; i < number;i ++)
     7776                                          which[i]=i+numberColumns;
     7777                                      }
     7778                                    }
     7779                                  }
     7780                                  double * valueIncrease = new double [ number];
     7781                                  int * sequenceIncrease = new int [ number];
     7782                                  double * valueDecrease = new double [ number];
     7783                                  int * sequenceDecrease = new int [ number];
     7784                                  switch (printMode) {
     7785                                    // bound or rhs ranging
     7786                                  case 6:
     7787                                  case 7:
     7788                                    solver->primalRanging(numberRows,
     7789                                                                 which, valueIncrease, sequenceIncrease,
     7790                                                                 valueDecrease, sequenceDecrease);
     7791                                    break;
     7792                                    // objective ranging
     7793                                  case 8:
     7794                                    solver->dualRanging(number,
     7795                                                               which, valueIncrease, sequenceIncrease,
     7796                                                               valueDecrease, sequenceDecrease);
     7797                                    break;
     7798                                  }
     7799                                  for (int i = 0; i < number; i++) {
     7800                                    int iWhich = which[i];
     7801                                    fprintf(fp, "%d,", (iWhich<numberColumns) ? iWhich : iWhich-numberColumns);
     7802                                    if (lengthName) {
     7803                                      const char * name = (printMode==7) ? rowNames[iWhich-numberColumns].c_str() : columnNames[iWhich].c_str();
     7804                                      fprintf(fp,"%s,",name);
     7805                                    }
     7806                                    if (valueIncrease[i]<1.0e30) {
     7807                                      fprintf(fp, "%.10g,", valueIncrease[i]);
     7808                                      int outSequence = sequenceIncrease[i];
     7809                                      if (outSequence<numberColumns) {
     7810                                        if (lengthName)
     7811                                          fprintf(fp,"%s,",columnNames[outSequence].c_str());
     7812                                        else
     7813                                          fprintf(fp,"C%7.7d,",outSequence);
     7814                                      } else {
     7815                                        outSequence -= numberColumns;
     7816                                        if (lengthName)
     7817                                          fprintf(fp,"%s,",rowNames[outSequence].c_str());
     7818                                        else
     7819                                          fprintf(fp,"R%7.7d,",outSequence);
     7820                                      }
     7821                                    } else {
     7822                                      fprintf(fp,"1.0e100,,");
     7823                                    }
     7824                                    if (valueDecrease[i]<1.0e30) {
     7825                                      fprintf(fp, "%.10g,", valueDecrease[i]);
     7826                                      int outSequence = sequenceDecrease[i];
     7827                                      if (outSequence<numberColumns) {
     7828                                        if (lengthName)
     7829                                          fprintf(fp,"%s",columnNames[outSequence].c_str());
     7830                                        else
     7831                                          fprintf(fp,"C%7.7d",outSequence);
     7832                                      } else {
     7833                                        outSequence -= numberColumns;
     7834                                        if (lengthName)
     7835                                          fprintf(fp,"%s",rowNames[outSequence].c_str());
     7836                                        else
     7837                                          fprintf(fp,"R%7.7d",outSequence);
     7838                                      }
     7839                                    } else {
     7840                                      fprintf(fp,"1.0e100,");
     7841                                    }
     7842                                    fprintf(fp,"\n");
     7843                                  }
     7844                                  if (fp != stdout)
     7845                                    fclose(fp);
     7846                                  delete [] which;
     7847                                  delete [] valueIncrease;
     7848                                  delete [] sequenceIncrease;
     7849                                  delete [] valueDecrease;
     7850                                  delete [] sequenceDecrease;
     7851                                  if (masks) {
     7852                                    delete [] maskStarts;
     7853                                    for (int i = 0; i < maxMasks; i++)
     7854                                      delete [] masks[i];
     7855                                    delete [] masks;
     7856                                  }
     7857                                  break;
     7858                                }
    77087859                                if (printMode > 2 && printMode < 5) {
    77097860                                    for (iRow = 0; iRow < numberRows; iRow++) {
     
    87368887  Source code changes so up to 2.0
    87378888*/
    8738 
    8739 
Note: See TracChangeset for help on using the changeset viewer.