Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • stable/2.8/Cbc/src/CbcLinked.cpp

    • Property svn:eol-style set to native
    • Property svn:keywords set to Author Date Id Revision
    r1573 r1902  
    1 /* $Id: CbcLinked.cpp 1200 2009-07-25 08:44:13Z forrest $ */
     1/* $Id$ */
    22// Copyright (C) 2006, International Business Machines
    33// Corporation and others.  All Rights Reserved.
     
    330330            }
    331331            modelPtr_->replaceMatrix(temp, true);
     332            modelPtr_->setNewRowCopy(NULL);
     333            modelPtr_->setClpScaledMatrix(NULL);
    332334        } else {
    333335            delete temp;
     
    402404        if (returnCode == 0)
    403405            OsiClpSolverInterface::resolve();
    404         if (!allFixed && (specialOptions2_&1) != 0) {
    405             const double * solution = getColSolution();
    406             bool satisfied = true;
    407             for (int i = 0; i < numberVariables_; i++) {
    408                 int iColumn = info_[i].variable();
    409                 double value = solution[iColumn];
    410                 if (fabs(value - floor(value + 0.5)) > 0.0001)
    411                     satisfied = false;
    412             }
    413             //if (satisfied)
    414             //printf("satisfied but not fixed\n");
    415         }
    416406        int satisfied = 2;
    417407        const double * solution = getColSolution();
     
    18901880            char * pos = temp;
    18911881            bool ifFirst = true;
    1892             double linearTerm = 0.0;
    18931882            while (*pos) {
    18941883                double value;
     
    18971886                if (jColumn >= 0) {
    18981887                    markNonlinear[jColumn] = 1;
    1899                 } else if (jColumn == -2) {
    1900                     linearTerm = value;
    1901                 } else {
     1888                } else if (jColumn != -2) {
    19021889                    printf("bad nonlinear term %s\n", temp);
    19031890                    abort();
     
    19181905                char * pos = temp;
    19191906                bool ifFirst = true;
    1920                 double linearTerm = 0.0;
    19211907                while (*pos) {
    19221908                    double value;
     
    19251911                    if (jColumn >= 0) {
    19261912                        markNonlinear[jColumn] = 1;
    1927                     } else if (jColumn == -2) {
    1928                         linearTerm = value;
    1929                     } else {
     1913                    } else if (jColumn != -2) {
    19301914                        printf("bad nonlinear term %s\n", temp);
    19311915                        abort();
     
    28622846    else
    28632847        cbcModel->setCutoff(cbcModel_->getCutoff());
    2864     // to change exits
    2865     bool isFeasible = false;
    28662848    int saveLogLevel = clpModel->logLevel();
    28672849    clpModel->setLogLevel(0);
     2850#ifndef NDEBUG
    28682851    int returnCode = 0;
     2852#endif
    28692853    if (clpModel->tightenPrimalBounds() != 0) {
    28702854        clpModel->setLogLevel(saveLogLevel);
     2855#ifndef NDEBUG
    28712856        returnCode = -1; // infeasible//std::cout<<"Problem is infeasible - tightenPrimalBounds!"<<std::endl;
     2857#endif
    28722858        //clpModel->writeMps("infeas2.mps");
    28732859    } else {
     
    29092895            std::cout << "Pre-processing says infeasible!" << std::endl;
    29102896            delete saveSolver;
     2897#ifndef NDEBUG
    29112898            returnCode = -1;
     2899#endif
    29122900        } else {
    29132901            std::cout << "processed model has " << solver2->getNumRows()
     
    29312919                // put back in original solver
    29322920                newSolver.setColSolution(cbcModel->bestSolution());
    2933                 isFeasible = true;
    29342921            } else {
    29352922                delete saveSolver;
     
    40144001        // weights must be increasing
    40154002        int i;
    4016         double last = -COIN_DBL_MAX;
    4017         for (i = 0; i < numberMembers_; i++) {
    4018             assert (weights_[i] > last + 1.0e-12);
    4019             last = weights_[i];
    4020         }
     4003#ifndef NDEBUG
     4004        for (i = 1; i < numberMembers_; i++)
     4005            assert (weights_[i] > weights_[i-1] + 1.0e-12);
     4006#endif
    40214007        for (i = 0; i < numberMembers_*numberLinks_; i++) {
    40224008            members_[i] = first + i;
     
    40484034        // weights must be increasing
    40494035        int i;
    4050         double last = -COIN_DBL_MAX;
    4051         for (i = 0; i < numberMembers_; i++) {
    4052             assert (weights_[i] > last + 1.0e-12);
    4053             last = weights_[i];
    4054         }
     4036#ifndef NDEBUG
     4037        for (i = 1; i < numberMembers_; i++)
     4038            assert (weights_[i] > weights_[i-1] + 1.0e-12);
     4039#endif
    40554040        for (i = 0; i < numberMembers_*numberLinks_; i++) {
    40564041            members_[i] = which[i];
     
    51335118                // make sure y equal
    51345119                double rhs = 0.0;
    5135                 CoinBigIndex starts[2];
    51365120                int index[4];
    51375121                double element[4] = {1.0, 1.0, -1.0, -1.0};
    5138                 starts[0] = 0;
    5139                 starts[1] = 4;
    51405122                index[0] = firstLambda_ + 0;
    51415123                index[1] = firstLambda_ + 1;
     
    51485130                // make sure x equal
    51495131                double rhs = 0.0;
    5150                 CoinBigIndex starts[2];
    51515132                int index[4];
    51525133                double element[4] = {1.0, 1.0, -1.0, -1.0};
    5153                 starts[0] = 0;
    5154                 starts[1] = 4;
    51555134                index[0] = firstLambda_ + 0;
    51565135                index[1] = firstLambda_ + 2;
     
    69066885    // get original bounds
    69076886    double xB[2];
    6908     double yB[2];
    69096887    const double * lower = solver->getColLower();
    69106888    const double * upper = solver->getColUpper();
     
    69126890    xB[1] = upper[xColumn_];
    69136891    assert (fabs((xB[1] - xB[0]) - xMeshSize_*(numberPoints_ - 1)) < 1.0e-7);
    6914     yB[0] = lower[yColumn_];
    6915     yB[1] = upper[yColumn_];
    69166892    double mesh = 0.0;
    69176893    int i;
     
    71647140void
    71657141CglTemporary::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
    7166                            const CglTreeInfo /*info*/) const
     7142                           const CglTreeInfo /*info*/)
    71677143{
    71687144    // Get basic problem information
     
    77577733            char * pos = temp;
    77587734            bool ifFirst = true;
    7759             double linearTerm = 0.0;
    77607735            while (*pos) {
    77617736                double value;
     
    77647739                if (jColumn >= 0) {
    77657740                    maximumQuadraticElements++;
    7766                 } else if (jColumn == -2) {
    7767                     linearTerm = value;
    7768                 } else {
     7741                } else if (jColumn != -2) {
    77697742                    printf("bad nonlinear term %s\n", temp);
    77707743                    abort();
     
    77957768                char * pos = temp;
    77967769                bool ifFirst = true;
    7797                 double linearTerm = 0.0;
    77987770                while (*pos) {
    77997771                    double value;
     
    78027774                    if (jColumn >= 0) {
    78037775                        numberQuadratic++;
    7804                     } else if (jColumn == -2) {
    7805                         linearTerm = value;
    7806                     } else {
     7776                    } else if (jColumn != -2) {
    78077777                        printf("bad nonlinear term %s\n", temp);
    78087778                        abort();
     
    79767946        model->setObjective(quadObj);
    79777947    delete quadObj;
     7948#ifndef NDEBUG
    79787949    int returnCode;
    79797950    if (numberConstraints) {
     
    79857956        returnCode = model->nonlinearSLP(numberPasses, deltaTolerance);
    79867957    }
     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
    79877968    delete [] constraints;
    7988     assert (!returnCode);
    79897969    return model;
    79907970#else
Note: See TracChangeset for help on using the changeset viewer.