Changeset 473 for branches/devel/Cbc


Ignore:
Timestamp:
Oct 30, 2006 10:27:34 AM (13 years ago)
Author:
forrest
Message:

for osibranching

Location:
branches/devel/Cbc/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • branches/devel/Cbc/src/CbcHeuristicFPump.cpp

    r464 r473  
    509509          solver->resolve();
    510510          assert (solver->isProvenOptimal());
     511          // in case very dubious solver
     512          lower = solver->getColLower();
     513          upper = solver->getColUpper();
     514          solution = solver->getColSolution();
    511515        } else {
    512516          int * addStart = new int[2*general+1];
  • branches/devel/Cbc/src/CbcModel.cpp

    r471 r473  
    113113void verifyTreeNodes (const CbcTree * branchingTree, const CbcModel &model)
    114114
    115 { printf("*** CHECKING tree after %d nodes\n",model.getNodeCount()) ;
    116 
     115{if (model.getNodeCount()==661) return; printf("*** CHECKING tree after %d nodes\n",model.getNodeCount()) ;
     116 
    117117  int j ;
    118118  int nNodes = branchingTree->size() ;
     
    620620  if (numberBeforeTrust_)
    621621    convertToDynamic();
    622   // take off heuristics if have to
    623   if (numberHeuristics_) {
    624     int numberOdd=0;
    625     for (int i=0;i<numberObjects_;i++) {
    626       if (!object_[i]->canDoHeuristics())
    627         numberOdd++;
    628     }
    629     if (numberOdd) {
    630       for (int i=0;i<numberHeuristics_;i++)
    631         delete heuristic_[i];
    632       delete [] heuristic_;
    633       heuristic_=NULL;
    634       numberHeuristics_=0;
    635       handler_->message(CBC_HEURISTICS_OFF,messages_)<< numberOdd<<CoinMessageEol ;
    636     }
    637   }
    638622  // Set up char array to say if integer
    639623  delete [] integerInfo_;
     
    754738        solver_->addObjects(numberObjects_,object_);
    755739      } else {
    756         printf("should have trapped that solver has objects before\n");
    757         abort();
     740        if (solver_->numberObjects()!=numberOriginalObjects) {
     741          printf("should have trapped that solver has objects before\n");
     742          abort();
     743        }
    758744      }
    759745    } else {
    760746      // do from solver
    761       deleteObjects();
     747      deleteObjects(false);
    762748      solver_->findIntegersAndSOS(false);
    763749      numberObjects_=solver_->numberObjects();
     
    768754    }
    769755    branchingMethod_->chooseMethod()->setSolver(solver_);
     756  }
     757  // take off heuristics if have to
     758  if (numberHeuristics_) {
     759    int numberOdd=0;
     760    for (int i=0;i<numberObjects_;i++) {
     761      if (!object_[i]->canDoHeuristics())
     762        numberOdd++;
     763    }
     764    if (numberOdd) {
     765      for (int i=0;i<numberHeuristics_;i++)
     766        delete heuristic_[i];
     767      delete [] heuristic_;
     768      heuristic_=NULL;
     769      numberHeuristics_=0;
     770      handler_->message(CBC_HEURISTICS_OFF,messages_)<< numberOdd<<CoinMessageEol ;
     771    }
    770772  }
    771773  // Save objective (just so user can access it)
     
    10721074                           NULL,NULL,NULL,branches,&usefulInfo);
    10731075  if (anyAction == -2||newNode->objectiveValue() >= cutoff) {
     1076    if (anyAction != -2) {
     1077      // zap parent nodeInfo
     1078#ifdef COIN_DEVELOP
     1079      printf("zapping CbcNodeInfo %x\n",newNode->nodeInfo()->parent());
     1080#endif
     1081      newNode->nodeInfo()->nullParent();
     1082    }
    10741083    delete newNode ;
    10751084    newNode = NULL ;
     
    16381647          // Reset bound anyway (no harm if not odd)
    16391648          solverCharacteristics_->setMipBound(-COIN_DBL_MAX);
     1649          node->nodeInfo()->decrement();
    16401650        }
    16411651        // May have slipped through i.e. anyAction == 0 and objective above cutoff
     
    16441654        if ( anyAction >=0 ) {
    16451655          assert (newNode);
    1646           if (newNode->objectiveValue() >= getCutoff())
     1656          if (newNode->objectiveValue() >= getCutoff()) {
    16471657            anyAction = -2; // say bad after all
     1658            printf("zapping2 CbcNodeInfo %x\n",newNode->nodeInfo()->parent());
     1659            // zap parent nodeInfo
     1660            newNode->nodeInfo()->nullParent();
     1661          }
    16481662        }
    16491663/*
     
    56355649// Delete all object information
    56365650void
    5637 CbcModel::deleteObjects()
     5651CbcModel::deleteObjects(bool getIntegers)
    56385652{
    56395653  int i;
     
    56435657  object_ = NULL;
    56445658  numberObjects_=0;
    5645   findIntegers(true);
     5659  if (getIntegers)
     5660    findIntegers(true);
    56465661}
    56475662
     
    59595974      mark[iColumn]=i+numberColumns;
    59605975      newIntegers++;
     5976    } else {
     5977      OsiSimpleInteger * obj2 =
     5978      dynamic_cast <OsiSimpleInteger *>(objects[i]) ;
     5979      if (obj2) {
     5980        // Osi takes precedence
     5981        int iColumn = obj2->columnNumber();
     5982        mark[iColumn]=i+numberColumns;
     5983        newIntegers++;
     5984      }
    59615985    }
    59625986  }
     
    60126036        delete object_[i];
    60136037      } else {
    6014         temp[n++]=object_[i];
     6038        temp[n++]=object_[i];
    60156039      }
    60166040    }
     
    60206044    CbcSimpleInteger * obj =
    60216045      dynamic_cast <CbcSimpleInteger *>(objects[i]) ;
    6022     if (!obj) {
     6046    OsiSimpleInteger * obj2 =
     6047      dynamic_cast <OsiSimpleInteger *>(objects[i]) ;
     6048    if (!obj&&!obj2) {
    60236049      temp[n]=objects[i]->clone();
    60246050      CbcObject * obj =
     
    83568382  if ( anyAction >=0 ) {
    83578383    assert (newNode);
    8358     if (newNode->objectiveValue() >= getCutoff())
     8384    if (newNode->objectiveValue() >= getCutoff()) {
    83598385      anyAction = -2; // say bad after all
     8386      // zap parent nodeInfo
     8387#ifdef COIN_DEVELOP
     8388      printf("zapping3 CbcNodeInfo %x\n",newNode->nodeInfo()->parent());
     8389#endif
     8390      newNode->nodeInfo()->nullParent();
     8391    }
    83608392  }
    83618393  return anyAction;
  • branches/devel/Cbc/src/CbcModel.hpp

    r471 r473  
    373373  inline OsiObject * modifiableObject(int which) const { return object_[which];};
    374374
    375   /// Delete all object information
    376   void deleteObjects();
     375  /// Delete all object information (and just back to integers if true)
     376  void deleteObjects(bool findIntegers=true);
    377377
    378378  /** Add in object information.
  • branches/devel/Cbc/src/CbcNode.cpp

    r463 r473  
    7373  if (parent_) {
    7474    numberRows_ = parent_->numberRows_+parent_->numberCuts_;
     75    //parent_->increment();
    7576  }
    7677}
     
    39433944    int numberToDelete=nodeInfo_->numberBranchesLeft();
    39443945    //    CbcNodeInfo * parent = nodeInfo_->parent();
     3946    //assert (nodeInfo_->numberPointingToThis()>0);
    39453947    if (nodeInfo_->decrement(numberToDelete)==0) {
    39463948      delete nodeInfo_;
  • branches/devel/Cbc/src/CbcNode.hpp

    r463 r473  
    117117  /// Increment number of references
    118118  inline void increment(int amount=1)
    119   {numberPointingToThis_+=amount;};
     119  {numberPointingToThis_+=amount;/*printf("CbcNodeInfo %x incremented by %d to %d\n",this,amount,numberPointingToThis_);*/};
    120120
    121121  /// Decrement number of references and return number left
    122122  inline int decrement(int amount=1)
    123   {numberPointingToThis_-=amount;return numberPointingToThis_;};
     123  {numberPointingToThis_-=amount;/*printf("CbcNodeInfo %x decremented by %d to %d\n",this,amount,numberPointingToThis_);*/return numberPointingToThis_;};
    124124
    125125  /** Initialize reference counts
     
    150150  CbcNodeInfo * parent() const
    151151  {return parent_;};
     152  /// Set parent null
     153  inline void nullParent()
     154  { parent_=NULL;};
    152155
    153156  void addCuts(OsiCuts & cuts,int numberToBranch, int * whichGenerator);
  • branches/devel/Cbc/src/CoinSolve.cpp

    r465 r473  
    23572357                  }
    23582358                }
    2359                 if (preProcess&&process.numberSOS()) {
    2360                   int numberSOS = process.numberSOS();
    2361                   int numberIntegers = babModel->numberIntegers();
    2362                   /* model may not have created objects
    2363                      If none then create
    2364                   */
    2365                   if (!numberIntegers||!babModel->numberObjects()) {
    2366                     int type = (pseudoUp) ? 1 : 0;
    2367                     babModel->findIntegers(true,type);
    2368                     numberIntegers = babModel->numberIntegers();
    2369                   }
    2370                   OsiObject ** oldObjects = babModel->objects();
    2371                   // Do sets and priorities
    2372                   OsiObject ** objects = new OsiObject * [numberSOS];
    2373                   // set old objects to have low priority
    2374                   int numberOldObjects = babModel->numberObjects();
    2375                   int numberColumns = babModel->getNumCols();
    2376                   for (int iObj = 0;iObj<numberOldObjects;iObj++) {
    2377                     oldObjects[iObj]->setPriority(numberColumns+1);
    2378                     int iColumn = oldObjects[iObj]->columnNumber();
    2379                     assert (iColumn>=0);
    2380                     if (iColumn>=numberOriginalColumns)
    2381                       continue;
    2382                     if (originalColumns)
    2383                       iColumn = originalColumns[iColumn];
    2384                     if (branchDirection) {
    2385                       CbcSimpleInteger * obj =
    2386                         dynamic_cast <CbcSimpleInteger *>(oldObjects[iObj]) ;
    2387                       if (obj) {
    2388                         obj->setPreferredWay(branchDirection[iColumn]);
    2389                       } else {
    2390                         CbcObject * obj =
    2391                           dynamic_cast <CbcObject *>(oldObjects[iObj]) ;
    2392                         assert (obj);
    2393                         obj->setPreferredWay(branchDirection[iColumn]);
     2359                int testOsiOptions = parameters[whichParam(TESTOSI,numberParameters,parameters)].intValue();
     2360                OsiSolverInterface * testOsiSolver= (testOsiOptions>=0) ? babModel->solver() : NULL;
     2361                if (!testOsiSolver) {
     2362                  // *************************************************************
     2363                  // CbcObjects
     2364                  if (preProcess&&process.numberSOS()) {
     2365                    int numberSOS = process.numberSOS();
     2366                    int numberIntegers = babModel->numberIntegers();
     2367                    /* model may not have created objects
     2368                       If none then create
     2369                    */
     2370                    if (!numberIntegers||!babModel->numberObjects()) {
     2371                      int type = (pseudoUp) ? 1 : 0;
     2372                      babModel->findIntegers(true,type);
     2373                      numberIntegers = babModel->numberIntegers();
     2374                    }
     2375                    OsiObject ** oldObjects = babModel->objects();
     2376                    // Do sets and priorities
     2377                    OsiObject ** objects = new OsiObject * [numberSOS];
     2378                    // set old objects to have low priority
     2379                    int numberOldObjects = babModel->numberObjects();
     2380                    int numberColumns = babModel->getNumCols();
     2381                    for (int iObj = 0;iObj<numberOldObjects;iObj++) {
     2382                      oldObjects[iObj]->setPriority(numberColumns+1);
     2383                      int iColumn = oldObjects[iObj]->columnNumber();
     2384                      assert (iColumn>=0);
     2385                      if (iColumn>=numberOriginalColumns)
     2386                        continue;
     2387                      if (originalColumns)
     2388                        iColumn = originalColumns[iColumn];
     2389                      if (branchDirection) {
     2390                        CbcSimpleInteger * obj =
     2391                          dynamic_cast <CbcSimpleInteger *>(oldObjects[iObj]) ;
     2392                        if (obj) {
     2393                          obj->setPreferredWay(branchDirection[iColumn]);
     2394                        } else {
     2395                          CbcObject * obj =
     2396                            dynamic_cast <CbcObject *>(oldObjects[iObj]) ;
     2397                          assert (obj);
     2398                          obj->setPreferredWay(branchDirection[iColumn]);
     2399                        }
     2400                      }
     2401                      if (pseudoUp) {
     2402                        CbcSimpleIntegerPseudoCost * obj1a =
     2403                          dynamic_cast <CbcSimpleIntegerPseudoCost *>(oldObjects[iObj]) ;
     2404                        assert (obj1a);
     2405                        if (pseudoDown[iColumn]>0.0)
     2406                          obj1a->setDownPseudoCost(pseudoDown[iColumn]);
     2407                        if (pseudoUp[iColumn]>0.0)
     2408                          obj1a->setUpPseudoCost(pseudoUp[iColumn]);
    23942409                      }
    23952410                    }
    2396                     if (pseudoUp) {
    2397                       CbcSimpleIntegerPseudoCost * obj1a =
    2398                         dynamic_cast <CbcSimpleIntegerPseudoCost *>(oldObjects[iObj]) ;
    2399                       assert (obj1a);
    2400                       if (pseudoDown[iColumn]>0.0)
    2401                         obj1a->setDownPseudoCost(pseudoDown[iColumn]);
    2402                       if (pseudoUp[iColumn]>0.0)
    2403                         obj1a->setUpPseudoCost(pseudoUp[iColumn]);
    2404                     }
    2405                   }
    2406                   const int * starts = process.startSOS();
    2407                   const int * which = process.whichSOS();
    2408                   const int * type = process.typeSOS();
    2409                   const double * weight = process.weightSOS();
    2410                   int iSOS;
    2411                   for (iSOS =0;iSOS<numberSOS;iSOS++) {
    2412                     int iStart = starts[iSOS];
    2413                     int n=starts[iSOS+1]-iStart;
    2414                     objects[iSOS] = new CbcSOS(babModel,n,which+iStart,weight+iStart,
    2415                                                iSOS,type[iSOS]);
    2416                     // branch on long sets first
    2417                     objects[iSOS]->setPriority(numberColumns-n);
    2418                   }
    2419                   babModel->addObjects(numberSOS,objects);
    2420                   for (iSOS=0;iSOS<numberSOS;iSOS++)
    2421                     delete objects[iSOS];
    2422                   delete [] objects;
    2423                 } else if (priorities||branchDirection||pseudoDown||pseudoUp||numberSOS) {
    2424                   // do anyway for priorities etc
    2425                   int numberIntegers = babModel->numberIntegers();
    2426                   /* model may not have created objects
    2427                      If none then create
    2428                   */
    2429                   if (!numberIntegers||!babModel->numberObjects()) {
    2430                     int type = (pseudoUp) ? 1 : 0;
    2431                     babModel->findIntegers(true,type);
    2432                   }
    2433                   if (numberSOS) {
    2434                     // Do sets and priorities
    2435                     OsiObject ** objects = new OsiObject * [numberSOS];
    2436                     int iSOS;
    2437                     if (originalColumns) {
    2438                       // redo sequence numbers
    2439                       int numberColumns = babModel->getNumCols();
    2440                       int nOld = originalColumns[numberColumns-1]+1;
    2441                       int * back = new int[nOld];
    2442                       int i;
    2443                       for (i=0;i<nOld;i++)
    2444                         back[i]=-1;
    2445                       for (i=0;i<numberColumns;i++)
    2446                         back[originalColumns[i]]=i;
    2447                       // Really need better checks
    2448                       int nMissing=0;
    2449                       int n=sosStart[numberSOS];
    2450                       for (i=0;i<n;i++) {
    2451                         int iColumn = sosIndices[i];
    2452                         int jColumn = back[iColumn];
    2453                         if (jColumn>=0)
    2454                           sosIndices[i] = jColumn;
    2455                         else
    2456                           nMissing++;
    2457                       }
    2458                       delete [] back;
    2459                       if (nMissing)
    2460                         printf("%d SOS variables vanished due to pre processing? - check validity?\n",nMissing);
    2461                     }
    2462                     for (iSOS =0;iSOS<numberSOS;iSOS++) {
    2463                       int iStart = sosStart[iSOS];
    2464                       int n=sosStart[iSOS+1]-iStart;
    2465                       objects[iSOS] = new CbcSOS(babModel,n,sosIndices+iStart,sosReference+iStart,
    2466                                                  iSOS,sosType[iSOS]);
    2467                       if (sosPriority)
    2468                         objects[iSOS]->setPriority(sosPriority[iSOS]);
    2469                       else if (!prioritiesIn)
    2470                         objects[iSOS]->setPriority(10);  // rather than 1000
    2471                     }
    2472                     // delete any existing SOS objects
    2473                     int numberObjects=babModel->numberObjects();
    2474                     OsiObject ** oldObjects=babModel->objects();
    2475                     int nNew=0;
    2476                     for (int i=0;i<numberObjects;i++) {
    2477                       OsiObject * objThis = oldObjects[i];
    2478                       CbcSOS * obj1 =
    2479                         dynamic_cast <CbcSOS *>(objThis) ;
    2480                       OsiSOS * obj2 =
    2481                         dynamic_cast <OsiSOS *>(objThis) ;
    2482                       if (!obj1&&!obj2) {
    2483                         oldObjects[nNew++]=objThis;
    2484                       } else {
    2485                         delete objThis;
     2411                    const int * starts = process.startSOS();
     2412                    const int * which = process.whichSOS();
     2413                    const int * type = process.typeSOS();
     2414                    const double * weight = process.weightSOS();
     2415                    int iSOS;
     2416                    for (iSOS =0;iSOS<numberSOS;iSOS++) {
     2417                      int iStart = starts[iSOS];
     2418                      int n=starts[iSOS+1]-iStart;
     2419                      objects[iSOS] = new CbcSOS(babModel,n,which+iStart,weight+iStart,
     2420                                                 iSOS,type[iSOS]);
     2421                      // branch on long sets first
     2422                      objects[iSOS]->setPriority(numberColumns-n);
     2423                    }
     2424                    babModel->addObjects(numberSOS,objects);
     2425                    for (iSOS=0;iSOS<numberSOS;iSOS++)
     2426                      delete objects[iSOS];
     2427                    delete [] objects;
     2428                  } else if (priorities||branchDirection||pseudoDown||pseudoUp||numberSOS) {
     2429                    // do anyway for priorities etc
     2430                    int numberIntegers = babModel->numberIntegers();
     2431                    /* model may not have created objects
     2432                       If none then create
     2433                    */
     2434                    if (!numberIntegers||!babModel->numberObjects()) {
     2435                      int type = (pseudoUp) ? 1 : 0;
     2436                      babModel->findIntegers(true,type);
     2437                    }
     2438                    if (numberSOS) {
     2439                      // Do sets and priorities
     2440                      OsiObject ** objects = new OsiObject * [numberSOS];
     2441                      int iSOS;
     2442                      if (originalColumns) {
     2443                        // redo sequence numbers
     2444                        int numberColumns = babModel->getNumCols();
     2445                        int nOld = originalColumns[numberColumns-1]+1;
     2446                        int * back = new int[nOld];
     2447                        int i;
     2448                        for (i=0;i<nOld;i++)
     2449                          back[i]=-1;
     2450                        for (i=0;i<numberColumns;i++)
     2451                          back[originalColumns[i]]=i;
     2452                        // Really need better checks
     2453                        int nMissing=0;
     2454                        int n=sosStart[numberSOS];
     2455                        for (i=0;i<n;i++) {
     2456                          int iColumn = sosIndices[i];
     2457                          int jColumn = back[iColumn];
     2458                          if (jColumn>=0)
     2459                            sosIndices[i] = jColumn;
     2460                          else
     2461                            nMissing++;
     2462                        }
     2463                        delete [] back;
     2464                        if (nMissing)
     2465                          printf("%d SOS variables vanished due to pre processing? - check validity?\n",nMissing);
    24862466                      }
     2467                      for (iSOS =0;iSOS<numberSOS;iSOS++) {
     2468                        int iStart = sosStart[iSOS];
     2469                        int n=sosStart[iSOS+1]-iStart;
     2470                        objects[iSOS] = new CbcSOS(babModel,n,sosIndices+iStart,sosReference+iStart,
     2471                                                   iSOS,sosType[iSOS]);
     2472                        if (sosPriority)
     2473                          objects[iSOS]->setPriority(sosPriority[iSOS]);
     2474                        else if (!prioritiesIn)
     2475                          objects[iSOS]->setPriority(10);  // rather than 1000
     2476                      }
     2477                      // delete any existing SOS objects
     2478                      int numberObjects=babModel->numberObjects();
     2479                      OsiObject ** oldObjects=babModel->objects();
     2480                      int nNew=0;
     2481                      for (int i=0;i<numberObjects;i++) {
     2482                        OsiObject * objThis = oldObjects[i];
     2483                        CbcSOS * obj1 =
     2484                          dynamic_cast <CbcSOS *>(objThis) ;
     2485                        OsiSOS * obj2 =
     2486                          dynamic_cast <OsiSOS *>(objThis) ;
     2487                        if (!obj1&&!obj2) {
     2488                          oldObjects[nNew++]=objThis;
     2489                        } else {
     2490                          delete objThis;
     2491                        }
     2492                      }
     2493                      babModel->setNumberObjects(nNew);
     2494                      babModel->addObjects(numberSOS,objects);
     2495                      for (iSOS=0;iSOS<numberSOS;iSOS++)
     2496                        delete objects[iSOS];
     2497                      delete [] objects;
    24872498                    }
    2488                     babModel->setNumberObjects(nNew);
    2489                     babModel->addObjects(numberSOS,objects);
    2490                     for (iSOS=0;iSOS<numberSOS;iSOS++)
    2491                       delete objects[iSOS];
    2492                     delete [] objects;
    24932499                  }
    24942500                  OsiObject ** objects = babModel->objects();
     
    25312537                    }
    25322538                  }
     2539                  // *************************************************************
     2540                } else {
     2541                  // *************************************************************
     2542                  // OsiObjects
     2543                  if (preProcess&&process.numberSOS()) {
     2544                    int numberSOS = process.numberSOS();
     2545                    int numberIntegers = testOsiSolver->getNumIntegers();
     2546                    /* model may not have created objects
     2547                       If none then create
     2548                    */
     2549                    if (!numberIntegers||!testOsiSolver->numberObjects()) {
     2550                      //int type = (pseudoUp) ? 1 : 0;
     2551                      testOsiSolver->findIntegers(false);
     2552                      numberIntegers = testOsiSolver->getNumIntegers();
     2553                    }
     2554                    OsiObject ** oldObjects = testOsiSolver->objects();
     2555                    // Do sets and priorities
     2556                    OsiObject ** objects = new OsiObject * [numberSOS];
     2557                    // set old objects to have low priority
     2558                    int numberOldObjects = testOsiSolver->numberObjects();
     2559                    int numberColumns = testOsiSolver->getNumCols();
     2560                    for (int iObj = 0;iObj<numberOldObjects;iObj++) {
     2561                      oldObjects[iObj]->setPriority(numberColumns+1);
     2562                      int iColumn = oldObjects[iObj]->columnNumber();
     2563                      assert (iColumn>=0);
     2564                      if (iColumn>=numberOriginalColumns)
     2565                        continue;
     2566                      if (originalColumns)
     2567                        iColumn = originalColumns[iColumn];
     2568                      if (branchDirection) {
     2569                        OsiSimpleInteger * obj =
     2570                          dynamic_cast <OsiSimpleInteger *>(oldObjects[iObj]) ;
     2571                        if (obj) {
     2572                          obj->setPreferredWay(branchDirection[iColumn]);
     2573                        } else {
     2574                          OsiObject2 * obj =
     2575                            dynamic_cast <OsiObject2 *>(oldObjects[iObj]) ;
     2576                          if (obj)
     2577                            obj->setPreferredWay(branchDirection[iColumn]);
     2578                        }
     2579                      }
     2580                      if (pseudoUp) {
     2581                        abort();
     2582                      }
     2583                    }
     2584                    const int * starts = process.startSOS();
     2585                    const int * which = process.whichSOS();
     2586                    const int * type = process.typeSOS();
     2587                    const double * weight = process.weightSOS();
     2588                    int iSOS;
     2589                    for (iSOS =0;iSOS<numberSOS;iSOS++) {
     2590                      int iStart = starts[iSOS];
     2591                      int n=starts[iSOS+1]-iStart;
     2592                      objects[iSOS] = new OsiSOS(testOsiSolver,n,which+iStart,weight+iStart,
     2593                                                 type[iSOS]);
     2594                      // branch on long sets first
     2595                      objects[iSOS]->setPriority(numberColumns-n);
     2596                    }
     2597                    testOsiSolver->addObjects(numberSOS,objects);
     2598                    for (iSOS=0;iSOS<numberSOS;iSOS++)
     2599                      delete objects[iSOS];
     2600                    delete [] objects;
     2601                  } else if (priorities||branchDirection||pseudoDown||pseudoUp||numberSOS) {
     2602                    // do anyway for priorities etc
     2603                    int numberIntegers = testOsiSolver->getNumIntegers();
     2604                    /* model may not have created objects
     2605                       If none then create
     2606                    */
     2607                    if (!numberIntegers||!testOsiSolver->numberObjects()) {
     2608                      //int type = (pseudoUp) ? 1 : 0;
     2609                      testOsiSolver->findIntegers(false);
     2610                    }
     2611                    if (numberSOS) {
     2612                      // Do sets and priorities
     2613                      OsiObject ** objects = new OsiObject * [numberSOS];
     2614                      int iSOS;
     2615                      if (originalColumns) {
     2616                        // redo sequence numbers
     2617                        int numberColumns = testOsiSolver->getNumCols();
     2618                        int nOld = originalColumns[numberColumns-1]+1;
     2619                        int * back = new int[nOld];
     2620                        int i;
     2621                        for (i=0;i<nOld;i++)
     2622                          back[i]=-1;
     2623                        for (i=0;i<numberColumns;i++)
     2624                          back[originalColumns[i]]=i;
     2625                        // Really need better checks
     2626                        int nMissing=0;
     2627                        int n=sosStart[numberSOS];
     2628                        for (i=0;i<n;i++) {
     2629                          int iColumn = sosIndices[i];
     2630                          int jColumn = back[iColumn];
     2631                          if (jColumn>=0)
     2632                            sosIndices[i] = jColumn;
     2633                          else
     2634                            nMissing++;
     2635                        }
     2636                        delete [] back;
     2637                        if (nMissing)
     2638                          printf("%d SOS variables vanished due to pre processing? - check validity?\n",nMissing);
     2639                      }
     2640                      for (iSOS =0;iSOS<numberSOS;iSOS++) {
     2641                        int iStart = sosStart[iSOS];
     2642                        int n=sosStart[iSOS+1]-iStart;
     2643                        objects[iSOS] = new OsiSOS(testOsiSolver,n,sosIndices+iStart,sosReference+iStart,
     2644                                                   sosType[iSOS]);
     2645                        if (sosPriority)
     2646                          objects[iSOS]->setPriority(sosPriority[iSOS]);
     2647                        else if (!prioritiesIn)
     2648                          objects[iSOS]->setPriority(10);  // rather than 1000
     2649                      }
     2650                      // delete any existing SOS objects
     2651                      int numberObjects=testOsiSolver->numberObjects();
     2652                      OsiObject ** oldObjects=testOsiSolver->objects();
     2653                      int nNew=0;
     2654                      for (int i=0;i<numberObjects;i++) {
     2655                        OsiObject * objThis = oldObjects[i];
     2656                        OsiSOS * obj1 =
     2657                          dynamic_cast <OsiSOS *>(objThis) ;
     2658                        OsiSOS * obj2 =
     2659                          dynamic_cast <OsiSOS *>(objThis) ;
     2660                        if (!obj1&&!obj2) {
     2661                          oldObjects[nNew++]=objThis;
     2662                        } else {
     2663                          delete objThis;
     2664                        }
     2665                      }
     2666                      testOsiSolver->setNumberObjects(nNew);
     2667                      testOsiSolver->addObjects(numberSOS,objects);
     2668                      for (iSOS=0;iSOS<numberSOS;iSOS++)
     2669                        delete objects[iSOS];
     2670                      delete [] objects;
     2671                    }
     2672                  }
     2673                  OsiObject ** objects = testOsiSolver->objects();
     2674                  int numberObjects = testOsiSolver->numberObjects();
     2675                  for (int iObj = 0;iObj<numberObjects;iObj++) {
     2676                    // skip sos
     2677                    OsiSOS * objSOS =
     2678                      dynamic_cast <OsiSOS *>(objects[iObj]) ;
     2679                    if (objSOS)
     2680                      continue;
     2681                    int iColumn = objects[iObj]->columnNumber();
     2682                    assert (iColumn>=0);
     2683                    if (originalColumns)
     2684                      iColumn = originalColumns[iColumn];
     2685                    if (branchDirection) {
     2686                      OsiSimpleInteger * obj =
     2687                        dynamic_cast <OsiSimpleInteger *>(objects[iObj]) ;
     2688                      if (obj) {
     2689                        obj->setPreferredWay(branchDirection[iColumn]);
     2690                      } else {
     2691                        OsiObject2 * obj =
     2692                          dynamic_cast <OsiObject2 *>(objects[iObj]) ;
     2693                        if (obj)
     2694                          obj->setPreferredWay(branchDirection[iColumn]);
     2695                      }
     2696                    }
     2697                    if (priorities) {
     2698                      int iPriority = priorities[iColumn];
     2699                      if (iPriority>0)
     2700                        objects[iObj]->setPriority(iPriority);
     2701                    }
     2702                    if (pseudoUp&&pseudoUp[iColumn]) {
     2703                      abort();
     2704                    }
     2705                  }
     2706                  // *************************************************************
    25332707                }
    25342708                int statistics = (printOptions>0) ? printOptions: 0;
     
    26112785                  babModel->setStrategy(strategy);
    26122786                }
    2613                 int testOsiOptions = parameters[whichParam(TESTOSI,numberParameters,parameters)].intValue();
    26142787                if (testOsiOptions>=0) {
    26152788                  printf("Testing OsiObject options %d\n",testOsiOptions);
    26162789                  CbcBranchDefaultDecision decision;
    2617                   babModel->solver()->findIntegersAndSOS(false);
     2790                  if (!numberSOS) {
     2791                    babModel->solver()->findIntegersAndSOS(false);
     2792                  } else {
     2793                    // move across
     2794                    babModel->deleteObjects(false);
     2795                    //babModel->addObjects(babModel->solver()->numberObjects(),babModel->solver()->objects());
     2796                  }
    26182797                  //OsiChooseVariable choose(babModel->solver());
    26192798                  OsiChooseStrong choose(babModel->solver());
     
    26252804                }
    26262805                checkSOS(babModel, babModel->solver());
     2806                if (doSprint>0) {
     2807                  // Sprint for primal solves
     2808                  ClpSolve::SolveType method = ClpSolve::usePrimalorSprint;
     2809                  ClpSolve::PresolveType presolveType = ClpSolve::presolveOff;
     2810                  int numberPasses = 5;
     2811                  int options[] = {0,3,0,0,0,0};
     2812                  int extraInfo[] = {-1,20,-1,-1,-1,-1};
     2813                  extraInfo[1]=doSprint;
     2814                  int independentOptions[] = {0,0,3};
     2815                  ClpSolve clpSolve(method,presolveType,numberPasses,
     2816                                    options,extraInfo,independentOptions);
     2817                  // say use in OsiClp
     2818                  clpSolve.setSpecialOption(6,1);
     2819                  OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel->solver());
     2820                  osiclp->setSolveOptions(clpSolve);
     2821                  osiclp->setHintParam(OsiDoDualInResolve,false);
     2822                }
    26272823                babModel->branchAndBound(statistics);
    26282824                checkSOS(babModel, babModel->solver());
Note: See TracChangeset for help on using the changeset viewer.