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, 2006 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 vcsn
{
  namespace misc
  {
    template <>
    struct limits< ::vcsn::algebra::RationalNumber > :
        public std::numeric_limits< ::vcsn::algebra::RationalNumber >
    {
    };
  } // misc
} // vcsn

# 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

---