Changeset 746 for branches


Ignore:
Timestamp:
Aug 11, 2007 12:22:33 AM (12 years ago)
Author:
lou
Message:

Add using declarations to suppress compiler warnings about hidden function
declarations.

Location:
branches/BSP/trunk/Cbc/src
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • branches/BSP/trunk/Cbc/src/CbcBranchActual.hpp

    r720 r746  
    3737  ~CbcClique ();
    3838 
     39  using CbcObject::infeasibility ;
    3940  /// Infeasibility - large is 0.5
    4041  virtual double infeasibility(int & preferredWay) const;
    4142
     43  using CbcObject::feasibleRegion ;
    4244  /// This looks at solution and sets bounds to contain solution
    4345  virtual void feasibleRegion();
     46
     47  using CbcObject::createBranch ;
    4448  /// Creates a branching object
    4549  virtual CbcBranchingObject * createBranch(int way) ;
     
    122126  ~CbcSOS ();
    123127 
     128  using CbcObject::infeasibility ;
    124129  /// Infeasibility - large is 0.5
    125130  virtual double infeasibility(int & preferredWay) const;
    126131
     132  using CbcObject::feasibleRegion ;
    127133  /// This looks at solution and sets bounds to contain solution
    128134  virtual void feasibleRegion();
     135
     136  using CbcObject::createBranch ;
    129137  /// Creates a branching object
    130138  virtual CbcBranchingObject * createBranch(int way) ;
    131139
     140  using CbcObject::solverBranch ;
    132141  /** Create an OsiSolverBranch object
    133142
     
    220229  /// Construct an OsiSimpleInteger object
    221230  OsiSimpleInteger * osiObject() const;
     231  using CbcObject::infeasibility ;
    222232  /// Infeasibility - large is 0.5
    223233  virtual double infeasibility(const OsiSolverInterface * solver,
    224234                               const OsiBranchingInformation * info, int & preferredWay) const;
    225235
     236  using CbcObject::feasibleRegion ;
    226237  /** Set bounds to fix the variable at the current (integer) value.
    227238
     
    231242  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
    232243
     244  using CbcObject::createBranch ;
    233245  /** Create a branching object and indicate which way to branch first.
    234246     
     
    238250  virtual CbcBranchingObject * createBranch(OsiSolverInterface * solver,
    239251                                            const OsiBranchingInformation * info, int way) ;
     252
     253  using CbcObject::solverBranch ;
    240254  /** Create an OsiSolverBranch object
    241255
     
    343357  void applyConsequence(int iSequence, int state) const;
    344358 
     359  using CbcObject::infeasibility ;
    345360  /// Infeasibility - large is 0.5 (and 0.5 will give this)
    346361  virtual double infeasibility(int & preferredWay) const;
    347362
     363  using CbcObject::feasibleRegion ;
    348364  /// This looks at solution and sets bounds to contain solution
    349365  virtual void feasibleRegion();
     366
     367  using CbcObject::createBranch ;
    350368  /// Creates a branching object
    351369  virtual CbcBranchingObject * createBranch(int way) ;
     370
    352371  /// Number of members
    353372  inline int numberMembers() const
     
    420439  virtual ~CbcIntegerBranchingObject ();
    421440 
     441  using CbcBranchingObject::branch ;
    422442  /** \brief Sets the bounds for the variable according to the current arm
    423443             of the branch and advances the object state to the next arm.
     
    426446  virtual double branch();
    427447
     448  using CbcBranchingObject::print ;
    428449  /** \brief Print something about branch - only if log level high
    429450  */
     
    470491  ~CbcSimpleIntegerPseudoCost ();
    471492 
     493  using CbcObject::infeasibility ;
    472494  /// Infeasibility - large is 0.5
    473495  virtual double infeasibility(int & preferredWay) const;
    474496
     497  using CbcObject::createBranch ;
    475498  /// Creates a branching object
    476499  virtual CbcBranchingObject * createBranch(int way) ;
     
    580603  virtual ~CbcIntegerPseudoCostBranchingObject ();
    581604 
     605  using CbcBranchingObject::branch ;
    582606  /** \brief Sets the bounds for the variable according to the current arm
    583607             of the branch and advances the object state to the next arm.
     
    631655  virtual ~CbcCliqueBranchingObject ();
    632656 
     657  using CbcBranchingObject::branch ;
    633658  /// Does next branch and updates state
    634659  virtual double branch();
    635660
     661  using CbcBranchingObject::print ;
    636662  /** \brief Print something about branch - only if log level high
    637663  */
     
    676702  virtual ~CbcLongCliqueBranchingObject ();
    677703 
     704  using CbcBranchingObject::branch ;
    678705  /// Does next branch and updates state
    679706  virtual double branch();
    680707
     708  using CbcBranchingObject::print ;
    681709  /** \brief Print something about branch - only if log level high
    682710  */
     
    720748  virtual ~CbcSOSBranchingObject ();
    721749 
     750  using CbcBranchingObject::branch ;
    722751  /// Does next branch and updates state
    723752  virtual double branch();
    724753
     754  using CbcBranchingObject::print ;
    725755  /** \brief Print something about branch - only if log level high
    726756  */
     
    762792  virtual ~CbcNWayBranchingObject ();
    763793 
     794  using CbcBranchingObject::branch ;
    764795  /// Does next branch and updates state
    765796  virtual double branch();
    766797
     798  using CbcBranchingObject::print ;
    767799  /** \brief Print something about branch - only if log level high
    768800  */
     
    905937  ~CbcFollowOn ();
    906938 
     939  using CbcObject::infeasibility ;
    907940  /// Infeasibility - large is 0.5
    908941  virtual double infeasibility(int & preferredWay) const;
    909942
     943  using CbcObject::feasibleRegion ;
    910944  /// This looks at solution and sets bounds to contain solution
    911945  virtual void feasibleRegion();
     946
     947  using CbcObject::createBranch ;
    912948  /// Creates a branching object
    913949  virtual CbcBranchingObject * createBranch(int way) ;
     
    952988  virtual ~CbcFixingBranchingObject ();
    953989 
     990  using CbcBranchingObject::branch ;
    954991  /// Does next branch and updates state
    955992  virtual double branch();
    956993
     994  using CbcBranchingObject::print ;
    957995  /** \brief Print something about branch - only if log level high
    958996  */
     
    10471085  virtual ~CbcDummyBranchingObject ();
    10481086 
     1087  using CbcBranchingObject::branch ;
    10491088  /** \brief Dummy branch
    10501089  */
    10511090  virtual double branch();
    10521091
     1092  using CbcBranchingObject::print ;
    10531093  /** \brief Print something about branch - only if log level high
    10541094  */
  • branches/BSP/trunk/Cbc/src/CbcBranchCut.hpp

    r640 r746  
    3434  ~CbcBranchCut ();
    3535 
     36  using CbcObject::infeasibility ;
    3637  /// Infeasibility
    3738  virtual double infeasibility(int & preferredWay) const;
    3839
     40  using CbcObject::feasibleRegion ;
    3941  /** Set bounds to contain the current solution.
    4042
     
    5153  */
    5254  virtual bool boundBranch() const ;
     55
     56  using CbcObject::createBranch ;
    5357  /// Creates a branching object
    5458  virtual CbcBranchingObject * createBranch(int way) ;
     
    8286  virtual CbcBranchingObject * notPreferredNewFeasible() const ;
    8387 
     88  using CbcObject::resetBounds ;
    8489  /** Reset original upper and lower bound values from the solver.
    8590 
     
    127132  virtual ~CbcCutBranchingObject ();
    128133 
     134  using CbcBranchingObject::branch ;
    129135  /** \brief Sets the bounds for variables or adds a cut depending on the
    130136             current arm of the branch and advances the object state to the next arm.
     
    133139  virtual double branch();
    134140
     141  using CbcBranchingObject::print ;
    135142  /** \brief Print something about branch - only if log level high
    136143  */
     
    193200  */
    194201  int shallWe() const;
     202
     203  using CbcObject::infeasibility ;
    195204  /// Infeasibility - large is 0.5
    196205  virtual double infeasibility(int & preferredWay) const;
    197206
     207  using CbcObject::createBranch ;
    198208  /// Creates a branching object
    199209  virtual CbcBranchingObject * createBranch(int way);
     
    248258  ~CbcBranchAllDifferent ();
    249259
     260  using CbcObject::infeasibility ;
    250261  /// Infeasibility - large is 0.5
    251262  virtual double infeasibility(int & preferredWay) const;
    252263
     264  using CbcObject::createBranch ;
    253265  /// Creates a branching object
    254266  virtual CbcBranchingObject * createBranch(int way);
  • branches/BSP/trunk/Cbc/src/CbcBranchDynamic.hpp

    r706 r746  
    4747  ~CbcSimpleIntegerDynamicPseudoCost ();
    4848 
     49  using CbcObject::infeasibility ;
    4950  /// Infeasibility - large is 0.5
    5051  virtual double infeasibility(int & preferredWay) const;
    5152
     53  using CbcObject::createBranch ;
    5254  /// Creates a branching object
    5355  virtual CbcBranchingObject * createBranch(int way) ;
     56
    5457  /// Infeasibility - large is 0.5
    5558  virtual double infeasibility(const OsiSolverInterface * solver,
     
    7679  void copySome(CbcSimpleIntegerDynamicPseudoCost * otherObject);
    7780
     81  using CbcSimpleInteger::solverBranch ;
    7882  /** Create an OsiSolverBranch object
    7983
     
    345349  virtual ~CbcDynamicPseudoCostBranchingObject ();
    346350 
     351  using CbcBranchingObject::branch ;
    347352  /** \brief Sets the bounds for the variable according to the current arm
    348353             of the branch and advances the object state to the next arm.
     
    350355  */
    351356  virtual double branch();
     357
    352358  /** Some branchingObjects may claim to be able to skip
    353359      strong branching.  If so they have to fill in CbcStrongInfo.
  • branches/BSP/trunk/Cbc/src/CbcBranchLotsize.hpp

    r706 r746  
    3434  ~CbcLotsize ();
    3535 
     36  using CbcObject::infeasibility ;
    3637  /// Infeasibility - large is 0.5
    3738  virtual double infeasibility(int & preferredWay) const;
    3839
     40  using CbcObject::feasibleRegion ;
    3941  /** Set bounds to contain the current solution.
    4042
     
    4648  virtual void feasibleRegion();
    4749
     50  using CbcObject::createBranch ;
    4851  /// Creates a branching object
    4952  virtual CbcBranchingObject * createBranch(int way) ;
     
    188191  virtual ~CbcLotsizeBranchingObject ();
    189192 
     193  using CbcBranchingObject::branch ;
    190194  /** \brief Sets the bounds for the variable according to the current arm
    191195             of the branch and advances the object state to the next arm.
     
    193197  virtual double branch();
    194198
     199  using CbcBranchingObject::print ;
    195200  /** \brief Print something about branch - only if log level high
    196201  */
  • branches/BSP/trunk/Cbc/src/CbcCompareActual.hpp

    r706 r746  
    8585     weighted value of node x */
    8686  virtual bool test (CbcNode * x, CbcNode * y) ;
     87
     88  using CbcCompareBase::newSolution ;
    8789  // This allows method to change behavior as it is called
    8890  // after each solution
  • branches/BSP/trunk/Cbc/src/CbcHeuristic.hpp

    r706 r746  
    161161  virtual void setModel(CbcModel * model);
    162162 
     163  using CbcHeuristic::solution ;
    163164  /** returns 0 if no solution, 1 if valid solution
    164165      with better objective value than one passed in
     
    220221  virtual void setModel(CbcModel * model);
    221222 
     223  using CbcHeuristic::solution ;
    222224  /** returns 0 if no solution, 1 if valid solution.
    223225      Sets solution values if good, sets objective value (only if good)
  • branches/BSP/trunk/Cbc/src/CbcHeuristicFPump.hpp

    r706 r746  
    3838  virtual void setModel(CbcModel * model);
    3939 
     40  using CbcHeuristic::solution ;
    4041  /** returns 0 if no solution, 1 if valid solution
    4142      with better objective value than one passed in
  • branches/BSP/trunk/Cbc/src/CbcHeuristicGreedy.hpp

    r706 r746  
    3535  virtual void setModel(CbcModel * model);
    3636 
     37  using CbcHeuristic::solution ;
    3738  /** returns 0 if no solution, 1 if valid solution.
    3839      Sets solution values if good, sets objective value (only if good)
     
    113114  virtual void setModel(CbcModel * model);
    114115 
     116  using CbcHeuristic::solution ;
    115117  /** returns 0 if no solution, 1 if valid solution.
    116118      Sets solution values if good, sets objective value (only if good)
  • branches/BSP/trunk/Cbc/src/CbcHeuristicLocal.hpp

    r706 r746  
    4040  virtual void setModel(CbcModel * model);
    4141 
     42  using CbcHeuristic::solution ;
    4243  /** returns 0 if no solution, 1 if valid solution.
    4344      Sets solution values if good, sets objective value (only if good)
  • branches/BSP/trunk/Cbc/src/CbcHeuristicRINS.hpp

    r706 r746  
    4141  virtual void setModel(CbcModel * model);
    4242 
     43  using CbcHeuristic::solution ;
    4344  /** returns 0 if no solution, 1 if valid solution.
    4445      Sets solution values if good, sets objective value (only if good)
  • branches/BSP/trunk/Cbc/src/CbcLinked.hpp

    r740 r746  
    377377  virtual void setModel(CbcModel * model);
    378378 
     379  using CbcHeuristic::solution ;
    379380  /** returns 0 if no solution, 1 if valid solution.
    380381      Sets solution values if good, sets objective value (only if good)
     
    446447  virtual ~OsiOldLink ();
    447448 
     449  using OsiObject::infeasibility ;
    448450  /// Infeasibility - large is 0.5
    449451  virtual double infeasibility(const OsiBranchingInformation * info,int & whichWay) const;
    450452
     453  using OsiObject::feasibleRegion ;
    451454  /** Set bounds to fix the variable at the current (integer) value.
    452455
     
    511514  virtual ~OsiOldLinkBranchingObject ();
    512515 
     516  using OsiBranchingObject::branch ;
    513517  /// Does next branch and updates state
    514518  virtual double branch(OsiSolverInterface * solver);
    515519
     520  using OsiBranchingObject::print ;
    516521  /** \brief Print something about branch - only if log level high
    517522  */
     
    592597  virtual ~OsiLink ();
    593598 
     599  using OsiObject::infeasibility ;
    594600  /// Infeasibility - large is 0.5
    595601  virtual double infeasibility(const OsiBranchingInformation * info,int & whichWay) const;
    596602
     603  using OsiObject::feasibleRegion ;
    597604  /** Set bounds to fix the variable at the current (integer) value.
    598605
     
    664671  virtual ~OsiLinkBranchingObject ();
    665672 
     673  using OsiBranchingObject::branch ;
    666674  /// Does next branch and updates state
    667675  virtual double branch(OsiSolverInterface * solver);
    668676
     677  using OsiBranchingObject::print ;
    669678  /** \brief Print something about branch - only if log level high
    670679  */
     
    719728  virtual ~OsiBiLinear ();
    720729 
     730  using OsiObject::infeasibility ;
    721731  /// Infeasibility - large is 0.5
    722732  virtual double infeasibility(const OsiBranchingInformation * info,int & whichWay) const;
    723733
     734  using OsiObject::feasibleRegion ;
    724735  /** Set bounds to fix the variable at the current (integer) value.
    725736
     
    943954  virtual ~OsiBiLinearBranchingObject ();
    944955 
     956  using OsiBranchingObject::branch ;
    945957  /// Does next branch and updates state
    946958  virtual double branch(OsiSolverInterface * solver);
    947959
     960  using OsiBranchingObject::print ;
    948961  /** \brief Print something about branch - only if log level high
    949962  */
     
    10411054  virtual ~OsiSimpleFixedInteger ();
    10421055 
     1056  using OsiObject::infeasibility ;
    10431057  /// Infeasibility - large is 0.5
    10441058  virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
     1059
    10451060  /** Creates a branching object
    10461061
     
    10891104  virtual ~OsiUsesBiLinear ();
    10901105 
     1106  using OsiObject::infeasibility ;
    10911107  /// Infeasibility - large is 0.5
    10921108  virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const;
     1109
    10931110  /** Creates a branching object
    10941111
     
    10961113  */
    10971114  virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const;
     1115
     1116  using OsiObject::feasibleRegion ;
    10981117  /** Set bounds to fix the variable at the current value.
    10991118
     
    11021121  */
    11031122  virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const;
     1123
    11041124  /// Add all bi-linear objects
    11051125  void addBiLinearObjects(OsiSolverLink * solver);
Note: See TracChangeset for help on using the changeset viewer.