Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcModel.hpp

    r2055 r2094  
    3434class CbcTree;
    3535class CbcStrategy;
     36class CbcSymmetry;
    3637class CbcFeasibilityBase;
    3738class CbcStatistics;
     
    350351    void makeGlobalCuts(int numberRows, const int * which);
    351352    /// Make given cut into a global cut
    352     void makeGlobalCut(const OsiRowCut * cut);
     353    int makeGlobalCut(const OsiRowCut * cut);
    353354    /// Make given cut into a global cut
    354     void makeGlobalCut(const OsiRowCut & cut);
     355    int makeGlobalCut(const OsiRowCut & cut);
    355356    /// Make given column cut into a global cut
    356357    void makeGlobalCut(const OsiColCut * cut);
     
    513514    void findIntegers(bool startAgain, int type = 0);
    514515
     516#ifdef SWITCH_VARIABLES
     517    /// Convert Dynamic to Switching
     518    int findSwitching();
     519    /// Fix associated variables
     520    int fixAssociated(OsiSolverInterface * solver,int cleanBasis);
     521    /// Debug associated variables
     522    int checkAssociated(const OsiSolverInterface * solver,
     523                        const double * solution, int printLevel);
     524#endif
    515525    //@}
    516526
     
    757767    inline int getCurrentPassNumber() const {
    758768        return currentPassNumber_;
     769    }
     770    /** Set current cut pass number in this round of cuts.
     771        (1 is first pass) */
     772    inline void setCurrentPassNumber(int value) {
     773        currentPassNumber_ = value;
    759774    }
    760775
     
    923938    inline int getExtraNodeCount() const {
    924939       return numberExtraNodes_;
     940    }
     941    /// Get how many times complete fathoming B&B was done
     942    inline int getFathomCount() const {
     943       return numberFathoms_;
    925944    }
    926945    /** Final status of problem
     
    17701789        22 bit (4194304) - do not initialize random seed in solver (user has)
    17711790        23 bit (8388608) - leave solver_ with cuts
     1791        24 bit (16777216) - just get feasible if no cutoff
    17721792    */
    17731793    inline void setSpecialOptions(int value) {
     
    18381858        return moreSpecialOptions_;
    18391859    }
     1860    /** Set more more special options
     1861        0 bit (1) - find switching variables
     1862        1 bit (2) - using fake objective until solution
     1863        2 bit (4) - switching variables exist
     1864        3 bit (8) - skip most of setBestSolution checks
     1865        4 bit (16) - very lightweight preprocessing in smallB&B
     1866        5 bit (32) - event handler needs to be cloned when parallel
     1867        6 bit (64) - testing - use probing to make cliques
     1868        7/8 bit (128) - try orbital branching (if nauty)
     1869        9 bit (512) - branching on objective (later)
     1870        10 bit (1024) - branching on constraints (later)
     1871        11/12 bit 2048 - intermittent cuts
     1872        13/14 bit 8192 - go to bitter end in strong branching (first time)
     1873    */
     1874    inline void setMoreSpecialOptions2(int value) {
     1875        moreSpecialOptions2_ = value;
     1876    }
     1877    /// Get more special options2
     1878    inline int moreSpecialOptions2() const {
     1879        return moreSpecialOptions2_;
     1880    }
    18401881    /// Set cutoff as constraint
    18411882    inline void setCutoffAsConstraint(bool yesNo) {
     
    21622203      addCuts() simply treats all the cuts as loose as it does the bookkeeping.
    21632204
    2164       canFix true if extra information being passed
    2165     */
    2166     int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws, bool canFix);
     2205    */
     2206    int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws);
    21672207
    21682208    /** Traverse the tree from node to root and prep the model
     
    22462286        return &globalCuts_;
    22472287    }
     2288    /// Get rid of global cuts
     2289    inline void zapGlobalCuts() {
     2290        globalCuts_ = CbcRowCuts();
     2291    }
    22482292    /// Copy and set a pointer to a row cut which will be added instead of normal branching.
    22492293    void setNextRowCut(const OsiRowCut & cut);
     
    22762320        maximumNumberIterations_ = value;
    22772321    }
     2322#ifdef COIN_HAS_NTY
     2323    /// Symmetry information
     2324    inline CbcSymmetry * symmetryInfo() const
     2325    { return symmetryInfo_;} 
     2326#endif
    22782327    /// Set depth for fast nodes
    22792328    inline void setFastNodeDepth(int value) {
     
    22922341        continuousPriority_ = value;
    22932342    }
    2294     inline void incrementExtra(int nodes, int iterations) {
     2343    inline void incrementExtra(int nodes, int iterations, int fathoms=1) {
    22952344        numberExtraNodes_ += nodes;
    22962345        numberExtraIterations_ += iterations;
     2346        numberFathoms_ += fathoms;
     2347    }
     2348    /// Zero extra
     2349    inline void zeroExtra() {
     2350        numberExtraNodes_ = 0;
     2351        numberExtraIterations_ = 0;
     2352        numberFathoms_ = 0;
    22972353    }
    22982354    /// Number of extra iterations
     
    23402396    void redoWalkBack();
    23412397    //@}
     2398   
     2399    void setMIPStart( const std::vector< std::pair< std::string, double > > &mips ) {
     2400       this->mipStart_ = mips;
     2401    }
     2402
     2403    const std::vector< std::pair< std::string, double > > &getMIPStart() {
     2404       return this->mipStart_;
     2405    }
     2406
    23422407
    23432408//---------------------------------------------------------------------------
     
    24152480    */
    24162481    mutable const double * testSolution_;
    2417     /** Warm start object produced by heuristic or strong branching
     2482    /** MIPstart values
     2483      values for integer variables which will be converted to a complete integer initial feasible solution
     2484    */
     2485    std::vector< std::pair< std::string, double > > mipStart_;
     2486     /** Warm start object produced by heuristic or strong branching
    24182487
    24192488        If get a valid integer solution outside branch and bound then it can take
     
    25632632        18 bit (262144) - donor CbcModel
    25642633        19 bit (524288) - recipient CbcModel
     2634        20 bit (1048576) - waiting for sub model to return
     2635        22 bit (4194304) - do not initialize random seed in solver (user has)
     2636        23 bit (8388608) - leave solver_ with cuts
     2637        24 bit (16777216) - just get feasible if no cutoff
    25652638    */
    25662639    int specialOptions_;
     
    25802653    */
    25812654    int moreSpecialOptions_;
     2655    /** More more special options
     2656        0 bit (1) - find switching variables
     2657        1 bit (2) - using fake objective until solution
     2658        2 bit (4) - switching variables exist
     2659        3 bit (8) - skip most of setBestSolution checks
     2660        4 bit (16) - very lightweight preprocessing in smallB&B
     2661        5 bit (32) - event handler needs to be cloned when parallel
     2662        6 bit (64) - testing - use probing to make cliques
     2663        7/8 bit (128) - try orbital branching (if nauty)
     2664        9 bit (512) - branching on objective (later)
     2665        10 bit (1024) - branching on constraints (later)
     2666        11/12 bit 2048 - intermittent cuts
     2667    */
     2668    int moreSpecialOptions2_;
    25822669    /// User node comparison function
    25832670    CbcCompareBase * nodeCompare_;
     
    26832770    CbcEventHandler *eventHandler_ ;
    26842771# endif
    2685 
     2772#ifdef COIN_HAS_NTY
     2773  /// Symmetry information
     2774  CbcSymmetry * symmetryInfo_;
     2775#endif
    26862776    /// Total number of objects
    26872777    int numberObjects_;
     
    27122802    /// Number of extra nodes in fast lp
    27132803    int numberExtraNodes_;
     2804    /// Number of times fast lp entered
     2805    int numberFathoms_;
    27142806    /** Value of objective at continuous
    27152807        (Well actually after initial round of cuts)
     
    28252917    */
    28262918    int threadMode_;
     2919    /// Number of global cuts on entry to a node
     2920    int numberGlobalCutsIn_;
    28272921    /// Thread stuff for master
    28282922    CbcBaseModel * master_;
Note: See TracChangeset for help on using the changeset viewer.