Ignore:
Timestamp:
Apr 1, 2013 1:09:22 PM (7 years ago)
Author:
forrest
Message:

make it easier to use slow exotic cuts
more on cutoff as constraint and multiple root solver fixes
general fixing of bugs found on MIQP etc

File:
1 edited

Legend:

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

    r1839 r1880  
    16331633                    break;
    16341634                }
    1635             }
     1635            } else {
     1636              obj->initializeForBranching(model);
     1637            }
    16361638        }
    16371639    }
     
    21322134                    if (dynamicObject) {
    21332135                        // Use this object's numberBeforeTrust
    2134                         int numberBeforeTrust = dynamicObject->numberBeforeTrust();
     2136                        int numberBeforeTrustThis = dynamicObject->numberBeforeTrust();
    21352137                        iColumn = dynamicObject->columnNumber();
    21362138                        gotDown = false;
    21372139                        numberThisDown = dynamicObject->numberTimesDown();
    2138                         if (numberThisDown >= numberBeforeTrust)
     2140                        if (numberThisDown >= numberBeforeTrustThis)
    21392141                            gotDown = true;
    21402142                        gotUp = false;
    21412143                        numberThisUp = dynamicObject->numberTimesUp();
    2142                         if (numberThisUp >= numberBeforeTrust)
     2144                        if (numberThisUp >= numberBeforeTrustThis)
    21432145                            gotUp = true;
    21442146                        if (!depth_ && false) {
     
    25592561                            dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object) ;
    25602562                        // Use this object's numberBeforeTrust
    2561                         int numberBeforeTrust = dynamicObject->numberBeforeTrust();
     2563                        int numberBeforeTrustThis = dynamicObject->numberBeforeTrust();
    25622564                        int iSequence = dynamicObject->columnNumber();
    25632565                        double value = saveSolution[iSequence];
     
    25672569                        int numberThisDown = dynamicObject->numberTimesDown();
    25682570                        int numberThisUp = dynamicObject->numberTimesUp();
    2569                         if (!numberBeforeTrust) {
     2571                        if (!numberBeforeTrustThis) {
    25702572                            // override
    25712573                            downEstimate[iObject] = downPenalty;
     
    25772579                            min1 = 0.8 * min1 + 0.2 * max1;
    25782580                            sort[j] = - min1;
    2579                         } else if (numberThisDown < numberBeforeTrust ||
    2580                                    numberThisUp < numberBeforeTrust) {
    2581                             double invTrust = 1.0 / static_cast<double> (numberBeforeTrust);
    2582                             if (numberThisDown < numberBeforeTrust) {
     2581                        } else if (numberThisDown < numberBeforeTrustThis ||
     2582                                   numberThisUp < numberBeforeTrustThis) {
     2583                            double invTrust = 1.0 / static_cast<double> (numberBeforeTrustThis);
     2584                            if (numberThisDown < numberBeforeTrustThis) {
    25832585                                double fraction = numberThisDown * invTrust;
    25842586                                downEstimate[iObject] = fraction * downEstimate[iObject] + (1.0 - fraction) * downPenalty;
    25852587                            }
    2586                             if (numberThisUp < numberBeforeTrust) {
     2588                            if (numberThisUp < numberBeforeTrustThis) {
    25872589                                double fraction = numberThisUp * invTrust;
    25882590                                upEstimate[iObject] = fraction * upEstimate[iObject] + (1.0 - fraction) * upPenalty;
     
    26172619                                delete branch;
    26182620                            }
    2619                             if (number >= numberBeforeTrust)
    2620                                 dynamicObject->setNumberBeforeTrust(number + 1);
     2621                            if (number >= numberBeforeTrustThis)
     2622                              dynamicObject->setNumberBeforeTrust(CoinMin(number + 1,5*numberBeforeTrust));
    26212623                            numberFixed++;
    26222624                        }
     
    28142816                numberTest = numberToDo;
    28152817                numberStrong=numberToDo;
    2816                 skipAll=false;
     2818                skipAll=0;
    28172819                searchStrategy=0;
    28182820                solver->setIntParam(OsiMaxNumIterationHotStart, 100000);
     2821                //printf("Strong branching type %d\n",strongType);
    28192822              }
    28202823            }
     
    28812884                if (model->messageHandler()->logLevel() > 3 && numberBeforeTrust && dynamicObject)
    28822885                    dynamicObject->print(1, choice.possibleBranch->value());
     2886                if (strongType)
     2887                  canSkip=0;
    28832888                if (skipAll < 0)
    2884                     canSkip = true;
    2885                 if (strongType)
    2886                   canSkip=false;
     2889                    canSkip = 1;
    28872890                if (!canSkip) {
    28882891                    if (!doneHotStart) {
     
    28962899                        if (!solver->isProvenOptimal()) {
    28972900                          skipAll=-2;
    2898                           canSkip = true;
     2901                          canSkip = 1;
    28992902                        }
    29002903                        xMark++;
     
    30893092                        memcpy(saveUpper,solver->getColUpper(),solver->getNumCols()*sizeof(double));
    30903093#endif
     3094                        if (!solver->isProvenOptimal()) {
     3095                          skipAll=-2;
     3096                          canSkip = 1;
     3097                        }
     3098                        xMark++;
    30913099                    }
    30923100#if 0 //def DO_ALL_AT_ROOT
     
    32773285                        memcpy(saveUpper,solver->getColUpper(),solver->getNumCols()*sizeof(double));
    32783286#endif
     3287                        if (!solver->isProvenOptimal()) {
     3288                          skipAll=-2;
     3289                          canSkip = 1;
     3290                        }
     3291                        xMark++;
    32793292                    }
    32803293
     
    34263439                        memcpy(saveUpper,solver->getColUpper(),solver->getNumCols()*sizeof(double));
    34273440#endif
     3441                        if (!solver->isProvenOptimal()) {
     3442                          skipAll=-2;
     3443                          canSkip = 1;
     3444                        }
     3445                        xMark++;
    34283446                        // may be infeasible (if other way stopped on iterations)
    34293447                        if (goneInfeasible) {
     
    34733491                        memcpy(saveUpper,solver->getColUpper(),solver->getNumCols()*sizeof(double));
    34743492#endif
     3493                        if (!solver->isProvenOptimal()) {
     3494                          skipAll=-2;
     3495                          canSkip = 1;
     3496                        }
     3497                        xMark++;
    34753498                        // may be infeasible (if other way stopped on iterations)
    34763499                        if (goneInfeasible) {
     
    36503673    }
    36513674    if (numberUnfinished*10 < numberStrongDone &&
    3652             numberStrongIterations*20 < model->getIterationCount()&&
     3675        model->numberStrongIterations()*20 < model->getIterationCount()&&
    36533676                                !auxiliaryInfo->solutionAddsCuts()) {
    36543677        //printf("increasing trust\n");
     
    45134536    double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
    45144537    if (thisOne->whichSolution() >= 0) {
    4515         ClpNode * nodeInfo = thisOne->nodeInfo(thisOne->whichSolution());
    4516         nodeInfo->applyNode(simplex, 2);
     4538        ClpNode * nodeInfo=NULL;
     4539        if ((model->moreSpecialOptions()&33554432)==0) {
     4540          nodeInfo = thisOne->nodeInfo(thisOne->whichSolution());
     4541          nodeInfo->applyNode(simplex, 2);
     4542        } else {
     4543          // from diving
     4544          CbcSubProblem ** nodes = reinterpret_cast<CbcSubProblem **>
     4545            (model->temporaryPointer());
     4546          assert (nodes);
     4547          int numberDo=thisOne->numberNodes()-1;
     4548          for (int iNode=0;iNode<numberDo;iNode++)
     4549            nodes[iNode]->apply(solver,1);
     4550          nodes[numberDo]->apply(solver,9+16);
     4551        }
    45174552        int saveLogLevel = simplex->logLevel();
    45184553        simplex->setLogLevel(0);
     
    45234558        if (simplex->status()) {
    45244559            //simplex->writeMps("bad7.mps",2);
    4525             if (nodeInfo->objectiveValue() > cutoff - 1.0e-2)
     4560            if (nodeInfo) {
     4561              if (nodeInfo->objectiveValue() > cutoff - 1.0e-2)
    45264562                goodSolution = false;
    4527             else
     4563              else
    45284564                assert (!simplex->status());
     4565            } else {
     4566              // debug diving
     4567              assert (!simplex->status());
     4568            }
    45294569        }
    45304570        if (goodSolution) {
     
    45844624        } else {
    45854625            branch_ = thisOne->createCbcBranch(solver, &usefulInfo, preferredWay);
    4586             // Set to firat one (and change when re-pushing)
    4587             CbcGeneralBranchingObject * branch =
     4626            if (branch_) {
     4627              // Set to first one (and change when re-pushing)
     4628              CbcGeneralBranchingObject * branch =
    45884629                dynamic_cast <CbcGeneralBranchingObject *> (branch_);
    4589             branch->state(objectiveValue_, sumInfeasibilities_,
    4590                           numberUnsatisfied_, 0);
    4591             branch->setNode(this);
    4592             anyAction = 0;
     4630              branch->state(objectiveValue_, sumInfeasibilities_,
     4631                            numberUnsatisfied_, 0);
     4632              branch->setNode(this);
     4633              anyAction = 0;
     4634            } else {
     4635              anyAction = -2; // mark as infeasible
     4636            }
    45934637        }
    45944638    } else {
Note: See TracChangeset for help on using the changeset viewer.