Changeset 1315 for branches/sandbox


Ignore:
Timestamp:
Nov 28, 2009 6:09:56 AM (10 years ago)
Author:
forrest
Message:

final changes before cleaning

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

Legend:

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

    r1314 r1315  
    2727        numberSolutions_(0),
    2828        treeSize_(0),
    29         breadthDepth_(5)
     29        breadthDepth_(5),
     30        startNodeNumber_(-1),
     31        afterNodeNumber_(-1)
    3032{
    3133    test_ = this;
     
    4143        numberSolutions_(0),
    4244        treeSize_(0),
    43         breadthDepth_(5)
     45        breadthDepth_(5),
     46        startNodeNumber_(-1),
     47        afterNodeNumber_(-1)
    4448{
    4549    test_ = this;
     
    5963    treeSize_ = rhs.treeSize_;
    6064    breadthDepth_ = rhs.breadthDepth_;
     65    startNodeNumber_ = rhs.startNodeNumber_;
     66    afterNodeNumber_ = rhs.afterNodeNumber_;
    6167}
    6268
     
    8187        treeSize_ = rhs.treeSize_;
    8288        breadthDepth_ = rhs.breadthDepth_;
     89        startNodeNumber_ = rhs.startNodeNumber_;
     90        afterNodeNumber_ = rhs.afterNodeNumber_;
    8391    }
    8492    return *this;
     
    94102CbcCompareDefault::test (CbcNode * x, CbcNode * y)
    95103{
    96 #if 0
    97     // always choose *smallest* depth if one or both <= breadthDepth_
    98     int depthX = x->depth();
    99     int depthY = y->depth();
    100     if (depthX <= breadthDepth_ || depthY <= breadthDepth_) {
    101         if (depthX != depthY)
    102             return depthX > depthY;
    103         else
    104             return equalityTest(x, y); // so ties will be broken in consistent manner
    105     }
    106     if (weight_ == -1.0 || weight_ == -3.0) {
    107         int adjust =  (weight_ == -3.0) ? 10000 : 0;
    108         // before solution
    109         /*printf("x %d %d %g, y %d %d %g\n",
    110            x->numberUnsatisfied(),x->depth(),x->objectiveValue(),
    111            y->numberUnsatisfied(),y->depth(),y->objectiveValue()); */
    112         if (x->numberUnsatisfied() > y->numberUnsatisfied() + adjust) {
     104    if (startNodeNumber_ >= 0) {
     105        // Diving
     106        int nX = x->nodeNumber();
     107        int nY = y->nodeNumber();
     108        if (nY == startNodeNumber_)
    113109            return true;
    114         } else if (x->numberUnsatisfied() < y->numberUnsatisfied() - adjust) {
     110        else if (nX == startNodeNumber_)
    115111            return false;
     112        if (nX >= afterNodeNumber_ && nY < afterNodeNumber_)
     113            return false;
     114        else if (nY >= afterNodeNumber_ && nX < afterNodeNumber_)
     115            return true;
     116        // treat as depth first
     117        int depthX = x->depth();
     118        int depthY = y->depth();
     119        if (depthX != depthY) {
     120            return depthX < depthY;
    116121        } else {
    117             int depthX = x->depth();
    118             int depthY = y->depth();
    119             if (depthX != depthY)
    120                 return depthX < depthY;
     122            double weight = CoinMax(weight_, 1.0e-9);
     123            double testX =  x->objectiveValue() + weight * x->numberUnsatisfied();
     124            double testY = y->objectiveValue() + weight * y->numberUnsatisfied();
     125            if (testX != testY)
     126                return testX > testY;
    121127            else
    122128                return equalityTest(x, y); // so ties will be broken in consistent manner
    123129        }
    124     } else {
    125         // after solution
    126         double weight = CoinMax(weight_, 0.0);
    127         double testX =  x->objectiveValue() + weight * x->numberUnsatisfied();
    128         double testY = y->objectiveValue() + weight * y->numberUnsatisfied();
    129         if (testX != testY)
    130             return testX > testY;
    131         else
    132             return equalityTest(x, y); // so ties will be broken in consistent manner
    133     }
    134 #else
     130    }
    135131    //weight_=0.0;
    136132    if ((weight_ == -1.0 && (y->depth() > breadthDepth_ && x->depth() > breadthDepth_)) || weight_ == -3.0 || weight_ == -2.0) {
     
    177173        double testY = y->objectiveValue() + weight * y->numberUnsatisfied();
    178174#elif TRY_THIS==1
    179     /* compute what weight would have to be to hit target
    180        then reverse sign as large weight good */
    181     double target = (1.0 - THRESH2) * bestPossible_ + THRESH2 * cutoff_;
    182     double weight;
    183     weight = (target - x->objectiveValue()) /
    184              static_cast<double>(x->numberUnsatisfied());
    185     double testX = - weight;
    186     weight = (target - y->objectiveValue()) /
    187              static_cast<double>(y->numberUnsatisfied());
    188     double testY = - weight;
     175        /* compute what weight would have to be to hit target
     176           then reverse sign as large weight good */
     177        double target = (1.0 - THRESH2) * bestPossible_ + THRESH2 * cutoff_;
     178        double weight;
     179        weight = (target - x->objectiveValue()) /
     180                 static_cast<double>(x->numberUnsatisfied());
     181        double testX = - weight;
     182        weight = (target - y->objectiveValue()) /
     183                 static_cast<double>(y->numberUnsatisfied());
     184        double testY = - weight;
    189185#elif TRY_THIS==2
    190     // Use estimates
    191     double testX = x->guessedObjectiveValue();
    192     double testY = y->guessedObjectiveValue();
     186        // Use estimates
     187        double testX = x->guessedObjectiveValue();
     188        double testY = y->guessedObjectiveValue();
    193189#elif TRY_THIS==3
    194190#define THRESH 0.95
    195     // Use estimates
    196     double testX = x->guessedObjectiveValue();
    197     double testY = y->guessedObjectiveValue();
    198     if (x->objectiveValue() - bestPossible_ > THRESH*(cutoff_ - bestPossible_))
    199         testX *= 2.0; // make worse
    200     if (y->objectiveValue() - bestPossible_ > THRESH*(cutoff_ - bestPossible_))
    201         testY *= 2.0; // make worse
     191        // Use estimates
     192        double testX = x->guessedObjectiveValue();
     193        double testY = y->guessedObjectiveValue();
     194        if (x->objectiveValue() - bestPossible_ > THRESH*(cutoff_ - bestPossible_))
     195            testX *= 2.0; // make worse
     196        if (y->objectiveValue() - bestPossible_ > THRESH*(cutoff_ - bestPossible_))
     197            testY *= 2.0; // make worse
    202198#endif
    203199        if (testX != testY)
     
    206202            return equalityTest(x, y); // so ties will be broken in consistent manner
    207203    }
    208 #endif
    209204}
    210205// This allows method to change behavior as it is called
     
    270265    return (weight_ != saveWeight);
    271266}
     267// Start dive
     268void
     269CbcCompareDefault::startDive(CbcModel * model)
     270{
     271    // Get best - using ? criterion
     272    double saveWeight = weight_;
     273    weight_ = 0.5 * saveWeight_; //0.0;
     274    // Switch off to get best
     275    startNodeNumber_ = -1;
     276    afterNodeNumber_ = -1;
     277    CbcNode * best = model->tree()->bestAlternate();
     278    startNodeNumber_ = best->nodeNumber();
     279    // send signal to setComparison
     280    afterNodeNumber_ = -2;
     281    // redo tree
     282    model->tree()->setComparison(*this);
     283    afterNodeNumber_ = model->tree()->maximumNodeNumber();
     284    weight_ = saveWeight;
     285}
     286// Clean up dive
     287void
     288CbcCompareDefault::cleanDive()
     289{
     290    if (afterNodeNumber_ != -2) {
     291        // switch off
     292        startNodeNumber_ = -1;
     293        afterNodeNumber_ = -1;
     294    }
     295}
    272296
    273297// Create C++ lines to get to current state
  • branches/sandbox/Cbc/src/CbcCompareDefault.hpp

    r1314 r1315  
    2525class CbcCompareDefault  : public CbcCompareBase {
    2626public:
    27     // Default Constructor
     27    /// Default Constructor
    2828    CbcCompareDefault () ;
    29     // Constructor with weight
     29    /// Constructor with weight
    3030    CbcCompareDefault (double weight);
    3131
    32     // Copy constructor
     32    /// Copy constructor
    3333    CbcCompareDefault ( const CbcCompareDefault &rhs);
    3434
    35     // Assignment operator
     35    /// Assignment operator
    3636    CbcCompareDefault & operator=( const CbcCompareDefault& rhs);
    3737
     
    4747
    4848    using CbcCompareBase::newSolution ;
    49     // This allows method to change behavior as it is called
    50     // after each solution
     49    /// This allows method to change behavior as it is called
     50    /// after each solution
    5151    virtual void newSolution(CbcModel * model,
    5252                             double objectiveAtContinuous,
    5353                             int numberInfeasibilitiesAtContinuous) ;
    54     // This allows method to change behavior
    55     // Return true if want tree re-sorted
     54    /// This allows method to change behavior
     55    /// Return true if want tree re-sorted
    5656    virtual bool every1000Nodes(CbcModel * model, int numberNodes);
    5757
     
    8080        bestPossible_ = bestPossible;
    8181    }
    82     // Depth above which want to explore first
     82    /// Depth above which want to explore first
    8383    inline void setBreadthDepth(int value) {
    8484        breadthDepth_ = value;
    8585    }
     86    /// Start dive
     87    void startDive(CbcModel * model);
     88    /// Clean up diving (i.e. switch off or prepare)
     89    void cleanDive();
    8690protected:
    87     // Weight for each infeasibility
     91    /// Weight for each infeasibility
    8892    double weight_;
    89     // Weight for each infeasibility - computed from solution
     93    /// Weight for each infeasibility - computed from solution
    9094    double saveWeight_;
    9195    /// Cutoff
     
    9397    /// Best possible solution
    9498    double bestPossible_;
    95     // Number of solutions
     99    /// Number of solutions
    96100    int numberSolutions_;
    97     // Tree size (at last check)
     101    /// Tree size (at last check)
    98102    int treeSize_;
    99     // Depth above which want to explore first
     103    /// Depth above which want to explore first
    100104    int breadthDepth_;
     105    /// Chosen node from estimated (-1 is off)
     106    int startNodeNumber_;
     107    /// Node number when dive started
     108    int afterNodeNumber_;
    101109};
    102110
  • branches/sandbox/Cbc/src/CbcCountRowCut.cpp

    r1286 r1315  
    5454           this, numberPointingToThis_);
    5555#endif
    56     assert (!numberPointingToThis || numberPointingToThis == 1000000000);
     56    //assert (!numberPointingToThis||numberPointingToThis==1000000000);
    5757}
    5858CbcCountRowCut::~CbcCountRowCut()
     
    6363#endif
    6464    // Look at owner and delete
    65     owner_->deleteCut(ownerCut_);
     65    if (owner_)
     66        owner_->deleteCut(ownerCut_);
    6667    ownerCut_ = -1234567;
    6768}
  • branches/sandbox/Cbc/src/CbcCutGenerator.cpp

    r1314 r1315  
    1616#else
    1717#include "OsiSolverInterface.hpp"
     18#endif
     19//#define CGL_DEBUG 1
     20#ifdef CGL_DEBUG
     21#include "OsiRowCutDebugger.hpp"
    1822#endif
    1923#include "CbcModel.hpp"
     
    378382                double primalTolerance = 1.0e-8;
    379383                const char * tightenBounds = generator->tightenBounds();
     384#ifdef CGL_DEBUG
     385                const OsiRowCutDebugger * debugger = solver->getRowCutDebugger();
     386                if (debugger && debugger->onOptimalPath(*solver)) {
     387                    printf("On optimal path CbcCut\n");
     388                    int nCols = solver->getNumCols();
     389                    int i;
     390                    const double * optimal = debugger->optimalSolution();
     391                    const double * objective = solver->getObjCoefficients();
     392                    double objval1 = 0.0, objval2 = 0.0;
     393                    for (i = 0; i < nCols; i++) {
     394#if CGL_DEBUG>1
     395                        printf("%d %g %g %g %g\n", i, lower[i], solution[i], upper[i], optimal[i]);
     396#endif
     397                        objval1 += solution[i] * objective[i];
     398                        objval2 += optimal[i] * objective[i];
     399                        assert(optimal[i] >= lower[i] - 1.0e-5 && optimal[i] <= upper[i] + 1.0e-5);
     400                        assert(optimal[i] >= tightLower[i] - 1.0e-5 && optimal[i] <= tightUpper[i] + 1.0e-5);
     401                    }
     402                    printf("current obj %g, integer %g\n", objval1, objval2);
     403                }
     404#endif
     405                bool feasible = true;
    380406                if ((model_->getThreadMode()&2) == 0) {
    381407                    for (j = 0; j < numberColumns; j++) {
     
    399425                                if (tightUpper[j] == tightLower[j]) {
    400426                                    // fix
     427                                    //if (tightLower[j]!=lower[j])
    401428                                    solver->setColLower(j, tightLower[j]);
     429                                    //if (tightUpper[j]!=upper[j])
    402430                                    solver->setColUpper(j, tightUpper[j]);
    403431                                    if (tightLower[j] > solution[j] + primalTolerance ||
     
    412440                                }
    413441                            }
     442                        }
     443                        if (upper[j] < lower[j] - 1.0e-3) {
     444                            feasible = false;
     445                            break;
    414446                        }
    415447                    }
     
    455487                            }
    456488                        }
     489                        if (upper[j] < lower[j] - 1.0e-3) {
     490                            feasible = false;
     491                            break;
     492                        }
    457493                    }
    458494                    if (numberChanged) {
     
    467503                        cs.insert(cc);
    468504                    }
     505                }
     506                if (!feasible) {
     507                    // not feasible -add infeasible cut
     508                    OsiRowCut rc;
     509                    rc.setLb(DBL_MAX);
     510                    rc.setUb(0.0);
     511                    cs.insert(rc);
    469512                }
    470513            }
     
    517560            int numberRowCutsAfter = cs.sizeRowCuts() ;
    518561            int k ;
     562#ifdef CGL_DEBUG
     563            const OsiRowCutDebugger * debugger = solver->getRowCutDebugger();
     564#endif
    519565            for (k = numberRowCutsBefore; k < numberRowCutsAfter; k++) {
    520566                OsiRowCut * thisCut = cs.rowCutPtr(k) ;
     567#ifdef CGL_DEBUG
     568                if (debugger && debugger->onOptimalPath(*solver))
     569                    assert(!debugger->invalidCut(*thisCut));
     570#endif
    521571                thisCut->mutableRow().setTestForDuplicateIndex(false);
    522572            }
  • branches/sandbox/Cbc/src/CbcHeuristic.cpp

    r1286 r1315  
    374374            3 only at root and if no solution
    375375            4 only at root and if this heuristic has not got solution
    376             5 only at depth <4
     376            5 as 3 but decay more
    377377            6 decay
    378378            7 run up to 2 times if solution found 4 otherwise
     
    389389                break;
    390390            case 5:
    391                 if (depth >= 4)
     391                assert (decayFactor_);
     392                if (model_->bestSolution()) {
    392393                    probability = -1.0;
     394                } else if (numCouldRun_ > 1000) {
     395                    decayFactor_ *= 0.99;
     396                    probability *= decayFactor_;
     397                }
    393398                break;
    394399            case 6:
     
    399404                        int old = howOften_;
    400405#endif
    401                         howOften_ = CoinMin(CoinMax(static_cast<int> (howOften_ * 1.1), howOften_ + 1), 10000);
     406                        howOften_ = CoinMin(CoinMax(static_cast<int> (howOften_ * 1.1), howOften_ + 1), 1000000);
    402407#ifdef COIN_DEVELOP
    403408                        printf("Howoften changed from %d to %d for %s\n",
     
    15321537    up_ = NULL;
    15331538    equal_ = NULL;
     1539    //whereFrom_ |= 16; // allow more often
    15341540}
    15351541
     
    15491555    equal_ = NULL;
    15501556    seed_ = 7654321;
     1557    //whereFrom_ |= 16; // allow more often
    15511558}
    15521559
  • branches/sandbox/Cbc/src/CbcHeuristicDive.cpp

    r1286 r1315  
    3434    maxTime_ = 600;
    3535    whereFrom_ = 255 - 2 - 16 + 256;
     36    decayFactor_ = 1.0;
    3637}
    3738
     
    5960    maxTime_ = 600;
    6061    whereFrom_ = 255 - 2 - 16 + 256;
     62    decayFactor_ = 1.0;
    6163}
    6264
     
    485487#ifdef GAP
    486488            int nLeft = maxNumberAtBoundToFix - numberAtBoundFixed;
    487 #ifdef CLP_INVESTIGATE
     489#ifdef CLP_INVESTIGATE4
    488490            printf("cutoff %g obj %g nover %d - %d free, %d fixed\n",
    489491                   cutoff, solver->getObjValue(), nOverGap, numberFree, numberFixed);
     
    494496            }
    495497#else
    496 #ifdef CLP_INVESTIGATE
     498#ifdef CLP_INVESTIGATE4
    497499            printf("cutoff %g obj %g - %d free, %d fixed\n",
    498500                   model_->getCutoff(), solver->getObjValue(), numberFree, numberFixed);
     
    10491051#ifdef GAP
    10501052    int nLeft = maxNumberToFix - numberFixedAlready;
    1051 #ifdef CLP_INVESTIGATE
     1053#ifdef CLP_INVESTIGATE4
    10521054    printf("cutoff %g obj %g nover %d - %d free, %d fixed\n",
    10531055           cutoff, solver->getObjValue(), nOverGap, numberFree,
     
    10591061    }
    10601062#else
    1061 #ifdef CLP_INVESTIGATE
     1063#ifdef CLP_INVESTIGATE4
    10621064    printf("cutoff %g obj %g - %d free, %d fixed\n",
    10631065           model_->getCutoff(), solver->getObjValue(), numberFree,
  • branches/sandbox/Cbc/src/CbcHeuristicLocal.cpp

    r1286 r1315  
    158158    }
    159159    int returnCode = 0;
     160#ifdef CLP_INVESTIGATE2
     161    printf("Fixing %d out of %d (%d continuous)\n",
     162           nFix, numberIntegers, newSolver->getNumCols() - numberIntegers);
     163#endif
     164    if (nFix*10 <= numberIntegers) {
     165        // see if we can fix more
     166        int * which = new int [2*(numberIntegers-nFix)];
     167        int * sort = which + (numberIntegers - nFix);
     168        int n = 0;
     169        for (i = 0; i < numberIntegers; i++) {
     170            int iColumn = integerVariable[i];
     171            if (used_[iColumn]) {
     172                which[n] = iColumn;
     173                sort[n++] = used_[iColumn];
     174            }
     175        }
     176        CoinSort_2(sort, sort + n, which);
     177        // only half fixed in total
     178        n = CoinMin(n, numberIntegers / 2 - nFix);
     179        int allow = CoinMax(numberSolutions_ - 2, sort[0]);
     180        int nFix2 = 0;
     181        for (i = 0; i < n; i++) {
     182            int iColumn = integerVariable[i];
     183            if (used_[iColumn] <= allow) {
     184                newSolver->setColUpper(iColumn, colLower[iColumn]);
     185                nFix2++;
     186            } else {
     187                break;
     188            }
     189        }
     190        delete [] which;
     191        nFix += nFix2;
     192        printf("Number fixed increased from %d to %d\n",
     193               nFix - nFix2, nFix);
     194    }
    160195    if (nFix*10 > numberIntegers) {
    161196        returnCode = smallBranchAndBound(newSolver, numberNodes_, newSolution, objectiveValue,
  • branches/sandbox/Cbc/src/CbcHeuristicRINS.cpp

    r1286 r1315  
    1 /* $Id: CbcHeuristicRINS.cpp 1261 2009-10-30 12:45:20Z forrest $ */
     1/* $Id: CbcHeuristicRINS.cpp 1240 2009-10-02 18:41:44Z forrest $ */
    22// Copyright (C) 2006, International Business Machines
    33// Corporation and others.  All Rights Reserved.
     
    3131    decayFactor_ = 0.5;
    3232    used_ = NULL;
     33    whereFrom_ = 1 + 8 + 16 + 255 * 256;
    3334    whereFrom_ = 1 + 8 + 255 * 256;
    3435}
     
    5051    used_ = new char[numberColumns];
    5152    memset(used_, 0, numberColumns);
     53    whereFrom_ = 1 + 8 + 16 + 255 * 256;
    5254    whereFrom_ = 1 + 8 + 255 * 256;
    5355}
     
    188190            numberNodes = howOften_;
    189191    }
     192    // Allow for infeasible nodes - so do anyway after a bit
     193    if (howOften_ >= 100 && numberNodes >= lastNode_ + 2*howOften_) {
     194        numberNodes = howOften_;
     195    }
    190196    if ((numberNodes % howOften_) == 0 && (model_->getCurrentPassNumber() == 1 ||
    191197                                           model_->getCurrentPassNumber() == 999999)) {
     
    228234        int divisor = 0;
    229235        if (5*nFix > numberIntegers) {
    230             if (numberContinuous > 2*numberIntegers && nFix*10 < numberColumns &&
    231                     ((!numRuns_ && numberTries_ > 2) || stateOfFixing_)) {
     236            if (numberContinuous > 2*numberIntegers && ((nFix*10 < numberColumns &&
     237                    !numRuns_ && numberTries_ > 2) ||
     238                    stateOfFixing_)) {
    232239#define RINS_FIX_CONTINUOUS
    233240#ifdef RINS_FIX_CONTINUOUS
     
    291298            if (returnCode < 0) {
    292299                returnCode = 0; // returned on size
    293                 if (divisor)
     300                if (divisor) {
    294301                    stateOfFixing_ = - divisor; // say failed
     302                } else if (numberContinuous > 2*numberIntegers &&
     303                           !numRuns_ && numberTries_ > 2) {
     304                    stateOfFixing_ = -4; //start fixing
     305                }
    295306            } else {
    296307                numRuns_++;
     
    513524        returnCode = smallBranchAndBound(newSolver, numberNodes_, betterSolution, solutionValue,
    514525                                         model_->getCutoff(), "CbcHeuristicRENS");
    515         if (returnCode < 0)
     526        if (returnCode < 0) {
    516527            returnCode = 0; // returned on size
     528#ifdef RENS_FIX_CONTINUOUS
     529            if (numberContinuous > numberIntegers && numberFixed >= numberColumns / 5) {
     530                const double * colLower = newSolver->getColLower();
     531                //const double * colUpper = newSolver->getColUpper();
     532                int nAtLb = 0;
     533                double sumDj = 0.0;
     534                const double * dj = newSolver->getReducedCost();
     535                double direction = newSolver->getObjSense();
     536                for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     537                    if (!newSolver->isInteger(iColumn)) {
     538                        double value = currentSolution[iColumn];
     539                        if (value < colLower[iColumn] + 1.0e-8) {
     540                            double djValue = dj[iColumn] * direction;
     541                            nAtLb++;
     542                            sumDj += djValue;
     543                        }
     544                    }
     545                }
     546                if (nAtLb) {
     547                    // fix some continuous
     548                    double * sort = new double[nAtLb];
     549                    int * which = new int [nAtLb];
     550                    double threshold = CoinMax((0.01 * sumDj) / static_cast<double>(nAtLb), 1.0e-6);
     551                    int nFix2 = 0;
     552                    for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     553                        if (!newSolver->isInteger(iColumn)) {
     554                            double value = currentSolution[iColumn];
     555                            if (value < colLower[iColumn] + 1.0e-8) {
     556                                double djValue = dj[iColumn] * direction;
     557                                if (djValue > threshold) {
     558                                    sort[nFix2] = -djValue;
     559                                    which[nFix2++] = iColumn;
     560                                }
     561                            }
     562                        }
     563                    }
     564                    CoinSort_2(sort, sort + nFix2, which);
     565                    nFix2 = CoinMin(nFix2, (numberColumns - numberFixed) / 2);
     566                    for (int i = 0; i < nFix2; i++) {
     567                        int iColumn = which[i];
     568                        newSolver->setColUpper(iColumn, colLower[iColumn]);
     569                    }
     570                    delete [] sort;
     571                    delete [] which;
     572#ifdef CLP_INVESTIGATE2
     573                    printf("%d integers fixed (%d tightened) (%d at bound), and %d continuous fixed at lb\n",
     574                           numberFixed, numberTightened, numberAtBound, nFix2);
     575#endif
     576                }
     577                returnCode = smallBranchAndBound(newSolver, numberNodes_, betterSolution, solutionValue,
     578                                                 model_->getCutoff(), "CbcHeuristicRENS");
     579#endif
     580            }
     581        }
    517582        //printf("return code %d",returnCode);
    518583        if ((returnCode&2) != 0) {
  • branches/sandbox/Cbc/src/CbcHeuristicRINS.hpp

    r1286 r1315  
    6161    inline char * used() const {
    6262        return used_;
     63    }
     64    /// Resets lastNode
     65    inline void setLastNode(int value) {
     66        lastNode_ = value;
    6367    }
    6468
  • branches/sandbox/Cbc/src/CbcModel.cpp

    r1286 r1315  
    4444#include "CbcHeuristic.hpp"
    4545#include "CbcHeuristicFPump.hpp"
     46#include "CbcHeuristicRINS.hpp"
    4647#include "CbcHeuristicDive.hpp"
    4748#include "CbcModel.hpp"
     
    11711172    dblParam_[CbcLargestChange] = 0.0;
    11721173    intParam_[CbcNumberBranches] = 0;
     1174    // Double check optimization directions line up
     1175    dblParam_[CbcOptimizationDirection] = solver_->getObjSense();
    11731176    strongInfo_[0] = 0;
    11741177    strongInfo_[1] = 0;
     
    18631866    maximumDepthActual_ = 0;
    18641867    numberDJFixed_ = 0.0;
     1868    if (!parentModel_) {
     1869        if ((specialOptions_&262144) != 0) {
     1870            // create empty stored cuts
     1871            //storedRowCuts_ = new CglStored(solver_->getNumCols());
     1872        } else if ((specialOptions_&524288) != 0 && storedRowCuts_) {
     1873            // tighten and set best solution
     1874            // A) tight bounds on integer variables
     1875            const double * lower = solver_->getColLower();
     1876            const double * upper = solver_->getColUpper();
     1877            const double * tightLower = storedRowCuts_->tightLower();
     1878            const double * tightUpper = storedRowCuts_->tightUpper();
     1879            int nTightened = 0;
     1880            for (int i = 0; i < numberIntegers_; i++) {
     1881                int iColumn = integerVariable_[i];
     1882                if (tightLower[iColumn] > lower[iColumn]) {
     1883                    nTightened++;
     1884                    solver_->setColLower(iColumn, tightLower[iColumn]);
     1885                }
     1886                if (tightUpper[iColumn] < upper[iColumn]) {
     1887                    nTightened++;
     1888                    solver_->setColUpper(iColumn, tightUpper[iColumn]);
     1889                }
     1890            }
     1891            if (nTightened)
     1892                printf("%d tightened by alternate cuts\n", nTightened);
     1893            if (storedRowCuts_->bestObjective() < bestObjective_) {
     1894                // B) best solution
     1895                double objValue = storedRowCuts_->bestObjective();
     1896                setBestSolution(CBC_SOLUTION, objValue,
     1897                                storedRowCuts_->bestSolution()) ;
     1898                // Do heuristics
     1899                // Allow RINS
     1900                for (int i = 0; i < numberHeuristics_; i++) {
     1901                    CbcHeuristicRINS * rins
     1902                    = dynamic_cast<CbcHeuristicRINS *> (heuristic_[i]);
     1903                    if (rins) {
     1904                        rins->setLastNode(-100);
     1905                    }
     1906                }
     1907            }
     1908        }
     1909    }
    18651910    // Do heuristics
    18661911    doHeuristicsAtRoot();
     
    22152260            if (numberUnsatisfied)   {
    22162261                // User event
    2217                 if (!eventHappened_ && feasible)
     2262                if (!eventHappened_ && feasible) {
    22182263                    feasible = solveWithCuts(cuts, maximumCutPassesAtRoot_,
    22192264                                             NULL);
    2220                 else
     2265                    if ((specialOptions_&524288) != 0 && !parentModel_
     2266                            && storedRowCuts_) {
     2267                        if (feasible) {
     2268                            /* pick up stuff and try again
     2269                            add cuts, maybe keep around
     2270                            do best solution and if so new heuristics
     2271                            obviously tighten bounds
     2272                            */
     2273                            // A and B probably done on entry
     2274                            // A) tight bounds on integer variables
     2275                            const double * lower = solver_->getColLower();
     2276                            const double * upper = solver_->getColUpper();
     2277                            const double * tightLower = storedRowCuts_->tightLower();
     2278                            const double * tightUpper = storedRowCuts_->tightUpper();
     2279                            int nTightened = 0;
     2280                            for (int i = 0; i < numberIntegers_; i++) {
     2281                                int iColumn = integerVariable_[i];
     2282                                if (tightLower[iColumn] > lower[iColumn]) {
     2283                                    nTightened++;
     2284                                    solver_->setColLower(iColumn, tightLower[iColumn]);
     2285                                }
     2286                                if (tightUpper[iColumn] < upper[iColumn]) {
     2287                                    nTightened++;
     2288                                    solver_->setColUpper(iColumn, tightUpper[iColumn]);
     2289                                }
     2290                            }
     2291                            if (nTightened)
     2292                                printf("%d tightened by alternate cuts\n", nTightened);
     2293                            if (storedRowCuts_->bestObjective() < bestObjective_) {
     2294                                // B) best solution
     2295                                double objValue = storedRowCuts_->bestObjective();
     2296                                setBestSolution(CBC_SOLUTION, objValue,
     2297                                                storedRowCuts_->bestSolution()) ;
     2298                                // Do heuristics
     2299                                // Allow RINS
     2300                                for (int i = 0; i < numberHeuristics_; i++) {
     2301                                    CbcHeuristicRINS * rins
     2302                                    = dynamic_cast<CbcHeuristicRINS *> (heuristic_[i]);
     2303                                    if (rins) {
     2304                                        rins->setLastNode(-100);
     2305                                    }
     2306                                }
     2307                                doHeuristicsAtRoot();
     2308                            }
     2309#if 0
     2310                            int nCuts = storedRowCuts_->sizeRowCuts();
     2311                            // add to global list
     2312                            for (int i = 0; i < nCuts; i++) {
     2313                                OsiRowCut newCut(*storedRowCuts_->rowCutPointer(i));
     2314                                newCut.setGloballyValidAsInteger(2);
     2315                                newCut.mutableRow().setTestForDuplicateIndex(false);
     2316                                globalCuts_.insert(newCut) ;
     2317                            }
     2318#else
     2319                            addCutGenerator(storedRowCuts_, -99, "Stored from previous run",
     2320                                            true, false, false, -200);
     2321#endif
     2322                            // Set cuts as active
     2323                            delete [] addedCuts_ ;
     2324                            maximumNumberCuts_ = cuts.sizeRowCuts();
     2325                            if (maximumNumberCuts_) {
     2326                                addedCuts_ = new CbcCountRowCut * [maximumNumberCuts_];
     2327                            } else {
     2328                                addedCuts_ = NULL;
     2329                            }
     2330                            for (int i = 0; i < maximumNumberCuts_; i++)
     2331                                addedCuts_[i] = new CbcCountRowCut(*cuts.rowCutPtr(i),
     2332                                                                   NULL, -1, -1, 2);
     2333                            printf("size %d\n", cuts.sizeRowCuts());
     2334                            cuts = OsiCuts();
     2335                            currentNumberCuts_ = maximumNumberCuts_;
     2336                            feasible = solveWithCuts(cuts, maximumCutPassesAtRoot_,
     2337                                                     NULL);
     2338                            for (int i = 0; i < maximumNumberCuts_; i++)
     2339                                delete addedCuts_[i];
     2340                        }
     2341                        delete storedRowCuts_;
     2342                        storedRowCuts_ = NULL;
     2343                    }
     2344                } else {
    22212345                    feasible = false;
     2346                }
    22222347            }   else if (solverCharacteristics_->solutionAddsCuts() ||
    22232348                       solverCharacteristics_->alwaysTryCutsAtRootNode()) {
     
    25052630            if (bestSolution_)
    25062631                heuristic.setInputSolution(bestSolution_, bestObjective_);
    2507             heuristic.setFractionSmall(0.5);
     2632            heuristic.setFractionSmall(0.9);
    25082633            heuristic.setFeasibilityPumpOptions(1008013);
    25092634            // Use numberNodes to say how many are original rows
     
    25362661            }
    25372662        }
     2663    }
     2664    if ((specialOptions_&262144) != 0 && !parentModel_) {
     2665        // Save stuff and return!
     2666        storedRowCuts_->saveStuff(bestObjective_, bestSolution_,
     2667                                  solver_->getColLower(),
     2668                                  solver_->getColUpper());
     2669        delete [] lowerBefore;
     2670        delete [] upperBefore;
     2671        delete saveSolver;
     2672        return;
    25382673    }
    25392674    /*
     
    28653000        }
    28663001#endif
    2867         if (probingInfo_) {
    2868             int number01 = probingInfo_->numberIntegers();
    2869             //const fixEntry * entry = probingInfo_->fixEntries();
    2870             const int * toZero = probingInfo_->toZero();
    2871             //const int * toOne = probingInfo_->toOne();
    2872             //const int * integerVariable = probingInfo_->integerVariable();
    2873             if (toZero[number01]) {
    2874                 if (probingInfo_->packDown()) {
    2875 #ifdef CLP_INVESTIGATE
    2876                     printf("%d implications on %d 0-1\n", toZero[number01], number01);
    2877 #endif
    2878                     CglImplication implication(probingInfo_);
    2879                     addCutGenerator(&implication, 1, "ImplicationCuts", true, false, false, -200);
    2880                 } else {
    2881                     delete probingInfo_;
    2882                     probingInfo_ = NULL;
    2883                 }
    2884             } else {
    2885                 delete probingInfo_;
    2886 
    2887                 probingInfo_ = NULL;
    2888             }
    2889         }
    28903002        newNode = new CbcNode ;
    28913003        // Set objective value (not so obvious if NLP etc)
     
    29333045            newNode = NULL ;
    29343046            feasible = false ;
     3047        }
     3048    }
     3049    if (newNode && probingInfo_) {
     3050        int number01 = probingInfo_->numberIntegers();
     3051        //const fixEntry * entry = probingInfo_->fixEntries();
     3052        const int * toZero = probingInfo_->toZero();
     3053        //const int * toOne = probingInfo_->toOne();
     3054        //const int * integerVariable = probingInfo_->integerVariable();
     3055        if (toZero[number01]) {
     3056            CglTreeProbingInfo info(*probingInfo_);
     3057#if 0
     3058            OsiSolverInterface * fake = info.analyze(*solver_, 1);
     3059            if (fake) {
     3060                fake->writeMps("fake");
     3061                CglFakeClique cliqueGen(fake);
     3062                cliqueGen.setStarCliqueReport(false);
     3063                cliqueGen.setRowCliqueReport(false);
     3064                cliqueGen.setMinViolation(0.1);
     3065                addCutGenerator(&cliqueGen, 1, "Fake cliques", true, false, false, -200);
     3066                generator_[numberCutGenerators_-1]->setTiming(true);
     3067            }
     3068#endif
     3069            if (probingInfo_->packDown()) {
     3070#ifdef CLP_INVESTIGATE
     3071                printf("%d implications on %d 0-1\n", toZero[number01], number01);
     3072#endif
     3073                CglImplication implication(probingInfo_);
     3074                addCutGenerator(&implication, 1, "ImplicationCuts", true, false, false, -200);
     3075            } else {
     3076                delete probingInfo_;
     3077                probingInfo_ = NULL;
     3078            }
     3079        } else {
     3080            delete probingInfo_;
     3081
     3082            probingInfo_ = NULL;
    29353083        }
    29363084    }
     
    32043352    int lastEvery1000 = 0;
    32053353    int lastPrintEvery = 0;
     3354    int numberConsecutiveInfeasible = 0;
    32063355    while (true) {
    32073356#ifdef CBC_THREAD
     
    34663615#endif
    34673616                    numberFixed += numberFixed2;
    3468                     if (numberFixed*10 < numberColumns)
     3617                    if (numberFixed*10 < numberColumns && numberFixed*4 < numberIntegers_)
    34693618                        tryNewSearch = false;
    34703619                }
     
    34873636                    if (bestSolution_)
    34883637                        heuristic.setInputSolution(bestSolution_, bestObjective_);
    3489                     heuristic.setFractionSmall(0.6);
     3638                    heuristic.setFractionSmall(0.8);
    34903639                    heuristic.setFeasibilityPumpOptions(1008013);
    34913640                    // Use numberNodes to say how many are original rows
     
    35403689        assert(!solverCharacteristics_->solutionAddsCuts() || solverCharacteristics_->mipFeasible());
    35413690#endif
     3691#define DIVE_WHEN 1000
     3692#define DIVE_STOP 2000
     3693        int kNode = numberNodes_ % 4000;
     3694        if (numberNodes_<100000 && kNode>DIVE_WHEN && kNode <= DIVE_STOP) {
     3695            if (!parallelMode()) {
     3696                if (kNode == DIVE_WHEN + 1 || numberConsecutiveInfeasible > 1) {
     3697                    CbcCompareDefault * compare = dynamic_cast<CbcCompareDefault *>
     3698                                                  (nodeCompare_);
     3699                    if (compare) {
     3700                        //printf("Redoing tree\n");
     3701                        compare->startDive(this);
     3702                        numberConsecutiveInfeasible = 0;
     3703                    }
     3704                }
     3705            }
     3706        }
    35423707        if (cutoff > getCutoff()) {
    35433708            double newCutoff = getCutoff();
     
    37313896            // Do main work of solving node here
    37323897            doOneNode(this, node, createdNode);
     3898#if 0
     3899            if (node) {
     3900                if (createdNode) {
     3901                    printf("Node %d depth %d, created %d depth %d\n",
     3902                           node->nodeNumber(), node->depth(),
     3903                           createdNode->nodeNumber(), createdNode->depth());
     3904                } else {
     3905                    printf("Node %d depth %d,  no created node\n",
     3906                           node->nodeNumber(), node->depth());
     3907                }
     3908            } else if (createdNode) {
     3909                printf("Node exhausted, created %d depth %d\n",
     3910                       createdNode->nodeNumber(), createdNode->depth());
     3911            } else {
     3912                printf("Node exhausted,  no created node\n");
     3913                numberConsecutiveInfeasible = 2;
     3914            }
     3915#endif
     3916            //if (createdNode)
     3917            //numberConsecutiveInfeasible=0;
     3918            //else
     3919            //numberConsecutiveInfeasible++;
    37333920#ifdef CBC_THREAD
    37343921        } else if (parallelMode() > 0) {
     
    44644651{
    44654652    assert (solver_);
     4653    // Double check optimization directions line up
     4654    dblParam_[CbcOptimizationDirection] = solver_->getObjSense();
    44664655    // Check if bounds are all integral (as may get messed up later)
    44674656    checkModel();
     
    46574846        maximumNumberUpdateItems_(0),
    46584847        updateItems_(NULL),
     4848        storedRowCuts_(NULL),
    46594849        numberThreads_(0),
    46604850        threadMode_(0)
     
    48145004        maximumNumberUpdateItems_(0),
    48155005        updateItems_(NULL),
     5006        storedRowCuts_(NULL),
    48165007        numberThreads_(0),
    48175008        threadMode_(0)
     
    50555246        maximumNumberUpdateItems_(rhs.maximumNumberUpdateItems_),
    50565247        updateItems_(NULL),
     5248        storedRowCuts_(NULL),
    50575249        numberThreads_(rhs.numberThreads_),
    50585250        threadMode_(rhs.threadMode_)
     
    68026994            CbcSimpleInteger * simpleObject =
    68036995                static_cast <CbcSimpleInteger *>(object) ;
    6804             int iObject;
     6996            int iObject = simpleObject->position();
     6997#ifndef NDEBUG
    68056998            int iColumn = simpleObject->columnNumber();
    6806             for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
     6999            int jObject;
     7000            for (jObject = 0 ; jObject < numberObjects_ ; jObject++) {
    68077001                simpleObject =
    6808                     static_cast <CbcSimpleInteger *>(object_[iObject]) ;
     7002                    static_cast <CbcSimpleInteger *>(object_[jObject]) ;
    68097003                if (simpleObject->columnNumber() == iColumn)
    68107004                    break;
    68117005            }
    6812             assert (iObject < numberObjects_);
     7006            assert (jObject < numberObjects_ && iObject == jObject);
     7007#else
     7008#ifdef TIGHTEN_BOUNDS
     7009            int iColumn = simpleObject->columnNumber();
     7010#endif
     7011#endif
    68137012            update.objectNumber_ = iObject;
    68147013            addUpdateInformation(update);
     
    71967395                if (generate) {
    71977396                    if (!node && cut_obj[CUT_HISTORY-1] != -COIN_DBL_MAX &&
    7198                             fabs(cut_obj[CUT_HISTORY-1] - cut_obj[CUT_HISTORY-2]) < 1.0e-7)
     7397                            fabs(cut_obj[CUT_HISTORY-1] - cut_obj[CUT_HISTORY-2]) < 1.0e-7 +
     7398                            1.0e-6*fabs(cut_obj[CUT_HISTORY-1]))
    71997399                        generator_[i]->setIneffectualCuts(true);
    72007400                    bool mustResolve =
     
    79518151                    addCuts[i] = &theseCuts.rowCut(i) ;
    79528152                }
     8153                if ((specialOptions_&262144) != 0 && !parentModel_) {
     8154                    //save
     8155                    for (i = 0 ; i < numberToAdd ; i++)
     8156                        storedRowCuts_->addCut(*addCuts[i]);
     8157                }
    79538158                solver_->applyRowCuts(numberToAdd, addCuts) ;
    79548159                CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis*>(solver_->getWarmStart()) ;
     
    81028307                    }
    81038308                }
    8104                 if (numberTries == 1 && currentDepth_ && currentPassNumber_ < 10) {
    8105                     if (thisObj - lastObjective > 10.0*minimumDrop) {
     8309                if (numberTries == 1 && currentDepth_ < 12 && currentPassNumber_ < 10) {
     8310                    double drop[12] = {1.0, 2.0, 3.0, 10.0, 10.0, 10.0, 10.0, 20.0, 100.0, 100.0, 1000.0, 1000.0};
     8311                    if (thisObj - lastObjective > drop[currentDepth_]*minimumDrop) {
    81068312                        numberTries++;
    81078313#ifdef CLP_INVESTIGATE
     
    1030610512            if (!type) {
    1030710513                obj2->setNumberBeforeTrust(numberBeforeTrust_);
    10308             } else {
     10514            } else if (type == 1) {
    1030910515                int value = obj2->numberBeforeTrust();
    1031010516                value = (value * 11) / 10 + 1;
    1031110517                value = CoinMax(numberBeforeTrust_, value);
    1031210518                obj2->setNumberBeforeTrust(value);
     10519            } else {
     10520                assert (type == 2);
     10521                int value = obj2->numberBeforeTrust();
     10522                int n = CoinMax(obj2->numberTimesDown(),
     10523                                obj2->numberTimesUp());
     10524                if (n >= value)
     10525                    obj2->setNumberBeforeTrust(n + 1);
    1031310526            }
    1031410527        }
     
    1242212635    if (currentNode_ && currentNode_->depth() >= 8)
    1242312636        stateOfSearch_ += 10;
     12637    //printf("STate %d, %d nodes - parent %c - sol %d %d\n",
     12638    // stateOfSearch_,numberNodes_,parentModel_ ? 'Y' :'N',
     12639    // numberSolutions_,numberHeuristicSolutions_);
    1242412640    int anyAction = -1 ;
    1242512641    resolved = false ;
     
    1381514031        bool checkingNode = false;
    1381614032        if (feasible) {
    13817 #if 0
     14033#ifdef FUNNY_BRANCHING
    1381814034            // Far too clever
    13819             if (numberThreads_ == -10 && node->numberBranches() == 2) {
     14035            if ((numberThreads_ == -10 || true) && node->numberBranches() == 2) {
    1382014036                // see if any parent branches redundant
    1382114037                // Look at state of "node"
    1382214038                CbcNodeInfo * nodeInfo = node->nodeInfo();
    13823                 // See if any branched variables off bounds
    13824                 const double * dj = solver_->getReducedCost();
    13825                 const double * lower = solver_->getColLower();
    13826                 const double * upper = solver_->getColUpper();
    13827                 const double * solution = solver_->getColSolution();
    13828                 double direction = solver_->getObjSense() ;
    1382914039                if (nodeInfo) {
     14040                    // See if any branched variables off bounds
     14041                    const double * dj = solver_->getReducedCost();
     14042                    const double * lower = solver_->getColLower();
     14043                    const double * upper = solver_->getColUpper();
     14044                    const double * solution = solver_->getColSolution();
     14045                    int numberColumns = solver_->getNumCols();
     14046                    double * currentLower = CoinCopyOfArray(lower, numberColumns);
     14047                    double * currentUpper = CoinCopyOfArray(upper, numberColumns);
     14048                    char * touched = new char[numberColumns];
     14049                    memset(touched, 0, numberColumns);
     14050                    double direction = solver_->getObjSense() ;
    1383014051                    bool canDelete = nodeInfo->numberBranchesLeft() > 0;
    1383114052                    //int numberBounds = nodeInfo->numberChangedBounds();
     
    1384414065                            double originalLower1 = object1->originalLowerBound();
    1384514066                            double originalUpper1 = object1->originalUpperBound();
     14067                            // Unset all bounds from parents
     14068                            CbcPartialNodeInfo * partial =
     14069                                dynamic_cast<CbcPartialNodeInfo *>(nodeInfo);
     14070                            touched[iColumn1] = 1;
     14071                            if (partial) {
     14072                                /* maybe don't do if obj hasn't changed
     14073                                as then you might get loop
     14074                                at present just 0-1
     14075                                as need to know original bound
     14076                                */
     14077                                int n = partial->numberChangedBounds();
     14078                                const int * which = partial->variables();
     14079                                const double * values = partial->newBounds();
     14080                                for (int i = 0; i < n; i++) {
     14081                                    int variable = which[i];
     14082                                    int k = variable & 0x3fffffff;
     14083                                    assert (k != iColumn1);
     14084                                    if (!touched[k]) {
     14085                                        if ((variable&0x80000000) == 0) {
     14086                                            // lower bound changing
     14087                                            assert (currentLower[k] == 1.0);
     14088                                            currentLower[k] = 0.0;
     14089                                        } else {
     14090                                            // upper bound changing
     14091                                            assert (currentUpper[k] == 0.0);
     14092                                            currentUpper[k] = 1.0;
     14093                                        }
     14094                                    }
     14095                                }
     14096                            }
    1384614097                            zeroOne1 = originalLower1 == 0.0 && originalUpper1 == 1.0;
    1384714098                            way1 = objectI->way();
    1384814099                            assert (way1 == -1 || way1 == 1);
     14100                            int kWay = way1;
    1384914101                            //way1 = -way1; // what last branch did
    1385014102                            // work out using bounds
     
    1385414106                            else
    1385514107                                way1 = 1;
     14108                            assert (kWay == -way1);
    1385614109                            if (way1 < 0) {
    1385714110                                // must have been down branch
     
    1392314176                                                previousBounds(node, nodeInfo, iColumn2, newLower, newUpper, 2);
    1392414177                                                solver_->setColUpper(iColumn2, newUpper);
     14178                                                assert (newLower == lower[iColumn2]);
    1392514179                                            } else {
    1392614180                                                printf("SKipping\n");
    1392714181                                            }
    13928                                         } else if (iColumn1 >= 0 && iColumn1 != iColumn2 && (!inBetween || true) && zeroOne1 && zeroOne2) {
     14182                                        } else if (iColumn1 >= 0 && iColumn1 != iColumn2 && (!inBetween || true) && zeroOne1 && zeroOne2 && false) {
    1392914183#if 1
    1393014184                                            if (true) {
     
    1396514219                                                previousBounds(node, nodeInfo, iColumn2, newLower, newUpper, 1);
    1396614220                                                solver_->setColLower(iColumn2, newLower);
     14221                                                assert (newUpper == upper[iColumn2]);
    1396714222                                            } else {
    1396814223                                                printf("SKipping\n");
    1396914224                                            }
    13970                                         } else if (iColumn1 >= 0 && iColumn1 != iColumn2 && (!inBetween || true) && zeroOne1 && zeroOne2) {
     14225                                        } else if (iColumn1 >= 0 && iColumn1 != iColumn2 && (!inBetween || true) && zeroOne1 && zeroOne2 && false) {
    1397114226#if 1
    1397214227                                            // add in bounds
     
    1399414249                        }
    1399514250                    }
     14251                    delete [] currentLower;
     14252                    delete [] currentUpper;
    1399614253                }
    1399714254            }
     
    1520015457        }
    1520115458    }
    15202 #ifdef CLP_INVESTIGATE
     15459#ifdef CLP_INVESTIGATE4
    1520315460    if (priority)
    1520415461        printf("Before fathom %d not trusted out of %d\n",
  • branches/sandbox/Cbc/src/CbcModel.hpp

    r1290 r1315  
    1313#include "CoinWarmStartBasis.hpp"
    1414#include "CbcCompareBase.hpp"
    15 #include "CbcCompare.hpp"
    1615#include "CbcMessage.hpp"
    1716#include "CbcEventHandler.hpp"
     
    2423class OsiRowCutDebugger;
    2524class CglCutGenerator;
     25class CglStored;
    2626class CbcCutModifier;
    2727class CglTreeProbingInfo;
     
    21262126        return strongInfo_;
    21272127    }
    2128 
     2128    /// Get stored row cuts for donor/recipient CbcModel
     2129    CglStored * storedRowCuts() const {
     2130        return storedRowCuts_;
     2131    }
     2132    /// Set stored row cuts for donor/recipient CbcModel
     2133    void setStoredRowCuts(CglStored * cuts) {
     2134        storedRowCuts_ = cuts;
     2135    }
    21292136    /// Says whether all dynamic integers
    21302137    inline bool allDynamic () const {
     
    23602367        16 bit (65536) - Original model had integer bounds
    23612368        17 bit (131072) - Perturbation switched off
     2369        18 bit (262144) - donor CbcModel
     2370        19 bit (524288) - recipient CbcModel
    23622371    */
    23632372    int specialOptions_;
     
    25752584    /// Update items
    25762585    CbcObjectUpdateData * updateItems_;
     2586    /// Stored row cuts for donor/recipient CbcModel
     2587    CglStored * storedRowCuts_;
    25772588    /**
    25782589       Parallel
  • branches/sandbox/Cbc/src/CbcNode.cpp

    r1313 r1315  
    33583358        }
    33593359    }
     3360    if (numberUnfinished*10 < numberStrongDone &&
     3361            numberStrongIterations*20 < model->getIterationCount()) {
     3362        //printf("increasing trust\n");
     3363        model->synchronizeNumberBeforeTrust(2);
     3364    }
     3365
    33603366    // Set guessed solution value
    33613367    guessedObjectiveValue_ = objectiveValue_ + estimatedDegradation;
  • branches/sandbox/Cbc/src/CbcSolver.cpp

    r1286 r1315  
    1 /* $Id: CbcSolver.cpp 1266 2009-11-02 14:07:49Z forrest $ */
     1/* $Id: CbcSolver.cpp 1240 2009-10-02 18:41:44Z forrest $ */
    22// Copyright (C) 2007, International Business Machines
    33// Corporation and others.  All Rights Reserved.
     
    4343// Version
    4444#ifndef CBCVERSION
    45 #define CBCVERSION "2.3.1"
     45#define CBCVERSION "2.4.01"
    4646#endif
    4747//#define ORBITAL
     
    32963296    int useCombine = parameters_[whichParam(COMBINE, numberParameters_, parameters_)].currentOptionAsInteger();
    32973297    int useCrossover = parameters_[whichParam(CROSSOVER2, numberParameters_, parameters_)].currentOptionAsInteger();
    3298     //int usePivotC = parameters_[whichParam(PIVOTANDCOMPLEMENT,numberParameters_,parameters_)].currentOptionAsInteger();
     3298    //int usePivotC = parameters_[whichParam(PIVOTANDCOMPLEMENT, numberParameters_, parameters_)].currentOptionAsInteger();
    32993299    int usePivotF = parameters_[whichParam(PIVOTANDFIX, numberParameters_, parameters_)].currentOptionAsInteger();
    33003300    int useRand = parameters_[whichParam(RANDROUND, numberParameters_, parameters_)].currentOptionAsInteger();
     
    43934393            parameters_[iParam].setCurrentOption("on");
    43944394            probingAction = 1;
     4395            parameters_[iParam].setCurrentOption("forceOnStrong");
     4396            probingAction = 8;
    43954397        }
    43964398        std::string field;
     
    47854787                                        << CoinMessageEol;
    47864788                                        generalMessageHandler->message(CLP_GENERAL, generalMessages)
    4787                                         << "only 10 iterations for strong branching"
    4788                                         << CoinMessageEol;
    4789                                         generalMessageHandler->message(CLP_GENERAL, generalMessages)
    47904789                                        << "extra options - -rens on -extra4 24003 -passc 1000!"
    47914790                                        << CoinMessageEol;
     
    47994798                                    parameters_[whichParam(FACTORIZATION, numberParameters_, parameters_)].setCurrentOption("osl");
    48004799                                    lpSolver->factorization()->forceOtherFactorization(3);
    4801                                     parameters_[whichParam(MAXHOTITS, numberParameters_, parameters_)].setIntValue(10);
     4800                                    parameters_[whichParam(MAXHOTITS, numberParameters_, parameters_)].setIntValue(100);
    48024801                                    parameters[whichParam(CUTPASS, numberParameters, parameters)].setIntValue(1000);
    48034802                                    cutPass = 1000;
     
    56645663                                int extra[5];
    56655664                                extra[1] = parameters_[whichParam(EXTRA1, numberParameters_, parameters_)].intValue();
    5666                                 if (parameters_[whichParam(EXPERIMENT, numberParameters_,
    5667                                                            parameters_)].intValue() >= 2 &&
    5668                                         extra[1] == -1)
     5665                                int exp1 = parameters_[whichParam(EXPERIMENT, numberParameters_,
     5666                                                                  parameters_)].intValue();
     5667                                if (exp1 == 2 && extra[1] == -1)
    56695668                                    extra[1] = 999998;
    56705669                                dextra[1] = parameters_[whichParam(FAKEINCREMENT, numberParameters_, parameters_)].doubleValue();
     
    59475946                                            int numberThreads = parameters_[whichParam(THREADS, numberParameters_, parameters_)].intValue();
    59485947                                            cbcModel->setNumberThreads(numberThreads % 100);
    5949                                             cbcModel->setThreadMode(numberThreads / 100);
     5948                                            cbcModel->setThreadMode(CoinMin(numberThreads / 100, 7));
    59505949#endif
    59515950                                            //setCutAndHeuristicOptions(*cbcModel);
     
    67356734                                    babModel_->setNumberBeforeTrust(10);
    67366735                            }
    6737                             int experimentFlag = CoinMax(parameters_[whichParam(EXPERIMENT, numberParameters_,
    6738                                                          parameters_)].intValue() - 1, 0);
     6736                            int experimentFlag = parameters_[whichParam(EXPERIMENT, numberParameters_,
     6737                                                             parameters_)].intValue();
    67396738                            int strategyFlag = parameters_[whichParam(STRATEGY, numberParameters_,
    67406739                                                           parameters_)].intValue();
    6741                             int bothFlags = CoinMax(experimentFlag, strategyFlag);
     6740                            int bothFlags = CoinMax(CoinMin(experimentFlag, 1), strategyFlag);
    67426741                            // add cut generators if wanted
    67436742                            int switches[20];
     
    70177016                                        } else {
    70187017                                            printf("BAD debug file\n");
     7018                                            siCopy->writeMps("Bad");
     7019                                            exit(22);
    70197020                                        }
    70207021                                        delete siCopy;
     
    70467047                            //OsiSolverInterface * strengthenedModel=NULL;
    70477048                            if (type == BAB || type == MIPLIB) {
    7048                                 if (experimentFlag == 2 || strategyFlag == 1) {
     7049                                if (strategyFlag == 1) {
    70497050                                    // try reduced model
    70507051                                    babModel_->setSpecialOptions(babModel_->specialOptions() | 512);
    70517052                                }
    7052                                 if (experimentFlag == 3 || strategyFlag == 2) {
     7053                                if (experimentFlag >= 3 || strategyFlag == 2) {
    70537054                                    // try reduced model at root
    70547055                                    babModel_->setSpecialOptions(babModel_->specialOptions() | 32768);
     
    82148215                                        babModel_->setFastNodeDepth(-2); // Use Cplex at root
    82158216                                }
     8217                                if (experimentFlag >= 2) {
     8218                                    CbcModel donor(*babModel_);
     8219                                    int options = babModel_->specialOptions();
     8220                                    donor.setSpecialOptions(options | 262144);
     8221                                    ClpSimplex * lpSolver2;
     8222                                    OsiClpSolverInterface * clpSolver2;
     8223                                    clpSolver2 =
     8224                                        dynamic_cast<OsiClpSolverInterface *> (donor.solver());
     8225                                    assert (clpSolver2);
     8226                                    lpSolver2 = clpSolver2->getModelPtr();
     8227                                    assert (lpSolver2);
     8228                                    if (lpSolver->factorization()->isDenseOrSmall()) {
     8229                                        lpSolver2->factorization()->forceOtherFactorization(0);
     8230                                        lpSolver2->factorization()->setGoOslThreshold(0);
     8231                                        lpSolver2->factorization()->setGoDenseThreshold(0);
     8232                                        lpSolver2->factorization()->setGoSmallThreshold(0);
     8233                                        lpSolver2->allSlackBasis();
     8234                                        lpSolver2->initialSolve();
     8235                                        int numberGenerators = donor.numberCutGenerators();
     8236                                        for (int iGenerator = 0; iGenerator < numberGenerators;
     8237                                                iGenerator++) {
     8238                                            CbcCutGenerator * generator = donor.cutGenerator(iGenerator);
     8239                                            CglGomory * gomory = dynamic_cast<CglGomory *>
     8240                                                                 (generator->generator());
     8241                                            if (gomory)
     8242                                                gomory->useAlternativeFactorization(false);
     8243                                        }
     8244                                    } else {
     8245                                        printf("code this\n");
     8246                                        abort();
     8247                                    }
     8248                                    babModel_->setSpecialOptions(options | 524288);
     8249                                    CglStored * stored = new CglStored(donor.getNumCols());
     8250                                    donor.setStoredRowCuts(stored);
     8251                                    donor.branchAndBound(0);
     8252                                    babModel_->setStoredRowCuts(donor.storedRowCuts());
     8253                                    donor.setStoredRowCuts(NULL);
     8254                                }
     8255#if 0
     8256                                int extra5 = parameters_[whichParam(EXTRA5, numberParameters_, parameters_)].intValue();
     8257                                if (extra5 > 0) {
     8258                                    int numberGenerators = babModel_->numberCutGenerators();
     8259                                    for (int iGenerator = 0; iGenerator < numberGenerators;
     8260                                            iGenerator++) {
     8261                                        CbcCutGenerator * generator = babModel_->cutGenerator(iGenerator);
     8262                                        CglGomory * gomory = dynamic_cast<CglGomory *>
     8263                                                             (generator->generator());
     8264                                        if (gomory) {
     8265                                            CglGomory gomory2(*gomory);
     8266                                            gomory2.useAlternativeFactorization(!gomory->alternativeFactorization());
     8267                                            babModel_->addCutGenerator(&gomory2, -99, "Gomory2");
     8268                                        }
     8269                                    }
     8270                                }
     8271#endif
    82168272                                babModel_->branchAndBound(statistics);
    82178273                                //#define CLP_FACTORIZATION_INSTRUMENT
  • branches/sandbox/Cbc/src/CbcTree.cpp

    r1286 r1315  
    177177{
    178178    comparison_.test_ = &compare;
     179    CbcCompareDefault * compareD = dynamic_cast<CbcCompareDefault *>
     180                                   (&compare);
     181    if (compareD) {
     182        // clean up diving
     183        compareD->cleanDive();
     184    }
    179185    std::make_heap(nodes_.begin(), nodes_.end(), comparison_);
    180186}
  • branches/sandbox/Cbc/src/CbcTree.hpp

    r1286 r1315  
    1111#include "CoinFinite.hpp"
    1212#include "CoinHelperFunctions.hpp"
     13#include "CbcCompare.hpp"
    1314
    1415/*! \class tree
     
    106107    inline void resetNodeNumbers() {
    107108        maximumNodeNumber_ = 0;
     109    }
     110    /// Get maximum node number
     111    inline int maximumNodeNumber() const {
     112        return maximumNodeNumber_;
    108113    }
    109114    /// Set number of branches
  • branches/sandbox/Cbc/src/unitTestClp.cpp

    r1286 r1315  
    99#include "CoinTime.hpp"
    1010#include "CbcModel.hpp"
     11#include "CbcHeuristic.hpp"
    1112#include "CbcCutGenerator.hpp"
    1213#include "CbcBranchCut.hpp"
     
    649650                    std::cout << std::endl;
    650651            }
     652            printf("%d solutions found by heuristics\n",
     653                   model->getNumberHeuristicSolutions());
     654            for (int iHeuristic = 0; iHeuristic < model->numberHeuristics(); iHeuristic++) {
     655                CbcHeuristic * heuristic = model->heuristic(iHeuristic);
     656                if (heuristic->numRuns()) {
     657                    // Need to bring others inline
     658                    char generalPrint[1000];
     659                    sprintf(generalPrint, "%s was tried %d times out of %d and created %d solutions\n",
     660                            heuristic->heuristicName(),
     661                            heuristic->numRuns(),
     662                            heuristic->numCouldRun(),
     663                            heuristic->numberSolutionsFound());
     664                    std::cout << generalPrint << std::endl;
     665                }
     666            }
    651667            if (!model->status()) {
    652668                double soln = model->getObjValue();
Note: See TracChangeset for help on using the changeset viewer.