Changeset 706


Ignore:
Timestamp:
Jul 25, 2007 11:54:56 AM (12 years ago)
Author:
forrest
Message:

take out };

Location:
trunk/Cbc
Files:
38 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/examples/CbcBranchFollow2.hpp

    r129 r706  
    5959  /// get and set for maximum rhws (affects cuts as branch)
    6060  inline int maximumRhs() const
    61   { return maximumRhs_;};
     61  { return maximumRhs_;}
    6262  inline void setMaximumRhs(int value)
    63   { maximumRhs_=value;};
     63  { maximumRhs_=value;}
    6464protected:
    6565  /// data
  • trunk/Cbc/examples/CbcBranchLink.hpp

    r640 r706  
    5959  /// Number of members
    6060  inline int numberMembers() const
    61   {return numberMembers_;};
     61  {return numberMembers_;}
    6262
    6363  /// Number of links for each member
    6464  inline int numberLinks() const
    65   {return numberLinks_;};
     65  {return numberLinks_;}
    6666
    6767  /// Which variables
    6868  inline const int * which() const
    69   {return which_;};
     69  {return which_;}
    7070
    7171  /** Array of weights */
    7272  inline const double * weights() const
    73   { return weights_;};
     73  { return weights_;}
    7474
    7575private:
  • trunk/Cbc/examples/CbcCompareUser.hpp

    r180 r706  
    4949  */
    5050  inline double getWeight() const
    51   { return weight_;};
     51  { return weight_;}
    5252  inline void setWeight(double weight)
    53   { weight_ = weight;};
     53  { weight_ = weight;}
    5454protected:
    5555  // Weight for each infeasibility
  • trunk/Cbc/examples/CbcSolver2.hpp

    r83 r706  
    5959  /// get which ones have been used
    6060  inline const int * when() const
    61   { return node_;};
     61  { return node_;}
    6262  /// Get memory (i.e. how recent use should be)
    6363  inline int getMemory() const
    64   { return memory_;};
     64  { return memory_;}
    6565  /// Get current count
    6666  inline int getCount() const
    67   { return count_;};
     67  { return count_;}
    6868  /// Set memory (i.e. how recent use should be)
    6969  inline void setMemory(int value)
    70   { memory_=value;};
     70  { memory_=value;}
    7171  /// Say whether to just count usage
    7272  inline void setAlgorithm(int value)
    73   { algorithm_=value;};
     73  { algorithm_=value;}
    7474  /// Say whether to just count usage
    7575  inline int getAlgorithm() const
    76   { return algorithm_;};
     76  { return algorithm_;}
    7777  /// Strategy
    7878  inline void setStrategy(int value)
    79   { strategy_=value;};
     79  { strategy_=value;}
    8080  /// Strategy
    8181  inline int getStrategy() const
    82   { return strategy_;};
     82  { return strategy_;}
    8383  //@}
    8484
  • trunk/Cbc/examples/CbcSolver3.hpp

    r123 r706  
    5555  /// get which ones have been used
    5656  inline const int * when() const
    57   { return node_;};
     57  { return node_;}
    5858  /// Get memory (i.e. how recent use should be)
    5959  inline int getMemory() const
    60   { return memory_;};
     60  { return memory_;}
    6161  /// Get current count
    6262  inline int getCount() const
    63   { return count_;};
     63  { return count_;}
    6464  /// Set memory (i.e. how recent use should be)
    6565  inline void setMemory(int value)
    66   { memory_=value;};
     66  { memory_=value;}
    6767  /// Say whether to believe infeasible
    6868  inline void setBelieveInfeasible(bool yesNo)
    69   { believeInfeasible_=yesNo;};
     69  { believeInfeasible_=yesNo;}
    7070  /// Say whether to just count usage
    7171  inline void setAlgorithm(int value)
    72   { algorithm_=value;};
     72  { algorithm_=value;}
    7373  /// Do nested search if this fraction fixed
    7474  inline void setNested(double value)
    75   { nestedSearch_=value;};
     75  { nestedSearch_=value;}
    7676  /// Say whether to just count usage
    7777  inline int getAlgorithm() const
    78   { return algorithm_;};
     78  { return algorithm_;}
    7979  /// Do nested search if this fraction fixed
    8080  inline double getNested() const
    81   { return nestedSearch_;};
     81  { return nestedSearch_;}
    8282  //@}
    8383
  • trunk/Cbc/examples/CbcSolverLongThin.hpp

    r124 r706  
    5555  /// get which ones have been used
    5656  inline const int * when() const
    57   { return node_;};
     57  { return node_;}
    5858  /// Get memory (i.e. how recent use should be)
    5959  inline int getMemory() const
    60   { return memory_;};
     60  { return memory_;}
    6161  /// Get current count
    6262  inline int getCount() const
    63   { return count_;};
     63  { return count_;}
    6464  /// Set memory (i.e. how recent use should be)
    6565  inline void setMemory(int value)
    66   { memory_=value;};
     66  { memory_=value;}
    6767  /// Say whether to believe infeasible
    6868  inline void setBelieveInfeasible(bool yesNo)
    69   { believeInfeasible_=yesNo;};
     69  { believeInfeasible_=yesNo;}
    7070  /// Say whether to just count usage
    7171  inline void setAlgorithm(int value)
    72   { algorithm_=value;};
     72  { algorithm_=value;}
    7373  /// Do nested search if this fraction fixed
    7474  inline void setNested(double value)
    75   { nestedSearch_=value;};
     75  { nestedSearch_=value;}
    7676  /// Say whether to just count usage
    7777  inline int getAlgorithm() const
    78   { return algorithm_;};
     78  { return algorithm_;}
    7979  /// Do nested search if this fraction fixed
    8080  inline double getNested() const
    81   { return nestedSearch_;};
     81  { return nestedSearch_;}
    8282  //@}
    8383
  • trunk/Cbc/examples/Makefile.in

    r640 r706  
    2323        CbcSolver2.@OBJEXT@ \
    2424        CbcSolver3.@OBJEXT@ \
    25         CbcSolverLink.@OBJEXT@ \
    26         ClpDynamicInterface.@OBJEXT@ \
    2725        ClpQuadInterface.@OBJEXT@ \
    28         CoinWarmStartBasisDynamic.@OBJEXT@ \
    2926        CbcBranchFollow2.@OBJEXT@ \
    30         CbcBranchLotsizeSimple.@OBJEXT@ \
    3127        CbcBranchUser.@OBJEXT@ \
    3228        CbcBranchLink.@OBJEXT@
  • trunk/Cbc/examples/qmip2.cpp

    r640 r706  
    3030public:
    3131  // Default Constructor
    32   CbcFeasibilityNoStrong () {};
    33 
    34   virtual ~CbcFeasibilityNoStrong() {};
     32  CbcFeasibilityNoStrong () {}
     33
     34  virtual ~CbcFeasibilityNoStrong() {}
    3535  // Copy constructor
    36   CbcFeasibilityNoStrong ( const CbcFeasibilityNoStrong &rhs) {};
     36  CbcFeasibilityNoStrong ( const CbcFeasibilityNoStrong &rhs) {}
    3737   
    3838  // Assignment operator
    3939  CbcFeasibilityNoStrong & operator=( const CbcFeasibilityNoStrong& rhs)
    40   { return * this;};
     40  { return * this;}
    4141
    4242  /// Clone
    4343  virtual CbcFeasibilityBase * clone() const
    44   { return new CbcFeasibilityNoStrong();};
     44  { return new CbcFeasibilityNoStrong();}
    4545
    4646  /**
     
    5454  */
    5555  virtual int feasible(CbcModel * model, int mode)
    56   {return mode;};
     56  {return mode;}
    5757};
    5858
  • trunk/Cbc/src/CbcBranchActual.hpp

    r640 r706  
    4646  /// Number of members
    4747  inline int numberMembers() const
    48   {return numberMembers_;};
     48  {return numberMembers_;}
    4949
    5050  /// Number of Non SOS members i.e. fixing to zero is strong
    5151  inline int numberNonSOSMembers() const
    52   {return numberNonSOSMembers_;};
     52  {return numberNonSOSMembers_;}
    5353
    5454  /// Members (indices in range 0 ... numberIntegers_-1)
    5555  inline const int * members() const
    56   {return members_;};
     56  {return members_;}
    5757
    5858  /** Type of each member i.e. which way is strong 0=non SOS, 1 =SOS,
    5959      index is 0 ... numberMembers_-1 */
    6060  inline const char type(int index) const
    61   {if (type_) return type_[index]; else return 1;};
     61  {if (type_) return type_[index]; else return 1;}
    6262
    6363  /// Clique type - 0 <=, 1 ==
    6464  inline int cliqueType() const
    65   {return cliqueType_;};
     65  {return cliqueType_;}
    6666  /// Redoes data when sequence numbers change
    6767  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
     
    142142  /// Number of members
    143143  inline int numberMembers() const
    144   {return numberMembers_;};
     144  {return numberMembers_;}
    145145
    146146  /// Members (indices in range 0 ... numberColumns-1)
    147147  inline const int * members() const
    148   {return members_;};
     148  {return members_;}
    149149
    150150  /// SOS type
    151151  inline int sosType() const
    152   {return sosType_;};
     152  {return sosType_;}
    153153
    154154  /** Array of weights */
    155155  inline const double * weights() const
    156   { return weights_;};
     156  { return weights_;}
    157157
    158158  /** \brief Return true if object can take part in normal heuristics
    159159  */
    160160  virtual bool canDoHeuristics() const
    161   {return (sosType_==1&&integerValued_);};
     161  {return (sosType_==1&&integerValued_);}
    162162  /// Set whether set is integer valued or not
    163163  inline void setIntegerValued(bool yesNo)
    164   { integerValued_=yesNo;};
     164  { integerValued_=yesNo;}
    165165private:
    166166  /// data
     
    254254  /// Set column number
    255255  inline void setColumnNumber(int value)
    256   { columnNumber_ = value;};
     256  { columnNumber_ = value;}
    257257
    258258  /** Reset variable bounds to their original values.
     
    266266  /// Original bounds
    267267  inline double originalLowerBound() const
    268   { return originalLower_;};
     268  { return originalLower_;}
    269269  inline void setOriginalLowerBound(double value)
    270   { originalLower_=value;};
     270  { originalLower_=value;}
    271271  inline double originalUpperBound() const
    272   { return originalUpper_;};
     272  { return originalUpper_;}
    273273  inline void setOriginalUpperBound(double value)
    274   { originalUpper_=value;};
     274  { originalUpper_=value;}
    275275  /// Breakeven e.g 0.7 -> >= 0.7 go up first
    276276  inline double breakEven() const
    277   { return breakEven_;};
     277  { return breakEven_;}
    278278  /// Set breakeven e.g 0.7 -> >= 0.7 go up first
    279279  inline void setBreakEven(double value)
    280   { breakEven_=value;};
     280  { breakEven_=value;}
    281281
    282282
     
    340340  /// Number of members
    341341  inline int numberMembers() const
    342   {return numberMembers_;};
     342  {return numberMembers_;}
    343343
    344344  /// Members (indices in range 0 ... numberColumns-1)
    345345  inline const int * members() const
    346   {return members_;};
     346  {return members_;}
    347347  /// Redoes data when sequence numbers change
    348348  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns);
     
    466466  /// Down pseudo cost
    467467  inline double downPseudoCost() const
    468   { return downPseudoCost_;};
     468  { return downPseudoCost_;}
    469469  /// Set down pseudo cost
    470470  inline void setDownPseudoCost(double value)
    471   { downPseudoCost_=value;};
     471  { downPseudoCost_=value;}
    472472
    473473  /// Up pseudo cost
    474474  inline double upPseudoCost() const
    475   { return upPseudoCost_;};
     475  { return upPseudoCost_;}
    476476  /// Set up pseudo cost
    477477  inline void setUpPseudoCost(double value)
    478   { upPseudoCost_=value;};
     478  { upPseudoCost_=value;}
    479479
    480480  /// Up down separator
    481481  inline double upDownSeparator() const
    482   { return upDownSeparator_;};
     482  { return upDownSeparator_;}
    483483  /// Set up down separator
    484484  inline void setUpDownSeparator(double value)
    485   { upDownSeparator_=value;};
     485  { upDownSeparator_=value;}
    486486
    487487  /// Return "up" estimate
     
    492492  /// method - see below for details
    493493  inline int method() const
    494   { return method_;};
     494  { return method_;}
    495495  /// Set method
    496496  inline void setMethod(int value)
    497   { method_=value;};
     497  { method_=value;}
    498498
    499499protected:
     
    576576  /// Change in guessed
    577577  inline double changeInGuessed() const
    578   { return changeInGuessed_;};
     578  { return changeInGuessed_;}
    579579  /// Set change in guessed
    580580  inline void setChangeInGuessed(double value)
    581   { changeInGuessed_=value;};
     581  { changeInGuessed_=value;}
    582582protected:
    583583  /// Change in guessed objective value for next branch
     
    759759  */
    760760  virtual int numberBranches() const
    761   {return numberInSet_;};
     761  {return numberInSet_;}
    762762  /// Is this a two way object (-1 down, +1 up)
    763763  virtual bool twoWay() const
    764   { return false;};
     764  { return false;}
    765765private:
    766766  /// order of branching - points back to CbcNWay
  • trunk/Cbc/src/CbcBranchBase.hpp

    r687 r706  
    167167  */
    168168  virtual CbcBranchingObject * preferredNewFeasible() const
    169   { return NULL;};
     169  { return NULL;}
    170170 
    171171  /** \brief Given a valid solution (with reduced costs, etc.),
     
    178178  */
    179179  virtual CbcBranchingObject * notPreferredNewFeasible() const
    180   { return NULL;};
     180  { return NULL;}
    181181
    182182  /** Reset variable bounds to their original values.
     
    184184    Bounds may be tightened, so it may be good to be able to set this info in object.
    185185   */
    186   virtual void resetBounds(const OsiSolverInterface * solver) {};
     186  virtual void resetBounds(const OsiSolverInterface * solver) {}
    187187 
    188188  /** Returns floor and ceiling i.e. closest valid points
     
    199199
    200200  /// Update object by CbcObjectUpdateData
    201   virtual void updateInformation(const CbcObjectUpdateData & data) {};
     201  virtual void updateInformation(const CbcObjectUpdateData & data) {}
    202202
    203203  /// Identifier (normally column number in matrix)
    204204  inline int id() const
    205   { return id_;};
     205  { return id_;}
    206206 
    207207   /// update model
    208208  inline void setModel(CbcModel * model)
    209   { model_ = model;};
     209  { model_ = model;}
    210210 
    211211  /// Return model
    212212  inline CbcModel * model() const
    213   {return  model_;};
     213  {return  model_;}
    214214
    215215  /// If -1 down always chosen first, +1 up always, 0 normal
    216216  inline int preferredWay() const
    217   { return preferredWay_;};
     217  { return preferredWay_;}
    218218  /// Set -1 down always chosen first, +1 up always, 0 normal
    219219  inline void setPreferredWay(int value)
    220   { preferredWay_=value;};
     220  { preferredWay_=value;}
    221221  /// Redoes data when sequence numbers change
    222   virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns) {};
     222  virtual void redoSequenceEtc(CbcModel * model, int numberColumns, const int * originalColumns) {}
    223223 
    224224protected:
     
    278278      The object mention in incoming CbcStrongInfo must match.
    279279      Returns nonzero if skip is wanted */
    280   virtual int fillStrongInfo( CbcStrongInfo & info) {return 0;};
     280  virtual int fillStrongInfo( CbcStrongInfo & info) {return 0;}
    281281  /// Reset number of branches left to original
    282282  inline void resetNumberBranchesLeft()
    283   { branchIndex_=0;};
     283  { branchIndex_=0;}
    284284
    285285  /** \brief Execute the actions required to branch, as specified by the
     
    297297  */
    298298  virtual double branch(OsiSolverInterface * solver)
    299   { return branch();};
     299  { return branch();}
    300300
    301301  /** \brief Print something about branch - only if log level high
    302302  */
    303   virtual void print() const {};
     303  virtual void print() const {}
    304304
    305305  /** \brief Index identifying the associated CbcObject within its class.
     
    315315  */
    316316  inline int variable() const
    317   {return variable_;};
     317  {return variable_;}
    318318
    319319  /** Get the state of the branching object
     
    325325  */
    326326  inline int way() const
    327   {return way_;};
     327  {return way_;}
    328328
    329329  /** Set the state of the branching object.
     
    332332  */
    333333  inline void way(int way)
    334   {way_=way;};
     334  {way_=way;}
    335335
    336336   /// update model
    337337  inline void setModel(CbcModel * model)
    338   { model_ = model;};
     338  { model_ = model;}
    339339  /// Return model
    340340  inline CbcModel * model() const
    341   {return  model_;};
     341  {return  model_;}
    342342
    343343  /// Return pointer back to object which created
    344344  inline CbcObject * object() const
    345   {return  originalCbcObject_;};
     345  {return  originalCbcObject_;}
    346346  /// Set pointer back to object which created
    347347  inline void setOriginalObject(CbcObject * object)
    348   {originalCbcObject_=object;};
     348  {originalCbcObject_=object;}
    349349
    350350protected:
     
    429429  /** Says whether this method can handle both methods -
    430430      1 better, 2 best, 3 both */
    431   virtual int whichMethod() {return 2;};
     431  virtual int whichMethod() {return 2;}
    432432
    433433  /** Saves a clone of current branching object.  Can be used to update
    434434      information on object causing branch - after branch */
    435   virtual void saveBranchingObject(OsiBranchingObject * object) {};
     435  virtual void saveBranchingObject(OsiBranchingObject * object) {}
    436436  /** Pass in information on branch just done.
    437437      assumes object can get information from solver */
    438438  virtual void updateInformation(OsiSolverInterface * solver,
    439                                  const CbcNode * node) {};
     439                                 const CbcNode * node) {}
    440440  /** Sets or gets best criterion so far */
    441   virtual void setBestCriterion(double value) {};
    442   virtual double getBestCriterion() const {return 0.0;};
     441  virtual void setBestCriterion(double value) {}
     442  virtual double getBestCriterion() const {return 0.0;}
    443443  /// Create C++ lines to get to current state
    444   virtual void generateCpp( FILE * fp) {};
     444  virtual void generateCpp( FILE * fp) {}
    445445  /// Model
    446446  inline CbcModel * cbcModel() const
     
    450450  */
    451451  OsiChooseVariable * chooseMethod() const
    452   { return chooseMethod_;};
     452  { return chooseMethod_;}
    453453  /// Set (clone) chooseMethod
    454454  void setChooseMethod(const OsiChooseVariable & method);
  • trunk/Cbc/src/CbcBranchDynamic.hpp

    r687 r706  
    8484  /// Down pseudo cost
    8585  inline double downDynamicPseudoCost() const
    86   { return downDynamicPseudoCost_;};
     86  { return downDynamicPseudoCost_;}
    8787  /// Set down pseudo cost
    8888  inline void setDownDynamicPseudoCost(double value)
    89   { downDynamicPseudoCost_=value;};
     89  { downDynamicPseudoCost_=value;}
    9090
    9191  /// Up pseudo cost
    9292  inline double upDynamicPseudoCost() const
    93   { return upDynamicPseudoCost_;};
     93  { return upDynamicPseudoCost_;}
    9494  /// Set up pseudo cost
    9595  inline void setUpDynamicPseudoCost(double value)
    96   { upDynamicPseudoCost_=value;};
     96  { upDynamicPseudoCost_=value;}
    9797
    9898  /// Up down separator
    9999  inline double upDownSeparator() const
    100   { return upDownSeparator_;};
     100  { return upDownSeparator_;}
    101101  /// Set up down separator
    102102  inline void setUpDownSeparator(double value)
    103   { upDownSeparator_=value;};
     103  { upDownSeparator_=value;}
    104104
    105105  /// Down sum cost
    106106  inline double sumDownCost() const
    107   { return sumDownCost_;};
     107  { return sumDownCost_;}
    108108  /// Set down sum cost
    109109  inline void setSumDownCost(double value)
    110   { sumDownCost_=value;};
     110  { sumDownCost_=value;}
    111111  /// Add to down sum cost and set last and square
    112112  inline void addToSumDownCost(double value)
    113   { sumDownCost_+=value;lastDownCost_=value;sumDownCostSquared_ += value*value;};
     113  { sumDownCost_+=value;lastDownCost_=value;sumDownCostSquared_ += value*value;}
    114114
    115115  /// Up sum cost
    116116  inline double sumUpCost() const
    117   { return sumUpCost_;};
     117  { return sumUpCost_;}
    118118  /// Set up sum cost
    119119  inline void setSumUpCost(double value)
    120   { sumUpCost_=value;};
     120  { sumUpCost_=value;}
    121121  /// Add to up sum cost and set last and square
    122122  inline void addToSumUpCost(double value)
    123   { sumUpCost_+=value;lastUpCost_=value;sumUpCostSquared_ += value*value;};
     123  { sumUpCost_+=value;lastUpCost_=value;sumUpCostSquared_ += value*value;}
    124124
    125125  /// Down sum change
    126126  inline double sumDownChange() const
    127   { return sumDownChange_;};
     127  { return sumDownChange_;}
    128128  /// Set down sum change
    129129  inline void setSumDownChange(double value)
    130   { sumDownChange_=value;};
     130  { sumDownChange_=value;}
    131131  /// Add to down sum change
    132132  inline void addToSumDownChange(double value)
    133   { sumDownChange_+=value;};
     133  { sumDownChange_+=value;}
    134134
    135135  /// Up sum change
    136136  inline double sumUpChange() const
    137   { return sumUpChange_;};
     137  { return sumUpChange_;}
    138138  /// Set up sum change
    139139  inline void setSumUpChange(double value)
    140   { sumUpChange_=value;};
     140  { sumUpChange_=value;}
    141141  /// Add to up sum change and set last and square
    142142  inline void addToSumUpChange(double value)
    143   { sumUpChange_+=value;};
     143  { sumUpChange_+=value;}
    144144
    145145  /// Sum down decrease number infeasibilities from strong or actual
    146146  inline double sumDownDecrease() const
    147   { return sumDownDecrease_;};
     147  { return sumDownDecrease_;}
    148148  /// Set sum down decrease number infeasibilities from strong or actual
    149149  inline void setSumDownDecrease(double value)
    150   { sumDownDecrease_=value;};
     150  { sumDownDecrease_=value;}
    151151  /// Add to sum down decrease number infeasibilities from strong or actual
    152152  inline void addToSumDownDecrease(double value)
    153   { sumDownDecrease_+=value;lastDownDecrease_ = (int) value;};
     153  { sumDownDecrease_+=value;lastDownDecrease_ = (int) value;}
    154154
    155155  /// Sum up decrease number infeasibilities from strong or actual
    156156  inline double sumUpDecrease() const
    157   { return sumUpDecrease_;};
     157  { return sumUpDecrease_;}
    158158  /// Set sum up decrease number infeasibilities from strong or actual
    159159  inline void setSumUpDecrease(double value)
    160   { sumUpDecrease_=value;};
     160  { sumUpDecrease_=value;}
    161161  /// Add to sum up decrease number infeasibilities from strong or actual
    162162  inline void addToSumUpDecrease(double value)
    163   { sumUpDecrease_+=value;lastUpDecrease_ = (int) value;};
     163  { sumUpDecrease_+=value;lastUpDecrease_ = (int) value;}
    164164
    165165  /// Down number times
    166166  inline int numberTimesDown() const
    167   { return numberTimesDown_;};
     167  { return numberTimesDown_;}
    168168  /// Set down number times
    169169  inline void setNumberTimesDown(int value)
    170   { numberTimesDown_=value;};
     170  { numberTimesDown_=value;}
    171171  /// Increment down number times
    172172  inline void incrementNumberTimesDown()
    173   { numberTimesDown_++;};
     173  { numberTimesDown_++;}
    174174
    175175  /// Up number times
    176176  inline int numberTimesUp() const
    177   { return numberTimesUp_;};
     177  { return numberTimesUp_;}
    178178  /// Set up number times
    179179  inline void setNumberTimesUp(int value)
    180   { numberTimesUp_=value;};
     180  { numberTimesUp_=value;}
    181181  /// Increment up number times
    182182  inline void incrementNumberTimesUp()
    183   { numberTimesUp_++;};
     183  { numberTimesUp_++;}
    184184
    185185  /// Down number times infeasible
    186186  inline int numberTimesDownInfeasible() const
    187   { return numberTimesDownInfeasible_;};
     187  { return numberTimesDownInfeasible_;}
    188188  /// Set down number times infeasible
    189189  inline void setNumberTimesDownInfeasible(int value)
    190   { numberTimesDownInfeasible_=value;};
     190  { numberTimesDownInfeasible_=value;}
    191191  /// Increment down number times infeasible
    192192  inline void incrementNumberTimesDownInfeasible()
    193   { numberTimesDownInfeasible_++;};
     193  { numberTimesDownInfeasible_++;}
    194194
    195195  /// Up number times infeasible
    196196  inline int numberTimesUpInfeasible() const
    197   { return numberTimesUpInfeasible_;};
     197  { return numberTimesUpInfeasible_;}
    198198  /// Set up number times infeasible
    199199  inline void setNumberTimesUpInfeasible(int value)
    200   { numberTimesUpInfeasible_=value;};
     200  { numberTimesUpInfeasible_=value;}
    201201  /// Increment up number times infeasible
    202202  inline void incrementNumberTimesUpInfeasible()
    203   { numberTimesUpInfeasible_++;};
     203  { numberTimesUpInfeasible_++;}
    204204
    205205  /// Number of times before trusted
    206206  inline int numberBeforeTrust() const
    207   { return numberBeforeTrust_;};
     207  { return numberBeforeTrust_;}
    208208  /// Set number of times before trusted
    209209  inline void setNumberBeforeTrust(int value)
    210   { numberBeforeTrust_=value;};
     210  { numberBeforeTrust_=value;}
    211211
    212212  /// Return "up" estimate
     
    217217  /// method - see below for details
    218218  inline int method() const
    219   { return method_;};
     219  { return method_;}
    220220  /// Set method
    221221  inline void setMethod(int value)
    222   { method_=value;};
     222  { method_=value;}
    223223
    224224  /// Pass in information on a down branch
     
    358358  /// Change in guessed
    359359  inline double changeInGuessed() const
    360   { return changeInGuessed_;};
     360  { return changeInGuessed_;}
    361361  /// Set change in guessed
    362362  inline void setChangeInGuessed(double value)
    363   { changeInGuessed_=value;};
     363  { changeInGuessed_=value;}
    364364  /// Return object
    365365  inline CbcSimpleIntegerDynamicPseudoCost * object() const
    366   { return object_;};
     366  { return object_;}
    367367protected:
    368368  /// Change in guessed objective value for next branch
     
    422422  /** Says whether this method can handle both methods -
    423423      1 better, 2 best, 3 both */
    424   virtual int whichMethod() {return 3;};
     424  virtual int whichMethod() {return 3;}
    425425
    426426  /** Saves a clone of current branching object.  Can be used to update
  • trunk/Cbc/src/CbcBranchLotsize.hpp

    r640 r706  
    9292  /// Model column number
    9393  inline int modelSequence() const
    94   {return columnNumber_;};
     94  {return columnNumber_;}
    9595
    9696  /** Column number if single column object -1 otherwise,
     
    101101  /// Original bounds
    102102  inline double originalLowerBound() const
    103   { return bound_[0];};
     103  { return bound_[0];}
    104104  inline double originalUpperBound() const
    105   { return bound_[rangeType_*numberRanges_-1];};
     105  { return bound_[rangeType_*numberRanges_-1];}
    106106  /// Type - 1 points, 2 ranges
    107107  inline int rangeType() const
    108   { return rangeType_;};
     108  { return rangeType_;}
    109109  /// Number of points
    110110  inline int numberRanges() const
    111   { return numberRanges_;};
     111  { return numberRanges_;}
    112112  /// Ranges
    113113  inline double * bound() const
    114   { return bound_;};
     114  { return bound_;}
    115115  /** \brief Return true if object can take part in normal heuristics
    116116  */
    117117  virtual bool canDoHeuristics() const
    118   {return false;};
     118  {return false;}
    119119
    120120private:
  • trunk/Cbc/src/CbcCompareActual.hpp

    r640 r706  
    9999  */
    100100  inline double getWeight() const
    101   { return weight_;};
     101  { return weight_;}
    102102  inline void setWeight(double weight)
    103   { weight_ = weight;};
     103  { weight_ = weight;}
    104104  // Depth above which want to explore first
    105105  inline void setBreadthDepth(int value)
    106   {  breadthDepth_ = value;};
     106  {  breadthDepth_ = value;}
    107107protected:
    108108  // Weight for each infeasibility
  • trunk/Cbc/src/CbcCompareBase.hpp

    r687 r706  
    2525public:
    2626  // Default Constructor
    27   CbcCompareBase () {test_=NULL;};
     27  CbcCompareBase () {test_=NULL;}
    2828
    2929  // This allows any method to change behavior as it is called
    3030  // after each solution
    31   virtual void newSolution(CbcModel * model) {};
     31  virtual void newSolution(CbcModel * model) {}
    3232
    3333  // This Also allows any method to change behavior as it is called
     
    3535  virtual void newSolution(CbcModel * model,
    3636                           double objectiveAtContinuous,
    37                            int numberInfeasibilitiesAtContinuous) {};
     37                           int numberInfeasibilitiesAtContinuous) {}
    3838
    3939  // This allows any method to change behavior as it is called
    4040  // after every 1000 nodes.
    4141  // Return true if want tree re-sorted
    42   virtual bool every1000Nodes(CbcModel * model,int numberNodes) {return false;};
     42  virtual bool every1000Nodes(CbcModel * model,int numberNodes) {return false;}
    4343
    4444  /** Returns true if wants code to do scan with alternate criterion
    4545      NOTE - this is temporarily disabled
    4646  */
    47   virtual bool fullScan() const { return false;};
     47  virtual bool fullScan() const { return false;}
    4848
    49   virtual ~CbcCompareBase() {};
     49  virtual ~CbcCompareBase() {}
    5050  /// Create C++ lines to get to current state
    51   virtual void generateCpp( FILE * fp) {};
     51  virtual void generateCpp( FILE * fp) {}
    5252
    5353  // Copy constructor
    5454  CbcCompareBase ( const CbcCompareBase & rhs)
    55   {test_=rhs.test_;};
     55  {test_=rhs.test_;}
    5656   
    5757  // Assignment operator
     
    5959  {  if (this!=&rhs) {test_=rhs.test_;}
    6060  return *this;
    61   };
     61  }
    6262
    6363  /// Clone
     
    6565
    6666  /// This is test function
    67   virtual bool test (CbcNode * x, CbcNode * y) {return true;};
     67  virtual bool test (CbcNode * x, CbcNode * y) {return true;}
    6868
    6969  /// This is alternate test function
    70   virtual bool alternateTest (CbcNode * x, CbcNode * y) {return test(x,y);};
     70  virtual bool alternateTest (CbcNode * x, CbcNode * y) {return test(x,y);}
    7171
    7272  bool operator() (CbcNode * x, CbcNode * y) {
     
    9292    return (x>y);
    9393#endif
    94   };
     94  }
    9595protected:
    9696  CbcCompareBase * test_;
     
    100100  CbcCompareBase * test_;
    101101  // Default Constructor
    102   CbcCompare () {test_=NULL;};
     102  CbcCompare () {test_=NULL;}
    103103
    104   virtual ~CbcCompare() {};
     104  virtual ~CbcCompare() {}
    105105
    106106  bool operator() (CbcNode * x, CbcNode * y) {
     
    108108  }
    109109  /// This is alternate test function
    110   inline bool alternateTest (CbcNode * x, CbcNode * y) {return test_->alternateTest(x,y);};
     110  inline bool alternateTest (CbcNode * x, CbcNode * y) {return test_->alternateTest(x,y);}
    111111
    112112  /// return comparison object
    113113  inline CbcCompareBase * comparisonObject() const
    114   { return test_;};
     114  { return test_;}
    115115};
    116116//#############################################################################
     
    122122public:
    123123  // Default Constructor
    124   CbcChooseVariable () {};
     124  CbcChooseVariable () {}
    125125
    126   virtual ~CbcChooseVariable() {};
     126  virtual ~CbcChooseVariable() {}
    127127  /** If strong branching, then only those passed in (and movement is that length)
    128128      .  If not strong
  • trunk/Cbc/src/CbcCountRowCut.hpp

    r2 r706  
    7373  /// Number of other CbcNodeInfo objects pointing to this row cut
    7474  inline int numberPointingToThis()
    75   { return numberPointingToThis_;};
     75  { return numberPointingToThis_;}
    7676
    7777  /// Which generator for cuts - as user order
    7878   int whichCutGenerator() const
    79   { return whichCutGenerator_;};
     79  { return whichCutGenerator_;}
    8080
    8181#ifdef CHECK_CUT_COUNTS
  • trunk/Cbc/src/CbcCutGenerator.hpp

    r687 r706  
    101101  /// return name of generator
    102102  inline const char * cutGeneratorName() const
    103   { return generatorName_;};
     103  { return generatorName_;}
    104104
    105105  /** Set the cut generation interval
     
    121121  /// Get the cut generation interval.
    122122  inline int howOften() const
    123   { return whenCutGenerator_;};
     123  { return whenCutGenerator_;}
    124124  /// Get the cut generation interval.in sub tree
    125125  inline int howOftenInSub() const
    126   { return whenCutGeneratorInSub_;};
     126  { return whenCutGeneratorInSub_;}
    127127
    128128  /** Set the cut generation depth
     
    141141  /// Get the cut generation depth criterion.
    142142  inline int whatDepth() const
    143   { return depthCutGenerator_;};
     143  { return depthCutGenerator_;}
    144144  /// Get the cut generation depth criterion.in sub tree
    145145  inline int whatDepthInSub() const
    146   { return depthCutGeneratorInSub_;};
     146  { return depthCutGeneratorInSub_;}
    147147
    148148  /// Get whether the cut generator should be called in the normal place
    149149  inline bool normal() const
    150   { return normal_;};
     150  { return normal_;}
    151151  /// Set whether the cut generator should be called in the normal place
    152152  inline void setNormal(bool value)
    153   { normal_=value;};
     153  { normal_=value;}
    154154  /// Get whether the cut generator should be called when a solution is found
    155155  inline bool atSolution() const
    156   { return atSolution_;};
     156  { return atSolution_;}
    157157  /// Set whether the cut generator should be called when a solution is found
    158158  inline void setAtSolution(bool value)
    159   { atSolution_=value;};
     159  { atSolution_=value;}
    160160  /** Get whether the cut generator should be called when the subproblem is
    161161      found to be infeasible.
    162162  */
    163163  inline bool whenInfeasible() const
    164   { return whenInfeasible_;};
     164  { return whenInfeasible_;}
    165165  /** Set whether the cut generator should be called when the subproblem is
    166166      found to be infeasible.
    167167  */
    168168  inline void setWhenInfeasible(bool value)
    169   { whenInfeasible_=value;};
     169  { whenInfeasible_=value;}
    170170  /// Get whether the cut generator is being timed
    171171  inline bool timing() const
    172   { return timing_;};
     172  { return timing_;}
    173173  /// Set whether the cut generator is being timed
    174174  inline void setTiming(bool value)
    175   { timing_=value; timeInCutGenerator_=0.0;};
     175  { timing_=value; timeInCutGenerator_=0.0;}
    176176  /// Return time taken in cut generator
    177177  inline double timeInCutGenerator() const
    178   { return timeInCutGenerator_;};
     178  { return timeInCutGenerator_;}
    179179  inline void incrementTimeInCutGenerator(double value)
    180   { timeInCutGenerator_ += value;};
     180  { timeInCutGenerator_ += value;}
    181181  /// Get the \c CglCutGenerator corresponding to this \c CbcCutGenerator.
    182182  inline CglCutGenerator * generator() const
    183   { return generator_;};
     183  { return generator_;}
    184184  /// Number times cut generator entered
    185185  inline int numberTimesEntered() const
    186   { return numberTimes_;};
     186  { return numberTimes_;}
    187187  inline void setNumberTimesEntered(int value)
    188   { numberTimes_ = value;};
     188  { numberTimes_ = value;}
    189189  inline void incrementNumberTimesEntered(int value=1)
    190   { numberTimes_ += value;};
     190  { numberTimes_ += value;}
    191191  /// Total number of cuts added
    192192  inline int numberCutsInTotal() const
    193   { return numberCuts_;};
     193  { return numberCuts_;}
    194194  inline void setNumberCutsInTotal(int value)
    195   { numberCuts_ = value;};
     195  { numberCuts_ = value;}
    196196  inline void incrementNumberCutsInTotal(int value=1)
    197   { numberCuts_ += value;};
     197  { numberCuts_ += value;}
    198198  /// Total number of column cuts
    199199  inline int numberColumnCuts() const
    200   { return numberColumnCuts_;};
     200  { return numberColumnCuts_;}
    201201  inline void setNumberColumnCuts(int value)
    202   { numberColumnCuts_ = value;};
     202  { numberColumnCuts_ = value;}
    203203  inline void incrementNumberColumnCuts(int value=1)
    204   { numberColumnCuts_ += value;};
     204  { numberColumnCuts_ += value;}
    205205  /// Total number of cuts active after (at end of n cut passes at each node)
    206206  inline int numberCutsActive() const
    207   { return numberCutsActive_;};
     207  { return numberCutsActive_;}
    208208  inline void setNumberCutsActive(int value)
    209   { numberCutsActive_ = value;};
     209  { numberCutsActive_ = value;}
    210210  inline void incrementNumberCutsActive(int value=1)
    211   { numberCutsActive_ += value;};
     211  { numberCutsActive_ += value;}
    212212  inline void setSwitchOffIfLessThan(int value)
    213   { switchOffIfLessThan_ = value;};
     213  { switchOffIfLessThan_ = value;}
    214214  inline int switchOffIfLessThan() const
    215   { return switchOffIfLessThan_;};
     215  { return switchOffIfLessThan_;}
    216216  /// Say if optimal basis needed
    217217  inline bool needsOptimalBasis() const
    218   { return generator_->needsOptimalBasis();};
     218  { return generator_->needsOptimalBasis();}
    219219  /// Whether generator MUST be called again if any cuts (i.e. ignore break from loop)
    220220  inline bool mustCallAgain() const
    221   { return mustCallAgain_;};
     221  { return mustCallAgain_;}
    222222  /// Set whether generator MUST be called again if any cuts (i.e. ignore break from loop)
    223223  inline void setMustCallAgain(bool yesNo)
    224   { mustCallAgain_=yesNo;};
     224  { mustCallAgain_=yesNo;}
    225225  /// Whether generator switched off for moment
    226226  inline bool switchedOff() const
    227   { return switchedOff_;};
     227  { return switchedOff_;}
    228228  /// Set whether generator switched off for moment
    229229  inline void setSwitchedOff(bool yesNo)
    230   { switchedOff_=yesNo;};
     230  { switchedOff_=yesNo;}
    231231  /// Number of cuts generated at root
    232232  inline int numberCutsAtRoot() const
    233   { return numberCutsAtRoot_;};
     233  { return numberCutsAtRoot_;}
    234234  inline void setNumberCutsAtRoot(int value)
    235   { numberCutsAtRoot_ = value;};
     235  { numberCutsAtRoot_ = value;}
    236236  /// Number of cuts active at root
    237237  inline int numberActiveCutsAtRoot() const
    238   { return numberActiveCutsAtRoot_;};
     238  { return numberActiveCutsAtRoot_;}
    239239  inline void setNumberActiveCutsAtRoot(int value)
    240   { numberActiveCutsAtRoot_ = value;};
     240  { numberActiveCutsAtRoot_ = value;}
    241241  /// Set model
    242242  inline void setModel(CbcModel * model)
    243   { model_ = model;};
     243  { model_ = model;}
    244244  //@}
    245245 
     
    340340  virtual int modify(const OsiSolverInterface * solver, OsiRowCut & cut) =0;
    341341  /// Create C++ lines to get to current state
    342   virtual void generateCpp( FILE * fp) {};
     342  virtual void generateCpp( FILE * fp) {}
    343343protected:
    344344 
     
    384384  virtual int modify(const OsiSolverInterface * solver, OsiRowCut & cut) ;
    385385  /// Create C++ lines to get to current state
    386   virtual void generateCpp( FILE * fp) {};
     386  virtual void generateCpp( FILE * fp) {}
    387387protected:
    388388  /// data
  • trunk/Cbc/src/CbcEventHandler.hpp

    r277 r706  
    164164
    165165  inline const CbcModel* getModel() const
    166   { return model_ ; } ;
     166  { return model_ ; }
    167167
    168168  /*! \brief Set the default action */
  • trunk/Cbc/src/CbcFathom.hpp

    r687 r706  
    5050  // Is this method possible
    5151  inline bool possible() const
    52   { return possible_;};
     52  { return possible_;}
    5353
    5454protected:
     
    102102  /// Set Cbc Model
    103103  inline void setCbcModel(CbcModel * model)
    104   { cbcModel_=model;};
     104  { cbcModel_=model;}
    105105  /// Return Cbc Model
    106106  inline CbcModel * cbcModel() const
    107   { return cbcModel_;};
     107  { return cbcModel_;}
    108108  //@}
    109109 
  • trunk/Cbc/src/CbcFathomDynamicProgramming.hpp

    r702 r706  
    5656  /// Maximum size allowed
    5757  inline int maximumSize() const
    58   { return maximumSizeAllowed_;};
     58  { return maximumSizeAllowed_;}
    5959  inline void setMaximumSize(int value)
    60   { maximumSizeAllowed_=value;};
     60  { maximumSizeAllowed_=value;}
    6161  /// Returns type of algorithm and sets up arrays
    6262  int checkPossible(int allowableSize=0);
    6363  // set algorithm
    6464  inline void setAlgorithm(int value)
    65   { algorithm_=value;};
     65  { algorithm_=value;}
    6666  /** Tries a column
    6767      returns true if was used in making any changes.
     
    7272  /// Returns cost array
    7373  inline const float * cost() const
    74   { return cost_;};
     74  { return cost_;}
    7575  /// Returns back array
    7676  inline const int * back() const
    77   { return back_;};
     77  { return back_;}
    7878  /// Gets bit pattern for target result
    7979  inline int target() const
    80   { return target_;};
     80  { return target_;}
    8181  /// Sets bit pattern for target result
    8282  inline void setTarget(int value)
    83   { target_=value;};
     83  { target_=value;}
    8484private:
    8585  /// Does deleteions
  • trunk/Cbc/src/CbcFeasibilityBase.hpp

    r165 r706  
    2020public:
    2121  // Default Constructor
    22   CbcFeasibilityBase () {};
     22  CbcFeasibilityBase () {}
    2323
    2424  /**
     
    3131     1 pretend integer solution
    3232  */
    33   virtual int feasible(CbcModel * model, int mode) {return 0;};
     33  virtual int feasible(CbcModel * model, int mode) {return 0;}
    3434
    35   virtual ~CbcFeasibilityBase() {};
     35  virtual ~CbcFeasibilityBase() {}
    3636
    3737  // Copy constructor
    3838  CbcFeasibilityBase ( const CbcFeasibilityBase & rhs)
    39   {};
     39  {}
    4040   
    4141  // Assignment operator
     
    4343  { 
    4444    return *this;
    45   };
     45  }
    4646
    4747  /// Clone
    4848  virtual CbcFeasibilityBase * clone() const
    49   { return new CbcFeasibilityBase(*this);};
     49  { return new CbcFeasibilityBase(*this);}
    5050};
    5151#endif
  • trunk/Cbc/src/CbcGenCbcParam.hpp

    r640 r706  
    134134  /*! \brief Get the parameter code  */
    135135
    136   inline CbcCbcParamCode paramCode() const { return (paramCode_) ; } ;
     136  inline CbcCbcParamCode paramCode() const { return (paramCode_) ; }
    137137
    138138  /*! \brief Set the parameter code */
    139139
    140   inline void setParamCode(CbcCbcParamCode code) { paramCode_ = code ; } ;
     140  inline void setParamCode(CbcCbcParamCode code) { paramCode_ = code ; }
    141141
    142142  /*! \brief Get the underlying CbcModel object */
    143143
    144   inline CbcModel *obj() const { return (obj_) ; } ;
     144  inline CbcModel *obj() const { return (obj_) ; }
    145145
    146146  /*! \brief Set the underlying CbcModel object */
    147147
    148   inline void setObj(CbcModel *obj) { obj_ = obj ; } ;
     148  inline void setObj(CbcModel *obj) { obj_ = obj ; }
    149149
    150150//@}
  • trunk/Cbc/src/CbcGenCtlBlk.hpp

    r640 r706  
    226226  */
    227227
    228   inline int getCutDepth() { return cutDepth_ ; } ;
     228  inline int getCutDepth() { return cutDepth_ ; }
    229229
    230230  /*! \brief Set cut depth setting.
     
    233233  */
    234234
    235   inline void setCutDepth(int cutDepth) { cutDepth_ = cutDepth ; } ;
     235  inline void setCutDepth(int cutDepth) { cutDepth_ = cutDepth ; }
    236236
    237237  /*1 \brief Get action state for use of integer preprocessing */
    238238
    239   inline IPPControl getIPPAction() { return (preProcess_) ; } ;
     239  inline IPPControl getIPPAction() { return (preProcess_) ; }
    240240
    241241  /*! \brief Set action state for use of integer preprocessing */
    242242
    243243  inline void setIPPAction(IPPControl action)
    244   { preProcess_ = action ; } ;
     244  { preProcess_ = action ; }
    245245
    246246  /*! \brief Obtain a prototype for a probing cut generator. */
     
    251251
    252252  inline void setProbingAction(CGControl action)
    253   { probing_.action_ = action ; } ;
     253  { probing_.action_ = action ; }
    254254
    255255  /*! \brief Obtain a prototype for a clique cut generator. */
     
    260260
    261261  inline void setCliqueAction(CGControl action)
    262   { clique_.action_ = action ; } ;
     262  { clique_.action_ = action ; }
    263263
    264264  /*! \brief Obtain a prototype for a flow cover cut generator. */
     
    269269
    270270  inline void setFlowAction(CGControl action)
    271   { flow_.action_ = action ; } ;
     271  { flow_.action_ = action ; }
    272272
    273273  /*! \brief Obtain a prototype for a Gomory cut generator. */
     
    278278
    279279  inline void setGomoryAction(CGControl action)
    280   { gomory_.action_ = action ; } ;
     280  { gomory_.action_ = action ; }
    281281
    282282  /*! \brief Obtain a prototype for a knapsack cover cut generator. */
     
    287287
    288288  inline void setKnapsackAction(CGControl action)
    289   { knapsack_.action_ = action ; } ;
     289  { knapsack_.action_ = action ; }
    290290
    291291/*  \brief Obtain a prototype for a lift-and-project cut generator.
     
    296296
    297297  inline void setLandPAction(CGControl action)
    298   { landp_.action_ = action ; } ;
     298  { landp_.action_ = action ; }
    299299*/
    300300
     
    308308
    309309  inline void setMirAction(CGControl action)
    310   { mir_.action_ = action ; } ;
     310  { mir_.action_ = action ; }
    311311
    312312  /*! \brief Obtain a prototype for a reduce and split cut generator. */
     
    317317
    318318  inline void setRedSplitAction(CGControl action)
    319   { redSplit_.action_ = action ; } ;
     319  { redSplit_.action_ = action ; }
    320320
    321321  /*! \brief Obtain a prototype for a 2-MIR cut generator. */
     
    326326
    327327  inline void setTwomirAction(CGControl action)
    328   { twomir_.action_ = action ; } ;
     328  { twomir_.action_ = action ; }
    329329
    330330
     
    342342
    343343  inline void setFPumpAction(CGControl action)
    344   { fpump_.action_ = action ; } ;
     344  { fpump_.action_ = action ; }
    345345
    346346  /*! \brief Obtain a local search/combine heuristic.
     
    357357
    358358  inline void setCombineAction(CGControl action)
    359   { combine_.action_ = action ; } ;
     359  { combine_.action_ = action ; }
    360360
    361361  /*! \brief Obtain a greedy cover heuristic.
     
    372372
    373373  inline void setGreedyCoverAction(CGControl action)
    374   { greedyCover_.action_ = action ; } ;
     374  { greedyCover_.action_ = action ; }
    375375
    376376  /*! \brief Obtain a greedy equality heuristic.
     
    387387
    388388  inline void setGreedyEqualityAction(CGControl action)
    389   { greedyEquality_.action_ = action ; } ;
     389  { greedyEquality_.action_ = action ; }
    390390
    391391  /*! \brief Obtain a simple rounding heuristic.
     
    402402
    403403  inline void setRoundingAction(CGControl action)
    404   { rounding_.action_ = action ; } ;
     404  { rounding_.action_ = action ; }
    405405
    406406  /*! \brief Obtain a local search tree object
     
    417417
    418418  inline void setTreeLocalAction(CGControl action)
    419   { localTree_.action_ = action ; } ;
     419  { localTree_.action_ = action ; }
    420420
    421421//@}
     
    488488
    489489  /*! \brief Return a pointer to the message handler */
    490   inline CoinMessageHandler *messageHandler() const { return msgHandler_ ; } ;
     490  inline CoinMessageHandler *messageHandler() const { return msgHandler_ ; }
    491491
    492492  /*! \brief Set up messages in the specified language.
     
    507507  inline void setLogLevel(int lvl)
    508508  { logLvl_ = lvl ;
    509     if (msgHandler_) msgHandler_->setLogLevel(lvl) ; } ;
     509    if (msgHandler_) msgHandler_->setLogLevel(lvl) ; }
    510510
    511511  /*! \brief Get log level */
    512   inline int logLevel() const { return (logLvl_) ; } ;
     512  inline int logLevel() const { return (logLvl_) ; }
    513513
    514514  /*! \brief When greater than 0, integer presolve gives more information and
  • trunk/Cbc/src/CbcGenOsiParam.hpp

    r640 r706  
    136136  /*! \brief Get the parameter code  */
    137137
    138   inline CbcOsiParamCode paramCode() const { return (paramCode_) ; } ;
     138  inline CbcOsiParamCode paramCode() const { return (paramCode_) ; }
    139139
    140140  /*! \brief Set the parameter code */
    141141
    142   inline void setParamCode(CbcOsiParamCode code) { paramCode_ = code ; } ;
     142  inline void setParamCode(CbcOsiParamCode code) { paramCode_ = code ; }
    143143
    144144  /*! \brief Get the underlying OsiSolverInterface object */
    145145
    146   inline OsiSolverInterface *obj() const { return (obj_) ; } ;
     146  inline OsiSolverInterface *obj() const { return (obj_) ; }
    147147
    148148  /*! \brief Set the underlying OsiSolverInterace object */
    149149
    150   inline void setObj(OsiSolverInterface *obj) { obj_ = obj ; } ;
     150  inline void setObj(OsiSolverInterface *obj) { obj_ = obj ; }
    151151
    152152//@}
  • trunk/Cbc/src/CbcGenParam.hpp

    r640 r706  
    143143  /*! \brief Get the parameter code  */
    144144
    145   inline CbcGenParamCode paramCode() const { return (paramCode_) ; } ;
     145  inline CbcGenParamCode paramCode() const { return (paramCode_) ; }
    146146
    147147  /*! \brief Set the parameter code */
    148148
    149   inline void setParamCode(CbcGenParamCode code) { paramCode_ = code ; } ;
     149  inline void setParamCode(CbcGenParamCode code) { paramCode_ = code ; }
    150150
    151151  /*! \brief Get the underlying cbc-generic control object */
    152152
    153   inline CbcGenCtlBlk *obj() const { return (obj_) ; } ;
     153  inline CbcGenCtlBlk *obj() const { return (obj_) ; }
    154154
    155155  /*! \brief Set the underlying cbc-generic control object */
    156156
    157   inline void setObj(CbcGenCtlBlk *obj) { obj_ = obj ; } ;
     157  inline void setObj(CbcGenCtlBlk *obj) { obj_ = obj ; }
    158158
    159159//@}
  • trunk/Cbc/src/CbcHeuristic.hpp

    r687 r706  
    5858  virtual int solution(double & objectiveValue,
    5959                       double * newSolution,
    60                        OsiCuts & cs) {return 0;};
     60                       OsiCuts & cs) {return 0;}
    6161
    6262  /// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
    63   virtual void validate() {};
     63  virtual void validate() {}
    6464
    6565  /** Sets "when" flag - 0 off, 1 at root, 2 other than root, 3 always.
     
    6868  */
    6969  inline void setWhen(int value)
    70   { when_=value;};
     70  { when_=value;}
    7171  /// Gets "when" flag - 0 off, 1 at root, 2 other than root, 3 always
    7272  inline int when() const
    73   { return when_;};
     73  { return when_;}
    7474
    7575  /// Sets number of nodes in subtree (default 200)
    7676  inline void setNumberNodes(int value)
    77   { numberNodes_=value;};
     77  { numberNodes_=value;}
    7878  /// Gets number of nodes in a subtree (default 200)
    7979  inline int numberNodes() const
    80   { return numberNodes_;};
     80  { return numberNodes_;}
    8181  /// Just set model - do not do anything else
    8282  inline void setModelOnly(CbcModel * model)
    83   { model_ = model;};
     83  { model_ = model;}
    8484 
    8585
    8686  /// Sets fraction of new(rows+columns)/old(rows+columns) before doing small branch and bound (default 1.0)
    8787  inline void setFractionSmall(double value)
    88   { fractionSmall_=value;};
     88  { fractionSmall_=value;}
    8989  /// Gets fraction of new(rows+columns)/old(rows+columns) before doing small branch and bound (default 1.0)
    9090  inline double fractionSmall() const
    91   { return fractionSmall_;};
     91  { return fractionSmall_;}
    9292
    9393  /** Do mini branch and bound - return
     
    102102                          double cutoff , std::string name) const;
    103103  /// Create C++ lines to get to current state
    104   virtual void generateCpp( FILE * fp) {};
     104  virtual void generateCpp( FILE * fp) {}
    105105  /// Create C++ lines to get to current state - does work for base class
    106106  void generateCpp( FILE * fp,const char * heuristic) ;
    107107  /// Returns true if can deal with "odd" problems e.g. sos type 2
    108108  virtual bool canDealWithOdd() const
    109   { return false;};
     109  { return false;}
    110110  /// return name of heuristic
    111111  inline const char *heuristicName() const
    112   { return heuristicName_.c_str();};
     112  { return heuristicName_.c_str();}
    113113  /// set name of heuristic
    114114  inline void setHeuristicName(const char *name)
    115   { heuristicName_ = name;};
     115  { heuristicName_ = name;}
    116116
    117117protected:
     
    174174  /// Set seed
    175175  void setSeed(int value)
    176   { seed_ = value;};
     176  { seed_ = value;}
    177177
    178178protected:
  • trunk/Cbc/src/CbcHeuristicFPump.hpp

    r687 r706  
    6060  /// Get maximum Time (default 0.0 == time limit off)
    6161  inline double maximumTime() const
    62   { return maximumTime_;};
     62  { return maximumTime_;}
    6363  /// Set fake cutoff (default COIN_DBL_MAX == off)
    6464  inline void setFakeCutoff(double value)
    65   { fakeCutoff_ = value;};
     65  { fakeCutoff_ = value;}
    6666  /// Get fake cutoff (default 0.0 == off)
    6767  inline double fakeCutoff() const
    68   { return fakeCutoff_;};
     68  { return fakeCutoff_;}
    6969  /// Set absolute increment (default 0.0 == off)
    7070  inline void setAbsoluteIncrement(double value)
    71   { absoluteIncrement_ = value;};
     71  { absoluteIncrement_ = value;}
    7272  /// Get absolute increment (default 0.0 == off)
    7373  inline double absoluteIncrement() const
    74   { return absoluteIncrement_;};
     74  { return absoluteIncrement_;}
    7575  /// Set relative increment (default 0.0 == off)
    7676  inline void setRelativeIncrement(double value)
    77   { relativeIncrement_ = value;};
     77  { relativeIncrement_ = value;}
    7878  /// Get relative increment (default 0.0 == off)
    7979  inline double relativeIncrement() const
    80   { return relativeIncrement_;};
     80  { return relativeIncrement_;}
    8181  /// Set default rounding (default 0.5)
    8282  inline void setDefaultRounding(double value)
    83   { defaultRounding_ = value;};
     83  { defaultRounding_ = value;}
    8484  /// Get default rounding (default 0.5)
    8585  inline double defaultRounding() const
    86   { return defaultRounding_;};
     86  { return defaultRounding_;}
    8787  /// Set initial weight (default 0.0 == off)
    8888  inline void setInitialWeight(double value)
    89   { initialWeight_ = value;};
     89  { initialWeight_ = value;}
    9090  /// Get initial weight (default 0.0 == off)
    9191  inline double initialWeight() const
    92   { return initialWeight_;};
     92  { return initialWeight_;}
    9393  /// Set weight factor (default 0.1)
    9494  inline void setWeightFactor(double value)
    95   { weightFactor_ = value;};
     95  { weightFactor_ = value;}
    9696  /// Get weight factor (default 0.1)
    9797  inline double weightFactor() const
    98   { return weightFactor_;};
     98  { return weightFactor_;}
    9999  /// Set maximum passes (default 100)
    100100  inline void setMaximumPasses(int value)
    101   { maximumPasses_=value;};
     101  { maximumPasses_=value;}
    102102  /// Get maximum passes (default 100)
    103103  inline int maximumPasses() const
    104   { return maximumPasses_;};
     104  { return maximumPasses_;}
    105105  /// Set maximum retries (default 1)
    106106  inline void setMaximumRetries(int value)
    107   { maximumRetries_=value;};
     107  { maximumRetries_=value;}
    108108  /// Get maximum retries (default 1)
    109109  inline int maximumRetries() const
    110   { return maximumRetries_;};
     110  { return maximumRetries_;}
    111111  /**  Set use of multiple solutions and solves
    112112       0 - do not reuse solves, do not accumulate integer solutions for local search
     
    116116  */
    117117  inline void setAccumulate(int value)
    118   { accumulate_=value;};
     118  { accumulate_=value;}
    119119  /// Get accumulation option
    120120  inline int accumulate() const
    121   { return accumulate_;};
     121  { return accumulate_;}
    122122
    123123protected:
  • trunk/Cbc/src/CbcHeuristicGreedy.hpp

    r640 r706  
    5858  */
    5959  inline int algorithm() const
    60   { return algorithm_; };
     60  { return algorithm_; }
    6161  inline void setAlgorithm(int value)
    62   { algorithm_=value; };
     62  { algorithm_=value; }
    6363  // Only do this many times
    6464  inline int numberTimes() const
    65   { return numberTimes_; };
     65  { return numberTimes_; }
    6666  inline void setNumberTimes(int value)
    67   { numberTimes_=value; };
     67  { numberTimes_=value; }
    6868
    6969protected:
     
    136136  */
    137137  inline int algorithm() const
    138   { return algorithm_; };
     138  { return algorithm_; }
    139139  inline void setAlgorithm(int value)
    140   { algorithm_=value; };
     140  { algorithm_=value; }
    141141  // Fraction of rhs to cover before branch and cut
    142142  inline void setFraction(double value)
    143   { fraction_ = value;};
     143  { fraction_ = value;}
    144144  inline double fraction() const
    145   { return fraction_;};
     145  { return fraction_;}
    146146  // Only do this many times
    147147  inline int numberTimes() const
    148   { return numberTimes_; };
     148  { return numberTimes_; }
    149149  inline void setNumberTimes(int value)
    150   { numberTimes_=value; };
     150  { numberTimes_=value; }
    151151protected:
    152152  // Data
  • trunk/Cbc/src/CbcHeuristicLocal.hpp

    r640 r706  
    6060  /// Sets type of search
    6161  inline void setSearchType(int value)
    62   { swap_=value;};
     62  { swap_=value;}
    6363  /// Used array so we can set
    6464  inline char * used() const
    65   { return used_;};
     65  { return used_;}
    6666
    6767protected:
  • trunk/Cbc/src/CbcHeuristicRINS.hpp

    r640 r706  
    5454  /// Sets how often to do it
    5555  inline void setHowOften(int value)
    56   { howOften_=value;};
     56  { howOften_=value;}
    5757  /// Used array so we can set
    5858  inline char * used() const
    59   { return used_;};
     59  { return used_;}
    6060
    6161protected:
  • trunk/Cbc/src/CbcLinked.hpp

    r700 r706  
    118118  /// Objective value of best solution found internally
    119119  inline double bestObjectiveValue() const
    120   { return bestObjectiveValue_;};
     120  { return bestObjectiveValue_;}
    121121  /// Set objective value of best solution found internally
    122122  inline void setBestObjectiveValue(double value)
    123   { bestObjectiveValue_ = value;};
     123  { bestObjectiveValue_ = value;}
    124124  /// Best solution found internally
    125125  inline const double * bestSolution() const
    126   { return bestSolution_;};
     126  { return bestSolution_;}
    127127  /// Set best solution found internally
    128128  void setBestSolution(const double * solution, int numberColumns);
    129129  /// Set special options
    130130  inline void setSpecialOptions2(int value)
    131   { specialOptions2_=value;};
     131  { specialOptions2_=value;}
    132132  /// Say convex (should work it out) - if convex false then strictly concave
    133133  void sayConvex(bool convex);
    134134  /// Get special options
    135135  inline int specialOptions2() const
    136   { return specialOptions2_;};
     136  { return specialOptions2_;}
    137137  /** Clean copy of matrix
    138138      So we can add rows
    139139  */
    140140  CoinPackedMatrix * cleanMatrix() const
    141   { return matrix_;};
     141  { return matrix_;}
    142142  /** Row copy of matrix
    143143      Just genuine columns and rows
     
    145145  */
    146146  CoinPackedMatrix * originalRowCopy() const
    147   { return originalRowCopy_;};
     147  { return originalRowCopy_;}
    148148  /// Copy of quadratic model if one
    149149  ClpSimplex * quadraticModel() const
    150   { return quadraticModel_;};
     150  { return quadraticModel_;}
    151151  /// Gets correct form for a quadratic row - user to delete
    152152  CoinPackedMatrix * quadraticRow(int rowNumber,double * linear) const;
    153153  /// Default meshSize
    154154  inline double defaultMeshSize() const
    155   { return defaultMeshSize_;};
     155  { return defaultMeshSize_;}
    156156  inline void setDefaultMeshSize(double value)
    157   { defaultMeshSize_=value;};
     157  { defaultMeshSize_=value;}
    158158  /// Default maximumbound
    159159  inline double defaultBound() const
    160   { return defaultBound_;};
     160  { return defaultBound_;}
    161161  inline void setDefaultBound(double value)
    162   { defaultBound_=value;};
     162  { defaultBound_=value;}
    163163  /// Set integer priority
    164164  inline void setIntegerPriority(int value)
    165   { integerPriority_=value;};
     165  { integerPriority_=value;}
    166166  /// Get integer priority
    167167  inline int integerPriority() const
    168   { return integerPriority_;};
     168  { return integerPriority_;}
    169169  /// Objective transfer variable if one
    170170  inline int objectiveVariable() const
     
    172172  /// Set biLinear priority
    173173  inline void setBiLinearPriority(int value)
    174   { biLinearPriority_=value;};
     174  { biLinearPriority_=value;}
    175175  /// Get biLinear priority
    176176  inline int biLinearPriority() const
    177   { return biLinearPriority_;};
     177  { return biLinearPriority_;}
    178178  /// Return CoinModel
    179179  inline const CoinModel * coinModel() const
    180   { return &coinModel_;};
     180  { return &coinModel_;}
    181181  /// Set all biLinear priorities on x-x variables
    182182  void setBiLinearPriorities(int value, double meshSize=1.0);
     
    312312  /// Get variable
    313313  inline int variable() const
    314   { return variable_;};
     314  { return variable_;}
    315315  /// Add a bound modifier
    316316  void addBoundModifier(bool upperBoundAffected, bool useUpperBound, int whichVariable,
     
    393393  /// Returns true if can deal with "odd" problems e.g. sos type 2
    394394  virtual bool canDealWithOdd() const
    395   { return true;};
     395  { return true;}
    396396 
    397397protected:
     
    467467  /// Number of links for each member
    468468  inline int numberLinks() const
    469   {return numberLinks_;};
     469  {return numberLinks_;}
    470470
    471471  /** \brief Return true if object can take part in normal heuristics
    472472  */
    473473  virtual bool canDoHeuristics() const
    474   {return false;};
     474  {return false;}
    475475  /** \brief Return true if branch should only bound variables
    476476  */
    477477  virtual bool boundBranch() const
    478   {return false;};
     478  {return false;}
    479479
    480480private:
     
    613613  /// Number of links for each member
    614614  inline int numberLinks() const
    615   {return numberLinks_;};
     615  {return numberLinks_;}
    616616
    617617  /** \brief Return true if object can take part in normal heuristics
    618618  */
    619619  virtual bool canDoHeuristics() const
    620   {return false;};
     620  {return false;}
    621621  /** \brief Return true if branch should only bound variables
    622622  */
    623623  virtual bool boundBranch() const
    624   {return false;};
     624  {return false;}
    625625
    626626private:
     
    744744  */
    745745  virtual bool canDoHeuristics() const
    746   {return false;};
     746  {return false;}
    747747  /** \brief Return true if branch should only bound variables
    748748  */
    749749  virtual bool boundBranch() const
    750   { return (branchingStrategy_&4)!=0;};
     750  { return (branchingStrategy_&4)!=0;}
    751751  /// X column
    752752  inline int xColumn() const
    753   { return xColumn_;};
     753  { return xColumn_;}
    754754  /// Y column
    755755  inline int yColumn() const
    756   { return yColumn_;};
     756  { return yColumn_;}
    757757  /// X row
    758758  inline int xRow() const
    759   { return xRow_;};
     759  { return xRow_;}
    760760  /// Y row
    761761  inline int yRow() const
    762   { return yRow_;};
     762  { return yRow_;}
    763763  /// XY row
    764764  inline int xyRow() const
    765   { return xyRow_;};
     765  { return xyRow_;}
    766766  /// Coefficient
    767767  inline double coefficient() const
    768   { return coefficient_;};
     768  { return coefficient_;}
    769769  /// Set coefficient
    770770  inline void setCoefficient(double value)
    771   { coefficient_ = value;};
     771  { coefficient_ = value;}
    772772  /// First lambda (of 4)
    773773  inline int firstLambda() const
    774   { return firstLambda_;};
     774  { return firstLambda_;}
    775775  /// X satisfied if less than this away from mesh
    776776  inline double xSatisfied() const
    777   { return xSatisfied_;};
     777  { return xSatisfied_;}
    778778  inline void setXSatisfied(double value)
    779   { xSatisfied_=value;};
     779  { xSatisfied_=value;}
    780780  /// Y satisfied if less than this away from mesh
    781781  inline double ySatisfied() const
    782   { return ySatisfied_;};
     782  { return ySatisfied_;}
    783783  inline void setYSatisfied(double value)
    784   { ySatisfied_=value;};
     784  { ySatisfied_=value;}
    785785  /// X other satisfied if less than this away from mesh
    786786  inline double xOtherSatisfied() const
    787   { return xOtherSatisfied_;};
     787  { return xOtherSatisfied_;}
    788788  inline void setXOtherSatisfied(double value)
    789   { xOtherSatisfied_=value;};
     789  { xOtherSatisfied_=value;}
    790790  /// Y other satisfied if less than this away from mesh
    791791  inline double yOtherSatisfied() const
    792   { return yOtherSatisfied_;};
     792  { return yOtherSatisfied_;}
    793793  inline void setYOtherSatisfied(double value)
    794   { yOtherSatisfied_=value;};
     794  { yOtherSatisfied_=value;}
    795795  /// X meshSize
    796796  inline double xMeshSize() const
    797   { return xMeshSize_;};
     797  { return xMeshSize_;}
    798798  inline void setXMeshSize(double value)
    799   { xMeshSize_=value;};
     799  { xMeshSize_=value;}
    800800  /// Y meshSize
    801801  inline double yMeshSize() const
    802   { return yMeshSize_;};
     802  { return yMeshSize_;}
    803803  inline void setYMeshSize(double value)
    804   { yMeshSize_=value;};
     804  { yMeshSize_=value;}
    805805  /// XY satisfied if two version differ by less than this
    806806  inline double xySatisfied() const
    807   { return xySatisfied_;};
     807  { return xySatisfied_;}
    808808  inline void setXYSatisfied(double value)
    809   { xySatisfied_=value;};
     809  { xySatisfied_=value;}
    810810  /** branching strategy etc
    811811      bottom 2 bits
     
    819819  */
    820820  inline int branchingStrategy() const
    821   { return branchingStrategy_;};
     821  { return branchingStrategy_;}
    822822  inline void setBranchingStrategy(int value)
    823   { branchingStrategy_=value;};
     823  { branchingStrategy_=value;}
    824824  /** Simple quadratic bound marker.
    825825      0 no
     
    830830  */
    831831  inline int boundType() const
    832   { return boundType_;};
     832  { return boundType_;}
    833833  inline void setBoundType(int value)
    834   { boundType_ = value;};
     834  { boundType_ = value;}
    835835  /// Does work of branching
    836836  void newBounds(OsiSolverInterface * solver, int way, short xOrY, double separator) const;
     
    10021002  /// Number of points
    10031003  inline int numberPoints() const
    1004   { return numberPoints_;};
     1004  { return numberPoints_;}
    10051005  inline void setNumberPoints(int value)
    1006   { numberPoints_ = value;};
     1006  { numberPoints_ = value;}
    10071007
    10081008private:
     
    11641164  /// Number of objects to use
    11651165  inline int numberObjectsToUse() const
    1166   { return numberObjectsToUse_;};
     1166  { return numberObjectsToUse_;}
    11671167  /// Set number of objects to use
    11681168  inline void setNumberObjectsToUse(int value)
    1169   { numberObjectsToUse_ = value;};
     1169  { numberObjectsToUse_ = value;}
    11701170
    11711171protected:
     
    12691269  /// Objective value of best solution found internally
    12701270  inline double bestObjectiveValue() const
    1271   { return bestObjectiveValue_;};
     1271  { return bestObjectiveValue_;}
    12721272  /// Best solution found internally
    12731273  const double * bestSolution() const
    1274   { return bestSolution_;};
     1274  { return bestSolution_;}
    12751275  /// Set special options
    12761276  inline void setSpecialOptions3(int value)
    1277   { specialOptions3_=value;};
     1277  { specialOptions3_=value;}
    12781278  /// Get special options
    12791279  inline int specialOptions3() const
    1280   { return specialOptions3_;};
     1280  { return specialOptions3_;}
    12811281  /// Copy of quadratic model if one
    12821282  ClpSimplex * quadraticModel() const
    1283   { return quadraticModel_;};
     1283  { return quadraticModel_;}
    12841284  //@}
    12851285 
  • trunk/Cbc/src/CbcModel.hpp

    r696 r706  
    293293  void unlockThread();
    294294#else
    295   inline void lockThread() {};
    296   inline void unlockThread() {};
     295  inline void lockThread() {}
     296  inline void unlockThread() {}
    297297#endif
    298298private:
     
    409409
    410410  /// Get the number of objects
    411   inline int numberObjects() const { return numberObjects_;};
     411  inline int numberObjects() const { return numberObjects_;}
    412412  /// Set the number of objects
    413413  inline void setNumberObjects(int number)
    414   {  numberObjects_=number;};
     414  {  numberObjects_=number;}
    415415
    416416  /// Get the array of objects
    417   inline OsiObject ** objects() const { return object_;};
     417  inline OsiObject ** objects() const { return object_;}
    418418
    419419  /// Get the specified object
    420   const inline OsiObject * object(int which) const { return object_[which];};
     420  const inline OsiObject * object(int which) const { return object_[which];}
    421421  /// Get the specified object
    422   inline OsiObject * modifiableObject(int which) const { return object_[which];};
     422  inline OsiObject * modifiableObject(int which) const { return object_[which];}
    423423
    424424  /// Delete all object information (and just back to integers if true)
     
    632632  /// Set the minimum drop to continue cuts
    633633  inline void setMinimumDrop(double value)
    634   {minimumDrop_=value;};
     634  {minimumDrop_=value;}
    635635  /// Get the minimum drop to continue cuts
    636636  inline double getMinimumDrop() const
    637   { return minimumDrop_;};
     637  { return minimumDrop_;}
    638638
    639639  /** Set the maximum number of cut passes at root node (default 20)
    640640      Minimum drop can also be used for fine tuning */
    641641  inline void setMaximumCutPassesAtRoot(int value)
    642   {maximumCutPassesAtRoot_=value;};
     642  {maximumCutPassesAtRoot_=value;}
    643643  /** Get the maximum number of cut passes at root node */
    644644  inline int getMaximumCutPassesAtRoot() const
    645   { return maximumCutPassesAtRoot_;};
     645  { return maximumCutPassesAtRoot_;}
    646646
    647647  /** Set the maximum number of cut passes at other nodes (default 10)
    648648      Minimum drop can also be used for fine tuning */
    649649  inline void setMaximumCutPasses(int value)
    650   {maximumCutPasses_=value;};
     650  {maximumCutPasses_=value;}
    651651  /** Get the maximum number of cut passes at other nodes (default 10) */
    652652  inline int getMaximumCutPasses() const
    653   { return maximumCutPasses_;};
     653  { return maximumCutPasses_;}
    654654  /** Get current cut pass number in this round of cuts.
    655655      (1 is first pass) */
    656656  inline int getCurrentPassNumber() const
    657   { return currentPassNumber_;};
     657  { return currentPassNumber_;}
    658658
    659659  /** Set the maximum number of candidates to be evaluated for strong
     
    667667  */
    668668  inline int numberStrong() const
    669   { return numberStrong_;};
     669  { return numberStrong_;}
    670670  /** Set global preferred way to branch
    671671      -1 down, +1 up, 0 no preference */
    672672  inline void setPreferredWay(int value)
    673   {preferredWay_=value;};
     673  {preferredWay_=value;}
    674674  /** Get the preferred way to branch (default 0) */
    675675  inline int getPreferredWay() const
    676   { return preferredWay_;};
     676  { return preferredWay_;}
    677677  /** Set size of mini - tree.  If > 1 then does total enumeration of
    678678      tree given by this best variables to branch on
    679679  */
    680680  inline void setSizeMiniTree(int value)
    681   { sizeMiniTree_=value;};
     681  { sizeMiniTree_=value;}
    682682  inline int sizeMiniTree() const
    683   { return sizeMiniTree_;};
     683  { return sizeMiniTree_;}
    684684
    685685  /** Set the number of branches before pseudo costs believed
     
    692692      in dynamic strong branching. */
    693693  inline int numberBeforeTrust() const
    694   { return numberBeforeTrust_;};
     694  { return numberBeforeTrust_;}
    695695  /** Set the number of variables for which to compute penalties
    696696      in dynamic strong branching.
     
    702702      in dynamic strong branching. */
    703703  inline int numberPenalties() const
    704   { return numberPenalties_;};
     704  { return numberPenalties_;}
    705705  /// Number of analyze iterations to do
    706706  inline void setNumberAnalyzeIterations(int number)
    707   { numberAnalyzeIterations_=number;};
     707  { numberAnalyzeIterations_=number;}
    708708  inline int numberAnalyzeIterations() const
    709   { return numberAnalyzeIterations_;};
     709  { return numberAnalyzeIterations_;}
    710710  /** Get scale factor to make penalties match strong.
    711711      Should/will be computed */
    712712  inline double penaltyScaleFactor() const
    713   { return penaltyScaleFactor_;};
     713  { return penaltyScaleFactor_;}
    714714  /** Set scale factor to make penalties match strong.
    715715      Should/will be computed */
     
    723723  */
    724724  void inline setProblemType(int number)
    725   { problemType_=number;};
     725  { problemType_=number;}
    726726  inline int problemType() const
    727   { return problemType_;};
     727  { return problemType_;}
    728728
    729729  /// Set how often to scan global cuts
     
    731731  /// Get how often to scan global cuts
    732732  inline int howOftenGlobalScan() const
    733   { return howOftenGlobalScan_;};
     733  { return howOftenGlobalScan_;}
    734734  /// Original columns as created by integerPresolve
    735735  inline int * originalColumns() const
    736   { return originalColumns_;};
     736  { return originalColumns_;}
    737737
    738738  /** Set the print frequency.
     
    744744  */
    745745  inline void setPrintFrequency(int number)
    746   { printFrequency_=number;};
     746  { printFrequency_=number;}
    747747  /// Get the print frequency
    748748  inline int printFrequency() const
    749   { return printFrequency_;};
     749  { return printFrequency_;}
    750750  //@}
    751751
     
    771771    /// Get how many iterations it took to solve the problem.
    772772    inline int getIterationCount() const
    773     { return numberIterations_;};
     773    { return numberIterations_;}
    774774    /// Get how many Nodes it took to solve the problem.
    775775    inline int getNodeCount() const
    776     { return numberNodes_;};
     776    { return numberNodes_;}
    777777    /** Final status of problem
    778778        Some of these can be found out by is...... functions
     
    785785    */
    786786    inline int status() const
    787     { return status_;};
     787    { return status_;}
    788788    inline void setProblemStatus(int value)
    789     { status_=value;};
     789    { status_=value;}
    790790    /** Secondary status of problem
    791791        -1 unset (status_ will also be -1)
     
    800800    */
    801801    inline int secondaryStatus() const
    802     { return secondaryStatus_;};
     802    { return secondaryStatus_;}
    803803    inline void setSecondaryStatus(int value)
    804     { secondaryStatus_=value;};
     804    { secondaryStatus_=value;}
    805805    /// Are there numerical difficulties (for initialSolve) ?
    806806    bool isInitialSolveAbandoned() const ;
     
    829829  /// Number of rows in continuous (root) problem.
    830830  inline int numberRowsAtContinuous() const
    831   { return numberRowsAtContinuous_;};
     831  { return numberRowsAtContinuous_;}
    832832
    833833  /// Get number of columns
    834834  inline int getNumCols() const
    835   { return solver_->getNumCols();};
     835  { return solver_->getNumCols();}
    836836 
    837837  /// Get number of rows
    838838  inline int getNumRows() const
    839   { return solver_->getNumRows();};
     839  { return solver_->getNumRows();}
    840840 
    841841  /// Get number of nonzero elements
    842842  inline CoinBigIndex getNumElements() const
    843   { return solver_->getNumElements();};
     843  { return solver_->getNumElements();}
    844844
    845845  /// Number of integers in problem
    846846  inline int numberIntegers() const
    847   { return numberIntegers_;};
     847  { return numberIntegers_;}
    848848  // Integer variables
    849849  inline const int * integerVariable() const
    850   { return integerVariable_;};
     850  { return integerVariable_;}
    851851  /// Whether or not integer
    852852  inline const char integerType(int i) const
    853   { return integerInfo_[i];};
     853  { return integerInfo_[i];}
    854854  /// Whether or not integer
    855855  inline const char * integerType() const
    856   { return integerInfo_;};
     856  { return integerInfo_;}
    857857
    858858  /// Get pointer to array[getNumCols()] of column lower bounds
    859859  inline const double * getColLower() const
    860   { return solver_->getColLower();};
     860  { return solver_->getColLower();}
    861861 
    862862  /// Get pointer to array[getNumCols()] of column upper bounds
    863863  inline const double * getColUpper() const
    864   { return solver_->getColUpper();};
     864  { return solver_->getColUpper();}
    865865 
    866866  /** Get pointer to array[getNumRows()] of row constraint senses.
     
    874874  */
    875875  inline const char * getRowSense() const
    876   { return solver_->getRowSense();};
     876  { return solver_->getRowSense();}
    877877 
    878878  /** Get pointer to array[getNumRows()] of rows right-hand sides
     
    885885  */
    886886  inline const double * getRightHandSide() const
    887   { return solver_->getRightHandSide();};
     887  { return solver_->getRightHandSide();}
    888888 
    889889  /** Get pointer to array[getNumRows()] of row ranges.
     
    896896  */
    897897  inline const double * getRowRange() const
    898   { return solver_->getRowRange();};
     898  { return solver_->getRowRange();}
    899899 
    900900  /// Get pointer to array[getNumRows()] of row lower bounds
    901901  inline const double * getRowLower() const
    902   { return solver_->getRowLower();};
     902  { return solver_->getRowLower();}
    903903 
    904904  /// Get pointer to array[getNumRows()] of row upper bounds
    905905  inline const double * getRowUpper() const
    906   { return solver_->getRowUpper();};
     906  { return solver_->getRowUpper();}
    907907 
    908908  /// Get pointer to array[getNumCols()] of objective function coefficients
    909909  inline const double * getObjCoefficients() const
    910   { return solver_->getObjCoefficients();};
     910  { return solver_->getObjCoefficients();}
    911911 
    912912  /// Get objective function sense (1 for min (default), -1 for max)
     
    914914  {
    915915    //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense());
    916     return dblParam_[CbcOptimizationDirection];};
     916    return dblParam_[CbcOptimizationDirection];}
    917917 
    918918  /// Return true if variable is continuous
    919919  inline bool isContinuous(int colIndex) const
    920   { return solver_->isContinuous(colIndex);};
     920  { return solver_->isContinuous(colIndex);}
    921921 
    922922  /// Return true if variable is binary
    923923  inline bool isBinary(int colIndex) const
    924   { return solver_->isBinary(colIndex);};
     924  { return solver_->isBinary(colIndex);}
    925925 
    926926  /** Return true if column is integer.
     
    929929  */
    930930  inline bool isInteger(int colIndex) const
    931   { return solver_->isInteger(colIndex);};
     931  { return solver_->isInteger(colIndex);}
    932932 
    933933  /// Return true if variable is general integer
    934934  inline bool isIntegerNonBinary(int colIndex) const
    935   { return solver_->isIntegerNonBinary(colIndex);};
     935  { return solver_->isIntegerNonBinary(colIndex);}
    936936 
    937937  /// Return true if variable is binary and not fixed at either bound
    938938  inline bool isFreeBinary(int colIndex) const
    939   { return solver_->isFreeBinary(colIndex) ;};
     939  { return solver_->isFreeBinary(colIndex) ;}
    940940 
    941941  /// Get pointer to row-wise copy of matrix
    942942  inline const CoinPackedMatrix * getMatrixByRow() const
    943   { return solver_->getMatrixByRow();};
     943  { return solver_->getMatrixByRow();}
    944944 
    945945  /// Get pointer to column-wise copy of matrix
    946946  inline const CoinPackedMatrix * getMatrixByCol() const
    947   { return solver_->getMatrixByCol();};
     947  { return solver_->getMatrixByCol();}
    948948 
    949949  /// Get solver's value for infinity
    950950  inline double getInfinity() const
    951   { return solver_->getInfinity();};
     951  { return solver_->getInfinity();}
    952952  /// Get pointer to array[getNumCols()] (for speed) of column lower bounds
    953953  inline const double * getCbcColLower() const
    954   { return cbcColLower_;};
     954  { return cbcColLower_;}
    955955  /// Get pointer to array[getNumCols()] (for speed) of column upper bounds
    956956  inline const double * getCbcColUpper() const
    957   { return cbcColUpper_;};
     957  { return cbcColUpper_;}
    958958  /// Get pointer to array[getNumRows()] (for speed) of row lower bounds
    959959  inline const double * getCbcRowLower() const
    960   { return cbcRowLower_;};
     960  { return cbcRowLower_;}
    961961  /// Get pointer to array[getNumRows()] (for speed) of row upper bounds
    962962  inline const double * getCbcRowUpper() const
    963   { return cbcRowUpper_;};
     963  { return cbcRowUpper_;}
    964964  /// Get pointer to array[getNumCols()] (for speed) of primal solution vector
    965965  inline const double * getCbcColSolution() const
    966   { return cbcColSolution_;};
     966  { return cbcColSolution_;}
    967967  /// Get pointer to array[getNumRows()] (for speed) of dual prices
    968968  inline const double * getCbcRowPrice() const
    969   { return cbcRowPrice_;};
     969  { return cbcRowPrice_;}
    970970  /// Get a pointer to array[getNumCols()] (for speed) of reduced costs
    971971  inline const double * getCbcReducedCost() const
    972   { return cbcReducedCost_;};
     972  { return cbcReducedCost_;}
    973973  /// Get pointer to array[getNumRows()] (for speed) of row activity levels.
    974974  inline const double * getCbcRowActivity() const
    975   { return cbcRowActivity_;};
     975  { return cbcRowActivity_;}
    976976  //@}
    977977 
     
    981981  /// Holds solution at continuous (after cuts if branchAndBound called)
    982982  inline double * continuousSolution() const
    983   { return continuousSolution_;};
     983  { return continuousSolution_;}
    984984  /** Array marked whenever a solution is found if non-zero.
    985985      Code marks if heuristic returns better so heuristic
     
    987987      are worse than current */
    988988  inline int * usedInSolution() const
    989   { return usedInSolution_;};
     989  { return usedInSolution_;}
    990990  /// Increases usedInSolution for nonzeros
    991991  void incrementUsed(const double * solution);
     
    10201020   
    10211021  inline double * currentSolution() const
    1022   { return currentSolution_;};
     1022  { return currentSolution_;}
    10231023  /** For testing infeasibilities - will point to
    10241024      currentSolution_ or solver-->getColSolution()
    10251025  */
    10261026  inline const double * testSolution() const
    1027   { return testSolution_;};
     1027  { return testSolution_;}
    10281028  inline void setTestSolution(const double * solution)
    1029   { testSolution_ = solution;};
     1029  { testSolution_ = solution;}
    10301030  /// Make sure region there and optionally copy solution
    10311031  void reserveCurrentSolution(const double * solution=NULL);
     
    10331033  /// Get pointer to array[getNumCols()] of primal solution vector
    10341034  inline const double * getColSolution() const
    1035   { return solver_->getColSolution();};
     1035  { return solver_->getColSolution();}
    10361036 
    10371037  /// Get pointer to array[getNumRows()] of dual prices
    10381038  inline const double * getRowPrice() const
    1039   { return solver_->getRowPrice();};
     1039  { return solver_->getRowPrice();}
    10401040 
    10411041  /// Get a pointer to array[getNumCols()] of reduced costs
    10421042  inline const double * getReducedCost() const
    1043   { return solver_->getReducedCost();};
     1043  { return solver_->getReducedCost();}
    10441044 
    10451045  /// Get pointer to array[getNumRows()] of row activity levels.
    10461046  inline const double * getRowActivity() const
    1047   { return solver_->getRowActivity();};
     1047  { return solver_->getRowActivity();}
    10481048 
    10491049  /// Get current objective function value
     
    10561056  /// Get best objective function value as minimization
    10571057  inline double getMinimizationObjValue() const
    1058   { return bestObjective_;};
     1058  { return bestObjective_;}
    10591059  /// Set best objective function value as minimization
    10601060  inline void setMinimizationObjValue(double value)
    1061   { bestObjective_=value;};
     1061  { bestObjective_=value;}
    10621062 
    10631063  /// Get best objective function value
    10641064  inline double getObjValue() const
    1065   { return bestObjective_ * solver_->getObjSense() ; } ;
     1065  { return bestObjective_ * solver_->getObjSense() ; }
    10661066  /** Get best possible objective function value.
    10671067      This is better of best possible left on tree
     
    10721072  /// Set best objective function value
    10731073  inline void setObjValue(double value)
    1074   { bestObjective_=value * solver_->getObjSense() ;};
     1074  { bestObjective_=value * solver_->getObjSense() ;}
    10751075 
    10761076  /** The best solution to the integer programming problem.
     
    10811081
    10821082  inline double * bestSolution() const
    1083   { return bestSolution_;};
     1083  { return bestSolution_;}
    10841084  void setBestSolution(const double * solution,int numberColumns,double objectiveValue);
    10851085 
    10861086  /// Get number of solutions
    10871087  inline int getSolutionCount() const
    1088   { return numberSolutions_;};
     1088  { return numberSolutions_;}
    10891089 
    10901090  /// Set number of solutions (so heuristics will be different)
    10911091  inline void setSolutionCount(int value)
    1092   { numberSolutions_=value;};
     1092  { numberSolutions_=value;}
    10931093  /** Current phase (so heuristics etc etc can find out).
    10941094      0 - initial solve
     
    11001100  */
    11011101  inline int phase() const
    1102   { return phase_;};
     1102  { return phase_;}
    11031103 
    11041104  /// Get number of heuristic solutions
    1105   inline int getNumberHeuristicSolutions() const { return numberHeuristicSolutions_;};
     1105  inline int getNumberHeuristicSolutions() const { return numberHeuristicSolutions_;}
    11061106
    11071107  /// Set objective function sense (1 for min (default), -1 for max,)
    11081108  inline void setObjSense(double s) { dblParam_[CbcOptimizationDirection]=s;
    1109   solver_->setObjSense(s);};
     1109  solver_->setObjSense(s);}
    11101110
    11111111  /// Value of objective at continuous
    11121112  inline double getContinuousObjective() const
    1113   { return originalContinuousObjective_;};
     1113  { return originalContinuousObjective_;}
    11141114  inline void setContinuousObjective(double value)
    1115   { originalContinuousObjective_=value;};
     1115  { originalContinuousObjective_=value;}
    11161116  /// Number of infeasibilities at continuous
    11171117  inline int getContinuousInfeasibilities() const
    1118   { return continuousInfeasibilities_;};
     1118  { return continuousInfeasibilities_;}
    11191119  inline void setContinuousInfeasibilities(int value)
    1120   { continuousInfeasibilities_=value;};
     1120  { continuousInfeasibilities_=value;}
    11211121  /// Value of objective after root node cuts added
    11221122  inline double rootObjectiveAfterCuts() const
    1123   { return continuousObjective_;};
     1123  { return continuousObjective_;}
    11241124  /// Sum of Changes to objective by first solve
    11251125  inline double sumChangeObjective() const
    1126   { return sumChangeObjective1_;};
     1126  { return sumChangeObjective1_;}
    11271127  /** Number of times global cuts violated.  When global cut pool then this
    11281128      should be kept for each cut and type of cut */
    11291129  inline int numberGlobalViolations() const
    1130   { return numberGlobalViolations_;};
     1130  { return numberGlobalViolations_;}
    11311131  inline void clearNumberGlobalViolations()
    1132   { numberGlobalViolations_=0;};
     1132  { numberGlobalViolations_=0;}
    11331133  /// Whether to force a resolve after takeOffCuts
    11341134  inline bool resolveAfterTakeOffCuts() const
    1135   { return resolveAfterTakeOffCuts_;};
     1135  { return resolveAfterTakeOffCuts_;}
    11361136  inline void setResolveAfterTakeOffCuts(bool yesNo)
    1137   { resolveAfterTakeOffCuts_=yesNo;};
     1137  { resolveAfterTakeOffCuts_=yesNo;}
    11381138  /// Get number of threads
    11391139  inline int getNumberThreads() const
    1140   { return numberThreads_;};
     1140  { return numberThreads_;}
    11411141  /// Set number of threads
    11421142  inline void setNumberThreads(int value)
    1143   { numberThreads_=value;};
     1143  { numberThreads_=value;}
    11441144  /// Get thread mode
    11451145  inline int getThreadMode() const
    1146   { return threadMode_;};
     1146  { return threadMode_;}
    11471147  /** Set thread mode
    11481148      always use numberThreads for branching
     
    11521152  */
    11531153  inline void setThreadMode(int value)
    1154   { threadMode_=value;};
     1154  { threadMode_=value;}
    11551155  //@}
    11561156
     
    11591159  // Comparison functions (which may be overridden by inheritance)
    11601160  inline CbcCompareBase * nodeComparison() const
    1161   { return nodeCompare_;};
     1161  { return nodeCompare_;}
    11621162  void setNodeComparison(CbcCompareBase * compare);
    11631163  void setNodeComparison(CbcCompareBase & compare);
     
    11681168  // Feasibility functions (which may be overridden by inheritance)
    11691169  inline CbcFeasibilityBase * problemFeasibility() const
    1170   { return problemFeasibility_;};
     1170  { return problemFeasibility_;}
    11711171  void setProblemFeasibility(CbcFeasibilityBase * feasibility);
    11721172  void setProblemFeasibility(CbcFeasibilityBase & feasibility);
     
    11771177  /// Tree method e.g. heap (which may be overridden by inheritance)
    11781178  inline CbcTree * tree() const
    1179   { return tree_;};
     1179  { return tree_;}
    11801180  /// For modifying tree handling (original is cloned)
    11811181  void passInTreeHandler(CbcTree & tree);
     
    11941194  /// Says a sub tree was stopped
    11951195  inline void incrementSubTreeStopped()
    1196   { numberStoppedSubTrees_++;};
     1196  { numberStoppedSubTrees_++;}
    11971197  /** Whether to automatically do presolve before branch and bound (subTrees).
    11981198      0 - no
     
    12011201  */
    12021202  inline int typePresolve() const
    1203   { return presolve_;};
     1203  { return presolve_;}
    12041204  inline void setTypePresolve(int value)
    1205   { presolve_=value;};
     1205  { presolve_=value;}
    12061206 
    12071207  //@}
     
    12151215  /// Get the current branching decision method.
    12161216  inline CbcBranchDecision * branchingMethod() const
    1217   { return branchingMethod_;};
     1217  { return branchingMethod_;}
    12181218  /// Set the branching decision method.
    12191219  inline void setBranchingMethod(CbcBranchDecision * method)
    1220   { delete branchingMethod_; branchingMethod_ = method->clone();};
     1220  { delete branchingMethod_; branchingMethod_ = method->clone();}
    12211221  /** Set the branching method
    12221222 
     
    12241224  */
    12251225  inline void setBranchingMethod(CbcBranchDecision & method)
    1226   { delete branchingMethod_; branchingMethod_ = method.clone();};
     1226  { delete branchingMethod_; branchingMethod_ = method.clone();}
    12271227  /// Get the current cut modifier method
    12281228  inline CbcCutModifier * cutModifier() const
    1229   { return cutModifier_;};
     1229  { return cutModifier_;}
    12301230  /// Set the cut modifier method
    12311231  void setCutModifier(CbcCutModifier * modifier);
     
    12471247  */
    12481248  inline int stateOfSearch() const
    1249   { return stateOfSearch_;};
     1249  { return stateOfSearch_;}
    12501250  inline void setStateOfSearch(int state)
    1251   { stateOfSearch_=state;};
     1251  { stateOfSearch_=state;}
    12521252  /// Strategy worked out - mainly at root node for use by CbcNode
    12531253  inline int searchStrategy() const
    1254   { return searchStrategy_;};
     1254  { return searchStrategy_;}
    12551255  /// Set strategy worked out - mainly at root node for use by CbcNode
    12561256  inline void setSearchStrategy(int value)
    1257   { searchStrategy_ = value; };
     1257  { searchStrategy_ = value; }
    12581258
    12591259  /// Get the number of cut generators
    12601260  inline int numberCutGenerators() const
    1261   { return numberCutGenerators_;};
     1261  { return numberCutGenerators_;}
    12621262  /// Get the list of cut generators
    12631263  inline CbcCutGenerator ** cutGenerators() const
    1264   { return generator_;};
     1264  { return generator_;}
    12651265  ///Get the specified cut generator
    12661266  inline CbcCutGenerator * cutGenerator(int i) const
    1267   { return generator_[i];};
     1267  { return generator_[i];}
    12681268  ///Get the specified cut generator before any changes
    12691269  inline CbcCutGenerator * virginCutGenerator(int i) const
    1270   { return virginGenerator_[i];};
     1270  { return virginGenerator_[i];}
    12711271  /** Add one generator - up to user to delete generators.
    12721272      howoften affects how generator is used. 0 or 1 means always,
     
    12911291  /// Get the current strategy
    12921292  inline CbcStrategy * strategy() const
    1293   { return strategy_;};
     1293  { return strategy_;}
    12941294  /// Set the strategy. Clones
    12951295  void setStrategy(CbcStrategy & strategy);
    12961296  /// Get the current parent model
    12971297  inline CbcModel * parentModel() const
    1298   { return parentModel_;};
     1298  { return parentModel_;}
    12991299  /// Set the parent model
    13001300  inline void setParentModel(CbcModel & parentModel)
    1301   { parentModel_ = &parentModel;};
     1301  { parentModel_ = &parentModel;}
    13021302  //@}
    13031303
     
    13121312  ///Get the specified heuristic
    13131313  inline CbcHeuristic * heuristic(int i) const
    1314   { return heuristic_[i];};
     1314  { return heuristic_[i];}
    13151315  /// Get the number of heuristics
    13161316  inline int numberHeuristics() const
    1317   { return numberHeuristics_;};
     1317  { return numberHeuristics_;}
    13181318  /// Pointer to heuristic solver which found last solution (or NULL)
    13191319  inline CbcHeuristic * lastHeuristic() const
    1320   { return lastHeuristic_;};
     1320  { return lastHeuristic_;}
    13211321  /// set last heuristic which found a solution
    13221322  inline void setLastHeuristic(CbcHeuristic * last)
    1323   { lastHeuristic_=last;};
     1323  { lastHeuristic_=last;}
    13241324
    13251325  /** Pass in branching priorities.
     
    13451345  /// Returns priority level for an object (or 1000 if no priorities exist)
    13461346  inline int priority(int sequence) const
    1347   { return object_[sequence]->priority();};
     1347  { return object_[sequence]->priority();}
    13481348
    13491349  /*! \brief Set an event handler
     
    13551355  /*! \brief Retrieve a pointer to the event handler */
    13561356  inline CbcEventHandler* getEventHandler() const
    1357   { return (eventHandler_) ; } ;
     1357  { return (eventHandler_) ; }
    13581358
    13591359  //@}
     
    13871387  /// Get solver characteristics
    13881388  inline const OsiBabSolver * solverCharacteristics() const
    1389   { return solverCharacteristics_;};
     1389  { return solverCharacteristics_;}
    13901390  //@}
    13911391 
     
    13991399  void newLanguage(CoinMessages::Language language);
    14001400  inline void setLanguage(CoinMessages::Language language)
    1401   {newLanguage(language);};
     1401  {newLanguage(language);}
    14021402  /// Return handler
    14031403  inline CoinMessageHandler * messageHandler() const
    1404   {return handler_;};
     1404  {return handler_;}
    14051405  /// Return messages
    14061406  inline CoinMessages & messages()
    1407   {return messages_;};
     1407  {return messages_;}
    14081408  /// Return pointer to messages
    14091409  inline CoinMessages * messagesPointer()
    1410   {return &messages_;};
     1410  {return &messages_;}
    14111411  /// Set log level
    14121412  void setLogLevel(int value);
    14131413  /// Get log level
    14141414  inline int logLevel() const
    1415   { return handler_->logLevel();};
     1415  { return handler_->logLevel();}
    14161416  //@}
    14171417  //---------------------------------------------------------------------------
     
    14311431  /// Set special options
    14321432  inline void setSpecialOptions(int value)
    1433   { specialOptions_=value;};
     1433  { specialOptions_=value;}
    14341434  /// Get special options
    14351435  inline int specialOptions() const
    1436   { return specialOptions_;};
     1436  { return specialOptions_;}
    14371437  /// Says if normal solver i.e. has well defined CoinPackedMatrix
    14381438  inline bool normalSolver() const
    1439   { return (specialOptions_&16)==0;};
     1439  { return (specialOptions_&16)==0;}
    14401440  /// Now we may not own objects - just point to solver's objects
    14411441  inline bool ownObjects() const
    1442   { return ownObjects_;};
     1442  { return ownObjects_;}
    14431443  /// Pointer to a mutex
    14441444  inline void * mutex()
    1445   { return mutex_;};
     1445  { return mutex_;}
    14461446  //@}
    14471447  //---------------------------------------------------------------------------
     
    14771477    */
    14781478    inline void setModelOwnsSolver (bool ourSolver)
    1479     { ourSolver_ = ourSolver ; } ;
     1479    { ourSolver_ = ourSolver ; }
    14801480
    14811481    /*! \brief Get ownership of solver
     
    14841484      take responsibility for deleting it when that becomes necessary.
    14851485    */
    1486     inline bool modelOwnsSolver () { return (ourSolver_) ; } ;
     1486    inline bool modelOwnsSolver () { return (ourSolver_) ; }
    14871487 
    14881488    /** Copy constructor .
     
    14991499    /// Returns solver - has current state
    15001500    inline OsiSolverInterface * solver() const
    1501     { return solver_;};
     1501    { return solver_;}
    15021502
    15031503    /// Returns solver with continuous state
    15041504    inline OsiSolverInterface * continuousSolver() const
    1505     { return continuousSolver_;};
     1505    { return continuousSolver_;}
    15061506
    15071507  /// A copy of the solver, taken at constructor or by saveReferenceSolver
    15081508  inline OsiSolverInterface * referenceSolver() const
    1509   { return referenceSolver_;};
     1509  { return referenceSolver_;}
    15101510
    15111511  /// Save a copy of the current solver so can be reset to
     
    15331533    /// Get how many Nodes it took to solve the problem.
    15341534    int getNodeCount2() const
    1535     { return numberNodes2_;};
     1535    { return numberNodes2_;}
    15361536  /// Set pointers for speed
    15371537  void setPointers(const OsiSolverInterface * solver);
     
    16221622  /// Get the hotstart solution
    16231623  inline const double * hotstartSolution() const
    1624   { return hotstartSolution_;};
     1624  { return hotstartSolution_;}
    16251625  /// Get the hotstart priorities
    16261626  inline const int * hotstartPriorities() const
    1627   { return hotstartPriorities_;};
     1627  { return hotstartPriorities_;}
    16281628
    16291629  /// Return the list of cuts initially collected for this subproblem
    16301630  inline CbcCountRowCut ** addedCuts() const
    1631   { return addedCuts_;};
     1631  { return addedCuts_;}
    16321632  /// Number of entries in the list returned by #addedCuts()
    16331633  inline int currentNumberCuts() const
    1634   { return currentNumberCuts_;};
     1634  { return currentNumberCuts_;}
    16351635  /// Global cuts
    16361636  inline OsiCuts * globalCuts()
    1637   { return &globalCuts_;};
     1637  { return &globalCuts_;}
    16381638  /// Copy and set a pointer to a row cut which will be added instead of normal branching.
    16391639  void setNextRowCut(const OsiRowCut & cut);
    16401640  /// Get a pointer to current node (be careful)
    16411641  inline CbcNode * currentNode() const
    1642   { return currentNode_;};
     1642  { return currentNode_;}
    16431643  /// Get a pointer to probing info
    16441644  inline CglTreeProbingInfo * probingInfo() const
    1645   { return probingInfo_;};
     1645  { return probingInfo_;}
    16461646  /// Set the number of iterations done in strong branching.
    16471647  inline void setNumberStrongIterations(int number)
    1648   { numberStrongIterations_ = number;};
     1648  { numberStrongIterations_ = number;}
    16491649  /// Get the number of iterations done in strong branching.
    16501650  inline int numberStrongIterations() const
    1651   { return numberStrongIterations_;};
     1651  { return numberStrongIterations_;}
    16521652  /// Increment strong info
    16531653  void incrementStrongInfo(int numberTimes, int numberIterations,
  • trunk/Cbc/src/CbcNode.hpp

    r640 r706  
    114114  virtual CbcNodeInfo * clone() const = 0;
    115115  /// Called when number branches left down to zero
    116   virtual void allBranchesGone() {};
     116  virtual void allBranchesGone() {}
    117117
    118118  /// Increment number of references
    119119  inline void increment(int amount=1)
    120   {numberPointingToThis_+=amount;/*printf("CbcNodeInfo %x incremented by %d to %d\n",this,amount,numberPointingToThis_);*/};
     120  {numberPointingToThis_+=amount;/*printf("CbcNodeInfo %x incremented by %d to %d\n",this,amount,numberPointingToThis_);*/}
    121121
    122122  /// Decrement number of references and return number left
    123123  inline int decrement(int amount=1)
    124   {numberPointingToThis_-=amount;/*printf("CbcNodeInfo %x decremented by %d to %d\n",this,amount,numberPointingToThis_);*/return numberPointingToThis_;};
     124  {numberPointingToThis_-=amount;/*printf("CbcNodeInfo %x decremented by %d to %d\n",this,amount,numberPointingToThis_);*/return numberPointingToThis_;}
    125125
    126126  /** Initialize reference counts
     
    130130
    131131  inline void initializeInfo(int number)
    132   {numberPointingToThis_=number;numberBranchesLeft_=number;};
     132  {numberPointingToThis_=number;numberBranchesLeft_=number;}
    133133
    134134  /// Return number of branches left in object
    135135  inline int numberBranchesLeft() const
    136   {return numberBranchesLeft_;};
     136  {return numberBranchesLeft_;}
    137137
    138138  /// Return number of objects pointing to this
    139139  inline int numberPointingToThis() const
    140   {return numberPointingToThis_;};
     140  {return numberPointingToThis_;}
    141141
    142142  /// Say one branch taken
    143143  inline int branchedOn()
    144   {numberPointingToThis_--;numberBranchesLeft_--;return numberBranchesLeft_;};
     144  {numberPointingToThis_--;numberBranchesLeft_--;return numberBranchesLeft_;}
    145145
    146146  /// Say thrown away
    147147  inline void throwAway()
    148   {numberPointingToThis_-=numberBranchesLeft_;numberBranchesLeft_=0;};
     148  {numberPointingToThis_-=numberBranchesLeft_;numberBranchesLeft_=0;}
    149149
    150150  /// Parent of this
    151151  CbcNodeInfo * parent() const
    152   {return parent_;};
     152  {return parent_;}
    153153  /// Set parent null
    154154  inline void nullParent()
    155   { parent_=NULL;};
     155  { parent_=NULL;}
    156156
    157157  void addCuts(OsiCuts & cuts,int numberToBranch, int * whichGenerator);
     
    177177  /// Array of pointers to cuts
    178178  inline CbcCountRowCut ** cuts() const
    179   {return cuts_;};
     179  {return cuts_;}
    180180
    181181  /// Number of row cuts (this node)
    182182  inline int numberCuts() const
    183   {return numberCuts_;};
     183  {return numberCuts_;}
    184184  inline void setNumberCuts(int value)
    185   {numberCuts_=value;};
     185  {numberCuts_=value;}
    186186
    187187  /// Set owner null
    188188  inline void nullOwner()
    189   { owner_=NULL;};
     189  { owner_=NULL;}
    190190  const inline CbcNode * owner() const
    191   { return owner_;};
     191  { return owner_;}
    192192  /// The node number
    193193  inline int nodeNumber() const
    194   { return nodeNumber_;};
     194  { return nodeNumber_;}
    195195  inline void setNodeNumber(int node)
    196   { nodeNumber_=node;};
     196  { nodeNumber_=node;}
    197197protected:
    198198
     
    308308
    309309
    310 
    311310/** \brief Holds information for recreating a subproblem by incremental change
    312311           from the parent.
     
    368367  CbcPartialNodeInfo & operator=(const CbcPartialNodeInfo& rhs);
    369368};
    370 
    371369
    372370
     
    536534  // Information to make basis and bounds
    537535  inline CbcNodeInfo * nodeInfo() const
    538   {return nodeInfo_;};
     536  {return nodeInfo_;}
    539537
    540538  // Objective value
    541539  inline double objectiveValue() const
    542   { return objectiveValue_;};
     540  { return objectiveValue_;}
    543541  inline void setObjectiveValue(double value)
    544   { objectiveValue_=value;};
     542  { objectiveValue_=value;}
    545543  /// Number of arms defined for the attached OsiBranchingObject.
    546544  inline int numberBranches() const
     
    548546      return (branch_->numberBranches()) ;
    549547    else
    550       return (-1) ; } ;
     548      return (-1) ; }
    551549
    552550  /* Active arm of the attached OsiBranchingObject.
     
    559557  /// Depth in branch-and-cut search tree
    560558  inline int depth() const
    561   {return depth_;};
     559  {return depth_;}
    562560  /// Get the number of objects unsatisfied at this node.
    563561  inline int numberUnsatisfied() const
    564   {return numberUnsatisfied_;};
     562  {return numberUnsatisfied_;}
    565563  /// Sum of "infeasibilities" reported by each object
    566564  inline double sumInfeasibilities() const
    567   { return sumInfeasibilities_;};
     565  { return sumInfeasibilities_;}
    568566  // Guessed objective value (for solution)
    569567  inline double guessedObjectiveValue() const
    570   {return guessedObjectiveValue_;};
     568  {return guessedObjectiveValue_;}
    571569  inline void setGuessedObjectiveValue(double value)
    572   {guessedObjectiveValue_=value;};
     570  {guessedObjectiveValue_=value;}
    573571  /// Branching object for this node
    574572  inline const OsiBranchingObject * branchingObject() const
    575   { return branch_;};
     573  { return branch_;}
    576574  /// Modifiable branching object for this node
    577575  inline OsiBranchingObject * modifiableBranchingObject() const
    578   { return branch_;};
     576  { return branch_;}
    579577  /// Set branching object for this node (takes ownership)
    580578  inline void setBranchingObject(OsiBranchingObject * branchingObject)
    581   { branch_ = branchingObject;};
     579  { branch_ = branchingObject;}
    582580
    583581private:
  • trunk/Cbc/src/CbcParam.hpp

    r388 r706  
    5858  OSLSTUFF = 401,CBCSTUFF,
    5959
    60   INVALID = 1000 } ;
     60  INVALID = 1000 }
    6161
    6262
     
    137137  /// Returns current parameter option
    138138  inline std::string currentOption (  ) const
    139   { return definedKeyWords_[currentKeyWord_]; };
     139  { return definedKeyWords_[currentKeyWord_]; }
    140140  /// Sets current parameter option
    141141  inline void setCurrentOption ( int value )
    142   { currentKeyWord_=value; };
     142  { currentKeyWord_=value; }
    143143  /// Sets int value
    144144  inline void setIntValue ( int value )
    145   { intValue_=value; };
     145  { intValue_=value; }
    146146  inline int intValue () const
    147   { return intValue_; };
     147  { return intValue_; }
    148148  /// Sets double value
    149149  inline void setDoubleValue ( double value )
    150   { doubleValue_=value; };
     150  { doubleValue_=value; }
    151151  inline double doubleValue () const
    152   { return doubleValue_; };
     152  { return doubleValue_; }
    153153  /// Sets string value
    154154  inline void setStringValue ( std::string value )
    155   { stringValue_=value; };
     155  { stringValue_=value; }
    156156  inline std::string stringValue () const
    157   { return stringValue_; };
     157  { return stringValue_; }
    158158  /// Returns 1 if matches minimum, 2 if matches less, 0 if not matched
    159159  int matches (std::string input) const;
    160160  /// type
    161161  inline CbcParameterType type() const
    162   { return type_;};
     162  { return type_;}
    163163  /// whether to display
    164164  inline bool displayThis() const
    165   { return display_;};
     165  { return display_;}
    166166  /// Set Long help
    167167  inline void setLonghelp(const std::string help)
    168   {longHelp_=help;};
     168  {longHelp_=help;}
    169169  /// Print Long help
    170170  void printLongHelp() const;
     
    173173  /// type for classification
    174174  inline int indexNumber() const
    175   { return indexNumber_;};
     175  { return indexNumber_;}
    176176private:
    177177  /// gutsOfConstructor
  • trunk/Cbc/src/CbcStatistics.hpp

    r310 r706  
    3030  // Node number
    3131  inline int node() const
    32   { return id_;};
     32  { return id_;}
    3333  // Parent node number
    3434  inline int parentNode() const
    35   { return parentId_;};
     35  { return parentId_;}
    3636  // depth
    3737  inline int depth() const
    38   { return depth_;};
     38  { return depth_;}
    3939  // way
    4040  inline int way() const
    41   { return way_;};
     41  { return way_;}
    4242  // value
    4343  inline double value() const
    44   { return value_;};
     44  { return value_;}
    4545  // starting objective
    4646  inline double startingObjective() const
    47   { return startingObjective_;};
     47  { return startingObjective_;}
    4848  // Unsatisfied at beginning
    4949  inline int startingInfeasibility() const
    50   { return startingInfeasibility_;};
     50  { return startingInfeasibility_;}
    5151  // starting objective
    5252  inline double endingObjective() const
    53   { return endingObjective_;};
     53  { return endingObjective_;}
    5454  // Unsatisfied at end
    5555  inline int endingInfeasibility() const
    56   { return endingInfeasibility_;};
     56  { return endingInfeasibility_;}
    5757  // Number iterations
    5858  inline int numberIterations() const
    59   { return numberIterations_;};
     59  { return numberIterations_;}
    6060
    6161protected:
  • trunk/Cbc/src/CbcStrategy.hpp

    r640 r706  
    3333  /// Set model depth (i.e. how nested)
    3434  inline void setNested(int depth)
    35   { depth_=depth;};
     35  { depth_=depth;}
    3636  /// Get model depth (i.e. how nested)
    3737  inline int getNested() const
    38   { return depth_;};
     38  { return depth_;}
    3939  /// Say preProcessing done
    4040  inline void setPreProcessState(int state)
    41   { preProcessState_=state;};
     41  { preProcessState_=state;}
    4242  /// See what sort of preprocessing was done
    4343  inline int preProcessState() const
    44   { return preProcessState_;};
     44  { return preProcessState_;}
    4545  /// Pre-processing object
    4646  inline CglPreProcess * process() const
    47   { return process_;};
     47  { return process_;}
    4848  /// Delete pre-processing object to save memory
    4949  void deletePreProcess();
     
    5656                                        const CoinWarmStartDiff *basisDiff) const;
    5757  /// Create C++ lines to get to current state
    58   virtual void generateCpp( FILE * fp) {};
     58  virtual void generateCpp( FILE * fp) {}
    5959  /** After a CbcModel::resolve this can return a status
    6060      -1 no effect
     
    9292
    9393  // Copy constructor
    94   CbcStrategyNull ( const CbcStrategyNull & rhs) : CbcStrategy(rhs) {};
     94  CbcStrategyNull ( const CbcStrategyNull & rhs) : CbcStrategy(rhs) {}
    9595   
    9696  // Destructor
    97   ~CbcStrategyNull () {};
    98  
    99   /// Clone
    100   virtual CbcStrategy * clone() const { return new CbcStrategyNull(*this);};
    101 
    102   /// Setup cut generators
    103   virtual void setupCutGenerators(CbcModel & model) {};
    104   /// Setup heuristics
    105   virtual void setupHeuristics(CbcModel & model) {};
    106   /// Do printing stuff
    107   virtual void setupPrinting(CbcModel & model,int modelLogLevel) {};
     97  ~CbcStrategyNull () {}
     98 
     99  /// Clone
     100  virtual CbcStrategy * clone() const { return new CbcStrategyNull(*this);}
     101
     102  /// Setup cut generators
     103  virtual void setupCutGenerators(CbcModel & model) {}
     104  /// Setup heuristics
     105  virtual void setupHeuristics(CbcModel & model) {}
     106  /// Do printing stuff
     107  virtual void setupPrinting(CbcModel & model,int modelLogLevel) {}
    108108  /// Other stuff e.g. strong branching
    109   virtual void setupOther(CbcModel & model) {};
     109  virtual void setupOther(CbcModel & model) {}
    110110
    111111protected:
     
    147147  /// Set up preProcessing - see below
    148148  inline void setupPreProcessing(int desired=1, int passes=10)
    149   { desiredPreProcess_=desired;preProcessPasses_=passes;};
     149  { desiredPreProcess_=desired;preProcessPasses_=passes;}
    150150  /// See what sort of preprocessing wanted
    151151  inline int desiredPreProcess() const
    152   { return desiredPreProcess_;};
     152  { return desiredPreProcess_;}
    153153  /// See how many passes wanted
    154154  inline int preProcessPasses() const
    155   { return preProcessPasses_;};
     155  { return preProcessPasses_;}
    156156  /// Create C++ lines to get to current state
    157157  virtual void generateCpp( FILE * fp) ;
  • trunk/Cbc/src/CbcTree.hpp

    r640 r706  
    3131  virtual CbcTree * clone() const;
    3232  /// Create C++ lines to get to current state
    33   virtual void generateCpp( FILE * fp) {};
     33  virtual void generateCpp( FILE * fp) {}
    3434
    3535/*! \name Heap access and maintenance methods */
     
    122122  virtual CbcNewTree * clone() const;
    123123  /// Create C++ lines to get to current state
    124   virtual void generateCpp( FILE * fp) {};
     124  virtual void generateCpp( FILE * fp) {}
    125125
    126126/*! \name Heap access and maintenance methods */
  • trunk/Cbc/src/CbcTreeLocal.hpp

    r511 r706  
    103103  // range i.e. k
    104104  inline int range() const
    105   { return range_;};
     105  { return range_;}
    106106  // setrange i.e. k
    107107  inline void setRange(int value)
    108   { range_ = value;};
     108  { range_ = value;}
    109109  // Type of cuts - 0=just 0-1, 1=all
    110110  inline int typeCuts() const
    111   { return typeCuts_;};
     111  { return typeCuts_;}
    112112  // Type of cuts - 0=just 0-1, 1=all
    113113  inline void setTypeCuts(int value)
    114   { typeCuts_ = value;};
     114  { typeCuts_ = value;}
    115115  // maximum number of diversifications
    116116  inline int maxDiversification() const
    117   { return maxDiversification_;};
     117  { return maxDiversification_;}
    118118  // maximum number of diversifications
    119119  inline void setMaxDiversification(int value)
    120   { maxDiversification_ = value;};
     120  { maxDiversification_ = value;}
    121121  // time limit per subtree
    122122  inline int timeLimit() const
    123   { return timeLimit_;};
     123  { return timeLimit_;}
    124124  // time limit per subtree
    125125  inline void setTimeLimit(int value)
    126   { timeLimit_ = value;};
     126  { timeLimit_ = value;}
    127127  // node limit for subtree
    128128  inline int nodeLimit() const
    129   { return nodeLimit_;};
     129  { return nodeLimit_;}
    130130  // node limit for subtree
    131131  inline void setNodeLimit(int value)
    132   { nodeLimit_ = value;};
     132  { nodeLimit_ = value;}
    133133  // Whether to do refinement step
    134134  inline bool refine() const
    135   { return refine_;};
     135  { return refine_;}
    136136  // Whether to do refinement step
    137137  inline void setRefine(bool yesNo)
    138     { refine_ = yesNo;};
     138    { refine_ = yesNo;}
    139139
    140140//@}
  • trunk/Cbc/src/ClpConstraintAmpl.hpp

    r687 r706  
    7979  /// Columns
    8080  inline const int * column() const
    81   { return column_;};
     81  { return column_;}
    8282  /// Coefficients
    8383  inline const double * coefficient() const
    84   { return coefficient_;};
     84  { return coefficient_;}
    8585  //@}
    8686
Note: See TracChangeset for help on using the changeset viewer.