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

      #if 0
      friend 
      std::istream & operator >> (std::istream & in, Rational & rational);
      #endif

      friend 
      std::ostream & operator << (std::ostream& out, Rational const & rational);

   };



   // 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_MPI

   template <>
   class MpiTraits<Rational>
   {
   public:
      static MPI::Datatype type;   
      static bool hasType;         
   };
   #endif

}
#endif