rational_number.hh

Go to the documentation of this file.

// rational_number.hh: this file is part of the Vaucanson project.
//
// Vaucanson, a generic library for finite state machines.
//
// Copyright (C) 2004, 2005 The Vaucanson Group.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// The complete GNU General Public Licence Notice can be found as the
// `COPYING' file in the root directory.
//
// The Vaucanson Group consists of people listed in the `AUTHORS' file.
//
#ifndef VCSN_ALGEBRA_IMPLEMENTATION_SEMIRING_RATIONAL_NUMBER_HH
# define VCSN_ALGEBRA_IMPLEMENTATION_SEMIRING_RATIONAL_NUMBER_HH

# include <iostream>

# include <vaucanson/misc/limits.hh>
/* @{ *//* @{ */
namespace vcsn
{
  namespace algebra
  {
/* @{ *//* @{ */

    class RationalNumber
    {
    public:



      RationalNumber(int num, unsigned int denom);
      RationalNumber();
      RationalNumber(const RationalNumber& nb);
      template <typename T>
      explicit RationalNumber(const T num);



      const int&        num() const;
      const unsigned&   denom() const;

      std::ostream&     print(std::ostream& ostr) const;



      RationalNumber    operator+(const RationalNumber& nb) const;
      RationalNumber    operator-(const RationalNumber& nb) const;
      RationalNumber    operator-() const;
      RationalNumber    operator*(const RationalNumber& nb) const;
      RationalNumber    operator/(const RationalNumber& nb) const;
      RationalNumber&   operator+=(const RationalNumber& nb);
      RationalNumber&   operator-=(const RationalNumber& nb);
      RationalNumber&   operator*=(const RationalNumber& nb);
      RationalNumber&   operator/=(const RationalNumber& nb);
      bool      operator<(const RationalNumber& nb) const;
      bool      operator>(const RationalNumber& nb) const;
      bool      operator<=(const RationalNumber& nb) const;
      bool      operator>=(const RationalNumber& nb) const;
      bool      operator==(const RationalNumber& nb) const;
      bool      operator!=(const RationalNumber& nb) const;



      int               to_int() const;
      double            to_double() const;

    protected:
      int               num_;
      unsigned int      denom_;



      RationalNumber&   set_result();
      RationalNumber&   set_result(int num, unsigned int denom);
    };

    // Provides generic operators on rational (calls the explicit generic
    // constructor for rational).
# define RATIONAL_NUMBER_OPERATOR(type, op)                     \
template <class T>                                              \
type operator op(const RationalNumber& nb, const T nb2)         \
{                                                               \
  return nb op RationalNumber(nb2);                             \
}                                                               \
                                                                \
template <class T>                                              \
type operator op(const T nb2, const RationalNumber& nb)         \
{                                                               \
  return RationalNumber(nb2) op nb;                             \
}

# define RATIONAL_NUMBER_IN_PLACE_OPERATOR(op)                  \
template <class T>                                              \
RationalNumber& operator op(RationalNumber& nb, const T nb2)    \
{                                                               \
  return nb op RationalNumber(nb2);                             \
}

    RATIONAL_NUMBER_OPERATOR(bool, <);
    RATIONAL_NUMBER_OPERATOR(bool, <=);
    RATIONAL_NUMBER_OPERATOR(bool, >);
    RATIONAL_NUMBER_OPERATOR(bool, >=);
    RATIONAL_NUMBER_OPERATOR(bool, ==);
    RATIONAL_NUMBER_OPERATOR(bool, !=);
    RATIONAL_NUMBER_OPERATOR(RationalNumber, +);
    RATIONAL_NUMBER_OPERATOR(RationalNumber, -);
    RATIONAL_NUMBER_OPERATOR(RationalNumber, *);
    RATIONAL_NUMBER_OPERATOR(RationalNumber, /);
    RATIONAL_NUMBER_IN_PLACE_OPERATOR(+=);
    RATIONAL_NUMBER_IN_PLACE_OPERATOR(-=);
    RATIONAL_NUMBER_IN_PLACE_OPERATOR(*=);
    RATIONAL_NUMBER_IN_PLACE_OPERATOR(/=);

# undef RATIONAL_NUMBER_OPERATOR
# undef RATIONAL_NUMBER_IN_PLACE_OPERATOR

    // FIXME: Add other goodies for standard library.
    std::ostream& operator<<(std::ostream& ostr, const RationalNumber& nb);

   // FIXME: We might prefer to define gcd and lcm somewhere else.
    int         gcd(int a, unsigned int b);
    int         lcm(int a, unsigned int b);

  } // End of namespace algebra.
} // End of namespace vcsn.

namespace std
{
  template <>
  struct numeric_limits< ::vcsn::algebra::RationalNumber >
  {
    static ::vcsn::algebra::RationalNumber min();
    static ::vcsn::algebra::RationalNumber max();
  };

} // End of namespace std.

namespace utility
{
  template <>
  struct limits< ::vcsn::algebra::RationalNumber > :
    public std::numeric_limits< ::vcsn::algebra::RationalNumber >
  {
  };
}

# ifndef VCSN_USE_INTERFACE_ONLY
#  include <vaucanson/algebra/implementation/semiring/rational_number.hxx>
# endif // VCSN_USE_INTERFACE_ONLY

#endif // ! VCSN_ALGEBRA_IMPLEMENTATION_SEMIRING_RATIONAL_NUMBER_HH

---