Changes from releases/2.8.12 at r2347 to releases/2.8.13 at r2347


Ignore:
Location:
releases/2.8.13
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • releases/2.8.13/Cbc/configure

    r2347 r2347  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.59 for Cbc 2.8.12.
     3# Generated by GNU Autoconf 2.59 for Cbc 2.8.13.
    44#
    55# Report bugs to <cbc@lists.coin-or.org>.
     
    430430PACKAGE_NAME='Cbc'
    431431PACKAGE_TARNAME='cbc'
    432 PACKAGE_VERSION='2.8.12'
    433 PACKAGE_STRING='Cbc 2.8.12'
     432PACKAGE_VERSION='2.8.13'
     433PACKAGE_STRING='Cbc 2.8.13'
    434434PACKAGE_BUGREPORT='cbc@lists.coin-or.org'
    435435
     
    10061006  # This message is too long to be a string in the A/UX 3.1 sh.
    10071007  cat <<_ACEOF
    1008 \`configure' configures Cbc 2.8.12 to adapt to many kinds of systems.
     1008\`configure' configures Cbc 2.8.13 to adapt to many kinds of systems.
    10091009
    10101010Usage: $0 [OPTION]... [VAR=VALUE]...
     
    10721072if test -n "$ac_init_help"; then
    10731073  case $ac_init_help in
    1074      short | recursive ) echo "Configuration of Cbc 2.8.12:";;
     1074     short | recursive ) echo "Configuration of Cbc 2.8.13:";;
    10751075   esac
    10761076  cat <<\_ACEOF
     
    13061306if $ac_init_version; then
    13071307  cat <<\_ACEOF
    1308 Cbc configure 2.8.12
     1308Cbc configure 2.8.13
    13091309generated by GNU Autoconf 2.59
    13101310
     
    13261326running configure, to aid debugging if configure makes a mistake.
    13271327
    1328 It was created by Cbc $as_me 2.8.12, which was
     1328It was created by Cbc $as_me 2.8.13, which was
    13291329generated by GNU Autoconf 2.59.  Invocation command line was
    13301330
     
    18521852
    18531853# Capture libtool library version, if given.
    1854  coin_libversion=11:12:8
     1854 coin_libversion=11:13:8
    18551855
    18561856
     
    20932093             fi
    20942094             ;;
    2095   *-*-darwin*) comps="clang gcc" ;;
     2095  *-*-darwin*) comps="clang gcc cc" ;;
    20962096  *-linux-gnu*) comps="gcc cc pgcc icc xlc" ;;
    20972097  *-linux-*) comps="xlc gcc cc pgcc icc" ;;
     
    32503250  *-*-solaris*)
    32513251             comps="CC xlC_r aCC g++ c++ pgCC icpc gpp cxx cc++ cl FCC KCC RCC" ;;
    3252   *-darwin*) comps="g++ c++ CC" ;;
     3252  *-darwin*) comps="clang++ g++ c++ CC" ;;
    32533253  *-linux-gnu*)
    32543254             comps="g++ c++ pgCC icpc gpp cxx cc++ cl FCC KCC RCC xlC_r aCC CC" ;;
     
    36873687# It seems that we need to cleanup something here for the Windows
    36883688case "$CXX" in
    3689   clang* ) ;;
     3689  clang* | */clang*) ;;
    36903690  cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
    36913691    sed -e 's/^void exit (int);//' confdefs.h >> confdefs.hh
     
    45754575# Define the identity of the package.
    45764576 PACKAGE='cbc'
    4577  VERSION='2.8.12'
     4577 VERSION='2.8.13'
    45784578
    45794579
     
    3114531145cat >&5 <<_CSEOF
    3114631146
    31147 This file was extended by Cbc $as_me 2.8.12, which was
     31147This file was extended by Cbc $as_me 2.8.13, which was
    3114831148generated by GNU Autoconf 2.59.  Invocation command line was
    3114931149
     
    3120831208cat >>$CONFIG_STATUS <<_ACEOF
    3120931209ac_cs_version="\\
    31210 Cbc config.status 2.8.12
     31210Cbc config.status 2.8.13
    3121131211configured by $0, generated by GNU Autoconf 2.59,
    3121231212  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
  • releases/2.8.13/Cbc/configure.ac

    r2347 r2347  
    1313AC_PREREQ(2.59)
    1414
    15 AC_INIT([Cbc],[2.8.12],[cbc@lists.coin-or.org])
     15AC_INIT([Cbc],[2.8.13],[cbc@lists.coin-or.org])
    1616
    1717AC_COPYRIGHT([
     
    4242# externals.  The following macro ensures that those externals are
    4343# retrieved by svn if they are not there yet.
    44 AC_COIN_PROJECTDIR_INIT(Cbc,11:12:8)
     44AC_COIN_PROJECTDIR_INIT(Cbc,11:13:8)
    4545
    4646# Check if user wants to produce debugging code
  • releases/2.8.13/Cbc/src/CbcHeuristicRENS.cpp

    r2347 r2347  
    3333    whereFrom_ = 256 + 1;
    3434}
    35 
    3635// Constructor with model - assumed before cuts
    3736
     
    8786    int returnCode = 0;
    8887    const double * bestSolution = model_->bestSolution();
     88    bool returnNow=false;
    8989    if ((numberTries_&&(rensType_&16)==0) || numberTries_>1 || (when() < 2 && bestSolution))
     90      returnNow=true;;
     91    // If 32 bit set then do once with bestSolution
     92    if ((rensType_&32)!=0&&bestSolution)
     93      returnNow=false;
     94    if (returnNow)
    9095        return 0;
     96    // switch off next time if bestSolution
     97    if (bestSolution) {
     98      if ((rensType_&32)!=0)
     99        rensType_ &= ~32; // switch off but leave bestSolution
     100      else
     101        bestSolution=NULL; // null bestSolution so won't use
     102    }
    91103    numberTries_++;
     104#ifdef HEURISTIC_INFORM
     105    printf("Entering heuristic %s - nRuns %d numCould %d when %d\n",
     106           heuristicName(),numRuns_,numCouldRun_,when_);
     107#endif
    92108    double saveFractionSmall=fractionSmall_;
    93109    OsiSolverInterface * solver = model_->solver();
     
    736752    int numberAtBound = 0;
    737753    int numberContinuous = numberColumns - numberIntegers;
    738 
     754    /*
     755      0 - allow fixing
     756      1 - don't allow fixing
     757     */
     758    char * marked = new char [numberColumns];
     759    memset(marked,0,numberColumns);
     760    if (bestSolution) {
     761      for (i = 0; i < numberIntegers; i++) {
     762        int iColumn = integerVariable[i];
     763        double value = currentSolution[iColumn];
     764        double lower = colLower[iColumn];
     765        double upper = colUpper[iColumn];
     766        value = CoinMax(value, lower);
     767        value = CoinMin(value, upper);
     768        if (fabs(bestSolution[iColumn]-value)>0.999)
     769          marked[iColumn]=1;
     770      }
     771    }
     772    if ((rensType_&(64|128))!=0&&model_->objects()) {
     773      int lowPriority=-COIN_INT_MAX;
     774      int highPriority=COIN_INT_MAX;
     775      for (i = 0; i < numberIntegers; i++) {
     776        int priority=model_->priority(i);
     777        lowPriority=CoinMax(lowPriority,priority);
     778        highPriority=CoinMin(highPriority,priority);
     779      }
     780      if (highPriority<lowPriority) {
     781        int keepPriority=((rensType_&64)!=0) ? highPriority : lowPriority;
     782        for (i = 0; i < numberIntegers; i++) {
     783          int iColumn = integerVariable[i];
     784          int priority=model_->priority(i);
     785          if (priority==keepPriority)
     786            marked[iColumn]=1;
     787        }
     788      }
     789    }
    739790    for (i = 0; i < numberIntegers; i++) {
    740791        int iColumn = integerVariable[i];
     
    745796        value = CoinMin(value, upper);
    746797        double djValue=dj[iColumn]*direction;
     798        bool dontFix=marked[iColumn]!=0;
    747799#define RENS_FIX_ONLY_LOWER
    748800#ifndef RENS_FIX_ONLY_LOWER
    749801        if (fabs(value - floor(value + 0.5)) < 1.0e-8) {
    750802            value = floor(value + 0.5);
     803            if (dontFix) {
     804              continue;
     805            }
    751806            if (value == lower || value == upper)
    752807                numberAtBound++;
     
    763818                floor(value + 0.5) == lower &&
    764819            djValue > djTolerance ) {
     820            if (dontFix) {
     821              continue;
     822            }
    765823          value = floor(value + 0.5);
    766824          numberAtBound++;
     
    772830                   -djValue > djTolerance && (djTolerance > 0.0||type==2)) {
    773831          value = floor(value + 0.5);
     832            if (dontFix) {
     833              continue;
     834            }
    774835          numberAtBound++;
    775836          newSolver->setColLower(iColumn, value);
     
    794855#endif
    795856    }
     857    delete [] marked;
    796858    delete [] dj;
    797859    if (numberFixed > numberIntegers / 5) {
  • releases/2.8.13/Cbc/src/CbcHeuristicRENS.hpp

    r2347 r2347  
    6767        3 - fix on 0.01*average dj
    6868        add 16 to allow two tries
     69        32 - if solution exists use to keep more variables
     70        64 - if priorities keep high priority
     71        128 - if priorities keep low priority
    6972    */
    7073    int rensType_;
  • releases/2.8.13/Cbc/src/CbcModel.cpp

    r2347 r2347  
    16351635    dblParam_[CbcLargestChange] = 0.0;
    16361636    intParam_[CbcNumberBranches] = 0;
     1637    // when to check for restart
     1638    int nextCheckRestart=50;
    16371639    // Force minimization !!!!
    16381640    bool flipObjective = (solver_->getObjSense()<0.0);
     
    27612763    */
    27622764    int iObject ;
    2763     int preferredWay ;
    27642765    int numberUnsatisfied = 0 ;
    27652766    delete [] currentSolution_;
     
    27732774    for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
    27742775        double infeasibility =
    2775             object_[iObject]->infeasibility(&usefulInfo, preferredWay) ;
     2776            object_[iObject]->checkInfeasibility(&usefulInfo) ;
    27762777        if (infeasibility ) numberUnsatisfied++ ;
    27772778    }
     
    28522853                  //rowCut.addCuts(globalCuts_);
    28532854                  int nTightened=0;
    2854                   bool feasible=true;
     2855                  assert (feasible);
    28552856                  {
    28562857                    double tolerance=1.0e-5;
     
    28602861                      if (tightBounds[2*i+0]>tightBounds[2*i+1]) {
    28612862                        feasible=false;
    2862                         printf("Bad bounds on %d %g,%g was %g,%g\n",
    2863                                i,tightBounds[2*i+0],tightBounds[2*i+1],
    2864                                lower[i],upper[i]);
     2863                        char general[200];
     2864                        sprintf(general,"Solvers give infeasible bounds on %d %g,%g was %g,%g - search finished\n",
     2865                               i,tightBounds[2*i+0],tightBounds[2*i+1],lower[i],upper[i]);
     2866                        messageHandler()->message(CBC_GENERAL,messages())
     2867                          << general << CoinMessageEol ;
     2868                        break;
    28652869                      }
    2866                       //int k=0;
    28672870                      double oldLower=lower[i];
    28682871                      double oldUpper=upper[i];
    28692872                      if (tightBounds[2*i+0]>oldLower+tolerance) {
    28702873                        nTightened++;
    2871                         //k++;
    28722874                        solver_->setColLower(i,tightBounds[2*i+0]);
    28732875                      }
    28742876                      if (tightBounds[2*i+1]<oldUpper-tolerance) {
    28752877                        nTightened++;
    2876                         //k++;
    28772878                        solver_->setColUpper(i,tightBounds[2*i+1]);
    28782879                      }
    2879                       //if (k)
    2880                       //printf("new bounds on %d %g,%g was %g,%g\n",
    2881                       //       i,tightBounds[2*i+0],tightBounds[2*i+1],
    2882                       //       oldLower,oldUpper);
    28832880                    }
    2884                     if (!feasible)
    2885                       abort(); // deal with later
    28862881                  }
    28872882                  delete [] tightBounds;
     
    29892984                  }
    29902985                }
    2991                 feasible = solveWithCuts(cuts, maximumCutPassesAtRoot_,
     2986                if (feasible)
     2987                  feasible = solveWithCuts(cuts, maximumCutPassesAtRoot_,
    29922988                                         NULL);
    29932989                if (multipleRootTries_&&
     
    41054101            unlockThread();
    41064102        }
    4107         // If done 100 nodes see if worth trying reduction
    4108         if (numberNodes_ == 50 || numberNodes_ == 100) {
     4103        // If done 50/100 nodes see if worth trying reduction
     4104        if (numberNodes_ >= nextCheckRestart) {
     4105          if (nextCheckRestart<100)
     4106            nextCheckRestart=100;
     4107          else
     4108            nextCheckRestart=COIN_INT_MAX;
    41094109#ifdef COIN_HAS_CLP
    41104110            OsiClpSolverInterface * clpSolver
     
    85278527        OsiBranchingInformation usefulInfo = usefulInformation();
    85288528        for (int i = 0; i < numberObjects_ && integerFeasible; i++) {
    8529             int preferredWay;
    8530             double infeasibility = object_[i]->infeasibility(&usefulInfo, preferredWay);
     8529            double infeasibility = object_[i]->checkInfeasibility(&usefulInfo);
    85318530            if (infeasibility)
    85328531                integerFeasible = false;
     
    1237312372    int numberUnsatisfied = 0;
    1237412373    //double sumUnsatisfied=0.0;
    12375     int preferredWay;
    1237612374    int j;
    1237712375    // Point to current solution
     
    1239412392#ifndef SIMPLE_INTEGER
    1239512393        const OsiObject * object = object_[j];
    12396         double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
     12394        double infeasibility = object->checkInfeasibility(&usefulInfo);
    1239712395        if (infeasibility) {
    1239812396            assert (infeasibility > 0);
     
    1241412412    for (; j < numberObjects_; j++) {
    1241512413        const OsiObject * object = object_[j];
    12416         double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
     12414        double infeasibility = object->checkInfeasibility(&usefulInfo);
    1241712415        if (infeasibility) {
    1241812416            assert (infeasibility > 0);
     
    1390813906            // again
    1390913907            //std::cout<<solver_<<std::endl;
     13908
     13909            OsiCuts feasCuts;
     13910
     13911            for (int i = 0; i < numberCutGenerators_ && (feasCuts.sizeRowCuts () == 0); i++) {
     13912              if (generator_ [i] -> normal () &&
     13913                  (!generator_ [i] -> needsOptimalBasis () || solver_ -> basisIsAvailable ()))
     13914                generator_ [i] -> generateCuts (feasCuts, 1 /* = fullscan */, solver_, NULL);
     13915            }
     13916            solver_ -> applyCuts (feasCuts);
     13917
    1391013918            resolve(solver_);
    1391113919            double objval = solver_->getObjValue();
     
    1432314331        bool exitNow = false;
    1432414332        for (i = 0; i < numberHeuristics_; i++) {
     14333            heuristic_[i]->setModelOnly(this);
    1432514334            if (heuristic_[i]->exitNow(bestObjective_))
    1432614335                exitNow = true;
     
    1493214941            if (feasible) {
    1493314942                int iObject ;
    14934                 int preferredWay ;
    1493514943                int numberUnsatisfied = 0 ;
    1493614944                memcpy(currentSolution_, solver_->getColSolution(),
     
    1494114949                for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
    1494214950                    double infeasibility =
    14943                         object_[iObject]->infeasibility(&usefulInfo, preferredWay) ;
     14951                        object_[iObject]->checkInfeasibility(&usefulInfo) ;
    1494414952                    if (infeasibility ) numberUnsatisfied++ ;
    1494514953                }
     
    1734617354    {
    1734717355        int iObject ;
    17348         int preferredWay ;
    1734917356        int numberUnsatisfied = 0 ;
    1735017357        memcpy(currentSolution_, solver_->getColSolution(),
     
    1735517362        for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
    1735617363            double infeasibility =
    17357                 object_[iObject]->infeasibility(&usefulInfo, preferredWay) ;
     17364                object_[iObject]->checkInfeasibility(&usefulInfo) ;
    1735817365            if (infeasibility) numberUnsatisfied++ ;
    1735917366        }
  • releases/2.8.13/Cbc/src/CbcNode.cpp

    r2347 r2347  
    699699                        if (saveUpper[iColumn] > saveLower[iColumn]) {
    700700                            double value = saveSolution[iColumn];
     701                            // clean
     702                            value = CoinMin(value,saveUpper[iColumn]);
     703                            value = CoinMax(value,saveLower[iColumn]);
    701704                            if (hotstartPriorities)
    702705                                priorityLevel = hotstartPriorities[iColumn];
     
    14121415                        choice[i].possibleBranch = NULL;
    14131416                        const OsiObject * object = model->object(thisChoice.objectNumber);
    1414                         int preferredWay;
    1415                         double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
     1417                        double infeasibility = object->checkInfeasibility(&usefulInfo);
    14161418                        if (!infeasibility) {
    14171419                            // take out
     
    16261628            CbcObject * obj =   dynamic_cast <CbcObject *>(object) ;
    16271629            if (!obj || !obj->optionalObject()) {
    1628                 int preferredWay;
    1629                 double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
     1630                double infeasibility = object->checkInfeasibility(&usefulInfo);
    16301631                if (infeasibility) {
    16311632                    useOldWay = true;
     
    20472048                CbcSimpleIntegerDynamicPseudoCost * dynamicObject =
    20482049                    dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object) ;
    2049                 int preferredWay;
    2050                 double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
     2050                double infeasibility = object->checkInfeasibility(&usefulInfo);
    20512051                int priorityLevel = object->priority();
    20522052                if (hotstartSolution) {
     
    20752075                                    //else
    20762076                                    infeasibility = fabs(value - targetValue);
    2077                                     //if (targetValue==1.0)
    2078                                     //infeasibility += 1.0;
    2079                                     if (value > targetValue) {
    2080                                         preferredWay = -1;
    2081                                     } else {
    2082                                         preferredWay = 1;
    2083                                     }
    20842077                                    priorityLevel = CoinAbs(priorityLevel);
    20852078                                } else if (priorityLevel < 0) {
    20862079                                    priorityLevel = CoinAbs(priorityLevel);
    2087                                     if (targetValue == saveLower[iColumn]) {
     2080                                    if (targetValue == saveLower[iColumn] ||
     2081                                    targetValue == saveUpper[iColumn]) {
    20882082                                        infeasibility = integerTolerance + 1.0e-12;
    2089                                         preferredWay = -1;
    2090                                     } else if (targetValue == saveUpper[iColumn]) {
    2091                                         infeasibility = integerTolerance + 1.0e-12;
    2092                                         preferredWay = 1;
    20932083                                    } else {
    20942084                                        // can't
     
    35883578            if (branch_) {
    35893579                 const OsiObject * object = model->object(bestChoice);
    3590                  int preferredWay;
    3591                  double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
     3580                 double infeasibility = object->checkInfeasibility(&usefulInfo);
    35923581                 if (!infeasibility) {
    35933582                   // take out
     
    35953584                   branch_ = NULL;
    35963585                 } else {
     3586                   // get preferred way
     3587                   int preferredWay;
     3588                   object->infeasibility(&usefulInfo, preferredWay);
    35973589                   CbcBranchingObject * branchObj =
    35983590                     dynamic_cast <CbcBranchingObject *>(branch_) ;
     
    38293821        if (!dynamicObject)
    38303822            continue;
    3831         int preferredWay;
    3832         double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
     3823        double infeasibility = object->checkInfeasibility(&usefulInfo);
    38333824        int iColumn = dynamicObject->columnNumber();
    38343825        if (saveUpper[iColumn] == saveLower[iColumn])
  • releases/2.8.13/Cbc/src/CbcSolver.cpp

    r2347 r2347  
    657657    parameters_[whichParam(CBC_PARAM_STR_FPUMP, numberParameters_, parameters_)].setCurrentOption("on");
    658658    parameters_[whichParam(CBC_PARAM_STR_GREEDY, numberParameters_, parameters_)].setCurrentOption("on");
    659     parameters_[whichParam(CBC_PARAM_STR_COMBINE, numberParameters_, parameters_)].setCurrentOption("on");
     659    parameters_[whichParam(CBC_PARAM_STR_COMBINE, numberParameters_, parameters_)].setCurrentOption("off");
    660660    parameters_[whichParam(CBC_PARAM_STR_CROSSOVER2, numberParameters_, parameters_)].setCurrentOption("off");
    661661    parameters_[whichParam(CBC_PARAM_STR_PIVOTANDCOMPLEMENT, numberParameters_, parameters_)].setCurrentOption("off");
     
    12891289  return CbcMain1(argc,argv,model,callBack,staticParameterData);
    12901290}
     1291#ifdef GENERAL_HANDLER_PRINTING
     1292static void printGeneralMessage(CbcModel &model,const char * message);
     1293#endif
    12911294/*
    12921295  Meaning of whereFrom:
     
    13081311    bool noPrinting = parameterData.noPrinting_;
    13091312    bool useSignalHandler = parameterData.useSignalHandler_;
     1313#ifdef GENERAL_HANDLER_PRINTING
     1314    //char printByHandler[1000];
     1315#endif
    13101316    CbcModel & model_ = model;
    13111317#ifdef CBC_THREAD_SAFE
     
    29822988#ifdef COIN_HAS_ASL
    29832989                            if (statusUserFunction_[0]) {
    2984                                 double value = model2->getObjValue() * model2->getObjSense();
     2990                                double value = model2->getObjValue();
    29852991                                char buf[300];
    29862992                                int pos = 0;
     
    30473053                        } else {
    30483054#ifndef DISALLOW_PRINTING
    3049                             std::cout << "** Current model not valid" << std::endl;
     3055#ifdef GENERAL_HANDLER_PRINTING
     3056                          sprintf(generalPrint, "** Current model not valid");
     3057                          printGeneralMessage(model_,generalPrint);
     3058#else
     3059                          std::cout << "** Current model not valid" << std::endl;
     3060#endif
    30503061#endif
    30513062                        }
     
    30853096                        } else {
    30863097#ifndef DISALLOW_PRINTING
    3087                             std::cout << "** Current model not valid" << std::endl;
     3098#ifdef GENERAL_HANDLER_PRINTING
     3099                          sprintf(generalPrint, "** Current model not valid");
     3100                          printGeneralMessage(model_,generalPrint);
     3101#else
     3102                          std::cout << "** Current model not valid" << std::endl;
     3103#endif
    30883104#endif
    30893105                        }
     
    30923108                        if (goodModel) {
    30933109                            int numberInfeasibilities = lpSolver->tightenPrimalBounds();
    3094                             if (numberInfeasibilities)
    3095                                 std::cout << "** Analysis indicates model infeasible" << std::endl;
     3110                            if (numberInfeasibilities) {
     3111#ifdef GENERAL_HANDLER_PRINTING
     3112                              sprintf(generalPrint,"** Analysis indicates model infeasible");
     3113                              printGeneralMessage(model_,generalPrint);
     3114#else
     3115                              std::cout << "** Analysis indicates model infeasible" << std::endl;
     3116#endif
     3117                            }
    30963118                        } else {
    30973119#ifndef DISALLOW_PRINTING
    3098                             std::cout << "** Current model not valid" << std::endl;
     3120#ifdef GENERAL_HANDLER_PRINTING
     3121                          sprintf(generalPrint, "** Current model not valid");
     3122                          printGeneralMessage(model_,generalPrint);
     3123#else
     3124                          std::cout << "** Current model not valid" << std::endl;
     3125#endif
    30993126#endif
    31003127                        }
     
    31103137                                    lpSolver->replaceMatrix(newMatrix);
    31113138                                    delete saveMatrix;
     3139#ifdef GENERAL_HANDLER_PRINTING
     3140                                    sprintf(generalPrint, "Matrix converted to +- one matrix");
     3141                                    printGeneralMessage(model_,generalPrint);
     3142#else
    31123143                                    std::cout << "Matrix converted to +- one matrix" << std::endl;
     3144#endif
    31133145                                } else {
     3146#ifdef GENERAL_HANDLER_PRINTING
     3147                                  sprintf(generalPrint, "Matrix can not be converted to +- 1 matrix");
     3148                                  printGeneralMessage(model_,generalPrint);
     3149#else
    31143150                                    std::cout << "Matrix can not be converted to +- 1 matrix" << std::endl;
     3151#endif
    31153152                                }
    31163153                            } else {
     3154#ifdef GENERAL_HANDLER_PRINTING
     3155                              sprintf(generalPrint, "Matrix not a ClpPackedMatrix");
     3156                              printGeneralMessage(model_,generalPrint);
     3157#else
    31173158                                std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
     3159#endif
    31183160                            }
    31193161                        } else {
    31203162#ifndef DISALLOW_PRINTING
     3163#ifdef GENERAL_HANDLER_PRINTING
     3164                          sprintf(generalPrint, "** Current model not valid");
     3165                          printGeneralMessage(model_,generalPrint);
     3166#else
    31213167                            std::cout << "** Current model not valid" << std::endl;
     3168#endif
    31223169#endif
    31233170                        }
     
    31393186                        } else {
    31403187#ifndef DISALLOW_PRINTING
     3188#ifdef GENERAL_HANDLER_PRINTING
     3189                          sprintf(generalPrint, "** Current model not valid");
     3190                          printGeneralMessage(model_,generalPrint);
     3191#else
    31413192                            std::cout << "** Current model not valid" << std::endl;
     3193#endif
    31423194#endif
    31433195                        }
     
    31543206                                    lpSolver->replaceMatrix(newMatrix);
    31553207                                    delete saveMatrix;
     3208#ifdef GENERAL_HANDLER_PRINTING
     3209                                    sprintf(generalPrint, "Matrix converted to network matrix");
     3210                                    printGeneralMessage(model_,generalPrint);
     3211#else
    31563212                                    std::cout << "Matrix converted to network matrix" << std::endl;
     3213#endif
    31573214                                } else {
     3215#ifdef GENERAL_HANDLER_PRINTING
     3216                                  sprintf(generalPrint, "Matrix can not be converted to network matrix");
     3217                                  printGeneralMessage(model_,generalPrint);
     3218#else
    31583219                                    std::cout << "Matrix can not be converted to network matrix" << std::endl;
     3220#endif
    31593221                                }
    31603222                            } else {
     3223#ifdef GENERAL_HANDLER_PRINTING
     3224                              sprintf(generalPrint, "Matrix not a ClpPackedMatrix");
     3225                              printGeneralMessage(model_,generalPrint);
     3226#else
    31613227                                std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
     3228#endif
    31623229                            }
    31633230                        } else {
    31643231#ifndef DISALLOW_PRINTING
     3232#ifdef GENERAL_HANDLER_PRINTING
     3233                          sprintf(generalPrint, "** Current model not valid");
     3234                          printGeneralMessage(model_,generalPrint);
     3235#else
    31653236                            std::cout << "** Current model not valid" << std::endl;
     3237#endif
    31663238#endif
    31673239                        }
     
    34523524                                            if (clpModel->tightenPrimalBounds() != 0) {
    34533525#ifndef DISALLOW_PRINTING
     3526#ifdef GENERAL_HANDLER_PRINTING
     3527                                              sprintf(generalPrint, "Problem is infeasible - tightenPrimalBounds!");
     3528                                              printGeneralMessage(model_,generalPrint);
     3529#else
    34543530                                                std::cout << "Problem is infeasible - tightenPrimalBounds!" << std::endl;
     3531#endif
    34553532#endif
    34563533                                                break;
     
    36243701                                if (!complicatedInteger && preProcess == 0 && clpSolver->tightenPrimalBounds(0.0, 0, true) != 0) {
    36253702#ifndef DISALLOW_PRINTING
     3703#ifdef GENERAL_HANDLER_PRINTING
     3704                                  sprintf(generalPrint, "Problem is infeasible - tightenPrimalBounds!");
     3705                                  printGeneralMessage(model_,generalPrint);
     3706#else
    36263707                                    std::cout << "Problem is infeasible - tightenPrimalBounds!" << std::endl;
     3708#endif
    36273709#endif
    36283710                                    model_.setProblemStatus(0);
     
    37293811                                    if (modelC->tightenPrimalBounds(tightenFactor) != 0) {
    37303812#ifndef DISALLOW_PRINTING
     3813#ifdef GENERAL_HANDLER_PRINTING
     3814                                      sprintf(generalPrint, "Problem is infeasible!");
     3815                                      printGeneralMessage(model_,generalPrint);
     3816#else
    37313817                                        std::cout << "Problem is infeasible!" << std::endl;
     3818#endif
    37323819#endif
    37333820                                        model_.setProblemStatus(0);
     
    43834470                                if (!complicatedInteger && modelC->tightenPrimalBounds() != 0) {
    43844471#ifndef DISALLOW_PRINTING
     4472#ifdef GENERAL_HANDLER_PRINTING
     4473                                  sprintf(generalPrint, "Problem is infeasible!");
     4474                                  printGeneralMessage(model_,generalPrint);
     4475#else
    43854476                                    std::cout << "Problem is infeasible!" << std::endl;
     4477#endif
    43864478#endif
    43874479                                    model_.setProblemStatus(0);
     
    70687160#endif
    70697161                            } else {
     7162#ifdef GENERAL_HANDLER_PRINTING
     7163                              sprintf(generalPrint, "Model strengthened - now has %d rows",
     7164                                      clpSolver->getNumRows());
     7165                              printGeneralMessage(model_,generalPrint);
     7166#else
    70707167                                std::cout << "Model strengthened - now has " << clpSolver->getNumRows()
    70717168                                          << " rows" << std::endl;
     7169#endif
    70727170                            }
    70737171                            time1 = time2;
     
    70867184                        } else {
    70877185#ifndef DISALLOW_PRINTING
     7186#ifdef GENERAL_HANDLER_PRINTING
     7187                          sprintf(generalPrint, "** Current model not valid");
     7188                          printGeneralMessage(model_,generalPrint);
     7189#else
    70887190                            std::cout << "** Current model not valid" << std::endl ;
     7191#endif
    70897192#endif
    70907193                        }
     
    72147317                                    } else {
    72157318                                        canOpen = false;
     7319#ifdef GENERAL_HANDLER_PRINTING
     7320                                        sprintf(generalPrint, "Unable to open file %s",gmplData.c_str());
     7321                                        printGeneralMessage(model_,generalPrint);
     7322#else
    72167323                                        std::cout << "Unable to open file " << gmplData << std::endl;
     7324#endif
    72177325                                    }
    72187326                                }
    72197327                            } else {
     7328#ifdef GENERAL_HANDLER_PRINTING
     7329                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7330                              printGeneralMessage(model_,generalPrint);
     7331#else
    72207332                                std::cout << "Unable to open file " << fileName << std::endl;
     7333#endif
    72217334                            }
    72227335                        }
     
    72857398                            } else {
    72867399                                // errors
     7400#ifdef GENERAL_HANDLER_PRINTING
     7401                              sprintf(generalPrint, "There were %d errors on input",status);
     7402                              printGeneralMessage(model_,generalPrint);
     7403#else
    72877404                                std::cout << "There were " << status <<
    72887405                                          " errors on input" << std::endl;
     7406#endif
    72897407                            }
    72907408                        }
     
    73437461                                    canOpen = true;
    73447462                                } else {
     7463#ifdef GENERAL_HANDLER_PRINTING
     7464                                  sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7465                                  printGeneralMessage(model_,generalPrint);
     7466#else
    73457467                                    std::cout << "Unable to open file " << fileName << std::endl;
     7468#endif
    73467469                                }
    73477470                            }
     
    74127535                                canOpen = true;
    74137536                            } else {
     7537#ifdef GENERAL_HANDLER_PRINTING
     7538                                  sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7539                                  printGeneralMessage(model_,generalPrint);
     7540#else
    74147541                                std::cout << "Unable to open file " << fileName << std::endl;
     7542#endif
    74157543                            }
    74167544                            if (canOpen) {
     
    75197647                        } else {
    75207648#ifndef DISALLOW_PRINTING
     7649#ifdef GENERAL_HANDLER_PRINTING
     7650                          sprintf(generalPrint, "** Current model not valid");
     7651                          printGeneralMessage(model_,generalPrint);
     7652#else
    75217653                            std::cout << "** Current model not valid" << std::endl;
     7654#endif
    75227655#endif
    75237656                        }
     
    75627695                                    canOpen = true;
    75637696                                } else {
     7697#ifdef GENERAL_HANDLER_PRINTING
     7698                                  sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     7699                                  printGeneralMessage(model_,generalPrint);
     7700#else
    75647701                                    std::cout << "Unable to open file " << fileName << std::endl;
     7702#endif
    75657703                                }
    75667704                            }
     
    75787716                        } else {
    75797717#ifndef DISALLOW_PRINTING
     7718#ifdef GENERAL_HANDLER_PRINTING
     7719                          sprintf(generalPrint, "** Current model not valid");
     7720                          printGeneralMessage(model_,generalPrint);
     7721#else
    75807722                            std::cout << "** Current model not valid" << std::endl;
     7723#endif
    75817724#endif
    75827725                        }
     
    78738016                                fclose(fp);
    78748017                            } else {
     8018#ifdef GENERAL_HANDLER_PRINTING
     8019                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8020                              printGeneralMessage(model_,generalPrint);
     8021#else
    78758022                                std::cout << "Unable to open file " << fileName << std::endl;
     8023#endif
    78768024                            }
    78778025                        } else {
    78788026#ifndef DISALLOW_PRINTING
     8027#ifdef GENERAL_HANDLER_PRINTING
     8028                          sprintf(generalPrint, "** Current model not valid");
     8029                          printGeneralMessage(model_,generalPrint);
     8030#else
    78798031                            std::cout << "** Current model not valid" << std::endl;
     8032#endif
    78808033#endif
    78818034                        }
     
    79248077                        } else {
    79258078#ifndef DISALLOW_PRINTING
     8079#ifdef GENERAL_HANDLER_PRINTING
     8080                          sprintf(generalPrint, "** Current model not valid");
     8081                          printGeneralMessage(model_,generalPrint);
     8082#else
    79268083                            std::cout << "** Current model not valid" << std::endl;
     8084#endif
    79278085#endif
    79288086                        }
     
    80018159                                fclose(fp);
    80028160                            } else {
     8161#ifdef GENERAL_HANDLER_PRINTING
     8162                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8163                              printGeneralMessage(model_,generalPrint);
     8164#else
    80038165                                std::cout << "Unable to open file " << fileName << std::endl;
     8166#endif
    80048167                            }
    80058168                        } else {
    80068169#ifndef DISALLOW_PRINTING
     8170#ifdef GENERAL_HANDLER_PRINTING
     8171                          sprintf(generalPrint, "** Current model not valid");
     8172                          printGeneralMessage(model_,generalPrint);
     8173#else
    80078174                            std::cout << "** Current model not valid" << std::endl;
     8175#endif
    80088176#endif
    80098177                        }
     
    80558223                                canOpen = true;
    80568224                            } else {
     8225#ifdef GENERAL_HANDLER_PRINTING
     8226                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8227                              printGeneralMessage(model_,generalPrint);
     8228#else
    80578229                                std::cout << "Unable to open file " << fileName << std::endl;
     8230#endif
    80588231                            }
    80598232                            if (canOpen) {
     
    80668239                        } else {
    80678240#ifndef DISALLOW_PRINTING
     8241#ifdef GENERAL_HANDLER_PRINTING
     8242                          sprintf(generalPrint, "** Current model not valid");
     8243                          printGeneralMessage(model_,generalPrint);
     8244#else
    80688245                            std::cout << "** Current model not valid" << std::endl;
     8246#endif
    80698247#endif
    80708248                        }
     
    81038281                            canOpen = true;
    81048282                        } else {
     8283#ifdef GENERAL_HANDLER_PRINTING
     8284                          sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8285                          printGeneralMessage(model_,generalPrint);
     8286#else
    81058287                            std::cout << "Unable to open file " << fileName << std::endl;
     8288#endif
    81068289                        }
    81078290                        if (canOpen) {
     
    81428325                            } else {
    81438326                                // errors
     8327#ifdef GENERAL_HANDLER_PRINTING
     8328                              sprintf(generalPrint, "There were errors on output");
     8329                              printGeneralMessage(model_,generalPrint);
     8330#else
    81448331                                std::cout << "There were errors on output" << std::endl;
     8332#endif
    81458333                            }
    81468334                        }
     
    81808368                            canOpen = true;
    81818369                        } else {
     8370#ifdef GENERAL_HANDLER_PRINTING
     8371                          sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8372                          printGeneralMessage(model_,generalPrint);
     8373#else
    81828374                            std::cout << "Unable to open file " << fileName << std::endl;
     8375#endif
    81838376                        }
    81848377                        if (canOpen) {
     
    81918384                            } else {
    81928385                                // errors
     8386#ifdef GENERAL_HANDLER_PRINTING
     8387                              sprintf(generalPrint, "There were errors on input");
     8388                              printGeneralMessage(model_,generalPrint);
     8389#else
    81938390                                std::cout << "There were errors on input" << std::endl;
     8391#endif
    81948392                            }
    81958393                        }
     
    83088506                            double value = CoinReadGetDoubleField(argc, argv, &valid);
    83098507                            if (!valid) {
     8508#ifdef GENERAL_HANDLER_PRINTING
     8509                              sprintf(generalPrint, "Setting %s to DEBUG %g",parameters_[iParam].name().c_str(),value);
     8510                              printGeneralMessage(model_,generalPrint);
     8511#else
    83108512                                std::cout << "Setting " << parameters_[iParam].name() <<
    83118513                                          " to DEBUG " << value << std::endl;
     8514#endif
    83128515                                int iRow;
    83138516                                int numberRows = lpSolver->numberRows();
     
    85468749                            fclose(fp);
    85478750                        } else {
     8751#ifdef GENERAL_HANDLER_PRINTING
     8752                          sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     8753                          printGeneralMessage(model_,generalPrint);
     8754#else
    85488755                            std::cout << "Unable to open file " << fileName << std::endl;
     8756#endif
    85498757                        }
    85508758                    }
     
    92249432                                }
    92259433                            } else {
     9434#ifdef GENERAL_HANDLER_PRINTING
     9435                              sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
     9436                              printGeneralMessage(model_,generalPrint);
     9437#else
    92269438                                std::cout << "Unable to open file " << fileName << std::endl;
     9439#endif
    92279440                            }
    92289441                        } else {
    92299442#ifndef DISALLOW_PRINTING
     9443#ifdef GENERAL_HANDLER_PRINTING
     9444                          sprintf(generalPrint, "** Current model not valid");
     9445                          printGeneralMessage(model_,generalPrint);
     9446#else
    92309447                            std::cout << "** Current model not valid" << std::endl;
     9448#endif
    92319449#endif
    92329450                        }
     
    92629480                        } else {
    92639481#ifndef DISALLOW_PRINTING
     9482#ifdef GENERAL_HANDLER_PRINTING
     9483                          sprintf(generalPrint, "** Current model not valid");
     9484                          printGeneralMessage(model_,generalPrint);
     9485#else
    92649486                            std::cout << "** Current model not valid" << std::endl;
     9487#endif
    92659488#endif
    92669489                        }
     
    93049527                               time1 = time2;
    93059528                          } else {
     9529#ifdef GENERAL_HANDLER_PRINTING
     9530                            sprintf(generalPrint, "** Current model not valid");
     9531                            printGeneralMessage(model_,generalPrint);
     9532#else
    93069533                               std::cout << "** Current model not valid" << std::endl;
     9534#endif
    93079535                          }
    93089536                          break;
     
    95549782    parameters[whichParam(CBC_PARAM_STR_FPUMP, numberParameters, parameters)].setCurrentOption("on");
    95559783    parameters[whichParam(CBC_PARAM_STR_GREEDY, numberParameters, parameters)].setCurrentOption("on");
    9556     parameters[whichParam(CBC_PARAM_STR_COMBINE, numberParameters, parameters)].setCurrentOption("on");
     9784    parameters[whichParam(CBC_PARAM_STR_COMBINE, numberParameters, parameters)].setCurrentOption("off");
    95579785    parameters[whichParam(CBC_PARAM_STR_CROSSOVER2, numberParameters, parameters)].setCurrentOption("off");
    95589786    parameters[whichParam(CBC_PARAM_STR_PIVOTANDCOMPLEMENT, numberParameters, parameters)].setCurrentOption("off");
     
    1009810326    printf("C++ file written to %s\n", fileName);
    1009910327}
     10328#ifdef GENERAL_HANDLER_PRINTING
     10329// Print a general message
     10330static void printGeneralMessage(CbcModel &model,const char * message)
     10331{
     10332  model.messageHandler()->message(CBC_FPUMP1, model.messages())
     10333    << message
     10334    << CoinMessageEol;
     10335}
     10336#endif
    1010010337/*
    1010110338  Version 1.00.00 November 16 2005.
  • releases/2.8.13/Cbc/src/CbcThread.cpp

    r2347 r2347  
    15691569        }
    15701570        continuousSolver_ = baseModel->continuousSolver_->clone();
     1571        // make sure solvers have correct message handler
     1572        solver_->passInMessageHandler(handler_);
     1573        continuousSolver_->passInMessageHandler(handler_);
    15711574        bool newMethod = (baseModel->branchingMethod_ && baseModel->branchingMethod_->chooseMethod());
    15721575        if (newMethod) {
  • releases/2.8.13/Cbc/src/OsiCbc/OsiCbcSolverInterface.cpp

    r2347 r2347  
    122122bool OsiCbcSolverInterface::isAbandoned() const
    123123{
    124   return modelPtr_->solver()->isAbandoned();
     124  if (modelPtr_->status()!=-1)
     125    return modelPtr_->isAbandoned();
     126  else
     127    return modelPtr_->solver()->isAbandoned();
    125128}
    126129
    127130bool OsiCbcSolverInterface::isProvenOptimal() const
    128131{
    129   return modelPtr_->solver()->isProvenOptimal();
     132  if (modelPtr_->status()!=-1)
     133    return modelPtr_->isProvenOptimal();
     134  else
     135    return modelPtr_->solver()->isProvenOptimal();
    130136}
    131137
    132138bool OsiCbcSolverInterface::isProvenPrimalInfeasible() const
    133139{
    134   return modelPtr_->solver()->isProvenPrimalInfeasible();
     140  if (modelPtr_->status()!=-1)
     141    return modelPtr_->isProvenInfeasible();
     142  else
     143    return modelPtr_->solver()->isProvenPrimalInfeasible();
    135144}
    136145
    137146bool OsiCbcSolverInterface::isProvenDualInfeasible() const
    138147{
     148  if (modelPtr_->status()!=-1)
     149  return modelPtr_->isProvenDualInfeasible();
     150  else
    139151  return modelPtr_->solver()->isProvenDualInfeasible();
    140152}
     
    151163bool OsiCbcSolverInterface::isIterationLimitReached() const
    152164{
    153   return modelPtr_->solver()->isIterationLimitReached();
     165  if (modelPtr_->status()!=-1)
     166    return modelPtr_->isNodeLimitReached();
     167  else
     168    return modelPtr_->solver()->isIterationLimitReached();
    154169}
    155170
  • releases/2.8.13/Cbc/src/config_cbc_default.h

    r2347 r2347  
    66
    77/* Version number of project */
    8 #define CBC_VERSION "2.8.12"
     8#define CBC_VERSION "2.8.13"
    99
    1010/* Major Version number of project */
     
    1515
    1616/* Release Version number of project */
    17 #define CBC_VERSION_RELEASE 12
     17#define CBC_VERSION_RELEASE 13
  • releases/2.8.13/configure

    r2347 r2347  
    22# From configure.ac 0.9.
    33# Guess values for system-dependent variables and create Makefiles.
    4 # Generated by GNU Autoconf 2.59 for Cbc 2.8.12.
     4# Generated by GNU Autoconf 2.59 for Cbc 2.8.13.
    55#
    66# Report bugs to <cbc@lists.coin-or.org>.
     
    431431PACKAGE_NAME='Cbc'
    432432PACKAGE_TARNAME='cbc'
    433 PACKAGE_VERSION='2.8.12'
    434 PACKAGE_STRING='Cbc 2.8.12'
     433PACKAGE_VERSION='2.8.13'
     434PACKAGE_STRING='Cbc 2.8.13'
    435435PACKAGE_BUGREPORT='cbc@lists.coin-or.org'
    436436
     
    10391039  # This message is too long to be a string in the A/UX 3.1 sh.
    10401040  cat <<_ACEOF
    1041 \`configure' configures Cbc 2.8.12 to adapt to many kinds of systems.
     1041\`configure' configures Cbc 2.8.13 to adapt to many kinds of systems.
    10421042
    10431043Usage: $0 [OPTION]... [VAR=VALUE]...
     
    11051105if test -n "$ac_init_help"; then
    11061106  case $ac_init_help in
    1107      short | recursive ) echo "Configuration of Cbc 2.8.12:";;
     1107     short | recursive ) echo "Configuration of Cbc 2.8.13:";;
    11081108   esac
    11091109  cat <<\_ACEOF
     
    13281328if $ac_init_version; then
    13291329  cat <<\_ACEOF
    1330 Cbc configure 2.8.12
     1330Cbc configure 2.8.13
    13311331generated by GNU Autoconf 2.59
    13321332
     
    13481348running configure, to aid debugging if configure makes a mistake.
    13491349
    1350 It was created by Cbc $as_me 2.8.12, which was
     1350It was created by Cbc $as_me 2.8.13, which was
    13511351generated by GNU Autoconf 2.59.  Invocation command line was
    13521352
     
    19461946             fi
    19471947             ;;
    1948   *-*-darwin*) comps="clang gcc" ;;
     1948  *-*-darwin*) comps="clang gcc cc" ;;
    19491949  *-linux-gnu*) comps="gcc cc pgcc icc xlc" ;;
    19501950  *-linux-*) comps="xlc gcc cc pgcc icc" ;;
     
    31053105  *-*-solaris*)
    31063106             comps="CC xlC_r aCC g++ c++ pgCC icpc gpp cxx cc++ cl FCC KCC RCC" ;;
    3107   *-darwin*) comps="g++ c++ CC" ;;
     3107  *-darwin*) comps="clang++ g++ c++ CC" ;;
    31083108  *-linux-gnu*)
    31093109             comps="g++ c++ pgCC icpc gpp cxx cc++ cl FCC KCC RCC xlC_r aCC CC" ;;
     
    35423542# It seems that we need to cleanup something here for the Windows
    35433543case "$CXX" in
    3544   clang* ) ;;
     3544  clang* | */clang*) ;;
    35453545  cl* | */cl* | CL* | */CL* | icl* | */icl* | ICL* | */ICL*)
    35463546    sed -e 's/^void exit (int);//' confdefs.h >> confdefs.hh
     
    51155115# Define the identity of the package.
    51165116 PACKAGE='cbc'
    5117  VERSION='2.8.12'
     5117 VERSION='2.8.13'
    51185118
    51195119
     
    2343423434cat >&5 <<_CSEOF
    2343523435
    23436 This file was extended by Cbc $as_me 2.8.12, which was
     23436This file was extended by Cbc $as_me 2.8.13, which was
    2343723437generated by GNU Autoconf 2.59.  Invocation command line was
    2343823438
     
    2349223492cat >>$CONFIG_STATUS <<_ACEOF
    2349323493ac_cs_version="\\
    23494 Cbc config.status 2.8.12
     23494Cbc config.status 2.8.13
    2349523495configured by $0, generated by GNU Autoconf 2.59,
    2349623496  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
  • releases/2.8.13/configure.ac

    r2347 r2347  
    1313AC_PREREQ(2.59)
    1414
    15 AC_INIT([Cbc],[2.8.12],[cbc@lists.coin-or.org])
     15AC_INIT([Cbc],[2.8.13],[cbc@lists.coin-or.org])
    1616
    1717AC_COPYRIGHT([
Note: See TracChangeset for help on using the changeset viewer.