Rational.h

#ifndef UTIL_RATIONAL_H
#define UTIL_RATIONAL_H
 
/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "gcd.h"
#include <util/global.h>
 
#ifdef UTIL_MPI
#include <util/mpi/MpiTraits.h>
#endif
 
#include <iostream>
 
namespace Util
{
 
   class Rational
   {
 
   public:
 
 
 
      Rational();
 
      Rational(int num, int den);
 
      Rational(int number);
 
      Rational(Rational const & v);
 
      ~Rational()
      {}
 
 
 
      Rational & operator = (Rational const & other);
 
      Rational & operator = (int other);
 
 
 
      Rational & operator += (Rational const & a);
 
      Rational & operator += (int a);
 
      Rational & operator -= (Rational const & a);
 
      Rational & operator -= (int);
 
      Rational & operator *= (Rational const & a);
 
      Rational & operator *= (int a);
 
      Rational & operator /= (Rational const & a);
 
      Rational & operator /= (int a);
 
 
 
      int num() const;
 
      int den() const;
 
      operator double () const;
 
 
      template <class Archive>
      void serialize(Archive & ar, const unsigned int version);
 
      #ifdef UTIL_MPI
      static void commitMpiType();
      #endif
 
 
   private:
 
      int num_;
 
      int den_;
 
      void reduce();
 
   //friends:
 
      friend Rational operator + (Rational const & a, Rational const & b);
      friend Rational operator + (Rational const & a, int b);
 
      friend Rational operator - (Rational const & a, Rational const & b);
      friend Rational operator - (Rational const & a, int b);
      friend Rational operator - (int b, Rational const & a);
 
      friend Rational operator * (Rational const & a, Rational const & b);
      friend Rational operator * (Rational const & a, int b);
 
      friend Rational operator / (Rational const & a, Rational const & b);
      friend Rational operator / (Rational const & a, int b);
      friend Rational operator / (int b, Rational const & a);
 
      friend bool operator == (Rational const & a, Rational const & b);
      friend bool operator == (Rational const & a, int b);
 
      // Unary negation operation
      friend Rational operator - (Rational const & a);
 
      friend 
      std::ostream & operator << (std::ostream& out, Rational const & rational);
 
      #ifdef UTIL_CXX11
      friend 
      std::istream & operator >> (std::istream & in, Rational & rational);
      #endif
 
   };
 
 
 
   // Inline methods
 
   /*
   * Default constructor
   */
   inline
   Rational::Rational()
    : num_(0),
      den_(1)
   { reduce(); }
 
   /*
   * Constructor from numerator and denominator.
   */
   inline
   Rational::Rational(int num, int den)
    : num_(num),
      den_(den)
   { reduce(); }
 
   /*
   * Constructor from integer.
   */
   inline
   Rational::Rational(int number)
    : num_(number),
      den_(1)
   {}
 
   /*
   * Copy constructor
   */
   inline
   Rational::Rational(Rational const & other)
    : num_(other.num_),
      den_(other.den_)
   {}
 
   /*
   * Assignment from another rational.
   */
   inline
   Rational & Rational::operator = (Rational const & other)
   {
      num_ = other.num_;
      den_ = other.den_;
      return *this;
   }
 
   /*
   * Assignment from integer.
   */
   inline
   Rational & Rational::operator = (int other)
   {
      num_ = other;
      den_ = 1;
      return *this;
   }
 
   // Inline arithmetic assignment operators
 
   /*
   * Addition assignment operator : add b to this.
   */
   inline
   Rational & Rational::operator += (Rational const & a)
   {
      num_ = num_*a.den_ + a.num_*den_;
      den_ = den_*a.den_;
      reduce();
      return *this;
   }
 
   /*
   * Addition assignment operator : add integer to this.
   */
   inline
   Rational & Rational::operator += (int a)
   {
      num_ += a*den_;
      reduce();
      return *this;
   }
 
   /*
   * Subtraction assignment operator : subtract a from this.
   */
   inline
   Rational & Rational::operator -= (Rational const & a)
   {
      num_ = num_*a.den_ - a.num_*den_;
      den_ = den_*a.den_;
      reduce();
      return *this;
   }
 
   /*
   * Subtraction assignment operator : subtract integer from this.
   */
   inline
   Rational & Rational::operator -= (int a)
   {
      num_ -= a*den_;
      reduce();
      return *this;
   }
 
   /*
   * Multipication assignment operator : multiply this by a.
   */
   inline
   Rational & Rational::operator *= (Rational const & a)
   {
      num_ *= a.num_;
      den_ *= a.den_;
      reduce();
      return *this;
   }
 
   /*
   * Multipication assignment operator : multiply this by a.
   */
   inline
   Rational & Rational::operator *= (int a)
   {
      num_ *= a;
      reduce();
      return *this;
   }
 
   /*
   * Division assignment operator : divide this by rational.
   */
   inline
   Rational & Rational::operator /= (Rational const & a)
   {
      if (a.num_ == 0) {
         UTIL_THROW("Attempt to divide by zero Rational"); 
      }
      num_ = num_*a.den_;
      den_ = den_*a.num_;
      reduce();
      return *this;
   }
 
   /*
   * Division assignment operator : divide this by rational.
   */
   inline
   Rational & Rational::operator /= (int a)
   {
      if (a == 0) {
         UTIL_THROW("Attempt to divide Rational by zero integer"); 
      }
      den_ *= a;
      reduce();
      return *this;
   }
 
   // Accessors
 
   /*
   * Return numerator.
   */
   inline
   int Rational::num() const
   { return num_; }
 
   /*
   * Return denominator.
   */
   inline
   int Rational::den() const
   {  return den_; }
 
   /*
   * Cast to double operator.
   */
   inline
   Rational::operator double () const
   {  return double(num_)/double(den_); }
 
   // Miscellaneous member functions
 
   /*
   * Serialize to/from an archive.
   */
   template <class Archive>
   inline void Rational::serialize(Archive & ar, const unsigned int version)
   {
      ar & den_;
      ar & num_;
   }
 
   /*
   * Reduce rational number to standard reduced form (private).
   */
   inline
   void Rational::reduce ()
   {
      UTIL_CHECK(den_ != 0);
      if (num_ == 0) {
         den_ = 1;
      } else {
         if (den_ < 0) {
            den_ *= -1;
            num_ *= -1;
         }
         int c = gcd(num_, den_);
         num_ /= c;
         den_ /= c;
      }
   }
 
   // Friend functions for binary arithmetic operations
 
   inline
   Rational operator + (Rational const & a, Rational const & b)
   {
     int num = a.num_*b.den_ + b.num_*a.den_;
     int den = a.den_*b.den_;
     return Rational(num, den);
   }
 
   inline
   Rational operator + (Rational const & a, int b)
   {
     int num = a.num_ + b*a.den_;
     return Rational(num, a.den_);
   }
 
   inline
   Rational operator + (int b, Rational const & a)
   { return (a + b); }
 
   inline
   Rational operator - (Rational const & a, Rational const & b)
   {
     int num = a.num_*b.den_ - b.num_*a.den_;
     int den = a.den_*b.den_;
     return Rational(num, den);
   }
 
   inline
   Rational operator - (Rational const & a, int b)
   {
     int num = a.num_ - b*a.den_;
     return Rational(num, a.den_);
   }
 
   inline
   Rational operator - (int b, Rational const & a)
   {
     int num = b*a.den_ - a.num_;
     return Rational(num, a.den_);
   }
 
   inline
   Rational operator * (Rational const & a, Rational const & b)
   {
      int num = a.num_*b.num_;
      int den = a.den_*b.den_;
      return Rational(num, den);
   }
 
   inline
   Rational operator * (Rational const & a, int b)
   { return Rational(b*a.num_, a.den_); }
 
   inline
   Rational operator * (int b, Rational const & a)
   { return a*b; }
 
   inline
   Rational operator / (Rational const & a, Rational const & b)
   {
      if (b.num_ == 0) {
         UTIL_THROW("Attempt to divide by zero Rational"); 
      }
      int num = a.num_*b.den_;
      int den = a.den_*b.num_;
      return Rational(num, den);
   }
 
   inline
   Rational operator / (Rational const & a, int b)
   {
      if (b == 0) {
         UTIL_THROW("Attempt to divide Rational by zero integer"); 
      }
      return Rational(a.num_, a.den_*b);
   }
 
   inline
   Rational operator / (int b, Rational const & a)
   {
      if (a.num_ == 0) {
         UTIL_THROW("Attempt to divide integer by zero Rational"); 
      }
      return Rational(b*a.den_, a.num_);
   }
 
   // Unary arithmetic operators
 
   inline
   Rational operator - ( Rational const & a)
   {  return Rational(-a.num_, a.den_); }
 
 
   inline 
   bool operator == (Rational const & a, Rational const & b)
   {  return ((a.num_ == b.num_) && (a.den_ == b.den_)); }
 
   inline bool operator == (Rational const & a, int b)
   {  return ((a.num_ == b) && (a.den_ == 1)); }
 
   inline bool operator == (int b, Rational const & a)
   {  return (a == b); }
 
 
   inline bool operator != (Rational const & a, Rational const & b)
   {  return !(a == b); }
 
   inline bool operator != (Rational const & a, int b)
   {  return !(a == b); }
 
   inline bool operator != (int b, Rational const & a)
   {  return !(a == b); }
 
   //  Miscellaneous global functions.
 
   std::ostream& operator << (std::ostream& out, Rational const & rational);
 
   #ifdef UTIL_CXX11
   std::istream& operator >> (std::istream& in, Rational & rational);
   #endif
 
   #ifdef UTIL_MPI
   template <>
   class MpiTraits<Rational>
   {
   public:
      static MPI::Datatype type;   
      static bool hasType;         
   };
   #endif
 
}
#endif