COIN-OR::LEMON - Graph Library

Changeset 587:9db62975c32b in lemon


Ignore:
Timestamp:
02/26/09 08:39:16 (9 years ago)
Author:
Alpar Juttner <alpar@…>
Branch:
default
Message:

Fix newSolver()/cloneSolver() API in LP tools + doc improvements (#230)

  • More logical structure for newSolver()/cloneSolver()
  • Fix compilation problem with gcc-3.3
  • Doc improvements
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • lemon/clp.cc

    r485 r587  
    5757  } 
    5858 
    59   ClpLp* ClpLp::_newSolver() const { 
     59  ClpLp* ClpLp::newSolver() const { 
    6060    ClpLp* newlp = new ClpLp; 
    6161    return newlp; 
    6262  } 
    6363 
    64   ClpLp* ClpLp::_cloneSolver() const { 
     64  ClpLp* ClpLp::cloneSolver() const { 
    6565    ClpLp* copylp = new ClpLp(*this); 
    6666    return copylp; 
  • lemon/clp.h

    r485 r587  
    5757    ~ClpLp(); 
    5858 
     59    /// \e 
     60    virtual ClpLp* newSolver() const; 
     61    /// \e 
     62    virtual ClpLp* cloneSolver() const; 
     63 
    5964  protected: 
    6065 
     
    6671 
    6772  protected: 
    68  
    69     virtual ClpLp* _newSolver() const; 
    70     virtual ClpLp* _cloneSolver() const; 
    7173 
    7274    virtual const char* _solverName() const; 
  • lemon/cplex.cc

    r485 r587  
    452452  CplexLp::~CplexLp() {} 
    453453 
    454   CplexLp* CplexLp::_newSolver() const { return new CplexLp; } 
    455   CplexLp* CplexLp::_cloneSolver() const {return new CplexLp(*this); } 
     454  CplexLp* CplexLp::newSolver() const { return new CplexLp; } 
     455  CplexLp* CplexLp::cloneSolver() const {return new CplexLp(*this); } 
    456456 
    457457  const char* CplexLp::_solverName() const { return "CplexLp"; } 
     
    824824  CplexMip::~CplexMip() {} 
    825825 
    826   CplexMip* CplexMip::_newSolver() const { return new CplexMip; } 
    827   CplexMip* CplexMip::_cloneSolver() const {return new CplexMip(*this); } 
     826  CplexMip* CplexMip::newSolver() const { return new CplexMip; } 
     827  CplexMip* CplexMip::cloneSolver() const {return new CplexMip(*this); } 
    828828 
    829829  const char* CplexMip::_solverName() const { return "CplexMip"; } 
  • lemon/cplex.h

    r485 r587  
    161161  /// This class implements an interface for the CPLEX LP solver. 
    162162  ///\ingroup lp_group 
    163   class CplexLp : public CplexBase, public LpSolver { 
     163  class CplexLp : public LpSolver, public CplexBase { 
    164164  public: 
    165165    /// \e 
     
    171171    /// \e 
    172172    virtual ~CplexLp(); 
     173 
     174    /// \e 
     175    virtual CplexLp* cloneSolver() const; 
     176    /// \e 
     177    virtual CplexLp* newSolver() const; 
    173178 
    174179  private: 
     
    186191 
    187192  protected: 
    188  
    189     virtual CplexLp* _cloneSolver() const; 
    190     virtual CplexLp* _newSolver() const; 
    191193 
    192194    virtual const char* _solverName() const; 
     
    223225  /// This class implements an interface for the CPLEX MIP solver. 
    224226  ///\ingroup lp_group 
    225   class CplexMip : public CplexBase, public MipSolver { 
     227  class CplexMip : public MipSolver, public CplexBase { 
    226228  public: 
    227229    /// \e 
  • lemon/glpk.cc

    r485 r587  
    535535  } 
    536536 
    537   GlpkLp* GlpkLp::_newSolver() const { return new GlpkLp; } 
    538   GlpkLp* GlpkLp::_cloneSolver() const { return new GlpkLp(*this); } 
     537  GlpkLp* GlpkLp::newSolver() const { return new GlpkLp; } 
     538  GlpkLp* GlpkLp::cloneSolver() const { return new GlpkLp(*this); } 
    539539 
    540540  const char* GlpkLp::_solverName() const { return "GlpkLp"; } 
     
    941941  } 
    942942 
    943   GlpkMip* GlpkMip::_newSolver() const { return new GlpkMip; } 
    944   GlpkMip* GlpkMip::_cloneSolver() const {return new GlpkMip(*this); } 
     943  GlpkMip* GlpkMip::newSolver() const { return new GlpkMip; } 
     944  GlpkMip* GlpkMip::cloneSolver() const {return new GlpkMip(*this); } 
    945945 
    946946  const char* GlpkMip::_solverName() const { return "GlpkMip"; } 
  • lemon/glpk.h

    r485 r587  
    120120  /// This class implements an interface for the GLPK LP solver. 
    121121  ///\ingroup lp_group 
    122   class GlpkLp : public GlpkBase, public LpSolver { 
     122  class GlpkLp : public LpSolver, public GlpkBase { 
    123123  public: 
    124124 
     
    127127    ///\e 
    128128    GlpkLp(const GlpkLp&); 
     129 
     130    ///\e 
     131    virtual GlpkLp* cloneSolver() const; 
     132    ///\e 
     133    virtual GlpkLp* newSolver() const; 
    129134 
    130135  private: 
     
    136141 
    137142  protected: 
    138  
    139     virtual GlpkLp* _cloneSolver() const; 
    140     virtual GlpkLp* _newSolver() const; 
    141143 
    142144    virtual const char* _solverName() const; 
     
    204206  /// This class implements an interface for the GLPK MIP solver. 
    205207  ///\ingroup lp_group 
    206   class GlpkMip : public GlpkBase, public MipSolver { 
     208  class GlpkMip : public MipSolver, public GlpkBase { 
    207209  public: 
    208210 
     
    212214    GlpkMip(const GlpkMip&); 
    213215 
    214   protected: 
    215  
    216     virtual GlpkMip* _cloneSolver() const; 
    217     virtual GlpkMip* _newSolver() const; 
     216    virtual GlpkMip* cloneSolver() const; 
     217    virtual GlpkMip* newSolver() const; 
     218 
     219  protected: 
    218220 
    219221    virtual const char* _solverName() const; 
  • lemon/lp_base.h

    r561 r587  
    919919 
    920920    //Abstract virtual functions 
    921     virtual LpBase* _newSolver() const = 0; 
    922     virtual LpBase* _cloneSolver() const = 0; 
    923921 
    924922    virtual int _addColId(int col) { return cols.addIndex(col); } 
     
    987985    /// Virtual destructor 
    988986    virtual ~LpBase() {} 
    989  
    990     ///Creates a new LP problem 
    991     LpBase* newSolver() {return _newSolver();} 
    992     ///Makes a copy of the LP problem 
    993     LpBase* cloneSolver() {return _cloneSolver();} 
    994987 
    995988    ///Gives back the name of the solver. 
     
    18221815  public: 
    18231816 
     1817    ///Allocate a new LP problem instance 
     1818    virtual LpSolver* newSolver() const = 0; 
     1819    ///Make a copy of the LP problem 
     1820    virtual LpSolver* cloneSolver() const = 0; 
     1821 
    18241822    ///\name Solve the LP 
    18251823 
     
    19361934    ///@} 
    19371935 
    1938     LpSolver* newSolver() {return _newSolver();} 
    1939     LpSolver* cloneSolver() {return _cloneSolver();} 
    1940  
    19411936  protected: 
    19421937 
    1943     virtual LpSolver* _newSolver() const = 0; 
    1944     virtual LpSolver* _cloneSolver() const = 0; 
    19451938  }; 
    19461939 
     
    19761969    }; 
    19771970 
     1971    ///Allocate a new MIP problem instance 
     1972    virtual MipSolver* newSolver() const = 0; 
     1973    ///Make a copy of the MIP problem 
     1974    virtual MipSolver* cloneSolver() const = 0; 
     1975 
    19781976    ///\name Solve the MIP 
    19791977 
     
    20632061    virtual Value _getSolValue() const = 0; 
    20642062 
    2065   public: 
    2066  
    2067     MipSolver* newSolver() {return _newSolver();} 
    2068     MipSolver* cloneSolver() {return _cloneSolver();} 
    2069  
    2070   protected: 
    2071  
    2072     virtual MipSolver* _newSolver() const = 0; 
    2073     virtual MipSolver* _cloneSolver() const = 0; 
    20742063  }; 
    20752064 
  • lemon/lp_skeleton.cc

    r482 r587  
    106106  { return BASIC; } 
    107107 
    108   LpSkeleton* LpSkeleton::_newSolver() const 
     108  LpSkeleton* LpSkeleton::newSolver() const 
    109109  { return static_cast<LpSkeleton*>(0); } 
    110110 
    111   LpSkeleton* LpSkeleton::_cloneSolver() const 
     111  LpSkeleton* LpSkeleton::cloneSolver() const 
    112112  { return static_cast<LpSkeleton*>(0); } 
    113113 
     
    123123  { return UNDEFINED; } 
    124124 
    125   MipSkeleton* MipSkeleton::_newSolver() const 
     125  MipSkeleton* MipSkeleton::newSolver() const 
    126126  { return static_cast<MipSkeleton*>(0); } 
    127127 
    128   MipSkeleton* MipSkeleton::_cloneSolver() const 
     128  MipSkeleton* MipSkeleton::cloneSolver() const 
    129129  { return static_cast<MipSkeleton*>(0); } 
    130130 
  • lemon/lp_skeleton.h

    r576 r587  
    2323 
    2424///\file 
    25 ///\brief A skeleton file to implement LP solver interfaces 
     25///\brief Skeleton file to implement LP/MIP solver interfaces 
     26///   
     27///The classes in this file do nothing, but they can serve as skeletons when 
     28///implementing an interface to new solvers. 
    2629namespace lemon { 
    2730 
    28   ///A skeleton class to implement LP solver interfaces 
     31  ///A skeleton class to implement LP/MIP solver base interface 
     32   
     33  ///This class does nothing, but it can serve as a skeleton when 
     34  ///implementing an interface to new solvers. 
    2935  class SkeletonSolverBase : public virtual LpBase { 
    3036    int col_num,row_num; 
     
    137143  }; 
    138144 
    139   /// \brief Interface for a skeleton LP solver 
     145  /// \brief Skeleton class for an LP solver interface 
    140146  /// 
    141   /// This class implements an interface for a skeleton LP solver. 
     147  ///This class does nothing, but it can serve as a skeleton when 
     148  ///implementing an interface to new solvers. 
     149 
    142150  ///\ingroup lp_group 
    143   class LpSkeleton : public SkeletonSolverBase, public LpSolver { 
     151  class LpSkeleton : public LpSolver, public SkeletonSolverBase { 
    144152  public: 
    145     LpSkeleton() : SkeletonSolverBase(), LpSolver() {} 
    146  
     153    ///\e 
     154    LpSkeleton() : LpSolver(), SkeletonSolverBase() {} 
     155    ///\e 
     156    virtual LpSkeleton* newSolver() const; 
     157    ///\e 
     158    virtual LpSkeleton* cloneSolver() const; 
    147159  protected: 
    148160 
     
    174186 
    175187    ///\e 
    176     virtual LpSkeleton* _newSolver() const; 
    177     ///\e 
    178     virtual LpSkeleton* _cloneSolver() const; 
    179     ///\e 
    180188    virtual const char* _solverName() const; 
    181189 
    182190  }; 
    183191 
    184   /// \brief Interface for a skeleton MIP solver 
     192  /// \brief Skeleton class for a MIP solver interface 
    185193  /// 
    186   /// This class implements an interface for a skeleton MIP solver. 
     194  ///This class does nothing, but it can serve as a skeleton when 
     195  ///implementing an interface to new solvers. 
    187196  ///\ingroup lp_group 
    188   class MipSkeleton : public SkeletonSolverBase, public MipSolver { 
     197  class MipSkeleton : public MipSolver, public SkeletonSolverBase { 
    189198  public: 
    190     MipSkeleton() : SkeletonSolverBase(), MipSolver() {} 
     199    ///\e 
     200    MipSkeleton() : MipSolver(), SkeletonSolverBase() {} 
     201    ///\e 
     202    virtual MipSkeleton* newSolver() const; 
     203    ///\e 
     204    virtual MipSkeleton* cloneSolver() const; 
    191205 
    192206  protected: 
     
    216230 
    217231    ///\e 
    218     virtual MipSkeleton* _newSolver() const; 
    219  
    220     ///\e 
    221     virtual MipSkeleton* _cloneSolver() const; 
    222     ///\e 
    223232    virtual const char* _solverName() const; 
    224  
    225233  }; 
    226234 
  • lemon/soplex.cc

    r586 r587  
    5555  } 
    5656 
    57   SoplexLp* SoplexLp::_newSolver() const { 
     57  SoplexLp* SoplexLp::newSolver() const { 
    5858    SoplexLp* newlp = new SoplexLp(); 
    5959    return newlp; 
    6060  } 
    6161 
    62   SoplexLp* SoplexLp::_cloneSolver() const { 
     62  SoplexLp* SoplexLp::cloneSolver() const { 
    6363    SoplexLp* newlp = new SoplexLp(*this); 
    6464    return newlp; 
  • lemon/soplex.h

    r485 r587  
    7474    /// \e 
    7575    ~SoplexLp(); 
     76    /// \e 
     77    virtual SoplexLp* newSolver() const; 
     78    /// \e 
     79    virtual SoplexLp* cloneSolver() const; 
    7680 
    7781  protected: 
    78  
    79     virtual SoplexLp* _newSolver() const; 
    80     virtual SoplexLp* _cloneSolver() const; 
    8182 
    8283    virtual const char* _solverName() const; 
  • test/lp_test.cc

    r485 r587  
    198198    check(const_cast<const LpSolver::Expr&>(e)[p2]==0, buf.str()); 
    199199 
     200    //Test for clone/new 
     201    LP* lpnew = lp.newSolver(); 
     202    LP* lpclone = lp.cloneSolver(); 
     203    delete lpnew; 
     204    delete lpclone; 
    200205 
    201206  } 
     
    248253  if (stat ==  LpSolver::OPTIMAL) { 
    249254    std::ostringstream sbuf; 
    250     sbuf << "Wrong optimal value: the right optimum is " << exp_opt; 
     255    sbuf << "Wrong optimal value (" << lp.primal() <<") with " 
     256         << lp.solverName() <<"\n     the right optimum is " << exp_opt; 
    251257    check(std::abs(lp.primal()-exp_opt) < 1e-3, sbuf.str()); 
    252258  } 
     
    356362} 
    357363 
     364template<class LP> 
     365void cloneTest() 
     366{ 
     367  //Test for clone/new 
     368   
     369  LP* lp = new LP(); 
     370  LP* lpnew = lp->newSolver(); 
     371  LP* lpclone = lp->cloneSolver(); 
     372  delete lp; 
     373  delete lpnew; 
     374  delete lpclone; 
     375} 
     376 
    358377int main() 
    359378{ 
     
    366385    lpTest(lp_glpk1); 
    367386    aTest(lp_glpk2); 
     387    cloneTest<GlpkLp>(); 
    368388  } 
    369389#endif 
     
    382402#endif 
    383403  } 
     404    cloneTest<CplexLp>(); 
    384405#endif 
    385406 
     
    389410    lpTest(lp_soplex1); 
    390411    aTest(lp_soplex2); 
     412    cloneTest<SoplexLp>(); 
    391413  } 
    392414#endif 
     
    397419    lpTest(lp_clp1); 
    398420    aTest(lp_clp2); 
     421    cloneTest<ClpLp>(); 
    399422  } 
    400423#endif 
  • test/mip_test.cc

    r485 r587  
    107107} 
    108108 
     109template<class MIP> 
     110void cloneTest() 
     111{ 
     112   
     113  MIP* mip = new MIP(); 
     114  MIP* mipnew = mip->newSolver(); 
     115  MIP* mipclone = mip->cloneSolver(); 
     116  delete mip; 
     117  delete mipnew; 
     118  delete mipclone; 
     119} 
    109120 
    110121int main() 
     
    115126    GlpkMip mip1; 
    116127    aTest(mip1); 
     128    cloneTest<GlpkMip>(); 
    117129  } 
    118130#endif 
     
    130142#endif 
    131143  } 
     144  cloneTest<CplexMip>(); 
    132145#endif 
    133146 
Note: See TracChangeset for help on using the changeset viewer.