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

for osibranching

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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.