mod.hpp

#ifndef __MOD_
#define __MOD_

#include <stdexcept>
using std::domain_error;

#include <iostream>
using std::ostream;

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

#include "rings.hpp"

namespace Rings {

template<typename T, T m>
class Mod : virtual public Commutative_Ring_Element {
protected:

  T value;
  bool invertible;

  void adjust_value() {
    value %= m;
    if (value < 0)
      value += m;
  }
  virtual void check_inverse() { invertible = 1 == gcd<T>(value, m); }
  void check_modulus() {
    if (m == 0) throw domain_error("Attempted to create a modulus of 0");
  }

public:

  Mod<T,m>();
  Mod<T, m>(T v);
  Mod<T, m>(const Mod<T, m> & other);

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

  virtual Mod<T, m> & operator + (const Ring_Element & other) const override;
  virtual Mod<T, m> & operator - (const Ring_Element & other) const override;
  virtual Mod<T, m> & operator * (const Ring_Element & other) const override;
  virtual Mod<T, m> & operator * (const T & other) const;

  const Mod<T,m> & operator = (const Ring_Element &);

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

  T get_value() const;

};

template<typename T, T m>
Mod<T,m>::Mod() : value(0) { check_modulus(); check_inverse(); }

template<typename T, T m>
Mod<T,m>::Mod(T v) : value(v) { adjust_value(); check_inverse(); }

template<typename T, T m>
Mod<T,m>::Mod(const Mod<T, m> & other)
    : value(other.value), invertible(other.invertible)
{ }

template<typename T, T m>
bool Mod<T,m>::is_one() const { return value == 1; }

template<typename T, T m>
bool Mod<T,m>::is_zero() const { return value == 0; }

template<typename T, T m>
bool Mod<T,m>::has_inverse() const { return invertible; }

template<typename T, T m>
Mod<T, m> & Mod<T,m>::operator + (const Ring_Element & other) const
{
  static Mod<T, m> result;
  auto o = dynamic_cast<const Mod<T, m> &>(other);
  result.value = value + o.value;
  result.adjust_value();
  return result;
}

template<typename T, T m>
Mod<T, m> & Mod<T,m>::operator - (const Ring_Element & other) const
{
  static Mod<T, m> result;
  auto o = dynamic_cast<const Mod<T, m> &>(other);
  result.value = value - o.value;
  result.adjust_value();
  return result;
}

template<typename T, T m>
Mod<T, m> & Mod<T,m>::operator * (const Ring_Element & other) const
{
  static Mod<T, m> result;
  auto o = dynamic_cast<const Mod<T, m> &>(other);
  result.value = value * o.value;
  result.adjust_value();
  return result;
}

template<typename T, T m>
Mod<T, m> & Mod<T,m>::operator * (const T & other) const {
  static Mod<T, m> result;
  result.value = value * other;
  result.adjust_value();
  return result;
}

template<typename T, T m>
const Mod<T,m> & Mod<T,m>::operator = (const Ring_Element & other) {
  if (*this != other) {
    const Mod<T,m> & o = dynamic_cast<const Mod<T,m> & >(other);
    value = o.value;
    invertible = o.invertible;
  }
  return *this;
}

template<typename T, T m>
bool Mod<T,m>::operator == (const Ring_Element & other) const {
  const Mod<T,m> & o = dynamic_cast<const Mod<T,m> & >(other);
  return value == o.value;
}

template<typename T, T m>
bool Mod<T,m>::operator != (const Ring_Element & other) const {
  const Mod<T,m> & o = dynamic_cast<const Mod<T,m> & >(other);
  return value != o.value;
}

template<typename T, T m>
T Mod<T,m>::get_value() const { return value; }

template <typename T, T m>
ostream & operator << (ostream & os, const Mod<T, m> & x) {
  os << x.get_value();
  return os;
}

template<typename T, T m>
constexpr Mod<T,m> prevent_zero_modulus;

}

#endif