Changeset 771 for trunk


Ignore:
Timestamp:
Aug 28, 2007 9:22:47 AM (12 years ago)
Author:
forrest
Message:

out printing

Location:
trunk/Cbc/src
Files:
2 edited

Legend:

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

    r719 r771  
    276276void OsiSolverLink::resolve()
    277277{
     278  if (false) {
     279    bool takeHint;
     280    OsiHintStrength strength;
     281    // Switch off printing if asked to
     282    bool gotHint = (getHintParam(OsiDoReducePrint,takeHint,strength));
     283    assert (gotHint);
     284    if (strength!=OsiHintIgnore&&takeHint) {
     285      printf("no printing\n");
     286    } else {
     287      printf("printing\n");
     288    }
     289  }
    278290  specialOptions_ =0;
    279291  modelPtr_->setWhatsChanged(0);
     
    680692                  upper[i]=upper2[i];
    681693                }
     694                qpTemp.setLogLevel(modelPtr_->logLevel());
    682695                qpTemp.primal();
    683696                assert (!qpTemp.problemStatus());
     
    12141227      element[n++]=-1.0;
    12151228      double offset = - coinModel.objectiveOffset();
    1216       assert (!offset); // get sign right if happens
     1229      //assert (!offset); // get sign right if happens
     1230      printf("***** offset %g\n",offset);
    12171231      coinModel.setObjectiveOffset(0.0);
    12181232      double lowerBound = -COIN_DBL_MAX;
  • trunk/Cbc/src/CbcSolver.cpp

    r768 r771  
    134134#include "CbcCompareActual.hpp"
    135135#include "CbcBranchActual.hpp"
     136#include "CbcBranchLotsize.hpp"
    136137#include  "CbcOrClpParam.hpp"
    137138#include  "CbcCutGenerator.hpp"
     
    496497             4 do BAB and just set best solution
    497498             -2 cleanup afterwards if using 2
    498   On ouput - number fixed
     499  On output - number fixed
    499500*/
    500501static OsiClpSolverInterface * fixVubs(CbcModel & model, int numberLevels,
    501502                                       int & doAction, CoinMessageHandler * generalMessageHandler)
    502503{
     504  double time1 = CoinCpuTime();
    503505  OsiSolverInterface * solver = model.solver()->clone();
    504506  OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
     
    507509  lpSolver->tightenPrimalBounds(0.0,11,true);
    508510  char generalPrint[200];
    509   //const double *objective = solver->getObjCoefficients() ;
     511  const double *objective = lpSolver->getObjCoefficients() ;
    510512  double *columnLower = lpSolver->columnLower() ;
    511513  double *columnUpper = lpSolver->columnUpper() ;
     
    548550  double tolerance = lpSolver->primalTolerance();
    549551  int * check = new int[numberRows];
    550   for (iRow=0;iRow<numberRows;iRow++)
    551     check[iRow]=-1;
     552  for (iRow=0;iRow<numberRows;iRow++) {
     553    check[iRow]=-2; // don't check
     554    if (rowLower[iRow]<-1.0e6&&rowUpper[iRow]>1.0e6)
     555      continue;// unlikely
     556    // possible row
     557    int numberPositive=0;
     558    int iPositive=-1;
     559    int numberNegative=0;
     560    int iNegative=-1;
     561    CoinBigIndex rStart = rowStart[iRow];
     562    CoinBigIndex rEnd = rowStart[iRow]+rowLength[iRow];
     563    CoinBigIndex j;
     564    int kColumn;
     565    for (j = rStart; j < rEnd; ++j) {
     566      double value=elementByRow[j];
     567      kColumn = column[j];
     568      if (columnUpper[kColumn]>columnLower[kColumn]) {
     569        if (value > 0.0) {
     570          numberPositive++;
     571          iPositive=kColumn;
     572        } else {
     573          numberNegative++;
     574          iNegative=kColumn;
     575        }
     576      }
     577    }
     578    if (numberPositive==1&&numberNegative==1)
     579      check[iRow]=-1; // try both
     580    if (numberPositive==1&&rowLower[iRow]>-1.0e20)
     581      check[iRow]=iPositive;
     582    else if (numberNegative==1&&rowUpper[iRow]<1.0e20)
     583      check[iRow]=iNegative;
     584  }
    552585  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    553586    fix[iColumn]=-1;
     
    564597             i<columnStart[iColumn]+columnLength[iColumn];i++) {
    565598          iRow = row[i];
    566           if (rowLower[iRow]<-1.0e6&&rowUpper[iRow]>1.0e6)
     599          if (check[iRow]!=-1&&check[iRow]!=iColumn)
    567600            continue; // unlikely
    568           //==
    569601          // possible row
    570602          int infiniteUpper = 0;
     
    801833    fixColumn2[iColumn+1]=numberOther;
    802834  }
     835  // Create other way and convert fixColumn to counts
    803836  for ( iColumn=0;iColumn<numberColumns;iColumn++) {
    804837    for (int i=fixColumn[iColumn];i<fixColumn[iColumn+1];i++) {
     
    813846  while (true) {
    814847    int numberLayered=0;
    815     int numberInteger=0;
    816848    for ( iColumn=0;iColumn<numberColumns;iColumn++) {
    817849      if (fix[iColumn]==kLayer) {
     
    819851          int jColumn=otherColumn2[i];
    820852          if (fix[jColumn]==kLayer) {
    821             fix[iColumn]=kLayer+1;
     853            fix[iColumn]=kLayer+100;
    822854          }
    823855        }
     
    825857      if (fix[iColumn]==kLayer) {
    826858        numberLayered++;
    827         if (solver->isInteger(iColumn))
    828           numberInteger++;
    829859      }
    830860    }
    831861    if (numberLayered) {
    832       printf("%d (%d integer) at priority %d\n",numberLayered,numberInteger,kLayer);
    833       kLayer++;
     862      kLayer+=100;
    834863    } else {
    835864      break;
    836865    }
    837866  }
     867  for (int iPass=0;iPass<2;iPass++) {
     868    for (int jLayer=0;jLayer<kLayer;jLayer++) {
     869      int check[]={-1,0,1,2,3,4,5,10,50,100,500,1000,5000,10000,INT_MAX};
     870      int nCheck = (int) (sizeof(check)/sizeof(int));
     871      int countsI[20];
     872      int countsC[20];
     873      assert (nCheck<=20);
     874      memset(countsI,0,nCheck*sizeof(int));
     875      memset(countsC,0,nCheck*sizeof(int));
     876      check[nCheck-1]=numberColumns;
     877      int numberLayered=0;
     878      int numberInteger=0;
     879      for ( iColumn=0;iColumn<numberColumns;iColumn++) {
     880        if (fix[iColumn]==jLayer) {
     881          numberLayered++;
     882          int nFix = fixColumn[iColumn+1]-fixColumn[iColumn];
     883          if (iPass) {
     884            // just integers
     885            nFix=0;
     886            for (int i=fixColumn[iColumn];i<fixColumn[iColumn+1];i++) {
     887              int jColumn=otherColumn[i];
     888              if (solver->isInteger(jColumn))
     889                nFix++;
     890            }
     891          }
     892          int iFix;
     893          for (iFix=0;iFix<nCheck;iFix++) {
     894            if (nFix<=check[iFix])
     895              break;
     896          }
     897          assert (iFix<nCheck);
     898          if (solver->isInteger(iColumn)) {
     899            numberInteger++;
     900            countsI[iFix]++;
     901          } else {
     902            countsC[iFix]++;
     903          }
     904        }
     905      }
     906      if (numberLayered) {
     907        printf("%d (%d integer) at priority %d\n",numberLayered,numberInteger,1+(jLayer/100));
     908        char buffer[50];
     909        for (int i=1;i<nCheck;i++) {
     910          if (countsI[i]||countsC[i]) {
     911            if (i==1)
     912              sprintf(buffer," ==    zero            ");
     913            else if (i<nCheck-1)
     914              sprintf(buffer,"> %6d and <= %6d ",check[i-1],check[i]);
     915            else
     916              sprintf(buffer,"> %6d                ",check[i-1]);
     917            printf("%s %8d integers and %8d continuous\n",buffer,countsI[i],countsC[i]);
     918          }
     919        }
     920      }
     921    }
     922  }
    838923  delete [] counts;
    839   delete [] fixColumn;
    840   delete [] otherColumn;
    841924  delete [] otherColumn2;
    842925  delete [] fixColumn2;
    843926  // Now do fixing
     927  {
     928    // switch off presolve and up weight
     929    ClpSolve solveOptions;
     930    //solveOptions.setPresolveType(ClpSolve::presolveOff,0);
     931    solveOptions.setSolveType(ClpSolve::usePrimalorSprint);
     932    //solveOptions.setSpecialOption(1,3,30); // sprint
     933    int numberColumns = lpSolver->numberColumns();
     934    int iColumn;
     935    bool allSlack=true;
     936    for (iColumn=0;iColumn<numberColumns;iColumn++) {
     937      if (lpSolver->getColumnStatus(iColumn)==ClpSimplex::basic) {
     938        allSlack=false;
     939        break;
     940      }
     941    }
     942    if (allSlack)
     943      solveOptions.setSpecialOption(1,2,50); // idiot
     944    lpSolver->setInfeasibilityCost(1.0e11);
     945    lpSolver->defaultFactorizationFrequency();
     946    lpSolver->initialSolve(solveOptions);
     947    double * columnLower = lpSolver->columnLower();
     948    double * columnUpper = lpSolver->columnUpper();
     949    double * fullSolution = lpSolver->primalColumnSolution();
     950    const double * dj = lpSolver->dualColumnSolution();
     951    // First squash small and fix big
     952    //double small=1.0e-7;
     953    //double djTol=20.0;
     954    int iPass=0;
     955#define MAXPROB 3
     956    ClpSimplex models[MAXPROB];
     957    int pass[MAXPROB];
     958    int kPass=-1;
     959    int kLayer=0;
     960    while (true) {
     961      double largest=-0.1;
     962      double smallest=1.1;
     963      int iLargest=-1;
     964      int iSmallest=-1;
     965      int atZero=0;
     966      int atOne=0;
     967      int toZero=0;
     968      int toOne=0;
     969      int numberFree=0;
     970      int numberGreater=0;
     971      columnLower = lpSolver->columnLower();
     972      columnUpper = lpSolver->columnUpper();
     973      fullSolution = lpSolver->primalColumnSolution();
     974      for ( iColumn=0;iColumn<numberColumns;iColumn++) {
     975        if (!solver->isInteger(iColumn)||fix[iColumn]>kLayer)
     976          continue;
     977        double value = fullSolution[iColumn];
     978        if (value>1.00001) {
     979          numberGreater++;
     980          continue;
     981        }
     982        double lower = columnLower[iColumn];
     983        double upper = columnUpper[iColumn];
     984        if (lower==upper) {
     985          if (lower)
     986            atOne++;
     987          else
     988            atZero++;
     989          continue;
     990        }
     991        if (value<1.0e-7) {
     992          toZero++;
     993          columnUpper[iColumn]=0.0;
     994          continue;
     995        }
     996        if (value>1.0-1.0e-7) {
     997          toOne++;
     998          columnLower[iColumn]=1.0;
     999          continue;
     1000        }
     1001        numberFree++;
     1002        if (value<smallest) {
     1003          smallest=value;
     1004          iSmallest=iColumn;
     1005        }
     1006        if (value>largest) {
     1007          largest=value;
     1008          iLargest=iColumn;
     1009        }
     1010      }
     1011      if (toZero||toOne)
     1012        printf("%d at 0 fixed and %d at one fixed\n",toZero,toOne);
     1013      printf("%d variables free, %d fixed to 0, %d to 1 - smallest %g, largest %g\n",
     1014             numberFree,atZero,atOne,smallest,largest);
     1015      if (numberGreater&&!iPass)
     1016        printf("%d variables have value > 1.0\n",numberGreater);
     1017      int jLayer=0;
     1018      int nFixed=-1;
     1019      int nTotalFixed=0;
     1020      while (nFixed) {
     1021        nFixed=0;
     1022        for ( iColumn=0;iColumn<numberColumns;iColumn++) {
     1023          if (columnUpper[iColumn]==0.0&&fix[iColumn]==jLayer) {
     1024            for (int i=fixColumn[iColumn];i<fixColumn[iColumn+1];i++) {
     1025              int jColumn=otherColumn[i];
     1026              columnUpper[jColumn]=0.0;
     1027              nFixed++;
     1028            }
     1029          }
     1030        }
     1031        nTotalFixed += nFixed;
     1032        jLayer++;
     1033      }
     1034      printf("This fixes %d variables in lower priorities\n",nTotalFixed);
     1035      if (iLargest<0)
     1036        break;
     1037      double movement;
     1038      int way;
     1039      if (smallest<=1.0-largest&&smallest<0.2) {
     1040        columnUpper[iSmallest]=0.0;
     1041        movement=smallest;
     1042        way=-1;
     1043      } else {
     1044        columnLower[iLargest]=1.0;
     1045        movement=1.0-largest;
     1046        way=1;
     1047      }
     1048      double saveObj = lpSolver->objectiveValue();
     1049      iPass++;
     1050      kPass = iPass%MAXPROB;
     1051      models[kPass]=*lpSolver;
     1052      pass[kPass]=iPass;
     1053      double maxCostUp = COIN_DBL_MAX;
     1054      if (way==-1)
     1055        maxCostUp= (1.0-movement)*objective[iSmallest];
     1056      lpSolver->setDualObjectiveLimit(saveObj+maxCostUp);
     1057      lpSolver->dual();
     1058      double moveObj = lpSolver->objectiveValue()-saveObj;
     1059      printf("movement %s was %g costing %g\n",
     1060             (smallest<=1.0-largest) ? "down" : "up",movement,moveObj);
     1061      if (way==-1&&(moveObj>=(1.0-movement)*objective[iSmallest]||lpSolver->status())) {
     1062        // go up
     1063        columnLower = models[kPass].columnLower();
     1064        columnUpper = models[kPass].columnUpper();
     1065        columnLower[iSmallest]=1.0;
     1066        columnUpper[iSmallest]=lpSolver->columnUpper()[iSmallest];
     1067        *lpSolver=models[kPass];
     1068        columnLower = lpSolver->columnLower();
     1069        columnUpper = lpSolver->columnUpper();
     1070        fullSolution = lpSolver->primalColumnSolution();
     1071        dj = lpSolver->dualColumnSolution();
     1072        columnLower[iSmallest]=1.0;
     1073        columnUpper[iSmallest]=lpSolver->columnUpper()[iSmallest];
     1074        lpSolver->dual();
     1075      }
     1076      models[kPass]=*lpSolver;
     1077    }
     1078  }
     1079  printf("Fixing took %g seconds\n",CoinCpuTime()-time1);
    8441080  delete [] fix;
     1081  delete [] fixColumn;
     1082  delete [] otherColumn;
    8451083  delete solver;
    8461084  return NULL;
     
    21852423        // need some relative granularity
    21862424        si->setDefaultBound(100.0);
    2187         si->setDefaultMeshSize(0.001);
     2425        double dextra3 = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
     2426        if (dextra3)
     2427          si->setDefaultMeshSize(dextra3);
    21882428        si->setDefaultBound(100000.0);
    21892429        si->setIntegerPriority(1000);
     
    33503590#endif
    33513591            } else {
     3592#ifndef DISALLOW_PRINTING
    33523593              std::cout<<"** Current model not valid"<<std::endl;
     3594#endif
    33533595            }
    33543596            break;
     
    33863628                delete model2;
    33873629            } else {
     3630#ifndef DISALLOW_PRINTING
    33883631              std::cout<<"** Current model not valid"<<std::endl;
     3632#endif
    33893633            }
    33903634            break;
     
    33953639                std::cout<<"** Analysis indicates model infeasible"<<std::endl;
    33963640            } else {
     3641#ifndef DISALLOW_PRINTING
    33973642              std::cout<<"** Current model not valid"<<std::endl;
     3643#endif
    33983644            }
    33993645            break;
     
    34163662              }
    34173663            } else {
     3664#ifndef DISALLOW_PRINTING
    34183665              std::cout<<"** Current model not valid"<<std::endl;
     3666#endif
    34193667            }
    34203668            break;
     
    34323680                <<CoinMessageEol;
    34333681            } else {
     3682#ifndef DISALLOW_PRINTING
    34343683              std::cout<<"** Current model not valid"<<std::endl;
     3684#endif
    34353685            }
    34363686            break;
     
    34533703              }
    34543704            } else {
     3705#ifndef DISALLOW_PRINTING
    34553706              std::cout<<"** Current model not valid"<<std::endl;
     3707#endif
    34563708            }
    34573709            break;
     
    34823734            goodModel=true;
    34833735/*
    3484   Run branch-and-cut. First set a few options -- node comparison, scaling. If
    3485   the solver is Clp, consider running some presolve code (not yet converted
    3486   this to generic OSI) with branch-and-cut. If presolve is disabled, or the
    3487   solver is not Clp, simply run branch-and-cut. Print elapsed time at the end.
     3736  Run branch-and-cut. First set a few options -- node comparison, scaling.
     3737  Print elapsed time at the end.
    34883738*/
    34893739          case BAB: // branchAndBound
     
    35223772                    // need some relative granularity
    35233773                    si->setDefaultBound(100.0);
    3524                     si->setDefaultMeshSize(0.001);
     3774                    double dextra3 = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
     3775                    if (dextra3)
     3776                      si->setDefaultMeshSize(dextra3);
    35253777                    si->setDefaultBound(1000.0);
    35263778                    si->setIntegerPriority(1000);
     
    36503902                      cbcModel->initialSolve();
    36513903                      if (clpModel->tightenPrimalBounds()!=0) {
     3904#ifndef DISALLOW_PRINTING
    36523905                        std::cout<<"Problem is infeasible - tightenPrimalBounds!"<<std::endl;
    3653                         exit(1);
     3906#endif
     3907                        break;
    36543908                      }
    36553909                      clpModel->dual();  // clean up
     
    37544008                }
    37554009                if (!complicatedInteger&&clpSolver->tightenPrimalBounds()!=0) {
     4010#ifndef DISALLOW_PRINTING
    37564011                  std::cout<<"Problem is infeasible - tightenPrimalBounds!"<<std::endl;
    3757                   exit(1);
     4012#endif
     4013                  model.setProblemStatus(0);
     4014                  model.setSecondaryStatus(1);
     4015                  // and in babModel if exists
     4016                  if (babModel) {
     4017                    babModel->setProblemStatus(0);
     4018                    babModel->setSecondaryStatus(1);
     4019                  }
     4020                  break;
    37584021                }
    37594022                if (clpSolver->dualBound()==1.0e10) {
     
    38254088                if (tightenFactor&&!complicatedInteger) {
    38264089                  if (modelC->tightenPrimalBounds(tightenFactor)!=0) {
     4090#ifndef DISALLOW_PRINTING
    38274091                    std::cout<<"Problem is infeasible!"<<std::endl;
     4092#endif
     4093                    model.setProblemStatus(0);
     4094                    model.setSecondaryStatus(1);
     4095                    // and in babModel if exists
     4096                    if (babModel) {
     4097                      babModel->setProblemStatus(0);
     4098                      babModel->setSecondaryStatus(1);
     4099                    }
    38284100                    break;
    38294101                  }
     
    39734245                          prohibited[iColumn]=1;
    39744246                        }
     4247                      }
     4248                      CbcLotsize * obj2 =
     4249                        dynamic_cast <CbcLotsize *>(oldObjects[iObj]) ;
     4250                      if (obj2) {
     4251                        int iColumn = obj2->columnNumber();
     4252                        prohibited[iColumn]=1;
    39754253                      }
    39764254                    }
     
    40894367                //modelC->setLogLevel(0);
    40904368                if (!complicatedInteger&&modelC->tightenPrimalBounds()!=0) {
     4369#ifndef DISALLOW_PRINTING
    40914370                  std::cout<<"Problem is infeasible!"<<std::endl;
     4371#endif
     4372                  model.setProblemStatus(0);
     4373                  model.setSecondaryStatus(1);
     4374                  // and in babModel if exists
     4375                  if (babModel) {
     4376                    babModel->setProblemStatus(0);
     4377                    babModel->setSecondaryStatus(1);
     4378                  }
    40924379                  break;
    40934380                }
     
    49825269                      serendipity.setHeuristicName("linked");
    49835270                      babModel->addHeuristic(&serendipity);
     5271                      double dextra3 = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
     5272                      if (dextra3)
     5273                        solver3->setMeshSizes(dextra3);
    49845274                      int options = parameters[whichParam(MIPOPTIONS,numberParameters,parameters)].intValue()/10000;
    49855275                      CglStored stored;
     
    56035893              //babModel=NULL;
    56045894            } else {
     5895#ifndef DISALLOW_PRINTING
    56055896              std::cout << "** Current model not valid" << std::endl ;
     5897#endif
    56065898            }
    56075899            break ;
     
    58436135                // need some relative granularity
    58446136                si->setDefaultBound(100.0);
    5845                 si->setDefaultMeshSize(0.001);
     6137                double dextra3 = parameters[whichParam(DEXTRA3,numberParameters,parameters)].doubleValue();
     6138                if (dextra3)
     6139                  si->setDefaultMeshSize(dextra3);
    58466140                si->setDefaultBound(100.0);
    58476141                si->setIntegerPriority(1000);
     
    59986292              }
    59996293            } else {
     6294#ifndef DISALLOW_PRINTING
    60006295              std::cout<<"** Current model not valid"<<std::endl;
     6296#endif
    60016297            }
    60026298            break;
     
    60536349              }
    60546350            } else {
     6351#ifndef DISALLOW_PRINTING
    60556352              std::cout<<"** Current model not valid"<<std::endl;
     6353#endif
    60566354            }
    60576355            break;
     
    63246622              }
    63256623            } else {
     6624#ifndef DISALLOW_PRINTING
    63266625              std::cout<<"** Current model not valid"<<std::endl;
     6626#endif
    63276627            }
    63286628            break;
     
    63806680              }
    63816681            } else {
     6682#ifndef DISALLOW_PRINTING
    63826683              std::cout<<"** Current model not valid"<<std::endl;
     6684#endif
    63836685            }
    63846686            break;
     
    64396741              }
    64406742            } else {
     6743#ifndef DISALLOW_PRINTING
    64416744              std::cout<<"** Current model not valid"<<std::endl;
     6745#endif
    64426746            }
    64436747            break;
     
    71127416              }
    71137417            } else {
     7418#ifndef DISALLOW_PRINTING
    71147419              std::cout<<"** Current model not valid"<<std::endl;
    7115              
     7420#endif
    71167421            }
    71177422            break;
     
    71457450              saveSolution(lpSolver,fileName);
    71467451            } else {
     7452#ifndef DISALLOW_PRINTING
    71477453              std::cout<<"** Current model not valid"<<std::endl;
    7148              
     7454#endif
    71497455            }
    71507456            break;
Note: See TracChangeset for help on using the changeset viewer.