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;                        \
    }

    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, /);

# undef RATIONAL_NUMBER_OPERATOR


# 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_IN_PLACE_OPERATOR (+=);
    RATIONAL_NUMBER_IN_PLACE_OPERATOR (-=);
    RATIONAL_NUMBER_IN_PLACE_OPERATOR (*=);
    RATIONAL_NUMBER_IN_PLACE_OPERATOR (/=);

# undef RATIONAL_NUMBER_IN_PLACE_OPERATOR

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

    // @todo 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 inline ::vcsn::algebra::RationalNumber min ();
      static inline ::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

# if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
#  include <vaucanson/algebra/implementation/semiring/rational_number.hxx>
# endif // VCSN_USE_INTERFACE_ONLY

#endif // ! VCSN_ALGEBRA_IMPLEMENTATION_SEMIRING_RATIONAL_NUMBER_HH

---