Changes from releases/2.8.9 at r2366 to releases/2.8.8 at r2366


Ignore:
Location:
releases
Files:
2 deleted
10 edited

Legend:

Unmodified
Added
Removed
  • releases/2.8.8/Cbc

  • releases/2.8.8/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.9.
     3# Generated by GNU Autoconf 2.59 for Cbc 2.8.8.
    44#
    55# Report bugs to <cbc@lists.coin-or.org>.
     
    430430PACKAGE_NAME='Cbc'
    431431PACKAGE_TARNAME='cbc'
    432 PACKAGE_VERSION='2.8.9'
    433 PACKAGE_STRING='Cbc 2.8.9'
     432PACKAGE_VERSION='2.8.8'
     433PACKAGE_STRING='Cbc 2.8.8'
    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.9 to adapt to many kinds of systems.
     1008\`configure' configures Cbc 2.8.8 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.9:";;
     1074     short | recursive ) echo "Configuration of Cbc 2.8.8:";;
    10751075   esac
    10761076  cat <<\_ACEOF
     
    13061306if $ac_init_version; then
    13071307  cat <<\_ACEOF
    1308 Cbc configure 2.8.9
     1308Cbc configure 2.8.8
    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.9, which was
     1328It was created by Cbc $as_me 2.8.8, 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:9:8
     1854 coin_libversion=11:8:8
    18551855
    18561856
     
    46154615# Define the identity of the package.
    46164616 PACKAGE='cbc'
    4617  VERSION='2.8.9'
     4617 VERSION='2.8.8'
    46184618
    46194619
     
    3120031200cat >&5 <<_CSEOF
    3120131201
    31202 This file was extended by Cbc $as_me 2.8.9, which was
     31202This file was extended by Cbc $as_me 2.8.8, which was
    3120331203generated by GNU Autoconf 2.59.  Invocation command line was
    3120431204
     
    3126331263cat >>$CONFIG_STATUS <<_ACEOF
    3126431264ac_cs_version="\\
    31265 Cbc config.status 2.8.9
     31265Cbc config.status 2.8.8
    3126631266configured by $0, generated by GNU Autoconf 2.59,
    3126731267  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
  • releases/2.8.8/Cbc/configure.ac

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

    r2366 r2366  
    20392039          flipModel();
    20402040        return ;
    2041     } else if (!numberObjects_) {
     2041    } else if (!numberObjects_ && (!strategy_ || strategy_->preProcessState() <= 0)) {
    20422042        // nothing to do
    2043         // Undo preprocessing performed during BaB.
    2044         if (strategy_ && strategy_->preProcessState() > 0) {
    2045           // undo preprocessing
    2046           CglPreProcess * process = strategy_->process();
    2047           assert (process);
    2048           int n = originalSolver->getNumCols();
    2049           if (bestSolution_) {
    2050             delete [] bestSolution_;
    2051             bestSolution_ = new double [n];
    2052             process->postProcess(*solver_);
    2053           }
    2054           strategy_->deletePreProcess();
    2055           // Solution now back in originalSolver
    2056           delete solver_;
    2057           solver_ = originalSolver;
    2058           if (bestSolution_) {
    2059             bestObjective_ = solver_->getObjValue() * solver_->getObjSense();
    2060             memcpy(bestSolution_, solver_->getColSolution(), n*sizeof(double));
    2061           }
    2062           // put back original objects if there were any
    2063           if (originalObject) {
    2064             int iColumn;
    2065             assert (ownObjects_);
    2066             for (iColumn = 0; iColumn < numberObjects_; iColumn++)
    2067               delete object_[iColumn];
    2068             delete [] object_;
    2069             numberObjects_ = numberOriginalObjects;
    2070             object_ = originalObject;
    2071             delete [] integerVariable_;
    2072             numberIntegers_ = 0;
    2073             for (iColumn = 0; iColumn < n; iColumn++) {
    2074               if (solver_->isInteger(iColumn))
    2075                 numberIntegers_++;
    2076             }
    2077             integerVariable_ = new int[numberIntegers_];
    2078             numberIntegers_ = 0;
    2079             for (iColumn = 0; iColumn < n; iColumn++) {
    2080             if (solver_->isInteger(iColumn))
    2081               integerVariable_[numberIntegers_++] = iColumn;
    2082             }
    2083           }
    2084         }
    20852043        if (flipObjective)
    20862044          flipModel();
     
    1083710795void CbcModel::synchronizeModel()
    1083810796{
    10839     if (!numberObjects_)
    10840       return;
    1084110797    int i;
    1084210798    for (i = 0; i < numberHeuristics_; i++)
  • releases/2.8.8/Cbc/src/CbcSolver.cpp

    r2366 r2366  
    809809#endif
    810810
     811static double totalTime = 0.0;
    811812static void statistics(ClpSimplex * originalModel, ClpSimplex * model);
    812813static bool maskMatches(const int * starts, char ** masks,
     
    969970FILE * CbcOrClpReadCommand = stdin;
    970971extern int CbcOrClpEnvironmentIndex;
    971 
    972 int callCbc1(const char * input2, CbcModel & model,
    973              int callBack(CbcModel * currentSolver, int whereFrom),
    974              CbcSolverUsefulData & parameterData);
     972static bool noPrinting = false;
     973
     974
    975975
    976976/*
     
    10251025int callCbc(const char * input2, CbcModel & babSolver)
    10261026{
    1027   CbcSolverUsefulData data;
    1028 #ifndef CBC_NO_INTERRUPT
    1029     data.useSignalHandler_=true;
    1030 #endif
    1031 #ifndef CBC_NO_PRINTING
    1032     data.noPrinting_ = false;
    1033 #endif
    1034   CbcMain0(babSolver, data);
    1035   return callCbc1(input2, babSolver, dummyCallBack, data);
     1027    CbcMain0(babSolver);
     1028    return callCbc1(input2, babSolver);
    10361029}
    10371030
     
    10761069    return returnCode;
    10771070}
     1071
    10781072int callCbc1(const char * input2, CbcModel & model,
    1079              int callBack(CbcModel * currentSolver, int whereFrom),
    1080              CbcSolverUsefulData & parameterData)
     1073             int callBack(CbcModel * currentSolver, int whereFrom))
    10811074{
    10821075    char * input = CoinStrdup(input2);
     
    11241117    argv[n+1] = CoinStrdup("-quit");
    11251118    free(input);
     1119    totalTime = 0.0;
    11261120    currentBranchModel = NULL;
    11271121    CbcOrClpRead_mode = 1;
    11281122    CbcOrClpReadCommand = stdin;
     1123    noPrinting = false;
    11291124    int returnCode = CbcMain1(n + 2, const_cast<const char **>(argv),
    1130                               model, callBack,parameterData);
     1125                              model, callBack);
    11311126    for (int k = 0; k < n + 2; k++)
    11321127        free(argv[k]);
     
    11341129    return returnCode;
    11351130}
    1136 static CbcSolverUsefulData staticParameterData;
    1137 int callCbc1(const char * input2, CbcModel & model,
    1138              int callBack(CbcModel * currentSolver, int whereFrom))
    1139 {
    1140   // allow interrupts and printing
    1141 #ifndef CBC_NO_INTERRUPT
    1142   staticParameterData.useSignalHandler_=true;
    1143 #endif
    1144 #ifndef CBC_NO_PRINTING
    1145   staticParameterData.noPrinting_ = false;
    1146 #endif
    1147   return callCbc1(input2,model,callBack,staticParameterData);
    1148 }
    1149 
     1131
     1132static CbcOrClpParam parameters[CBCMAXPARAMETERS];
     1133static int numberParameters = 0 ;
    11501134CglPreProcess * cbcPreProcessPointer=NULL;
    11511135
     
    11591143    return CbcMain1(argc, argv, model, dummyCallBack);
    11601144}
    1161 #ifdef CBC_THREAD_SAFE
    1162 // Copies of some input decoding
    1163 
    1164 static std::string
    1165 CoinReadGetCommand(int &whichArgument, int argc, const char *argv[])
    1166 {
    1167   std::string field;
    1168   if (whichArgument < argc)
    1169     field = argv[whichArgument++];
    1170   else
    1171     field = "quit";
    1172   if (field[0] == '-')
    1173     field = field.substr(1);
    1174   return field;
    1175 }
    1176 static std::string
    1177 CoinReadGetString(int &whichArgument, int argc, const char *argv[])
    1178 {
    1179   std::string field;
    1180   if (whichArgument < argc)
    1181     field = argv[whichArgument++];
    1182   else
    1183     field = "";
    1184   return field;
    1185 }
    1186 // valid 0 - okay, 1 bad, 2 not there
    1187 static int
    1188 CoinReadGetIntField(int &whichArgument, int argc, const char *argv[], int * valid)
    1189 {
    1190   std::string field;
    1191   if (whichArgument < argc)
    1192     field = argv[whichArgument++];
    1193   else
    1194     field = "0";
    1195   long int value = 0;
    1196   const char * start = field.c_str();
    1197   char * endPointer = NULL;
    1198   // check valid
    1199   value =  strtol(start, &endPointer, 10);
    1200   if (*endPointer == '\0') {
    1201     *valid = 0;
    1202   } else {
    1203     *valid = 1;
    1204     std::cout << "String of " << field;
    1205   }
    1206   return static_cast<int>(value);
    1207 }
    1208 static double
    1209 CoinReadGetDoubleField(int &whichArgument, int argc, const char *argv[], int * valid)
    1210 {
    1211   std::string field;
    1212   if (whichArgument < argc)
    1213     field = argv[whichArgument++];
    1214   else
    1215     field = "0.0";
    1216   double value = 0.0;
    1217   const char * start = field.c_str();
    1218   char * endPointer = NULL;
    1219   // check valid
    1220   value =  strtod(start, &endPointer);
    1221   if (*endPointer == '\0') {
    1222     *valid = 0;
    1223   } else {
    1224     *valid = 1;
    1225     std::cout << "String of " << field;
    1226   }
    1227   return value;
    1228 }
    1229 // Redefine all
    1230 #define CoinReadGetCommand(x,y) CoinReadGetCommand(whichArgument,x,y)
    1231 #define CoinReadGetString(x,y) CoinReadGetString(whichArgument,x,y)
    1232 #define CoinReadGetIntField(x,y,z) CoinReadGetIntField(whichArgument,x,y,z)
    1233 #define CoinReadGetDoubleField(x,y,z) CoinReadGetDoubleField(whichArgument,x,y,z)
    1234 #endif
    1235 // Default Constructor
    1236 CbcSolverUsefulData::CbcSolverUsefulData()
    1237 {
    1238   totalTime_ = 0.0;
    1239   noPrinting_ = true;
    1240   useSignalHandler_ = false;
    1241   establishParams(numberParameters_,parameters_);
    1242 }
    1243 
    1244 /* Copy constructor .
    1245  */
    1246 CbcSolverUsefulData::CbcSolverUsefulData(const CbcSolverUsefulData & rhs)
    1247 {
    1248   totalTime_ = rhs.totalTime_;
    1249   noPrinting_ = rhs.noPrinting_;
    1250   useSignalHandler_ = rhs.useSignalHandler_;
    1251   numberParameters_ = rhs.numberParameters_;
    1252   memcpy(parameters_,rhs.parameters_,sizeof(parameters_));
    1253 }
    1254 
    1255 // Assignment operator
    1256 CbcSolverUsefulData & CbcSolverUsefulData::operator=(const CbcSolverUsefulData& rhs)
    1257 {
    1258   if (this != &rhs) {
    1259     totalTime_ = rhs.totalTime_;
    1260     noPrinting_ = rhs.noPrinting_;
    1261     useSignalHandler_ = rhs.useSignalHandler_;
    1262     numberParameters_ = rhs.numberParameters_;
    1263     memcpy(parameters_,rhs.parameters_,sizeof(parameters_));
    1264   }
    1265   return *this;
    1266 }
    1267 
    1268 // Destructor
    1269 CbcSolverUsefulData::~CbcSolverUsefulData ()
    1270 {
    1271 }
     1145
     1146
    12721147/*
    12731148  Meaning of whereFrom:
     
    12841159              int callBack(CbcModel * currentSolver, int whereFrom))
    12851160{
    1286   // allow interrupts and printing
    1287   staticParameterData.noPrinting_ = false;
    1288   staticParameterData.useSignalHandler_=true;
    1289   return CbcMain1(argc,argv,model,callBack,staticParameterData);
    1290 }
    1291 /*
    1292   Meaning of whereFrom:
    1293     1 after initial solve by dualsimplex etc
    1294     2 after preprocessing
    1295     3 just before branchAndBound (so user can override)
    1296     4 just after branchAndBound (before postprocessing)
    1297     5 after postprocessing
    1298     6 after a user called heuristic phase
    1299 */
    1300 int CbcMain1 (int argc, const char *argv[],
    1301               CbcModel  & model,
    1302               int callBack(CbcModel * currentSolver, int whereFrom),
    1303               CbcSolverUsefulData & parameterData)
    1304 {
    1305     CbcOrClpParam * parameters_ = parameterData.parameters_;
    1306     int numberParameters_ = parameterData.numberParameters_;
    1307     double totalTime = parameterData.totalTime_;
    1308     bool noPrinting = parameterData.noPrinting_;
    1309     bool useSignalHandler = parameterData.useSignalHandler_;
     1161    CbcOrClpParam * parameters_ = parameters;
     1162    int numberParameters_ = numberParameters;
    13101163    CbcModel & model_ = model;
    1311 #ifdef CBC_THREAD_SAFE
    1312     // Initialize argument
    1313     int whichArgument=1;
    1314 #endif
    13151164#ifdef CBC_USE_INITIAL_TIME
    13161165    if (model_.useElapsedTime())
     
    13961245        //CoinSighandler_t saveSignal=signal(SIGINT,signal_handler);
    13971246#if CBC_QUIET < 2
    1398         if (useSignalHandler)
    1399           signal(SIGINT, signal_handler);
     1247        signal(SIGINT, signal_handler);
    14001248#endif
    14011249        // Set up all non-standard stuff
     
    22572105                                  addFlags = 1048576*(value/10);
    22582106                                  value = value % 10;
    2259                                   parameters_[whichParam(CBC_PARAM_INT_EXPERIMENT, numberParameters_, parameters_)].setIntValue(value);
     2107                                  parameters[whichParam(CBC_PARAM_INT_EXPERIMENT, numberParameters, parameters)].setIntValue(value);
    22602108                                }
    22612109                                if (value >= 1) {
     
    22692117                                    }
    22702118                                    int extra4 = values[value-1]+addFlags;
    2271                                     parameters_[whichParam(CBC_PARAM_INT_EXTRA4, numberParameters_, parameters_)].setIntValue(extra4);
     2119                                    parameters[whichParam(CBC_PARAM_INT_EXTRA4, numberParameters, parameters)].setIntValue(extra4);
    22722120                                    if (!noPrinting_) {
    22732121                                        generalMessageHandler->message(CLP_GENERAL, generalMessages)
     
    22822130                                        << CoinMessageEol;
    22832131                                    }
    2284                                     parameters_[whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters_, parameters_)].setCurrentOption("forceOnStrong");
     2132                                    parameters[whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters, parameters)].setCurrentOption("forceOnStrong");
    22852133                                    probingAction = 8;
    22862134                                    parameters_[whichParam(CBC_PARAM_STR_GOMORYCUTS, numberParameters_, parameters_)].setCurrentOption("onGlobal");
     
    22912139                                    lpSolver->factorization()->forceOtherFactorization(3);
    22922140                                    parameters_[whichParam(CBC_PARAM_INT_MAXHOTITS, numberParameters_, parameters_)].setIntValue(100);
    2293                                     parameters_[whichParam(CBC_PARAM_INT_CUTPASS, numberParameters_, parameters_)].setIntValue(1000);
     2141                                    parameters[whichParam(CBC_PARAM_INT_CUTPASS, numberParameters, parameters)].setIntValue(1000);
    22942142                                    cutPass = 1000;
    2295                                     parameters_[whichParam(CBC_PARAM_STR_RENS, numberParameters_, parameters_)].setCurrentOption("on");
     2143                                    parameters[whichParam(CBC_PARAM_STR_RENS, numberParameters, parameters)].setCurrentOption("on");
    22962144                                }
    22972145                            } else if (parameters_[iParam].type() == CBC_PARAM_INT_STRATEGY) {
     
    41043952                                if (preProcess == 2) {
    41053953                                    OsiClpSolverInterface * clpSolver2 = dynamic_cast< OsiClpSolverInterface*> (solver2);
    4106 #if 1
    4107                                     ClpSimplex * lpSolver =
    4108                                       clpSolver2->getModelPtr();
     3954                                    ClpSimplex * lpSolver = clpSolver2->getModelPtr();
    41093955                                    lpSolver->writeMps("presolved.mps", 0, 1, lpSolver->optimizationDirection());
    4110 #else
    4111                                     // put back names
    4112                                     ClpSimplex lpSolver(*clpSolver2->getModelPtr());
    4113                                     //OsiClpSolverInterface * originalSolver = dynamic_cast< OsiClpSolverInterface*> (olver);
    4114                                     ClpSimplex * originalLp = clpSolver->getModelPtr();
    4115                                     const int * originalColumns = process.originalColumns();
    4116                                     int numberColumns = lpSolver.getNumCols();
    4117                                     for (int i = 0; i < numberColumns; i++) {
    4118                                       int jColumn = originalColumns[i];
    4119                                       std::string name = originalLp->getColumnName(jColumn);
    4120                                       lpSolver.setColumnName(i,name);
    4121                                     }
    4122                                     lpSolver.writeMps("presolved.mps", 0, 1, lpSolver.optimizationDirection());
    4123 #endif
    41243956                                    printf("Preprocessed model (minimization) on presolved.mps\n");
    41253957                                }
     
    89288760                                    break;
    89298761                                  }
    8930                                   if (printMode<9) {
    8931                                     if (lengthName)
     8762                                  if (lengthName)
    89328763                                    fprintf(fp,",name");
    8933                                     fprintf(fp,",increase,variable,decrease,variable\n");
    8934                                   }
     8764                                  fprintf(fp,",increase,variable,decrease,variable\n");
    89358765                                  int * which = new int [ number];
    89368766                                  if (printMode != 7) {
     
    92669096                               field = CoinReadGetString(argc, argv);
    92679097                               if (field == "$") {
    9268                                     field = parameters_[iParam].stringValue();
     9098                                    field = parameters[iParam].stringValue();
    92699099                               } else if (field == "EOL") {
    9270                                     parameters_[iParam].printString();
     9100                                    parameters[iParam].printString();
    92719101                                    break;
    92729102                               } else {
    9273                                     parameters_[iParam].setStringValue(field);
     9103                                    parameters[iParam].setStringValue(field);
    92749104                               }
    92759105                               std::string fileName;
     
    94029232}
    94039233
     9234
    94049235void CbcMain0 (CbcModel  & model)
    94059236{
    9406   CbcMain0(model,staticParameterData);
    9407 }
    9408 void CbcMain0 (CbcModel  & model,
    9409                CbcSolverUsefulData & parameterData)
    9410 {
    9411     CbcOrClpParam * parameters = parameterData.parameters_;
    9412     int numberParameters = parameterData.numberParameters_;
    94139237#ifndef CBC_OTHER_SOLVER
    94149238    OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model.solver());
     
    94309254    lpSolver->messageHandler()->setPrefix(false);
    94319255#endif
    9432     //establishParams(numberParameters, parameters) ;
     9256    establishParams(numberParameters, parameters) ;
    94339257    const char dirsep =  CoinFindDirSeparator();
    94349258    std::string directory;
  • releases/2.8.8/Cbc/src/CbcSolver.hpp

    r2366 r2366  
    1010
    1111    This class is currently an orphan. With the removal of all code flagged
    12     with the NEW_STYLE_SOLVER, this class is never instantiated (and cannot
     12    with the NEWS_STYLE_SOLVER, this class is never instantiated (and cannot
    1313    be instantiated). It is available to be coopted as a top-level object
    1414    wrapping the current CbcMain0 and CbcMain1, should that appear to be a
     
    237237//#############################################################################
    238238
    239 /**
    240    The CbcSolver class was taken out at a 9/12/09 meeting
    241    This is a feeble replacement.
    242    At present everything is public
    243 */
    244 class CbcSolverUsefulData {
    245 
    246 public:
    247     ///@name Constructors and destructors etc
    248     //@{
    249     /// Default Constructor
    250     CbcSolverUsefulData();
    251 
    252     /** Copy constructor .
    253      */
    254     CbcSolverUsefulData(const CbcSolverUsefulData & rhs);
    255 
    256     /// Assignment operator
    257     CbcSolverUsefulData & operator=(const CbcSolverUsefulData& rhs);
    258 
    259     /// Destructor
    260     ~CbcSolverUsefulData ();
    261     //@}
    262 
    263     ///@name Member data
    264     //@{
    265     // For time
    266     double totalTime_;
    267     // Parameters
    268     CbcOrClpParam parameters_[CBCMAXPARAMETERS];
    269     // Printing
    270     bool noPrinting_;
    271     // Whether to use signal handler
    272     bool useSignalHandler_;
    273     // Number of Parameters
    274     int numberParameters_;
    275     // Default pump tuning
    276     int initialPumpTune_;
    277     //@}
    278 };
    279 /// And this uses it
    280 // When we want to load up CbcModel with options first
    281 void CbcMain0 (CbcModel & babSolver,CbcSolverUsefulData & solverData);
    282 int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom),CbcSolverUsefulData & solverData);
    283 
    284 //#############################################################################
     239/// Structure to hold useful arrays
     240typedef struct {
     241    // Priorities
     242    int * priorities_;
     243    // SOS priorities
     244    int * sosPriority_;
     245    // Direction to branch first
     246    int * branchDirection_;
     247    // Input solution
     248    double * primalSolution_;
     249    // Down pseudo costs
     250    double * pseudoDown_;
     251    // Up pseudo costs
     252    double * pseudoUp_;
     253} CbcSolverUsefulData;
     254
    285255
    286256/*! \brief A class to allow the use of unknown user functionality
  • releases/2.8.8/Cbc/src/Cbc_ampl.cpp

    r2366 r2366  
    413413    /* for basis info */
    414414    info->columnStatus = (int *) malloc(n_var * sizeof(int));
    415     for (int i=0;i<n_var;i++)
    416       info->columnStatus[i]=3;
    417415    info->rowStatus = (int *) malloc(n_con * sizeof(int));
    418     for (int i=0;i<n_con;i++)
    419       info->rowStatus[i]=1;
    420416    csd = suf_iput("sstatus", ASL_Sufkind_var, info->columnStatus);
    421417    rsd = suf_iput("sstatus", ASL_Sufkind_con, info->rowStatus);
  • releases/2.8.8/Cbc/src/config_cbc_default.h

    r2366 r2366  
    66
    77/* Version number of project */
    8 #define CBC_VERSION "2.8.9"
     8#define CBC_VERSION "2.8.8"
    99
    1010/* Major Version number of project */
     
    1515
    1616/* Release Version number of project */
    17 #define CBC_VERSION_RELEASE 9
     17#define CBC_VERSION_RELEASE 8
  • releases/2.8.8/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.9.
     4# Generated by GNU Autoconf 2.59 for Cbc 2.8.8.
    55#
    66# Report bugs to <cbc@lists.coin-or.org>.
     
    431431PACKAGE_NAME='Cbc'
    432432PACKAGE_TARNAME='cbc'
    433 PACKAGE_VERSION='2.8.9'
    434 PACKAGE_STRING='Cbc 2.8.9'
     433PACKAGE_VERSION='2.8.8'
     434PACKAGE_STRING='Cbc 2.8.8'
    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.9 to adapt to many kinds of systems.
     1041\`configure' configures Cbc 2.8.8 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.9:";;
     1107     short | recursive ) echo "Configuration of Cbc 2.8.8:";;
    11081108   esac
    11091109  cat <<\_ACEOF
     
    13281328if $ac_init_version; then
    13291329  cat <<\_ACEOF
    1330 Cbc configure 2.8.9
     1330Cbc configure 2.8.8
    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.9, which was
     1350It was created by Cbc $as_me 2.8.8, which was
    13511351generated by GNU Autoconf 2.59.  Invocation command line was
    13521352
     
    51695169# Define the identity of the package.
    51705170 PACKAGE='cbc'
    5171  VERSION='2.8.9'
     5171 VERSION='2.8.8'
    51725172
    51735173
     
    2348823488cat >&5 <<_CSEOF
    2348923489
    23490 This file was extended by Cbc $as_me 2.8.9, which was
     23490This file was extended by Cbc $as_me 2.8.8, which was
    2349123491generated by GNU Autoconf 2.59.  Invocation command line was
    2349223492
     
    2354623546cat >>$CONFIG_STATUS <<_ACEOF
    2354723547ac_cs_version="\\
    23548 Cbc config.status 2.8.9
     23548Cbc config.status 2.8.8
    2354923549configured by $0, generated by GNU Autoconf 2.59,
    2355023550  with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
  • releases/2.8.8/configure.ac

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