Changeset 1393


Ignore:
Timestamp:
Dec 10, 2009 7:29:38 PM (10 years ago)
Author:
lou
Message:

Mark #if 0 with JJF_ZERO and #if 1 with JJF_ONE as a historical reference
point.

Location:
branches/sandbox/Cbc/src
Files:
29 edited

Legend:

Unmodified
Added
Removed
  • branches/sandbox/Cbc/src/CbcBranchDynamic.cpp

    r1389 r1393  
    473473        // use pseudo shadow prices modified by locks
    474474        // test testosi
    475 #if 1
     475#ifndef JJF_ONE
    476476        double objectiveValue = model->getCurrentMinimizationObjValue();
    477477        double distanceToCutoff =  model->getCutoff()  - objectiveValue;
     
    492492        changeDown += perInf * numInfDown;
    493493        changeUp += perInf * numInfUp;
    494 #if 0
     494#ifdef JJF_ZERO
    495495        if (numInfDown == 1) {
    496496            if (numInfUp == 1) {
  • branches/sandbox/Cbc/src/CbcCompareDefault.cpp

    r1315 r1393  
    228228CbcCompareDefault::every1000Nodes(CbcModel * model, int numberNodes)
    229229{
    230 #if 0
     230#ifdef JJF_ZERO
    231231    // was
    232232    if (numberNodes > 10000)
  • branches/sandbox/Cbc/src/CbcCutGenerator.cpp

    r1362 r1393  
    258258        int numberRowCutsBefore = cs.sizeRowCuts() ;
    259259        int numberColumnCutsBefore = cs.sizeColCuts() ;
    260 #if 0
     260#ifdef JJF_ZERO
    261261        int cutsBefore = cs.sizeCuts();
    262262#endif
     
    538538            //if (!solver->basisIsAvailable())
    539539            //returnCode=true;
    540 #if 0
     540#ifdef JJF_ZERO
    541541            // Pass across info to pseudocosts
    542542            char * mark = new char[numberColumns];
     
    721721                //printf("need to remove cuts\n");
    722722                // just add most effective
    723 #if 1
     723#ifndef JJF_ONE
    724724                int nDelete = nEls - nReasonable;
    725725
     
    769769                            }
    770770                        }
    771 #if 0
     771#ifdef JJF_ZERO
    772772                        int nS = n - nU;
    773773                        if (numberColumns > 20000) {
     
    11131113                    numberElements_ += n;
    11141114                }
    1115 #if 0
     1115#ifdef JJF_ZERO
    11161116                printf("generator %s generated %d row cuts\n",
    11171117                       generatorName_, numberRowCutsAfter - numberRowCutsBefore);
     
    11211121            int numberColumnCutsAfter = cs.sizeColCuts() ;
    11221122            if (numberColumnCutsBefore < numberColumnCutsAfter) {
    1123 #if 0
     1123#ifdef JJF_ZERO
    11241124                printf("generator %s generated %d column cuts\n",
    11251125                       generatorName_, numberColumnCutsAfter - numberColumnCutsBefore);
     
    11301130        if (timing())
    11311131            timeInCutGenerator_ += CoinCpuTime() - time1;
    1132 #if 0
     1132#ifdef JJF_ZERO
    11331133        // switch off if first time and no good
    11341134        if (node == NULL && !pass) {
  • branches/sandbox/Cbc/src/CbcDummyBranchingObject.hpp

    r1389 r1393  
    3434    virtual double branch();
    3535
    36 #if 0
     36#ifdef JJF_ZERO
    3737    // No need to override. Default works fine.
    3838    /** Reset every information so that the branching object appears to point to
  • branches/sandbox/Cbc/src/CbcFollowOn.cpp

    r1357 r1393  
    507507(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
    508508{
    509 #if 0 //ndef NDEBUG
     509#ifdef JJF_ZERO //ndef NDEBUG
    510510    const CbcFixingBranchingObject* br =
    511511        dynamic_cast<const CbcFixingBranchingObject*>(brObj);
  • branches/sandbox/Cbc/src/CbcFollowOn.hpp

    r1389 r1393  
    9393    virtual double branch();
    9494
    95 #if 0
     95#ifdef JJF_ZERO
    9696    // No need to override. Default works fine.
    9797    /** Reset every information so that the branching object appears to point to
  • branches/sandbox/Cbc/src/CbcHeuristic.cpp

    r1357 r1393  
    270270        return false;
    271271    // No longer used for original purpose - so use for ever run at all JJF
    272 #if 1
     272#ifndef JJF_ONE
    273273    // Don't run if hot start
    274274    if (model_ && model_->hotstartSolution())
     
    277277        return true;
    278278#else
    279 #if 0
     279#ifdef JJF_ZERO
    280280    const CbcNode* currentNode = model_->currentNode();
    281281    if (currentNode == NULL) {
     
    309309        // LL: should we save these nodes in the list of nodes where the heur was
    310310        // LL: run?
    311 #if 1
     311#ifndef JJF_ONE
    312312        if (currentNode != NULL) {
    313313            // Get where we are and create the appropriate CbcHeuristicNode object
     
    334334        CbcHeuristicNode* nodeDesc = new CbcHeuristicNode(*model_);
    335335        //#ifdef PRINT_DEBUG
    336 #if 1
     336#ifndef JJF_ONE
    337337        const double minDistanceToRun = 1.5 * log((double)depth) / log((double)2);
    338338#else
     
    23182318#ifdef NEW_ROUNDING
    23192319    if (!returnCode) {
    2320 #if 0
     2320#ifdef JJF_ZERO
    23212321        // back to starting point
    23222322        memcpy(newSolution, solution, numberColumns*sizeof(double));
  • branches/sandbox/Cbc/src/CbcHeuristic.hpp

    r1286 r1393  
    374374
    375375
    376 #if 0
     376#ifdef JJF_ZERO
    377377    /// Lower bounds of last node where the heuristic found a solution
    378378    double * lowerBoundLastNode_;
  • branches/sandbox/Cbc/src/CbcHeuristicDINS.cpp

    r1368 r1393  
    328328            << CoinMessageEol;
    329329            if (nFix > numberIntegers / 10) {
    330 #if 0
     330#ifdef JJF_ZERO
    331331                newSolver->initialSolve();
    332332                printf("obj %g\n", newSolver->getObjValue());
  • branches/sandbox/Cbc/src/CbcHeuristicDive.cpp

    r1315 r1393  
    204204        return 0;
    205205
    206 #if 0
     206#ifdef JJF_ZERO
    207207    // See if to do
    208208    if (!when() || (when() % 10 == 1 && model_->phase() != 1) ||
     
    448448#endif
    449449        if (reducedCost && true) {
    450 #if 1
     450#ifndef JJF_ONE
    451451            cnt = fixOtherVariables(solver, solution, candidate, random);
    452452#else
     
    911911{
    912912    //return 0; // temp
    913 #if 1
     913#ifndef JJF_ONE
    914914    if (!model_->solverCharacteristics()->reducedCostsAccurate())
    915915        return 0; //NLP
  • branches/sandbox/Cbc/src/CbcHeuristicFPump.cpp

    r1364 r1393  
    588588            // Tweak rhs and save
    589589            useRhs = rhs;
    590 #if 0
     590#ifdef JJF_ZERO
    591591            double tempValue = 60.0 * useRhs;
    592592            if (fabs(tempValue - floor(tempValue + 0.5)) < 1.0e-7 && rhs != fakeCutoff_) {
     
    12321232                        }
    12331233                        if (newNumberInfeas && newNumberInfeas < 15) {
    1234 #if 0
     1234#ifdef JJF_ZERO
    12351235                            roundingObjective = solutionValue;
    12361236                            OsiSolverInterface * saveSolver = model_->swapSolver(solver);
     
    18811881                            if (value < newSolutionValue) {
    18821882                                //newSolver->writeMps("query","mps");
    1883 #if 0
     1883#ifdef JJF_ZERO
    18841884                                {
    18851885                                    double saveOffset;
     
    21872187    }
    21882188    int numberColumns = solver->getNumCols();
    2189 #if 0
     2189#ifdef JJF_ZERO
    21902190    // Do set covering variables
    21912191    const CoinPackedMatrix * matrixByRow = solver->getMatrixByRow();
     
    23352335        double round = floor(value + primalTolerance);
    23362336        if (value - round > downValue) round += 1.;
    2337 #if 1
     2337#ifndef JJF_ONE
    23382338        if (round < integerTolerance && cost[iColumn] < -1. + integerTolerance) flip_down++;
    23392339        if (round > 1. - integerTolerance && cost[iColumn] > 1. - integerTolerance) flip_up++;
     
    24102410        }
    24112411    }
    2412 #if 0
     2412#ifdef JJF_ZERO
    24132413    if (largestInfeasibility > primalTolerance && numberBadRows*10 < numberRows) {
    24142414        // Can we improve by flipping
     
    25422542            }
    25432543            // Now flip some integers?
    2544 #if 0
     2544#ifdef JJF_ZERO
    25452545            for (i = 0; i < numberIntegers; i++) {
    25462546                int iColumn = integerVariable[i];
  • branches/sandbox/Cbc/src/CbcHeuristicFPump.hpp

    r1364 r1393  
    282282    */
    283283    //@{
    284 #if 0
     284#ifdef JJF_ZERO
    285285    /// Into simplex
    286286    virtual void intoSimplex();
  • branches/sandbox/Cbc/src/CbcLinked.cpp

    r1286 r1393  
    876876    gutsOfDestructor(true);
    877877}
    878 #if 0
     878#ifdef JJF_ZERO
    879879/* returns
    880880   sequence of nonlinear or
     
    16811681        }
    16821682    }
    1683 #if 0
     1683#ifdef JJF_ZERO
    16841684    // possibly do bounds
    16851685    for (int iColumn = 0; iColumn < firstLambda; iColumn++) {
     
    18341834        if (obj) {
    18351835            if (obj->xMeshSize() < 1.0 && obj->yMeshSize() < 1.0) {
    1836 #if 0
     1836#ifdef JJF_ZERO
    18371837                numberContinuous++;
    18381838                int xColumn = obj->xColumn();
     
    23262326            memset(r, 0, numberColumns*sizeof(double));
    23272327        }
    2328 #if 0
     2328#ifdef JJF_ZERO
    23292329        for (jNon = 0; jNon < numberNonLinearColumns; jNon++) {
    23302330            iColumn = listNonLinearColumn[jNon];
     
    25812581        cbcModel->cutGenerator(6)->setTiming(true);
    25822582        // For now - switch off most heuristics (because CglPreProcess is bad with QP)
    2583 #if 1
     2583#ifndef JJF_ONE
    25842584        CbcHeuristicFPump heuristicFPump(*cbcModel);
    25852585        heuristicFPump.setWhen(13);
     
    36213621                if (zeroObjective) {
    36223622                    cbcModel->setMaximumSolutions(1); // just getting a solution
    3623 #if 0
     3623#ifdef JJF_ZERO
    36243624                    OsiClpSolverInterface * osiclpModel = dynamic_cast< OsiClpSolverInterface*> (cbcModel->solver());
    36253625                    ClpSimplex * clpModel = osiclpModel->getModelPtr();
     
    38613861    }
    38623862}
    3863 #if 0
     3863#ifdef JJF_ZERO
    38643864// Add an element modifier
    38653865void
     
    44194419        int iColumn = members_[j];
    44204420        int i;
    4421 #if 0
     4421#ifdef JJF_ZERO
    44224422        for (i = 0; i < numberColumns; i++) {
    44234423            if (originalColumns[i] == iColumn)
     
    52765276    yB[0] = info->lower_[yColumn_];
    52775277    yB[1] = info->upper_[yColumn_];
    5278 #if 0
     5278#ifdef JJF_ZERO
    52795279    if (info->lower_[1] <= 43.0 && info->upper_[1] >= 43.0) {
    52805280        if (info->lower_[4] <= 49.0 && info->upper_[4] >= 49.0) {
     
    54545454        assert (xyTrue - 1.0e-5 < xB[0]*y + yB[1]*x - xB[0]*yB[1]);
    54555455        // see if all convexification constraints OK with lambda version
    5456 #if 1
     5456#ifndef JJF_ONE
    54575457        assert (xyLambda + 1.0e-5 > xB[0]*y + yB[0]*x - xB[0]*yB[0]);
    54585458        assert (xyLambda + 1.0e-5 > xB[1]*y + yB[1]*x - xB[1]*yB[1]);
     
    56195619            if (fabs(xyLambda - xyTrue) < xySatisfied_ || (xB[0] == xB[1] && yB[0] == yB[1])) {
    56205620                // satisfied
    5621 #if 0
     5621#ifdef JJF_ZERO
    56225622                printf("all satisfied true %g lambda %g\n",
    56235623                       xyTrue, xyLambda);
     
    59745974    if (yRow_ < 0)
    59755975        yLambda = xLambda;
    5976 #if 0
     5976#ifdef JJF_ZERO
    59775977    if (fabs(x - xLambda) > 1.0e-4 ||
    59785978            fabs(y - yLambda) > 1.0e-4)
     
    60826082{
    60836083    int i;
    6084 #if 0
     6084#ifdef JJF_ZERO
    60856085    for (i = 0; i < numberColumns; i++) {
    60866086        if (originalColumns[i] == firstLambda_)
     
    62006200               iColumn, oldLower, oldUpper);
    62016201#endif
    6202 #if 0
     6202#ifdef JJF_ZERO
    62036203    // always free up lambda
    62046204    for (int i = firstLambda_; i < firstLambda_ + 4; i++) {
     
    72237223void checkQP(ClpSimplex * /*model*/)
    72247224{
    7225 #if 0
     7225#ifdef JJF_ZERO
    72267226    printf("Checking quadratic model %x\n", model);
    72277227    if (model) {
     
    77117711                    int /*mode*/)
    77127712{
    7713 #if 1
     7713#ifndef JJF_ONE
    77147714    //#ifdef COIN_HAS_ASL
    77157715    // matrix etc will be changed
  • branches/sandbox/Cbc/src/CbcModel.cpp

    r1387 r1393  
    595595                const int * columnLength = matrixByCol->getVectorLengths();
    596596                const double * solution = clpSolver->getColSolution();
    597 #if 0
     597#ifdef JJF_ZERO
    598598                int nAtBound = 0;
    599599                for (int i = 0; i < numberColumns; i++) {
     
    16521652            // Initialise solvers seed
    16531653            clpSolver->getModelPtr()->setRandomSeed(1234567);
    1654 #if 0
     1654#ifdef JJF_ZERO
    16551655            // reduce factorization frequency
    16561656            int frequency = clpSolver->getModelPtr()->factorizationFrequency();
     
    18121812                        // already has column numbers changed
    18131813                        object_[numberObjects_] = originalObject[iObject]->clone();
    1814 #if 0
     1814#ifdef JJF_ZERO
    18151815                        // redo ids etc
    18161816                        CbcObject * obj =
     
    22772277        compareActual->setBestPossible(direction*solver_->getObjValue());
    22782278        compareActual->setCutoff(getCutoff());
    2279 #if 0
     2279#ifdef JJF_ZERO
    22802280        if (false && !numberThreads_ && !parentModel_) {
    22812281            printf("CbcTreeArray ? threads ? parentArray\n");
     
    25312531                            doHeuristicsAtRoot();
    25322532                        }
    2533 #if 0
     2533#ifdef JJF_ZERO
    25342534                        int nCuts = storedRowCuts_->sizeRowCuts();
    25352535                        // add to global list
     
    31623162        if (toZero[number01]) {
    31633163            CglTreeProbingInfo info(*probingInfo_);
    3164 #if 0
     3164#ifdef JJF_ZERO
    31653165/*
    31663166  Marginal idea. Further exploration probably good. Build some extra
     
    40244024            // Do main work of solving node here
    40254025            doOneNode(this, node, createdNode);
    4026 #if 0
     4026#ifdef JJF_ZERO
    40274027            if (node) {
    40284028                if (createdNode) {
     
    69996999
    70007000{
    7001 #if 0
     7001#ifdef JJF_ZERO
    70027002    if (node && numberTries > 1) {
    70037003        if (currentDepth_ < 5)
     
    75167516                !solver_->optimalBasisIsAvailable()) {
    75177517            //printf("XXXXYY no opt basis\n");
    7518 #if 0//def COIN_HAS_CLP
     7518#ifdef JJF_ZERO//def COIN_HAS_CLP
    75197519            //OsiClpSolverInterface * clpSolver
    75207520            //= dynamic_cast<OsiClpSolverInterface *> (solver_);
     
    75267526#endif
    75277527            resolve(node ? node->nodeInfo() : NULL, 3);
    7528 #if 0//def COIN_HAS_CLP
     7528#ifdef JJF_ZERO//def COIN_HAS_CLP
    75297529            if (clpSolver)
    75307530                clpSolver->setSpecialOptions(save);
     
    77937793            }
    77947794            if (violated >= 0 && feasible) {
    7795 #if 0
     7795#ifdef JJF_ZERO
    77967796                //winnowCuts(theseCuts);
    77977797                // look at all cuts here
     
    82308230        }
    82318231
    8232 #if 0
     8232#ifdef JJF_ZERO
    82338233        // switch on to get all cuts printed
    82348234        theseCuts.printCuts() ;
     
    84748474                bool badObj = (allowZeroIterations) ? thisObj < cut_obj[0] + minimumDrop
    84758475                              : thisObj < cut_obj[CUT_HISTORY-1] + minimumDrop;
    8476 #if 0 // probably not a good idea
     8476#ifdef JJF_ZERO // probably not a good idea
    84778477                if (!badObj)
    84788478                    numberLastAttempts = CoinMax(0, numberLastAttempts - 1);
     
    88518851                                maximumCutPasses_ = CoinMax(maximumCutPasses_ >> 1, 1);
    88528852                        }
    8853 #if 0
     8853#ifdef JJF_ZERO
    88548854                    } else if (currentPassNumber_ < CoinMin(CoinAbs(maximumCutPassesAtRoot_), 8)) {
    88558855                        if (whenCuts_ == 999999) {
     
    88908890                } else {
    88918891                    // Objective changed
    8892 #if 0
     8892#ifdef JJF_ZERO
    88938893                    if (currentPassNumber_ < CoinMin(CoinAbs(maximumCutPassesAtRoot_), 8)) {
    88948894                        if (whenCuts_ == 999999) {
     
    98649864        }
    98659865    }
    9866 #if 0
     9866#ifdef JJF_ZERO
    98679867    if (cutModifier_ && feasible && !solverCharacteristics_->solutionAddsCuts()) {
    98689868        //double increment = getDblParam(CbcModel::CbcCutoffIncrement) ;
     
    1032210322                    //assert (obj1->downShadowPrice()>0.0);
    1032310323#define P_FACTOR 1.0
    10324 #if 1
     10324#ifndef JJF_ONE
    1032510325                    obj1->setDownShadowPrice(-P_FACTOR*obj1->downShadowPrice());
    1032610326                    obj1->setUpShadowPrice(-P_FACTOR*obj1->upShadowPrice());
     
    1122611226
    1122711227{
    11228 #if 0
     11228#ifdef JJF_ZERO
    1122911229    double tol = 0 ;
    1123011230    int fathomStrict = getIntParam(CbcFathomDiscipline) ;
     
    1131311313            CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis*>(saveSolver->getWarmStart()) ;
    1131411314            assert(basis != NULL);
    11315 #if 0 //ndef CBC_OTHER_SOLVER
     11315#ifdef JJF_ZERO //ndef CBC_OTHER_SOLVER
    1131611316            for (i = 0; i < numberObjects_; i++) {
    1131711317                CbcSimpleInteger * obj =
     
    1135511355            solver_->setHintParam(OsiDoDualInInitial, true, OsiHintTry);
    1135611356            solver_->initialSolve();
    11357 #if 0
     11357#ifdef JJF_ZERO
    1135811358            if (solver_->isProvenOptimal()) {
    1135911359                solver_->writeMps("feasible");
     
    1150711507#endif
    1150811508            if ((specialOptions_&16) == 0) {
    11509 #if 0
     11509#ifdef JJF_ZERO
    1151011510                // check without scaling
    1151111511                bool saveTakeHint;
     
    1173311733{
    1173411734    double * solution = CoinCopyOfArray(solutionIn, solver_->getNumCols());
    11735 #if 0
     11735#ifdef JJF_ZERO
    1173611736    {
    1173711737        double saveOffset;
     
    1313213132        dblParam_[CbcSmallChange] = 1.0e-8;
    1313313133    }
    13134 #if 0
     13134#ifdef JJF_ZERO
    1313513135    // Say not on optimal path
    1313613136    bool onOptimalPath = false;
     
    1344513445    }
    1344613446    stateOfSearch_ = 0; // outside chooseBranch
    13447 #if 0
     13447#ifdef JJF_ZERO
    1344813448    if (onOptimalPath) {
    1344913449        const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
     
    1469614696                                        if (canDelete) {
    1469714697                                            //nRedundantDown++;
    14698 #if 1
     14698#ifndef JJF_ONE
    1469914699                                            printf("%d redundant branch down with bounds %g, %g current upper %g solution %g dj %g\n",
    1470014700                                                   iColumn2, bounds[0], bounds[1], upper[iColumn2], solution[iColumn2], djValue);
     
    1471314713                                            }
    1471414714                                        } else if (iColumn1 >= 0 && iColumn1 != iColumn2 && (!inBetween || true) && zeroOne1 && zeroOne2 && false) {
    14715 #if 1
     14715#ifndef JJF_ONE
    1471614716                                            if (true) {
    1471714717                                                // add in bounds
     
    1473914739                                        if (canDelete) {
    1474014740                                            //nRedundantUp++;
    14741 #if 1
     14741#ifndef JJF_ONE
    1474214742                                            printf("%d redundant branch up with bounds %g, %g current lower %g solution %g dj %g\n",
    1474314743                                                   iColumn2, bounds[0], bounds[1], lower[iColumn2], solution[iColumn2], djValue);
     
    1475614756                                            }
    1475714757                                        } else if (iColumn1 >= 0 && iColumn1 != iColumn2 && (!inBetween || true) && zeroOne1 && zeroOne2 && false) {
    14758 #if 1
     14758#ifndef JJF_ONE
    1475914759                                            // add in bounds
    1476014760                                            newLower = bounds1[0];
     
    1514415144      to this code block also performs this action.
    1514515145    */
    15146 #if 1
     15146#ifndef JJF_ONE
    1514715147    //if (numberThreads_)
    1514815148    {
     
    1522615226        otherModel->numberNodes_ = 1; //numberNodes_;
    1522715227        otherModel->numberIterations_ = numberIterations_;
    15228 #if 0
     15228#ifdef JJF_ZERO
    1522915229        if (maximumNumberCuts_ > otherModel->maximumNumberCuts_) {
    1523015230            otherModel->maximumNumberCuts_ = maximumNumberCuts_;
     
    1591315913        --nNode;
    1591415914        walkback_[nNode]->applyBounds(iColumn, lower, upper, force);
    15915 #if 0
     15915#ifdef JJF_ZERO
    1591615916        CbcNode * nodeLook = walkback_[nNode]->mutableOwner();
    1591715917        if (nodeLook) {
     
    1661816618        }
    1661916619        delete [] back;
    16620 #if 0
     16620#ifdef JJF_ZERO
    1662116621        // ** looks as if presolve needs more intelligence
    1662216622        // do presolve - for now just clp but easy to get osi interface
  • branches/sandbox/Cbc/src/CbcNWay.hpp

    r1389 r1393  
    103103    virtual double branch();
    104104
    105 #if 0
     105#ifdef JJF_ZERO
    106106    // FIXME: what do we need to do here?
    107107    /** Reset every information so that the branching object appears to point to
  • branches/sandbox/Cbc/src/CbcNode.cpp

    r1366 r1393  
    17661766    int numberNodes = model->getNodeCount();
    17671767    int saveLogLevel = model->logLevel();
    1768 #if 0
     1768#ifdef JJF_ZERO
    17691769    if ((numberNodes % 500) == 0) {
    17701770        model->setLogLevel(6);
     
    19711971            sumInfeasibilities_ = 0.0;
    19721972            int bestPriority = COIN_INT_MAX;
    1973 #if 0
     1973#ifdef JJF_ZERO
    19741974            int number01 = 0;
    19751975            const cliqueEntry * entry = NULL;
     
    21292129                            infeasibility = 0.5 - fabs(0.5 - part);
    21302130                        }
    2131 #if 0
     2131#ifdef JJF_ZERO
    21322132                        if (probingInfo) {
    21332133                            int iSeq = backward[iColumn];
  • branches/sandbox/Cbc/src/CbcNodeInfo.cpp

    r1357 r1393  
    8686}
    8787
    88 #if 0
     88#ifdef JJF_ZERO
    8989// Constructor given parent
    9090CbcNodeInfo::CbcNodeInfo (CbcNodeInfo * parent)
     
    289289    }
    290290}
    291 #if 0
     291#ifdef JJF_ZERO
    292292void
    293293CbcNodeInfo::incrementParentCuts(CbcModel * model, int change)
  • branches/sandbox/Cbc/src/CbcNodeInfo.hpp

    r1357 r1393  
    7575    CbcNodeInfo ( const CbcNodeInfo &);
    7676
    77 #if 0
     77#ifdef JJF_ZERO
    7878    /** Construct with parent
    7979
     
    119119    /// Called when number branches left down to zero
    120120    virtual void allBranchesGone() {}
    121 #if 1
     121#ifndef JJF_ONE
    122122    /// Increment number of references
    123123    inline void increment(int amount = 1) {
  • branches/sandbox/Cbc/src/CbcSimpleInteger.cpp

    r1357 r1393  
    229229    //assert (numberColumns>0);
    230230    int iColumn;
    231 #if 0
     231#ifdef JJF_ZERO
    232232    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    233233        if (columnNumber_ == originalColumns[iColumn])
  • branches/sandbox/Cbc/src/CbcSimpleInteger.hpp

    r1389 r1393  
    6767                     int branchState) const ;
    6868
    69 #if 0
     69#ifdef JJF_ZERO
    7070    // No need to override. Default works fine.
    7171    /** Reset every information so that the branching object appears to point to
  • branches/sandbox/Cbc/src/CbcSolver.cpp

    r1392 r1393  
    36273627                    case CLP_PARAM_ACTION_OUTDUPROWS:
    36283628                        dominatedCuts = true;
    3629 #if 0
     3629#ifdef JJF_ZERO
    36303630                        if (goodModel) {
    36313631                            int numberRows = clpSolver->getNumRows();
     
    46114611                            int testOsiOptions = parameters_[whichParam(CBC_PARAM_INT_TESTOSI, numberParameters_, parameters_)].intValue();
    46124612                            //#ifdef COIN_HAS_ASL
    4613 #if 1
     4613#ifndef JJF_ONE
    46144614                            // If linked then see if expansion wanted
    46154615                            {
     
    56565656                                        int way = (((nodeStrategy - 1) % 1) == 1) ? -1 : +1;
    56575657                                        babModel_->setPreferredWay(way);
    5658 #if 0
     5658#ifdef JJF_ZERO
    56595659                                        OsiObject ** objects = babModel_->objects();
    56605660                                        int numberObjects = babModel_->numberObjects();
     
    61216121                                    osiclp->getModelPtr()->setPerturbation(52); // try less
    61226122#endif
    6123 #if 0
     6123#ifdef JJF_ZERO
    61246124                                if (osiclp->getNumCols() == 29404) {
    61256125                                    void restoreSolution(ClpSimplex * lpSolver,
     
    62116211                                    donor.setStoredRowCuts(NULL);
    62126212                                }
    6213 #if 0
     6213#ifdef JJF_ZERO
    62146214                                int extra5 = parameters_[whichParam(EXTRA5, numberParameters_, parameters_)].intValue();
    62156215                                if (extra5 > 0) {
     
    62386238#endif
    62396239#ifdef COIN_DEVELOP
    6240 #if 1
     6240#ifndef JJF_ONE
    62416241                                {
    62426242                                    int numberColumns = babModel_->getNumCols();
     
    65636563                                        }
    65646564                                    }
    6565 #if 0
     6565#ifdef JJF_ZERO
    65666566                                    // See if sos so we can fix
    65676567                                    OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (saveSolver);
  • branches/sandbox/Cbc/src/CbcSolverHeuristics.cpp

    r1386 r1393  
    4545crunchIt(ClpSimplex * model)
    4646{
    47 #if 0
     47#ifdef JJF_ZERO
    4848    model->dual();
    4949#else
     
    11371137                 int numberParameters_,int noPrinting_,int initialPumpTune)
    11381138{
    1139 #if 0 //NEW_STYLE_SOLVER==0
     1139#ifdef JJF_ZERO //NEW_STYLE_SOLVER==0
    11401140    CbcOrClpParam * parameters_ = parameters;
    11411141    int numberParameters_ = numberParameters;
     
    13551355    }
    13561356    if (useRENS >= kType && useRENS <= kType + 1) {
    1357 #if 1
     1357#ifndef JJF_ONE
    13581358        CbcHeuristicRENS heuristic6(*model);
    13591359        heuristic6.setHeuristicName("RENS");
     
    14771477        anyToDo = true;
    14781478    }
    1479 #if 0
     1479#ifdef JJF_ZERO
    14801480    if (usePivotC >= type && usePivotC <= kType + 1) {
    14811481        CbcHeuristicPivotAndComplement heuristic(*model);
     
    15521552    if (type == 2 && anyToDo) {
    15531553        // Do heuristics
    1554 #if 1
     1554#ifndef JJF_ONE
    15551555        // clean copy
    15561556        CbcModel model2(*model);
  • branches/sandbox/Cbc/src/CbcStrategy.cpp

    r1387 r1393  
    296296    if (!found)
    297297        model.addHeuristic(&heuristic1);
    298 #if 0
     298#ifdef JJF_ZERO
    299299    // Allow join solutions
    300300    CbcHeuristicLocal heuristic2(model);
     
    863863            model.addCutGenerator(&mixedGen, setting, "MixedIntegerRounding2");
    864864    }
    865 #if 0
     865#ifdef JJF_ZERO
    866866    // Say we want timings
    867867    int newNumberGenerators = model.numberCutGenerators();
     
    952952            cglProbing->setRowCuts(3);
    953953        }
    954 #if 0
     954#ifdef JJF_ZERO
    955955        CglGomory * cglGomory = dynamic_cast<CglGomory *>(generator);
    956956        if (cglGomory) {
  • branches/sandbox/Cbc/src/CbcSubProblem.cpp

    r1357 r1393  
    220220                   numberChangedBounds_, what);
    221221    }
    222 #if 0
     222#ifdef JJF_ZERO
    223223    if ((what&2) != 0) {
    224224        OsiClpSolverInterface * clpSolver
  • branches/sandbox/Cbc/src/CbcTree.cpp

    r1342 r1393  
    239239        }
    240240        if (!best || best->objectiveValue() >= cutoff) {
    241 #if 0
     241#ifdef JJF_ZERO
    242242            // take off
    243243            std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
     
    463463}
    464464
    465 #if 0 // not used, referenced removed in CbcModel.cpp
     465#ifdef JJF_ZERO // not used, referenced removed in CbcModel.cpp
    466466CbcTreeArray::CbcTreeArray()
    467467        : CbcTree(),
     
    869869       x->nodeInfo()->numberBranchesLeft(),x->nodeInfo()->numberPointingToThis());*/
    870870    assert(x->objectiveValue() != COIN_DBL_MAX && x->nodeInfo());
    871 #if 0
     871#ifdef JJF_ZERO
    872872    nodes_.push_back(x);
    873873    push_heap(nodes_.begin(), nodes_.end(), comparison_);
     
    881881CbcTree::pop()
    882882{
    883 #if 0
     883#ifdef JJF_ZERO
    884884    std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
    885885    nodes_.pop_back();
     
    916916        }
    917917        if (!best || best->objectiveValue() >= cutoff) {
    918 #if 0
     918#ifdef JJF_ZERO
    919919            // take off
    920920            std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
     
    956956    } else if (best) {
    957957        // take off
    958 #if 0
     958#ifdef JJF_ZERO
    959959        std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
    960960        nodes_.pop_back();
  • branches/sandbox/Cbc/src/CbcTree.hpp

    r1343 r1393  
    166166*/
    167167
    168 #if 0 // not used
     168#ifdef JJF_ZERO // not used
    169169class CbcTreeArray : public CbcTree {
    170170
  • branches/sandbox/Cbc/src/CbcTreeLocal.cpp

    r1361 r1393  
    1010#include "OsiRowCutDebugger.hpp"
    1111#include <cassert>
    12 #if 0
     12#ifdef JJF_ZERO
    1313// gdb doesn't always put breakpoints in this virtual function
    1414// just stick xxxxxx() where you want to start
  • branches/sandbox/Cbc/src/Cbc_ampl.cpp

    r1361 r1393  
    159159// strdup used to avoid g++ compiler warning
    160160static SufDecl suftab[] = {
    161 #if 0
     161#ifdef JJF_ZERO
    162162    { const_cast<char*>("current"), 0, ASL_Sufkind_con | ASL_Sufkind_outonly },
    163163    { const_cast<char*>("current"), 0, ASL_Sufkind_var | ASL_Sufkind_outonly },
     
    182182    { const_cast<char*>("sstatus"), 0, ASL_Sufkind_con, 0 },
    183183    { const_cast<char*>("upPseudocost"), 0, ASL_Sufkind_var | ASL_Sufkind_real }
    184 #if 0
     184#ifdef JJF_ZERO
    185185    { const_cast<char*>("unbdd"), 0, ASL_Sufkind_var | ASL_Sufkind_outonly},
    186186    { const_cast<char*>("up"), 0, ASL_Sufkind_con | ASL_Sufkind_outonly },
     
    525525            /* all slack basis */
    526526            // leave status for output */
    527 #if 0
     527#ifdef JJF_ZERO
    528528            free(info->rowStatus);
    529529            info->rowStatus = NULL;
     
    785785    }
    786786}
    787 #if 0
     787#ifdef JJF_ZERO
    788788static real
    789789qterm(ASL *asl, fint *colq, fint *rowq, real *delsq)
     
    893893            if (nsos) {
    894894                abort();
    895 #if 0
     895#ifdef JJF_ZERO
    896896                info->numberSos = nsos;
    897897                info->sosType = (char *) malloc(nsos);
     
    976976            /* all slack basis */
    977977            // leave status for output */
    978 #if 0
     978#ifdef JJF_ZERO
    979979            free(rowStatus);
    980980            rowStatus = NULL;
     
    13461346                    continue;
    13471347                }
    1348 #if 0
     1348#ifdef JJF_ZERO
    13491349                printf("%d quadratic els\n", nels);
    13501350                for (int j = 0; j < n_var; j++) {
  • branches/sandbox/Cbc/src/unitTestClp.cpp

    r1361 r1393  
    306306                    clpMatrix->makeSpecialColumnCopy();
    307307                }
    308 #if 0
     308#ifdef JJF_ZERO
    309309                if (clpMatrix) {
    310310                    int numberRows = clpMatrix->getNumRows();
     
    436436                    std::cout << "Largest (scaled) away from bound " << largestScaled
    437437                              << " unscaled " << largest << std::endl;
    438 #if 0
     438#ifdef JJF_ZERO
    439439                    modelC->setDualBound(CoinMax(1.0001e8,
    440440                                                 CoinMin(1000.0*largestScaled, 1.00001e10)));
Note: See TracChangeset for help on using the changeset viewer.