rational.hpp

#ifndef __RATIONAL_HPP_
#define __RATIONAL_HPP_

#include "../gcd/gcd_template.hpp"
#include "rings.hpp"
#include "integer.hpp"

namespace Rings {

template<typename T>
class Rational : public Field_Element {

protected:

  T num;
  T den;

  void simplify();

public:

  using Field_Element::has_inverse;
  using Field_Element::is_cancellable;
  using Field_Element::is_commutative;

  Rational<T>();
  Rational<T>(T);
  Rational<T>(T, T);
  Rational<T>(const Integer<T> &);
  Rational<T>(const Rational<T> &);

  virtual bool is_one() const override;
  virtual bool is_zero() const override;

  virtual Ring_Element & operator + (const Ring_Element &) const override;
  virtual Ring_Element & operator - (const Ring_Element &) const override;
  virtual Ring_Element & operator * (const Ring_Element &) const override;
  virtual Field_Element & operator / (const Field_Element &) const override;

  const Rational<T> & operator = (const Ring_Element &);

  virtual bool operator == (const Ring_Element &) const override;
  virtual bool operator != (const Ring_Element &) const override;

  virtual Field_Element & inverse() const override;

  T get_numerator() const;
  T get_denominator() const;

};

template<typename T>
void Rational<T>::simplify() {
  if (num == 0)
    den = 1;
  else {
    T d = gcd<T>(num, den);
    num /= d;
    den /= d;
  }
}

template<typename T>
Rational<T>::Rational() : num(0), den(1) { }

template<typename T>
Rational<T>::Rational(T integer) : num(integer), den(1) { }

template<typename T>
Rational<T>::Rational(T numerator, T denominator)
    : num(numerator), den(denominator)
{
  simplify();
}

template<typename T>
Rational<T>::Rational(const Integer<T> & other) : num(other.get_value()), den(1)
{ }

template<typename T>
Rational<T>::Rational(const Rational<T> & other) : num(other.num), den(other.den)
{ }

template<typename T>
bool Rational<T>::is_one() const { return num == den; }

template<typename T>
bool Rational<T>::is_zero() const { return num == 0; }

template<typename T>
Ring_Element & Rational<T>::operator + (const Ring_Element & other) const {
  static Rational<T> result;
  result = dynamic_cast<const Rational<T> &>(other);
  result.num = result.num * den + num * result.den;
  result.den *= den;
  result.simplify();
  return result;
}

template<typename T>
Ring_Element & Rational<T>::operator - (const Ring_Element & other) const {
  static Rational<T> result;
  result = dynamic_cast<const Rational<T> &>(other);
  result.num = - result.num * den + num * result.den;
  result.den *= den;
  result.simplify();
  return result;
}

template<typename T>
Ring_Element & Rational<T>::operator * (const Ring_Element & other) const {
  static Rational<T> result;
  result = dynamic_cast<const Rational<T> &>(other);
  result.num *= num;
  result.den *= den;
  result.simplify();
  return result;
}

template<typename T>
Field_Element & Rational<T>::operator / (const Field_Element & other) const {
  static Rational<T> result;
  result.num = num;
  result.den = den;
  result.num *= dynamic_cast<const Rational<T> &>(other).num;
  result.den *= dynamic_cast<const Rational<T> &>(other).den;
  result.simplify();
  return result;
}

template<typename T>
const Rational<T> & Rational<T>::operator = (const Ring_Element & o) {
  if (*this != o) {
    const Rational<T> & other = dynamic_cast<const Rational<T> &>(o);
    num = other.num;
    den = other.den;
  }
  return *this;
}

template<typename T>
bool Rational<T>::operator == (const Ring_Element & o) const {
  const Rational<T> & other = dynamic_cast<const Rational<T> &>(o);
  return num == other.num and den == other.den;
}

template<typename T>
bool Rational<T>::operator != (const Ring_Element & o) const {
  const Rational<T> & other = dynamic_cast<const Rational<T> &>(o);
  return num != other.num or den != other.den;
}

template<typename T>
Field_Element & Rational<T>::inverse() const {
  static Rational<T> result(den, num);
  return result;
}

template<typename T>
T Rational<T>::get_numerator() const { return num; }

template<typename T>
T Rational<T>::get_denominator() const { return den; }

template<typename T>
ostream & operator << (ostream & os, const Rational<T> & r) {
  os << r.get_numerator();
  if (r.get_denominator() != 1)
    os << " / " << r.get_denominator();
  return os;
}

}


#endif