AndroMeta/include/AndroMeta/MRational.h

Go to the documentation of this file.

/*
 * Copyright 2009-2012 AndroMeta LLC. All rights reserved.
 *
 * AndroMeta LLC retains all intellectual property and proprietary 
 * rights to this software and related documentation and any modifications 
 * thereto.  Any use, reproduction, disclosure, or distribution of this 
 * software and related documentation without an express license agreement 
 * from AndroMeta LLC is strictly prohibited.
 * 
 */

#ifndef ANDROMETA_M_RATIONAL_H
#define ANDROMETA_M_RATIONAL_H

#include <cstddef>
#include <ostream>

#include <AndroMeta/MStr.h>

namespace Meta{
  
  class MRational{
  public:
    MRational();
    
    MRational(const MRational& r);
    
    MRational(int numerator);
    
    MRational(int64_t numerator);
    
    MRational(int64_t numerator, int64_t denominator);
    
    ~MRational();
    
    int64_t numerator() const;
    
    int64_t denominator() const;
    
    MRational& operator=(const MRational& r);
    
    MRational& operator+=(const MRational& r);
    
    template<typename T>
    MRational operator+(const T& t) const{
      MRational ret(*this);
      return ret += MRational(t);
    }
    
    double operator+(double d) const{
      return this->toDouble() + d;
    }
    
    MRational operator+(const MRational& r) const{
      MRational ret(*this);
      return ret += r;
    }
    
    MRational operator++(int){
      MRational ret(*this);
      *this += 1;
      return ret;
    }
    
    MRational& operator++(){
      return *this += 1;
    }
    
    MRational& operator-=(const MRational& r);
    
    template<typename T>
    MRational operator-(const T& t) const{
      MRational ret(*this);
      return ret -= MRational(t);
    }
    
    double operator-(double d) const{
      return this->toDouble() - d;
    }
    
    MRational operator-(const MRational& r) const{
      MRational ret(*this);
      return ret -= r;
    }
    
    MRational operator-() const;
    
    MRational operator--(int){
      MRational ret(*this);
      *this -= 1;
      return ret;
    }
    
    MRational& operator--(){
      return *this -= 1;
    }
    
    MRational& operator*=(const MRational& r);
    
    template<typename T>
    MRational operator*(const T& t) const{
      MRational ret(*this);
      return ret *= MRational(t);
    }
    
    double operator*(double d) const{
      return this->toDouble() * d;
    }
    
    MRational operator*(const MRational& r) const{
      MRational ret(*this);
      return ret *= r;
    }
    
    MRational& operator/=(const MRational& r);
    
    template<typename T>
    MRational operator/(const T& t) const{
      MRational ret(*this);
      return ret /= MRational(t);
    }
    
    double operator/(double d) const{
      return this->toDouble() / d;
    }
    
    MRational operator/(const MRational& r) const{
      MRational ret(*this);
      return ret /= r;
    }
    
    bool operator<(const MRational& r) const;
    
    template<typename T>
    bool operator<(const T& t) const{
      return *this < MRational(t);
    }
    
    bool operator<(double d) const{
      return this->toDouble() < d;
    }  
    
    bool operator>(const MRational& r) const;
    
    template<typename T>
    bool operator>(const T& t) const{
      return *this > MRational(t);
    }
    
    bool operator>(double d) const{
      return this->toDouble() > d;
    }  
    
    bool operator==(const MRational& r) const;
    
    template<typename T>
    bool operator==(const T& t) const{
      return *this == MRational(t);
    }
    
    bool operator==(double d) const{
      return this->toDouble() == d;
    }
    
    bool operator<=(const MRational& r) const;
    
    template<typename T>
    bool operator<=(const T& t) const{
      return *this <= MRational(t);
    }
    
    bool operator<=(double d) const{
      return this->toDouble() <= d;
    }
    
    bool operator>=(const MRational& r) const;
    
    template<typename T>
    bool operator>=(const T& t) const{
      return *this >= MRational(t);
    }
    
    bool operator>=(double d) const{
      return this->toDouble() >= d;
    }
    
    bool operator!=(const MRational& r) const;
    
    template<typename T>
    bool operator!=(const T& t) const{
      return *this != MRational(t);
    }
    
    bool operator!=(double d) const{
      return this->toDouble() != d;
    }
    
    int64_t toLong() const;
    
    double toDouble() const;
    
    bool toBool() const;
    
    mstr toStr(int precision) const;
    
  private:
    class MRational_* x_;
  };
  
  std::ostream& operator<<(std::ostream& ostr, const MRational& r);
  
  inline bool operator<(double d, const MRational& r){
    return d < r.toDouble();
  }
  
  template<typename T>
  inline bool operator<(const T& t, const MRational& r){
    return MRational(t) < r;
  }
  
  inline bool operator>(double d, const MRational& r){
    return d > r.toDouble();
  }
  
  template<typename T>
  inline bool operator>(const T& t, const MRational& r){
    return MRational(t) > r;
  }
  
  inline bool operator<=(double d, const MRational& r){
    return d <= r.toDouble();
  }
  
  template<typename T>
  inline bool operator<=(const T& t, const MRational& r){
    return MRational(t) <= r;
  }
  
  inline bool operator>=(double d, const MRational& r){
    return d >= r.toDouble();
  }
  
  template<typename T>
  inline bool operator>=(const T& t, const MRational& r){
    return MRational(t) >= r;
  }
  
  inline bool operator==(double d, const MRational& r){
    return d == r.toDouble();
  }
  
  template<typename T>
  inline bool operator==(const T& t, const MRational& r){
    return MRational(t) == r;
  }
  
  inline bool operator!=(double d, const MRational& r){
    return d == r.toDouble();
  }
  
  template<typename T>
  inline bool operator!=(const T& t, const MRational& r){
    return MRational(t) != r;
  }
  
  inline double operator+(double d, const MRational& r){
    return d + r.toDouble();
  }
  
  template<typename T>
  inline MRational operator+(const T& t, const MRational& r){
    return MRational(t) + r;
  }
  
  inline double operator-(double d, const MRational& r){
    return d - r.toDouble();
  }
  
  template<typename T>
  inline MRational operator-(const T& t, const MRational& r){
    return MRational(t) - r;
  }
  
  inline double operator*(double d, const MRational& r){
    return d * r.toDouble();
  }
  
  template<typename T>
  inline MRational operator*(const T& t, const MRational& r){
    return MRational(t) * r;
  }
  
  inline double operator/(double d, const MRational& r){
    return d / r.toDouble();
  }
  
  template<typename T>
  inline MRational operator/(const T& t, const MRational& r){
    return MRational(t) / r;
  }
  
  typedef MRational mrat;
  
} // end namespace Meta

#endif // ANDROMETA_M_RATIONAL_H