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


Ignore:
Location:
releases/2.8.12
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • releases/2.8.12/Cbc/configure

    r2366 r2366  
    11#! /bin/sh
    22# Guess values for system-dependent variables and create Makefiles.
    3 # Generated by GNU Autoconf 2.59 for Cbc 2.8.13.
     3# Generated by GNU Autoconf 2.59 for Cbc 2.8.12.
    44#
    55# Report bugs to <cbc@lists.coin-or.org>.
     
    430430PACKAGE_NAME='Cbc'
    431431PACKAGE_TARNAME='cbc'
    432 PACKAGE_VERSION='2.8.13'
    433 PACKAGE_STRING='Cbc 2.8.13'
     432PACKAGE_VERSION='2.8.12'
     433PACKAGE_STRING='Cbc 2.8.12'
    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.13 to adapt to many kinds of systems.
     1008\`configure' configures Cbc 2.8.12 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.13:";;
     1074     short | recursive ) echo "Configuration of Cbc 2.8.12:";;
    10751075   esac
    10761076  cat <<\_ACEOF
     
    13061306if $ac_init_version; then
    13071307  cat <<\_ACEOF
    1308 Cbc configure 2.8.13
     1308Cbc configure 2.8.12
    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.13, which was
     1328It was created by Cbc $as_me 2.8.12, 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:13:8
     1854 coin_libversion=11:12:8
    18551855
    18561856
     
    20932093             fi
    20942094             ;;
    2095   *-*-darwin*) comps="clang gcc cc" ;;
     2095  *-*-darwin*) comps="clang gcc" ;;
    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="clang++ g++ c++ CC" ;;
     3252  *-darwin*) comps="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* | */clang*) ;;
     3689  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.13'
     4577 VERSION='2.8.12'
    45784578
    45794579
     
    3114531145cat >&5 <<_CSEOF
    3114631146
    31147 This file was extended by Cbc $as_me 2.8.13, which was
     31147This file was extended by Cbc $as_me 2.8.12, 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.13
     31210Cbc config.status 2.8.12
    3121131211configured by $0, generated by GNU Autoconf 2.59,
    3121231212  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
  • releases/2.8.12/Cbc/configure.ac

    r2366 r2366  
    1313AC_PREREQ(2.59)
    1414
    15 AC_INIT([Cbc],[2.8.13],[cbc@lists.coin-or.org])
     15AC_INIT([Cbc],[2.8.12],[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:13:8)
     44AC_COIN_PROJECTDIR_INIT(Cbc,11:12:8)
    4545
    4646# Check if user wants to produce debugging code
  • releases/2.8.12/Cbc/src/CbcHeuristicRENS.cpp

    r2366 r2366  
    3333    whereFrom_ = 256 + 1;
    3434}
     35
    3536// Constructor with model - assumed before cuts
    3637
     
    8687    int returnCode = 0;
    8788    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)
    9590        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     }
    10391    numberTries_++;
    104 #ifdef HEURISTIC_INFORM
    105     printf("Entering heuristic %s - nRuns %d numCould %d when %d\n",
    106            heuristicName(),numRuns_,numCouldRun_,when_);
    107 #endif
    10892    double saveFractionSmall=fractionSmall_;
    10993    OsiSolverInterface * solver = model_->solver();
     
    752736    int numberAtBound = 0;
    753737    int numberContinuous = numberColumns - numberIntegers;
    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     }
     738
    790739    for (i = 0; i < numberIntegers; i++) {
    791740        int iColumn = integerVariable[i];
     
    796745        value = CoinMin(value, upper);
    797746        double djValue=dj[iColumn]*direction;
    798         bool dontFix=marked[iColumn]!=0;
    799747#define RENS_FIX_ONLY_LOWER
    800748#ifndef RENS_FIX_ONLY_LOWER
    801749        if (fabs(value - floor(value + 0.5)) < 1.0e-8) {
    802750            value = floor(value + 0.5);
    803             if (dontFix) {
    804               continue;
    805             }
    806751            if (value == lower || value == upper)
    807752                numberAtBound++;
     
    818763                floor(value + 0.5) == lower &&
    819764            djValue > djTolerance ) {
    820             if (dontFix) {
    821               continue;
    822             }
    823765          value = floor(value + 0.5);
    824766          numberAtBound++;
     
    830772                   -djValue > djTolerance && (djTolerance > 0.0||type==2)) {
    831773          value = floor(value + 0.5);
    832             if (dontFix) {
    833               continue;
    834             }
    835774          numberAtBound++;
    836775          newSolver->setColLower(iColumn, value);
     
    855794#endif
    856795    }
    857     delete [] marked;
    858796    delete [] dj;
    859797    if (numberFixed > numberIntegers / 5) {
  • releases/2.8.12/Cbc/src/CbcHeuristicRENS.hpp

    r2366 r2366  
    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
    7269    */
    7370    int rensType_;
  • releases/2.8.12/Cbc/src/CbcModel.cpp

    r2366 r2366  
    16351635    dblParam_[CbcLargestChange] = 0.0;
    16361636    intParam_[CbcNumberBranches] = 0;
    1637     // when to check for restart
    1638     int nextCheckRestart=50;
    16391637    // Force minimization !!!!
    16401638    bool flipObjective = (solver_->getObjSense()<0.0);
     
    27632761    */
    27642762    int iObject ;
     2763    int preferredWay ;
    27652764    int numberUnsatisfied = 0 ;
    27662765    delete [] currentSolution_;
     
    27742773    for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
    27752774        double infeasibility =
    2776             object_[iObject]->checkInfeasibility(&usefulInfo) ;
     2775            object_[iObject]->infeasibility(&usefulInfo, preferredWay) ;
    27772776        if (infeasibility ) numberUnsatisfied++ ;
    27782777    }
     
    28532852                  //rowCut.addCuts(globalCuts_);
    28542853                  int nTightened=0;
    2855                   assert (feasible);
     2854                  bool feasible=true;
    28562855                  {
    28572856                    double tolerance=1.0e-5;
     
    28612860                      if (tightBounds[2*i+0]>tightBounds[2*i+1]) {
    28622861                        feasible=false;
    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;
     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]);
    28692865                      }
     2866                      //int k=0;
    28702867                      double oldLower=lower[i];
    28712868                      double oldUpper=upper[i];
    28722869                      if (tightBounds[2*i+0]>oldLower+tolerance) {
    28732870                        nTightened++;
     2871                        //k++;
    28742872                        solver_->setColLower(i,tightBounds[2*i+0]);
    28752873                      }
    28762874                      if (tightBounds[2*i+1]<oldUpper-tolerance) {
    28772875                        nTightened++;
     2876                        //k++;
    28782877                        solver_->setColUpper(i,tightBounds[2*i+1]);
    28792878                      }
     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);
    28802883                    }
     2884                    if (!feasible)
     2885                      abort(); // deal with later
    28812886                  }
    28822887                  delete [] tightBounds;
     
    29842989                  }
    29852990                }
    2986                 if (feasible)
    2987                   feasible = solveWithCuts(cuts, maximumCutPassesAtRoot_,
     2991                feasible = solveWithCuts(cuts, maximumCutPassesAtRoot_,
    29882992                                         NULL);
    29892993                if (multipleRootTries_&&
     
    41014105            unlockThread();
    41024106        }
    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;
     4107        // If done 100 nodes see if worth trying reduction
     4108        if (numberNodes_ == 50 || numberNodes_ == 100) {
    41094109#ifdef COIN_HAS_CLP
    41104110            OsiClpSolverInterface * clpSolver
     
    85278527        OsiBranchingInformation usefulInfo = usefulInformation();
    85288528        for (int i = 0; i < numberObjects_ && integerFeasible; i++) {
    8529             double infeasibility = object_[i]->checkInfeasibility(&usefulInfo);
     8529            int preferredWay;
     8530            double infeasibility = object_[i]->infeasibility(&usefulInfo, preferredWay);
    85308531            if (infeasibility)
    85318532                integerFeasible = false;
     
    1237212373    int numberUnsatisfied = 0;
    1237312374    //double sumUnsatisfied=0.0;
     12375    int preferredWay;
    1237412376    int j;
    1237512377    // Point to current solution
     
    1239212394#ifndef SIMPLE_INTEGER
    1239312395        const OsiObject * object = object_[j];
    12394         double infeasibility = object->checkInfeasibility(&usefulInfo);
     12396        double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
    1239512397        if (infeasibility) {
    1239612398            assert (infeasibility > 0);
     
    1241212414    for (; j < numberObjects_; j++) {
    1241312415        const OsiObject * object = object_[j];
    12414         double infeasibility = object->checkInfeasibility(&usefulInfo);
     12416        double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
    1241512417        if (infeasibility) {
    1241612418            assert (infeasibility > 0);
     
    1390613908            // again
    1390713909            //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 
    1391813910            resolve(solver_);
    1391913911            double objval = solver_->getObjValue();
     
    1433114323        bool exitNow = false;
    1433214324        for (i = 0; i < numberHeuristics_; i++) {
    14333             heuristic_[i]->setModelOnly(this);
    1433414325            if (heuristic_[i]->exitNow(bestObjective_))
    1433514326                exitNow = true;
     
    1494114932            if (feasible) {
    1494214933                int iObject ;
     14934                int preferredWay ;
    1494314935                int numberUnsatisfied = 0 ;
    1494414936                memcpy(currentSolution_, solver_->getColSolution(),
     
    1494914941                for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
    1495014942                    double infeasibility =
    14951                         object_[iObject]->checkInfeasibility(&usefulInfo) ;
     14943                        object_[iObject]->infeasibility(&usefulInfo, preferredWay) ;
    1495214944                    if (infeasibility ) numberUnsatisfied++ ;
    1495314945                }
     
    1735417346    {
    1735517347        int iObject ;
     17348        int preferredWay ;
    1735617349        int numberUnsatisfied = 0 ;
    1735717350        memcpy(currentSolution_, solver_->getColSolution(),
     
    1736217355        for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
    1736317356            double infeasibility =
    17364                 object_[iObject]->checkInfeasibility(&usefulInfo) ;
     17357                object_[iObject]->infeasibility(&usefulInfo, preferredWay) ;
    1736517358            if (infeasibility) numberUnsatisfied++ ;
    1736617359        }
  • releases/2.8.12/Cbc/src/CbcNode.cpp

    r2366 r2366  
    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]);
    704701                            if (hotstartPriorities)
    705702                                priorityLevel = hotstartPriorities[iColumn];
     
    14151412                        choice[i].possibleBranch = NULL;
    14161413                        const OsiObject * object = model->object(thisChoice.objectNumber);
    1417                         double infeasibility = object->checkInfeasibility(&usefulInfo);
     1414                        int preferredWay;
     1415                        double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
    14181416                        if (!infeasibility) {
    14191417                            // take out
     
    16281626            CbcObject * obj =   dynamic_cast <CbcObject *>(object) ;
    16291627            if (!obj || !obj->optionalObject()) {
    1630                 double infeasibility = object->checkInfeasibility(&usefulInfo);
     1628                int preferredWay;
     1629                double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
    16311630                if (infeasibility) {
    16321631                    useOldWay = true;
     
    20482047                CbcSimpleIntegerDynamicPseudoCost * dynamicObject =
    20492048                    dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object) ;
    2050                 double infeasibility = object->checkInfeasibility(&usefulInfo);
     2049                int preferredWay;
     2050                double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
    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                                    }
    20772084                                    priorityLevel = CoinAbs(priorityLevel);
    20782085                                } else if (priorityLevel < 0) {
    20792086                                    priorityLevel = CoinAbs(priorityLevel);
    2080                                     if (targetValue == saveLower[iColumn] ||
    2081                                     targetValue == saveUpper[iColumn]) {
     2087                                    if (targetValue == saveLower[iColumn]) {
    20822088                                        infeasibility = integerTolerance + 1.0e-12;
     2089                                        preferredWay = -1;
     2090                                    } else if (targetValue == saveUpper[iColumn]) {
     2091                                        infeasibility = integerTolerance + 1.0e-12;
     2092                                        preferredWay = 1;
    20832093                                    } else {
    20842094                                        // can't
     
    35783588            if (branch_) {
    35793589                 const OsiObject * object = model->object(bestChoice);
    3580                  double infeasibility = object->checkInfeasibility(&usefulInfo);
     3590                 int preferredWay;
     3591                 double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
    35813592                 if (!infeasibility) {
    35823593                   // take out
     
    35843595                   branch_ = NULL;
    35853596                 } else {
    3586                    // get preferred way
    3587                    int preferredWay;
    3588                    object->infeasibility(&usefulInfo, preferredWay);
    35893597                   CbcBranchingObject * branchObj =
    35903598                     dynamic_cast <CbcBranchingObject *>(branch_) ;
     
    38213829        if (!dynamicObject)
    38223830            continue;
    3823         double infeasibility = object->checkInfeasibility(&usefulInfo);
     3831        int preferredWay;
     3832        double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
    38243833        int iColumn = dynamicObject->columnNumber();
    38253834        if (saveUpper[iColumn] == saveLower[iColumn])
  • releases/2.8.12/Cbc/src/CbcSolver.cpp

    r2366 r2366  
    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("off");
     659    parameters_[whichParam(CBC_PARAM_STR_COMBINE, numberParameters_, parameters_)].setCurrentOption("on");
    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
    1292 static void printGeneralMessage(CbcModel &model,const char * message);
    1293 #endif
    12941291/*
    12951292  Meaning of whereFrom:
     
    13111308    bool noPrinting = parameterData.noPrinting_;
    13121309    bool useSignalHandler = parameterData.useSignalHandler_;
    1313 #ifdef GENERAL_HANDLER_PRINTING
    1314     //char printByHandler[1000];
    1315 #endif
    13161310    CbcModel & model_ = model;
    13171311#ifdef CBC_THREAD_SAFE
     
    29882982#ifdef COIN_HAS_ASL
    29892983                            if (statusUserFunction_[0]) {
    2990                                 double value = model2->getObjValue();
     2984                                double value = model2->getObjValue() * model2->getObjSense();
    29912985                                char buf[300];
    29922986                                int pos = 0;
     
    30533047                        } else {
    30543048#ifndef DISALLOW_PRINTING
    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
     3049                            std::cout << "** Current model not valid" << std::endl;
    30613050#endif
    30623051                        }
     
    30963085                        } else {
    30973086#ifndef DISALLOW_PRINTING
    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
     3087                            std::cout << "** Current model not valid" << std::endl;
    31043088#endif
    31053089                        }
     
    31083092                        if (goodModel) {
    31093093                            int numberInfeasibilities = lpSolver->tightenPrimalBounds();
    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                             }
     3094                            if (numberInfeasibilities)
     3095                                std::cout << "** Analysis indicates model infeasible" << std::endl;
    31183096                        } else {
    31193097#ifndef DISALLOW_PRINTING
    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
     3098                            std::cout << "** Current model not valid" << std::endl;
    31263099#endif
    31273100                        }
     
    31373110                                    lpSolver->replaceMatrix(newMatrix);
    31383111                                    delete saveMatrix;
    3139 #ifdef GENERAL_HANDLER_PRINTING
    3140                                     sprintf(generalPrint, "Matrix converted to +- one matrix");
    3141                                     printGeneralMessage(model_,generalPrint);
    3142 #else
    31433112                                    std::cout << "Matrix converted to +- one matrix" << std::endl;
    3144 #endif
    31453113                                } else {
    3146 #ifdef GENERAL_HANDLER_PRINTING
    3147                                   sprintf(generalPrint, "Matrix can not be converted to +- 1 matrix");
    3148                                   printGeneralMessage(model_,generalPrint);
    3149 #else
    31503114                                    std::cout << "Matrix can not be converted to +- 1 matrix" << std::endl;
    3151 #endif
    31523115                                }
    31533116                            } else {
    3154 #ifdef GENERAL_HANDLER_PRINTING
    3155                               sprintf(generalPrint, "Matrix not a ClpPackedMatrix");
    3156                               printGeneralMessage(model_,generalPrint);
    3157 #else
    31583117                                std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
    3159 #endif
    31603118                            }
    31613119                        } else {
    31623120#ifndef DISALLOW_PRINTING
    3163 #ifdef GENERAL_HANDLER_PRINTING
    3164                           sprintf(generalPrint, "** Current model not valid");
    3165                           printGeneralMessage(model_,generalPrint);
    3166 #else
    31673121                            std::cout << "** Current model not valid" << std::endl;
    3168 #endif
    31693122#endif
    31703123                        }
     
    31863139                        } else {
    31873140#ifndef DISALLOW_PRINTING
    3188 #ifdef GENERAL_HANDLER_PRINTING
    3189                           sprintf(generalPrint, "** Current model not valid");
    3190                           printGeneralMessage(model_,generalPrint);
    3191 #else
    31923141                            std::cout << "** Current model not valid" << std::endl;
    3193 #endif
    31943142#endif
    31953143                        }
     
    32063154                                    lpSolver->replaceMatrix(newMatrix);
    32073155                                    delete saveMatrix;
    3208 #ifdef GENERAL_HANDLER_PRINTING
    3209                                     sprintf(generalPrint, "Matrix converted to network matrix");
    3210                                     printGeneralMessage(model_,generalPrint);
    3211 #else
    32123156                                    std::cout << "Matrix converted to network matrix" << std::endl;
    3213 #endif
    32143157                                } else {
    3215 #ifdef GENERAL_HANDLER_PRINTING
    3216                                   sprintf(generalPrint, "Matrix can not be converted to network matrix");
    3217                                   printGeneralMessage(model_,generalPrint);
    3218 #else
    32193158                                    std::cout << "Matrix can not be converted to network matrix" << std::endl;
    3220 #endif
    32213159                                }
    32223160                            } else {
    3223 #ifdef GENERAL_HANDLER_PRINTING
    3224                               sprintf(generalPrint, "Matrix not a ClpPackedMatrix");
    3225                               printGeneralMessage(model_,generalPrint);
    3226 #else
    32273161                                std::cout << "Matrix not a ClpPackedMatrix" << std::endl;
    3228 #endif
    32293162                            }
    32303163                        } else {
    32313164#ifndef DISALLOW_PRINTING
    3232 #ifdef GENERAL_HANDLER_PRINTING
    3233                           sprintf(generalPrint, "** Current model not valid");
    3234                           printGeneralMessage(model_,generalPrint);
    3235 #else
    32363165                            std::cout << "** Current model not valid" << std::endl;
    3237 #endif
    32383166#endif
    32393167                        }
     
    35243452                                            if (clpModel->tightenPrimalBounds() != 0) {
    35253453#ifndef DISALLOW_PRINTING
    3526 #ifdef GENERAL_HANDLER_PRINTING
    3527                                               sprintf(generalPrint, "Problem is infeasible - tightenPrimalBounds!");
    3528                                               printGeneralMessage(model_,generalPrint);
    3529 #else
    35303454                                                std::cout << "Problem is infeasible - tightenPrimalBounds!" << std::endl;
    3531 #endif
    35323455#endif
    35333456                                                break;
     
    37013624                                if (!complicatedInteger && preProcess == 0 && clpSolver->tightenPrimalBounds(0.0, 0, true) != 0) {
    37023625#ifndef DISALLOW_PRINTING
    3703 #ifdef GENERAL_HANDLER_PRINTING
    3704                                   sprintf(generalPrint, "Problem is infeasible - tightenPrimalBounds!");
    3705                                   printGeneralMessage(model_,generalPrint);
    3706 #else
    37073626                                    std::cout << "Problem is infeasible - tightenPrimalBounds!" << std::endl;
    3708 #endif
    37093627#endif
    37103628                                    model_.setProblemStatus(0);
     
    38113729                                    if (modelC->tightenPrimalBounds(tightenFactor) != 0) {
    38123730#ifndef DISALLOW_PRINTING
    3813 #ifdef GENERAL_HANDLER_PRINTING
    3814                                       sprintf(generalPrint, "Problem is infeasible!");
    3815                                       printGeneralMessage(model_,generalPrint);
    3816 #else
    38173731                                        std::cout << "Problem is infeasible!" << std::endl;
    3818 #endif
    38193732#endif
    38203733                                        model_.setProblemStatus(0);
     
    44704383                                if (!complicatedInteger && modelC->tightenPrimalBounds() != 0) {
    44714384#ifndef DISALLOW_PRINTING
    4472 #ifdef GENERAL_HANDLER_PRINTING
    4473                                   sprintf(generalPrint, "Problem is infeasible!");
    4474                                   printGeneralMessage(model_,generalPrint);
    4475 #else
    44764385                                    std::cout << "Problem is infeasible!" << std::endl;
    4477 #endif
    44784386#endif
    44794387                                    model_.setProblemStatus(0);
     
    71607068#endif
    71617069                            } else {
    7162 #ifdef GENERAL_HANDLER_PRINTING
    7163                               sprintf(generalPrint, "Model strengthened - now has %d rows",
    7164                                       clpSolver->getNumRows());
    7165                               printGeneralMessage(model_,generalPrint);
    7166 #else
    71677070                                std::cout << "Model strengthened - now has " << clpSolver->getNumRows()
    71687071                                          << " rows" << std::endl;
    7169 #endif
    71707072                            }
    71717073                            time1 = time2;
     
    71847086                        } else {
    71857087#ifndef DISALLOW_PRINTING
    7186 #ifdef GENERAL_HANDLER_PRINTING
    7187                           sprintf(generalPrint, "** Current model not valid");
    7188                           printGeneralMessage(model_,generalPrint);
    7189 #else
    71907088                            std::cout << "** Current model not valid" << std::endl ;
    7191 #endif
    71927089#endif
    71937090                        }
     
    73177214                                    } else {
    73187215                                        canOpen = false;
    7319 #ifdef GENERAL_HANDLER_PRINTING
    7320                                         sprintf(generalPrint, "Unable to open file %s",gmplData.c_str());
    7321                                         printGeneralMessage(model_,generalPrint);
    7322 #else
    73237216                                        std::cout << "Unable to open file " << gmplData << std::endl;
    7324 #endif
    73257217                                    }
    73267218                                }
    73277219                            } else {
    7328 #ifdef GENERAL_HANDLER_PRINTING
    7329                               sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    7330                               printGeneralMessage(model_,generalPrint);
    7331 #else
    73327220                                std::cout << "Unable to open file " << fileName << std::endl;
    7333 #endif
    73347221                            }
    73357222                        }
     
    73987285                            } else {
    73997286                                // errors
    7400 #ifdef GENERAL_HANDLER_PRINTING
    7401                               sprintf(generalPrint, "There were %d errors on input",status);
    7402                               printGeneralMessage(model_,generalPrint);
    7403 #else
    74047287                                std::cout << "There were " << status <<
    74057288                                          " errors on input" << std::endl;
    7406 #endif
    74077289                            }
    74087290                        }
     
    74617343                                    canOpen = true;
    74627344                                } else {
    7463 #ifdef GENERAL_HANDLER_PRINTING
    7464                                   sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    7465                                   printGeneralMessage(model_,generalPrint);
    7466 #else
    74677345                                    std::cout << "Unable to open file " << fileName << std::endl;
    7468 #endif
    74697346                                }
    74707347                            }
     
    75357412                                canOpen = true;
    75367413                            } else {
    7537 #ifdef GENERAL_HANDLER_PRINTING
    7538                                   sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    7539                                   printGeneralMessage(model_,generalPrint);
    7540 #else
    75417414                                std::cout << "Unable to open file " << fileName << std::endl;
    7542 #endif
    75437415                            }
    75447416                            if (canOpen) {
     
    76477519                        } else {
    76487520#ifndef DISALLOW_PRINTING
    7649 #ifdef GENERAL_HANDLER_PRINTING
    7650                           sprintf(generalPrint, "** Current model not valid");
    7651                           printGeneralMessage(model_,generalPrint);
    7652 #else
    76537521                            std::cout << "** Current model not valid" << std::endl;
    7654 #endif
    76557522#endif
    76567523                        }
     
    76957562                                    canOpen = true;
    76967563                                } else {
    7697 #ifdef GENERAL_HANDLER_PRINTING
    7698                                   sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    7699                                   printGeneralMessage(model_,generalPrint);
    7700 #else
    77017564                                    std::cout << "Unable to open file " << fileName << std::endl;
    7702 #endif
    77037565                                }
    77047566                            }
     
    77167578                        } else {
    77177579#ifndef DISALLOW_PRINTING
    7718 #ifdef GENERAL_HANDLER_PRINTING
    7719                           sprintf(generalPrint, "** Current model not valid");
    7720                           printGeneralMessage(model_,generalPrint);
    7721 #else
    77227580                            std::cout << "** Current model not valid" << std::endl;
    7723 #endif
    77247581#endif
    77257582                        }
     
    80167873                                fclose(fp);
    80177874                            } else {
    8018 #ifdef GENERAL_HANDLER_PRINTING
    8019                               sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    8020                               printGeneralMessage(model_,generalPrint);
    8021 #else
    80227875                                std::cout << "Unable to open file " << fileName << std::endl;
    8023 #endif
    80247876                            }
    80257877                        } else {
    80267878#ifndef DISALLOW_PRINTING
    8027 #ifdef GENERAL_HANDLER_PRINTING
    8028                           sprintf(generalPrint, "** Current model not valid");
    8029                           printGeneralMessage(model_,generalPrint);
    8030 #else
    80317879                            std::cout << "** Current model not valid" << std::endl;
    8032 #endif
    80337880#endif
    80347881                        }
     
    80777924                        } else {
    80787925#ifndef DISALLOW_PRINTING
    8079 #ifdef GENERAL_HANDLER_PRINTING
    8080                           sprintf(generalPrint, "** Current model not valid");
    8081                           printGeneralMessage(model_,generalPrint);
    8082 #else
    80837926                            std::cout << "** Current model not valid" << std::endl;
    8084 #endif
    80857927#endif
    80867928                        }
     
    81598001                                fclose(fp);
    81608002                            } else {
    8161 #ifdef GENERAL_HANDLER_PRINTING
    8162                               sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    8163                               printGeneralMessage(model_,generalPrint);
    8164 #else
    81658003                                std::cout << "Unable to open file " << fileName << std::endl;
    8166 #endif
    81678004                            }
    81688005                        } else {
    81698006#ifndef DISALLOW_PRINTING
    8170 #ifdef GENERAL_HANDLER_PRINTING
    8171                           sprintf(generalPrint, "** Current model not valid");
    8172                           printGeneralMessage(model_,generalPrint);
    8173 #else
    81748007                            std::cout << "** Current model not valid" << std::endl;
    8175 #endif
    81768008#endif
    81778009                        }
     
    82238055                                canOpen = true;
    82248056                            } else {
    8225 #ifdef GENERAL_HANDLER_PRINTING
    8226                               sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    8227                               printGeneralMessage(model_,generalPrint);
    8228 #else
    82298057                                std::cout << "Unable to open file " << fileName << std::endl;
    8230 #endif
    82318058                            }
    82328059                            if (canOpen) {
     
    82398066                        } else {
    82408067#ifndef DISALLOW_PRINTING
    8241 #ifdef GENERAL_HANDLER_PRINTING
    8242                           sprintf(generalPrint, "** Current model not valid");
    8243                           printGeneralMessage(model_,generalPrint);
    8244 #else
    82458068                            std::cout << "** Current model not valid" << std::endl;
    8246 #endif
    82478069#endif
    82488070                        }
     
    82818103                            canOpen = true;
    82828104                        } else {
    8283 #ifdef GENERAL_HANDLER_PRINTING
    8284                           sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    8285                           printGeneralMessage(model_,generalPrint);
    8286 #else
    82878105                            std::cout << "Unable to open file " << fileName << std::endl;
    8288 #endif
    82898106                        }
    82908107                        if (canOpen) {
     
    83258142                            } else {
    83268143                                // errors
    8327 #ifdef GENERAL_HANDLER_PRINTING
    8328                               sprintf(generalPrint, "There were errors on output");
    8329                               printGeneralMessage(model_,generalPrint);
    8330 #else
    83318144                                std::cout << "There were errors on output" << std::endl;
    8332 #endif
    83338145                            }
    83348146                        }
     
    83688180                            canOpen = true;
    83698181                        } else {
    8370 #ifdef GENERAL_HANDLER_PRINTING
    8371                           sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    8372                           printGeneralMessage(model_,generalPrint);
    8373 #else
    83748182                            std::cout << "Unable to open file " << fileName << std::endl;
    8375 #endif
    83768183                        }
    83778184                        if (canOpen) {
     
    83848191                            } else {
    83858192                                // errors
    8386 #ifdef GENERAL_HANDLER_PRINTING
    8387                               sprintf(generalPrint, "There were errors on input");
    8388                               printGeneralMessage(model_,generalPrint);
    8389 #else
    83908193                                std::cout << "There were errors on input" << std::endl;
    8391 #endif
    83928194                            }
    83938195                        }
     
    85068308                            double value = CoinReadGetDoubleField(argc, argv, &valid);
    85078309                            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
    85128310                                std::cout << "Setting " << parameters_[iParam].name() <<
    85138311                                          " to DEBUG " << value << std::endl;
    8514 #endif
    85158312                                int iRow;
    85168313                                int numberRows = lpSolver->numberRows();
     
    87498546                            fclose(fp);
    87508547                        } else {
    8751 #ifdef GENERAL_HANDLER_PRINTING
    8752                           sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    8753                           printGeneralMessage(model_,generalPrint);
    8754 #else
    87558548                            std::cout << "Unable to open file " << fileName << std::endl;
    8756 #endif
    87578549                        }
    87588550                    }
     
    94329224                                }
    94339225                            } else {
    9434 #ifdef GENERAL_HANDLER_PRINTING
    9435                               sprintf(generalPrint, "Unable to open file %s",fileName.c_str());
    9436                               printGeneralMessage(model_,generalPrint);
    9437 #else
    94389226                                std::cout << "Unable to open file " << fileName << std::endl;
    9439 #endif
    94409227                            }
    94419228                        } else {
    94429229#ifndef DISALLOW_PRINTING
    9443 #ifdef GENERAL_HANDLER_PRINTING
    9444                           sprintf(generalPrint, "** Current model not valid");
    9445                           printGeneralMessage(model_,generalPrint);
    9446 #else
    94479230                            std::cout << "** Current model not valid" << std::endl;
    9448 #endif
    94499231#endif
    94509232                        }
     
    94809262                        } else {
    94819263#ifndef DISALLOW_PRINTING
    9482 #ifdef GENERAL_HANDLER_PRINTING
    9483                           sprintf(generalPrint, "** Current model not valid");
    9484                           printGeneralMessage(model_,generalPrint);
    9485 #else
    94869264                            std::cout << "** Current model not valid" << std::endl;
    9487 #endif
    94889265#endif
    94899266                        }
     
    95279304                               time1 = time2;
    95289305                          } else {
    9529 #ifdef GENERAL_HANDLER_PRINTING
    9530                             sprintf(generalPrint, "** Current model not valid");
    9531                             printGeneralMessage(model_,generalPrint);
    9532 #else
    95339306                               std::cout << "** Current model not valid" << std::endl;
    9534 #endif
    95359307                          }
    95369308                          break;
     
    97829554    parameters[whichParam(CBC_PARAM_STR_FPUMP, numberParameters, parameters)].setCurrentOption("on");
    97839555    parameters[whichParam(CBC_PARAM_STR_GREEDY, numberParameters, parameters)].setCurrentOption("on");
    9784     parameters[whichParam(CBC_PARAM_STR_COMBINE, numberParameters, parameters)].setCurrentOption("off");
     9556    parameters[whichParam(CBC_PARAM_STR_COMBINE, numberParameters, parameters)].setCurrentOption("on");
    97859557    parameters[whichParam(CBC_PARAM_STR_CROSSOVER2, numberParameters, parameters)].setCurrentOption("off");
    97869558    parameters[whichParam(CBC_PARAM_STR_PIVOTANDCOMPLEMENT, numberParameters, parameters)].setCurrentOption("off");
     
    1032610098    printf("C++ file written to %s\n", fileName);
    1032710099}
    10328 #ifdef GENERAL_HANDLER_PRINTING
    10329 // Print a general message
    10330 static void printGeneralMessage(CbcModel &model,const char * message)
    10331 {
    10332   model.messageHandler()->message(CBC_FPUMP1, model.messages())
    10333     << message
    10334     << CoinMessageEol;
    10335 }
    10336 #endif
    1033710100/*
    1033810101  Version 1.00.00 November 16 2005.
  • releases/2.8.12/Cbc/src/CbcThread.cpp

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

    r2366 r2366  
    122122bool OsiCbcSolverInterface::isAbandoned() const
    123123{
    124   if (modelPtr_->status()!=-1)
    125     return modelPtr_->isAbandoned();
    126   else
    127     return modelPtr_->solver()->isAbandoned();
     124  return modelPtr_->solver()->isAbandoned();
    128125}
    129126
    130127bool OsiCbcSolverInterface::isProvenOptimal() const
    131128{
    132   if (modelPtr_->status()!=-1)
    133     return modelPtr_->isProvenOptimal();
    134   else
    135     return modelPtr_->solver()->isProvenOptimal();
     129  return modelPtr_->solver()->isProvenOptimal();
    136130}
    137131
    138132bool OsiCbcSolverInterface::isProvenPrimalInfeasible() const
    139133{
    140   if (modelPtr_->status()!=-1)
    141     return modelPtr_->isProvenInfeasible();
    142   else
    143     return modelPtr_->solver()->isProvenPrimalInfeasible();
     134  return modelPtr_->solver()->isProvenPrimalInfeasible();
    144135}
    145136
    146137bool OsiCbcSolverInterface::isProvenDualInfeasible() const
    147138{
    148   if (modelPtr_->status()!=-1)
    149   return modelPtr_->isProvenDualInfeasible();
    150   else
    151139  return modelPtr_->solver()->isProvenDualInfeasible();
    152140}
     
    163151bool OsiCbcSolverInterface::isIterationLimitReached() const
    164152{
    165   if (modelPtr_->status()!=-1)
    166     return modelPtr_->isNodeLimitReached();
    167   else
    168     return modelPtr_->solver()->isIterationLimitReached();
     153  return modelPtr_->solver()->isIterationLimitReached();
    169154}
    170155
  • releases/2.8.12/Cbc/src/config_cbc_default.h

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

    r2366 r2366  
    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.13.
     4# Generated by GNU Autoconf 2.59 for Cbc 2.8.12.
    55#
    66# Report bugs to <cbc@lists.coin-or.org>.
     
    431431PACKAGE_NAME='Cbc'
    432432PACKAGE_TARNAME='cbc'
    433 PACKAGE_VERSION='2.8.13'
    434 PACKAGE_STRING='Cbc 2.8.13'
     433PACKAGE_VERSION='2.8.12'
     434PACKAGE_STRING='Cbc 2.8.12'
    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.13 to adapt to many kinds of systems.
     1041\`configure' configures Cbc 2.8.12 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.13:";;
     1107     short | recursive ) echo "Configuration of Cbc 2.8.12:";;
    11081108   esac
    11091109  cat <<\_ACEOF
     
    13281328if $ac_init_version; then
    13291329  cat <<\_ACEOF
    1330 Cbc configure 2.8.13
     1330Cbc configure 2.8.12
    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.13, which was
     1350It was created by Cbc $as_me 2.8.12, which was
    13511351generated by GNU Autoconf 2.59.  Invocation command line was
    13521352
     
    19461946             fi
    19471947             ;;
    1948   *-*-darwin*) comps="clang gcc cc" ;;
     1948  *-*-darwin*) comps="clang gcc" ;;
    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="clang++ g++ c++ CC" ;;
     3107  *-darwin*) comps="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* | */clang*) ;;
     3544  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.13'
     5117 VERSION='2.8.12'
    51185118
    51195119
     
    2343423434cat >&5 <<_CSEOF
    2343523435
    23436 This file was extended by Cbc $as_me 2.8.13, which was
     23436This file was extended by Cbc $as_me 2.8.12, 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.13
     23494Cbc config.status 2.8.12
    2349523495configured by $0, generated by GNU Autoconf 2.59,
    2349623496  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
  • releases/2.8.12/configure.ac

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