Ignore:
Timestamp:
Apr 6, 2013 2:13:35 PM (7 years ago)
Author:
stefan
Message:

fix compiler (gcc 4.6.2) warnings in optimized mode, mainly about unused variables

File:
1 edited

Legend:

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

    r1876 r1886  
    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;
     
    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
Note: See TracChangeset for help on using the changeset viewer.