Changeset 1888


Ignore:
Timestamp:
Apr 6, 2013 4:52:59 PM (6 years ago)
Author:
stefan
Message:

sync with trunk rev 1887

Location:
stable/2.8/Cbc
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • stable/2.8/Cbc

  • stable/2.8/Cbc/README

    r1853 r1888  
    2626==========
    2727
    28 Release 2.8:
     28Release 2.8.0:
    2929
    30301. Introduced new secondaryStatus 8 to indicate that solving stopped due to an iteration limit.
     
    4444   probability of finding an improved solution by flipping a small number of binary variables), in particular
    4545   when it is applied to the first heuristic solutions found at the root node.
     46   
    46475. An implementation of Zero-Half-Cuts by Alberto Caprara is now available.
    4748   By default, these cuts are off.  To use add to your command line -zerohalfCuts root (or other options) or just -zero.
     
    4950
    5051   The implementation of these cuts is described in
    51    G. Andreello, A. Caprara, M. Fischetti
    52    â€œEmbedding Cuts in a Branch and Cut Framework: a Computational Study with {0,1/2}-Cuts”
     52   G. Andreello, A. Caprara, and M. Fischetti
     53   "Embedding Cuts in a Branch and Cut Framework: a Computational Study with {0,1/2}-Cuts"
    5354   INFORMS Journal on Computing 19(2), 229-238, 2007
    54 6.  Allow initialization of random seed by user.  Pseudo-random numbers are used in Cbc and Clp.  In Clp they
     55   http://dx.doi.org/10.1287/ijoc.1050.0162
     56
     576. An alternative implementation of a reduce and split cut generator by Giacomo Nannicini is now available.
     58   By default, these cuts are off.  To use add to your command line -reduce2AndSplitCuts root (or other options).
     59
     60   The implementation of these cuts is described in
     61   G. Cornuejols and G. Nannicini
     62   "Practical strategies for generating rank-1 split cuts in mixed-integer linear programming"
     63   Mathematical Programming Computation 3(4), 281-318, 2011
     64   http://dx.doi.org/10.1007/s12532-011-0028-6
     65
     667. An alternative robust implementation of a Gomory cut generator by Giacomo Nannicini is now available.
     67   By default, these cuts are off.  To use add to your command line -GMI root (or other options).
     68
     69   The implementation of these cuts is described in
     70   G. Cornuejols, F. Margot, and G. Nannicini
     71   "On the safety of Gomory cut generators"
     72   http://faculty.sutd.edu.sg/~nannicini/index.php?page=publications
     73   
     748.  Allow initialization of random seed by user.  Pseudo-random numbers are used in Cbc and Clp.  In Clp they
    5575   are used to break ties in degenerate problems, while in Cbc heuristics such as the Feasibility Pump use them   
    5676   to decide whether to round up or down.  So if a different pseudo-random seed is given to Clp then you may get
     
    5878   setting randomSeed for Clp and/or randomCbcSeed for Cbc.  The special value of 0 tells code to use time of day
    5979   for initial seed.
    60 7.  Building on this idea Andrea Lodi , Matteo Fischetti , Michele Monaci , Domenico Salvagnin and Andrea Tramontani
     80   
     819.  Building on this idea Andrea Lodi, Matteo Fischetti, Michele Monaci, Domenico Salvagnin and Andrea Tramontani
    6182   suggest that this idea be be improved by running at the root node with multiple copies of solver, each
    6283   with its own different seed and then passing in the solutions and cuts so that the main solver has a richer
    6384   set of solutions and possibly stronger cuts.  This is switched on by setting multipleRootPasses.  These can also
    6485   be done in parallel.
     86 
     8710. Few changes to presolve for special variables and badly scaled problems (in CoinUtils).
    6588
     8911. New option -extraVariables <number> which switches on a trivial re-formulation to group variables with same cost together.
    6690
    6791
  • stable/2.8/Cbc/src/CbcBranchLotsize.cpp

    r1573 r1888  
    183183        bound_[0] = points[sort[0] * 2];
    184184        bound_[1] = points[sort[0] * 2 + 1];
    185         double lo = bound_[0];
    186185        double hi = bound_[1];
    187         assert (hi >= lo);
     186        assert (hi >= bound_[0]);
    188187        for (i = 1; i < numberPoints; i++) {
    189188            double thisLo = points[sort[i] * 2];
     
    194193                bound_[2*numberRanges_+1] = thisHi;
    195194                numberRanges_++;
    196                 lo = thisLo;
    197195                hi = thisHi;
    198196            } else {
  • stable/2.8/Cbc/src/CbcFathomDynamicProgramming.cpp

    r1641 r1888  
    760760    int n2 = 0;
    761761    int mask[40];
    762     int nextbit[40];
    763762    int adjust[40];
    764763    assert (numberElements <= 40);
     
    784783            adjust[n2] = start * hi2;
    785784            mask2 += start * gap;
    786             nextbit[n2] = startBit + numberBits;
    787785            mask[n2++] = start * (size - 1);
    788786        }
  • stable/2.8/Cbc/src/CbcHeuristic.cpp

    r1883 r1888  
    716716    getHistoryStatistics_ = false;
    717717#endif
     718#ifdef COIN_DEVELOP
    718719    int status = 0;
     720#endif
    719721    int logLevel = model_->logLevel();
    720722#define LEN_PRINT 250
     
    13201322                }
    13211323                if (model.status() == 5)
    1322                     model_->sayEventHappened();
     1324                   model_->sayEventHappened();
     1325#ifdef COIN_DEVELOP
    13231326                if (model.isProvenInfeasible())
    13241327                    status = 1;
    13251328                else if (model.isProvenOptimal())
    13261329                    status = 2;
     1330#endif
    13271331            }
    13281332        }
  • stable/2.8/Cbc/src/CbcHeuristicGreedy.cpp

    r1883 r1888  
    13621362      int nL=0;
    13631363      int nG=0;
    1364       int iUnder=-1;
    13651364      int nUnder=0;
    13661365      for (iRow = 0; iRow < numberRows; iRow++) {
     
    13721371          gap += rowLower[iRow]-rowActivity[iRow];
    13731372          nUnder++;
    1374           iUnder=iRow;
    13751373          rowWeight[iRow] *= 1.1;
    13761374        } else if (rowActivity[iRow] > rowUpper[iRow] + 10.0*primalTolerance) {
  • stable/2.8/Cbc/src/CbcLinked.cpp

    r1883 r1888  
    404404        if (returnCode == 0)
    405405            OsiClpSolverInterface::resolve();
    406         if (!allFixed && (specialOptions2_&1) != 0) {
    407             const double * solution = getColSolution();
    408             bool satisfied = true;
    409             for (int i = 0; i < numberVariables_; i++) {
    410                 int iColumn = info_[i].variable();
    411                 double value = solution[iColumn];
    412                 if (fabs(value - floor(value + 0.5)) > 0.0001)
    413                     satisfied = false;
    414             }
    415             //if (satisfied)
    416             //printf("satisfied but not fixed\n");
    417         }
    418406        int satisfied = 2;
    419407        const double * solution = getColSolution();
     
    18921880            char * pos = temp;
    18931881            bool ifFirst = true;
    1894             double linearTerm = 0.0;
    18951882            while (*pos) {
    18961883                double value;
     
    18991886                if (jColumn >= 0) {
    19001887                    markNonlinear[jColumn] = 1;
    1901                 } else if (jColumn == -2) {
    1902                     linearTerm = value;
    1903                 } else {
     1888                } else if (jColumn != -2) {
    19041889                    printf("bad nonlinear term %s\n", temp);
    19051890                    abort();
     
    19201905                char * pos = temp;
    19211906                bool ifFirst = true;
    1922                 double linearTerm = 0.0;
    19231907                while (*pos) {
    19241908                    double value;
     
    19271911                    if (jColumn >= 0) {
    19281912                        markNonlinear[jColumn] = 1;
    1929                     } else if (jColumn == -2) {
    1930                         linearTerm = value;
    1931                     } else {
     1913                    } else if (jColumn != -2) {
    19321914                        printf("bad nonlinear term %s\n", temp);
    19331915                        abort();
     
    28642846    else
    28652847        cbcModel->setCutoff(cbcModel_->getCutoff());
    2866     // to change exits
    2867     bool isFeasible = false;
    28682848    int saveLogLevel = clpModel->logLevel();
    28692849    clpModel->setLogLevel(0);
     2850#ifndef NDEBUG
    28702851    int returnCode = 0;
     2852#endif
    28712853    if (clpModel->tightenPrimalBounds() != 0) {
    28722854        clpModel->setLogLevel(saveLogLevel);
     2855#ifndef NDEBUG
    28732856        returnCode = -1; // infeasible//std::cout<<"Problem is infeasible - tightenPrimalBounds!"<<std::endl;
     2857#endif
    28742858        //clpModel->writeMps("infeas2.mps");
    28752859    } else {
     
    29112895            std::cout << "Pre-processing says infeasible!" << std::endl;
    29122896            delete saveSolver;
     2897#ifndef NDEBUG
    29132898            returnCode = -1;
     2899#endif
    29142900        } else {
    29152901            std::cout << "processed model has " << solver2->getNumRows()
     
    29332919                // put back in original solver
    29342920                newSolver.setColSolution(cbcModel->bestSolution());
    2935                 isFeasible = true;
    29362921            } else {
    29372922                delete saveSolver;
     
    40164001        // weights must be increasing
    40174002        int i;
    4018         double last = -COIN_DBL_MAX;
    4019         for (i = 0; i < numberMembers_; i++) {
    4020             assert (weights_[i] > last + 1.0e-12);
    4021             last = weights_[i];
    4022         }
     4003#ifndef NDEBUG
     4004        for (i = 1; i < numberMembers_; i++)
     4005            assert (weights_[i] > weights_[i-1] + 1.0e-12);
     4006#endif
    40234007        for (i = 0; i < numberMembers_*numberLinks_; i++) {
    40244008            members_[i] = first + i;
     
    40504034        // weights must be increasing
    40514035        int i;
    4052         double last = -COIN_DBL_MAX;
    4053         for (i = 0; i < numberMembers_; i++) {
    4054             assert (weights_[i] > last + 1.0e-12);
    4055             last = weights_[i];
    4056         }
     4036#ifndef NDEBUG
     4037        for (i = 1; i < numberMembers_; i++)
     4038            assert (weights_[i] > weights_[i-1] + 1.0e-12);
     4039#endif
    40574040        for (i = 0; i < numberMembers_*numberLinks_; i++) {
    40584041            members_[i] = which[i];
     
    51355118                // make sure y equal
    51365119                double rhs = 0.0;
    5137                 CoinBigIndex starts[2];
    51385120                int index[4];
    51395121                double element[4] = {1.0, 1.0, -1.0, -1.0};
    5140                 starts[0] = 0;
    5141                 starts[1] = 4;
    51425122                index[0] = firstLambda_ + 0;
    51435123                index[1] = firstLambda_ + 1;
     
    51505130                // make sure x equal
    51515131                double rhs = 0.0;
    5152                 CoinBigIndex starts[2];
    51535132                int index[4];
    51545133                double element[4] = {1.0, 1.0, -1.0, -1.0};
    5155                 starts[0] = 0;
    5156                 starts[1] = 4;
    51575134                index[0] = firstLambda_ + 0;
    51585135                index[1] = firstLambda_ + 2;
     
    69086885    // get original bounds
    69096886    double xB[2];
    6910     double yB[2];
    69116887    const double * lower = solver->getColLower();
    69126888    const double * upper = solver->getColUpper();
     
    69146890    xB[1] = upper[xColumn_];
    69156891    assert (fabs((xB[1] - xB[0]) - xMeshSize_*(numberPoints_ - 1)) < 1.0e-7);
    6916     yB[0] = lower[yColumn_];
    6917     yB[1] = upper[yColumn_];
    69186892    double mesh = 0.0;
    69196893    int i;
     
    71667140void
    71677141CglTemporary::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
    7168                            const CglTreeInfo /*info*/) const
     7142                           const CglTreeInfo /*info*/)
    71697143{
    71707144    // Get basic problem information
     
    77597733            char * pos = temp;
    77607734            bool ifFirst = true;
    7761             double linearTerm = 0.0;
    77627735            while (*pos) {
    77637736                double value;
     
    77667739                if (jColumn >= 0) {
    77677740                    maximumQuadraticElements++;
    7768                 } else if (jColumn == -2) {
    7769                     linearTerm = value;
    7770                 } else {
     7741                } else if (jColumn != -2) {
    77717742                    printf("bad nonlinear term %s\n", temp);
    77727743                    abort();
     
    77977768                char * pos = temp;
    77987769                bool ifFirst = true;
    7799                 double linearTerm = 0.0;
    78007770                while (*pos) {
    78017771                    double value;
     
    78047774                    if (jColumn >= 0) {
    78057775                        numberQuadratic++;
    7806                     } else if (jColumn == -2) {
    7807                         linearTerm = value;
    7808                     } else {
     7776                    } else if (jColumn != -2) {
    78097777                        printf("bad nonlinear term %s\n", temp);
    78107778                        abort();
     
    79787946        model->setObjective(quadObj);
    79797947    delete quadObj;
     7948#ifndef NDEBUG
    79807949    int returnCode;
    79817950    if (numberConstraints) {
     
    79877956        returnCode = model->nonlinearSLP(numberPasses, deltaTolerance);
    79887957    }
     7958    assert (!returnCode);
     7959#else
     7960    if (numberConstraints) {
     7961        model->nonlinearSLP(numberConstraints, constraints, numberPasses, deltaTolerance);
     7962        for (iConstraint = 0; iConstraint < saveNumber; iConstraint++)
     7963            delete constraints[iConstraint];
     7964    } else {
     7965        model->nonlinearSLP(numberPasses, deltaTolerance);
     7966    }
     7967#endif
    79897968    delete [] constraints;
    7990     assert (!returnCode);
    79917969    return model;
    79927970#else
  • stable/2.8/Cbc/src/CbcLinked.hpp

    r1854 r1888  
    12801280    */
    12811281    virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
    1282                                const CglTreeInfo info = CglTreeInfo()) const;
     1282                               const CglTreeInfo info = CglTreeInfo());
    12831283    //@}
    12841284
  • stable/2.8/Cbc/src/CbcLinkedUtils.cpp

    r1854 r1888  
    107107        return true;
    108108    }  else {
    109         double  retval = objval(0, info->non_const_x_, (fint*)info->nerror_);
     109        double  retval = objval(0, info->non_const_x_, (fint*)&info->nerror_);
    110110        if (!info->nerror_) {
    111111            obj_val = info->obj_sign_ * retval;
     
    126126    assert (g);
    127127
    128     conval(info->non_const_x_, g, (fint*)info->nerror_);
     128    conval(info->non_const_x_, g, (fint*)&info->nerror_);
    129129
    130130    if (!info->nerror_) {
     
    158158
    159159        // tell ampl that we have a new x
    160         xknowne(info->non_const_x_, (fint*)info->nerror_);
     160        xknowne(info->non_const_x_, (fint*)&info->nerror_);
    161161        return info->nerror_ ? false : true;
    162162    }
     
    189189        }
    190190    } else {
    191         objgrd(0, info->non_const_x_, grad_f, (fint*)info->nerror_);
     191        objgrd(0, info->non_const_x_, grad_f, (fint*)&info->nerror_);
    192192        if (info->nerror_) {
    193193            return false;
     
    231231    }
    232232
    233     jacval(info->non_const_x_, values, (fint*)info->nerror_);
     233    jacval(info->non_const_x_, values, (fint*)&info->nerror_);
    234234    if (!info->nerror_) {
    235235        return true;
     
    340340    if (model)
    341341        assert (model->optimizationDirection() == 1.0);
    342     bool scaling = false;
    343     if (model && (model->rowScale() ||
    344                   model->objectiveScale() != 1.0 || model->optimizationDirection() != 1.0))
    345         scaling = true;
     342#ifndef NDEBUG
     343    bool scaling = model && (model->rowScale() || model->objectiveScale() != 1.0 || model->optimizationDirection() != 1.0);
     344#endif
    346345    const double * cost = NULL;
    347346    if (model)
     
    350349        // not in solve
    351350        cost = objective_;
     351#ifndef NDEBUG
    352352        scaling = false;
     353#endif
    353354    }
    354355    assert (!scaling);
  • stable/2.8/Cbc/src/CbcMipStartIO.cpp

    r1854 r1888  
    2020bool isNumericStr( const char *str )
    2121{
    22    const int l = strlen(str);
    23 
    24    for ( int i=0 ; (i<l) ; ++i )
     22   const size_t l = strlen(str);
     23
     24   for ( size_t i=0 ; i<l ; ++i )
    2525      if (!(isdigit(str[i])||(str[i]=='.')))
    2626         return false;
     
    170170      babModel.setMaximumSeconds( 60 );
    171171      babModel.branchAndBound();
    172       clock_t end = clock();
    173172      if (babModel.bestSolution())
    174173      {
  • stable/2.8/Cbc/src/CbcModel.cpp

    r1883 r1888  
    398398        int numberColumns = solver_->getNumCols() ;
    399399        // Column copy of matrix
    400         bool allPlusOnes = true;
    401         bool allOnes = true;
    402400        int problemType = -1;
    403401        const double * element = solver_->getMatrixByCol()->getElements();
     
    670668                        } else if (value == -1.0) {
    671669                            rhs[row[j]] = -0.5;
    672                             allPlusOnes = false;
    673670                        } else {
    674671                            rhs[row[j]] = -COIN_DBL_MAX;
    675                             allOnes = false;
    676672                        }
    677673                    }
     
    20702066    */
    20712067    // Convert to Osi if wanted
    2072     bool useOsiBranching = false;
    20732068    //OsiBranchingInformation * persistentInfo = NULL;
    20742069    if (branchingMethod_ && branchingMethod_->chooseMethod()) {
    2075         useOsiBranching = true;
    20762070        //persistentInfo = new OsiBranchingInformation(solver_);
    20772071        if (numberOriginalObjects) {
     
    38813875      this node is still live, push it onto the heap that holds the live set.
    38823876    */
    3883     double bestValue = 0.0 ;
    38843877    if (newNode) {
    3885         bestValue = newNode->objectiveValue();
    38863878        if (newNode->branchingObject()) {
    38873879            newNode->initializeInfo() ;
     
    77997791#ifdef CHECK_DEBUGGER
    78007792                if ((specialOptions_&1) != 0 ) {
    7801                   const OsiRowCutDebugger * debugger =
    7802                     solver_->getRowCutDebuggerAlways();
    7803                   CoinAssert (!debugger->invalidCut(*thisCut));
     7793                  CoinAssert (!solver_->getRowCutDebuggerAlways()->invalidCut(*thisCut));
    78047794                }
    78057795#endif
     
    1187711867                int iAway = -1;
    1187811868                double largestInfeasibility = tolerance;
     11869#if COIN_DEVELOP>1
    1187911870                int iInfeas = -1;
     11871#endif
    1188011872                const double * columnLower = continuousSolver_->getColLower();
    1188111873                const double * columnUpper = continuousSolver_->getColUpper();
     
    1188411876                    double value = solution2[i];
    1188511877                    if (value > columnUpper[i] + largestInfeasibility) {
     11878#if COIN_DEVELOP>1
    1188611879                        iInfeas = i;
     11880#endif
    1188711881                        largestInfeasibility = value - columnUpper[i];
    1188811882                    } else if (value < columnLower[i] - largestInfeasibility) {
     11883#if COIN_DEVELOP>1
    1188911884                        iInfeas = i;
     11885#endif
    1189011886                        largestInfeasibility = columnLower[i] - value;
    1189111887                    }
     
    1465614652        numberCutGenerators_=0; // so can dive and branch
    1465714653    }
    14658     int currentNumberCuts = 0 ;
    1465914654    currentNode_ = node; // so can be accessed elsewhere
    1466014655    double bestObjective = bestObjective_;
     
    1479014785        phase_ = 2;
    1479114786        OsiCuts cuts ;
    14792         currentNumberCuts = solver_->getNumRows() - numberRowsAtContinuous_ ;
    1479314787        int saveNumber = numberIterations_;
    1479414788        if (solverCharacteristics_->solutionAddsCuts()) {
     
    1516315157                  solver_->writeMpsNative("infeas2.mps", NULL, NULL, 2);
    1516415158                  solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_);
     15159#ifndef NDEBUG
    1516515160                  const OsiRowCutDebugger * debugger = solver_->getRowCutDebugger() ;
     15161#endif
    1516615162                  assert (debugger) ;
    1516715163                  int numberRows0=continuousSolver_->getNumRows();
  • stable/2.8/Cbc/src/CbcNode.cpp

    r1883 r1888  
    14761476                //if (smallestNumberInfeasibilities>=numberIntegerInfeasibilities)
    14771477                //numberNodes=1000000; // switch off search for better solution
    1478                 int numberNodes = 1000000; // switch off anyway
    14791478                averageCostPerIteration /= totalNumberIterations;
    14801479                // all feasible - choose best bet
     
    27012700            int saveLimit2;
    27022701            solver->getIntParam(OsiMaxNumIterationHotStart, saveLimit2);
    2703             bool doQuickly = false; // numberToDo>2*numberStrong;
    2704             if (searchStrategy == 2)
    2705                 doQuickly = true;
    27062702            int numberTest = numberNotTrusted > 0 ? numberStrong : (numberStrong + 1) / 2;
    27072703            if (searchStrategy == 3) {
    27082704                // Previously decided we need strong
    2709                 doQuickly = false;
    27102705                numberTest = numberStrong;
    27112706            }
     
    27162711                    if ((model->specialOptions()&8) == 0) {
    27172712                        numberTest = 0;
    2718                         doQuickly = true;
    27192713                    }
    27202714                    //} else {
    2721                     //doQuickly=false;
    27222715                    //numberTest=2*numberStrong;
    27232716                    //skipAll=0;
     
    27262719            } else {
    27272720                // Just take first
    2728                 doQuickly = true;
    27292721                numberTest = 1;
    27302722            }
     
    27322724            if (depth_ < testDepth && numberStrong) {
    27332725                if (searchStrategy != 2) {
    2734                     doQuickly = false;
    27352726                    int numberRows = solver->getNumRows();
    27362727                    // whether to do this or not is important - think
     
    27512742                if (skipAll) {
    27522743                    numberTest = 0;
    2753                     doQuickly = true;
    27542744                }
    27552745            } else {
     
    27602750            if (skipAll < 0) {
    27612751                numberTest = 0;
    2762                 doQuickly = true;
    27632752            }
    27642753            int realMaxHotIterations = 999999;
     
    35253514                if (hitMaxTime) {
    35263515                    // make sure rest are fast
    3527                     doQuickly = true;
    35283516                    for ( int jDo = iDo + 1; jDo < numberToDo; jDo++) {
    35293517                        int iObject = whichObject[iDo];
     
    37783766    double * saveUpper = new double[numberColumns];
    37793767    double * saveLower = new double[numberColumns];
    3780     int anyAction = 0;
    37813768    // Save solution in case heuristics need good solution later
    37823769
     
    40784065            } else {
    40794066                // up feasible, down infeasible
    4080                 anyAction = -1;
    40814067                if (!satisfied)
    40824068                    needResolve = true;
     
    40894075            if (choice.downMovement < 1.0e100) {
    40904076                // down feasible, up infeasible
    4091                 anyAction = -1;
    40924077                if (!satisfied)
    40934078                    needResolve = true;
     
    40984083            } else {
    40994084                // neither side feasible
    4100                 anyAction = -2;
    41014085                COIN_DETAIL_PRINT(printf("Both infeasible for choice %d sequence %d\n", i,
    41024086                                         model->object(choice.objectNumber)->columnNumber()));
  • stable/2.8/Cbc/src/CbcSimpleIntegerDynamicPseudoCost.cpp

    r1854 r1888  
    736736        double minValue = CoinMin(downCost, upCost);
    737737        double maxValue = CoinMax(downCost, upCost);
     738#ifdef COIN_DEVELOP
    738739        char where;
     740#endif
    739741        // was <= 10
    740742        //if (stateOfSearch<=1||model_->currentNode()->depth()<=-10 /* was ||maxValue>0.2*distanceToCutoff*/) {
    741743        if (stateOfSearch <= 2) {
    742744            // no branching solution
     745#ifdef COIN_DEVELOP
    743746            where = 'i';
     747#endif
    744748            returnValue = WEIGHT_BEFORE * minValue + (1.0 - WEIGHT_BEFORE) * maxValue;
    745749            if (0) {
     
    768772        } else {
    769773            // some solution
     774#ifdef COIN_DEVELOP
    770775            where = 'I';
     776#endif
    771777#ifndef WEIGHT_PRODUCT
    772778            returnValue = WEIGHT_AFTER * minValue + (1.0 - WEIGHT_AFTER) * maxValue;
  • stable/2.8/Cbc/src/CbcSolver.cpp

    r1883 r1888  
    49524952                                   int status = computeCompleteSolution( babModel_, colNames, mipStart, &x[0], obj );
    49534953                                   if (!status)
    4954                                      babModel_->setBestSolution( &x[0], x.size(), obj, false );
     4954                                     babModel_->setBestSolution( &x[0], static_cast<int>(x.size()), obj, false );
    49554955                                }
    49564956
     
    85598559                                  assert (clpSolver->getModelPtr()==saveLpSolver);
    85608560                                  lpSolver = new ClpSimplex(*saveLpSolver);
     8561#ifndef NDEBUG
    85618562                                  ClpSimplex * oldSimplex = clpSolver->swapModelPtr(lpSolver);
    85628563                                  assert (oldSimplex==saveLpSolver);
     8564#else
     8565              clpSolver->swapModelPtr(lpSolver);
     8566#endif
    85638567                                  double * solution = lpSolver->primalColumnSolution();
    85648568                                  double * lower = lpSolver->columnLower();
  • stable/2.8/Cbc/src/CbcSolverExpandKnapsack.cpp

    r1854 r1888  
    552552   for (iKnapsack=0;iKnapsack<numberKnapsack;iKnapsack++) {
    553553      int k=-1;
    554       double value=0.0;
    555554      for (iColumn=knapsackStart[iKnapsack];iColumn<knapsackStart[iKnapsack+1];iColumn++) {
    556555         if (knapsackSolution[iColumn]>1.0e-5) {
     
    561560            }
    562561            k=iColumn;
    563             value=floor(knapsackSolution[iColumn]+0.5);
    564             assert (fabs(value-knapsackSolution[iColumn])<1.0e-5);
     562            assert (fabs(floor(knapsackSolution[iColumn]+0.5)-knapsackSolution[iColumn])<1.0e-5);
    565563         }
    566564      }
  • stable/2.8/Cbc/src/CbcSolverHeuristics.cpp

    r1883 r1888  
    636636#define MAXPROB 2
    637637        ClpSimplex models[MAXPROB];
    638         int pass[MAXPROB];
    639638        int kPass = -1;
    640639        int kLayer = 0;
     
    866865                }
    867866            }
    868             pass[kPass] = iPass;
    869867            double maxCostUp = COIN_DBL_MAX;
    870868            objective = lpSolver->getObjCoefficients() ;
  • stable/2.8/Cbc/src/CbcThread.cpp

    r1883 r1888  
    175175    struct timespec absTime2;
    176176    my_gettime(&absTime2);
    177     double time2 = absTime2.tv_sec + 1.0e-9 * absTime2.tv_nsec;
     177    double time2 = (double)absTime2.tv_sec + 1.0e-9 * (double)absTime2.tv_nsec;
    178178    return time2;
    179179}
     
    244244{
    245245#ifdef CBC_PTHREAD
    246     return threadId_.status;
     246    return static_cast<int>(threadId_.status);
    247247#else
    248248#endif
     
    879879            children_[i].setReturnCode( 0);
    880880            children_[i].unlockFromMaster();
    881             int returnCode;
    882             returnCode = children_[i].exit();
     881#ifndef NDEBUG
     882            int returnCode = children_[i].exit();
     883            assert (!returnCode);
     884#else
     885            children_[i].exit();
     886#endif
    883887            children_[i].setStatus( 0);
    884             assert (!returnCode);
    885888            //else
    886889            threadModel_[i]->moveToModel(baseModel, 2);
  • stable/2.8/Cbc/src/Cbc_C_Interface.cpp

    r1573 r1888  
    22732273
    22742274    assert(1 > 0);// this is probably broken
    2275     int i, j, l;
    2276     const int *w;
     2275    int i, j;
    22772276    // I think this is a different model due to overriding = operator
    22782277    CbcModel m = *(model->model_);
     
    22972296        // Make a CbcSOS and assign it to objects
    22982297        if (VERBOSE > 1) printf("%s len[%i] = %i\n", prefix, i, len[i]);
    2299         l = len[i];
    2300         w = which[i];
    23012298        if (VERBOSE > 1) printf("%s new CbcSOS()\n", prefix);
    23022299        // ***
  • stable/2.8/Cbc/src/Cbc_ampl.cpp

    r1873 r1888  
    441441                sos_kludge(nsos, sosbeg, sosref, sosind);
    442442                for (int i = 0; i < nsos; i++) {
    443                     int ichar = sostype[i];
     443                    char ichar = sostype[i];
    444444                    assert (ichar == '1' || ichar == '2');
    445                     info->sosType[i] = ichar - '0';
     445                    info->sosType[i] = static_cast<char>(ichar - '0');
    446446                }
    447447                memcpy(info->sosPriority, sospri, nsos*sizeof(int));
     
    619619            fprintf(stderr, "You can copy .nl file %s for debug purposes or attach debugger\n", saveArgv[1]);
    620620            fprintf(stderr, "Type q to quit, anything else to continue\n");
    621             char getChar = getc(stdin);
     621            int getChar = getc(stdin);
    622622            if (getChar == 'q' || getChar == 'Q')
    623623                exit(1);
     
    988988        // quadratic
    989989        asl = ASL_alloc(ASL_read_fg);
    990         nl = jac0dim(stub, (long) strlen(stub));
     990        nl = jac0dim(stub, (ftnlen) strlen(stub));
    991991        free(stub);
    992992        suf_declare(suftab, sizeof(suftab) / sizeof(SufDecl));
     
    10941094        //ASL_pfgh* asl = (ASL_pfgh*)ASL_alloc(ASL_read_pfgh);
    10951095        asl = ASL_alloc(ASL_read_pfgh);
    1096         nl = jac0dim(stub, (long) strlen(stub));
     1096        nl = jac0dim(stub, (ftnlen) strlen(stub));
    10971097        free(stub);
    10981098        suf_declare(suftab, sizeof(suftab) / sizeof(SufDecl));
Note: See TracChangeset for help on using the changeset viewer.