integer.hpp

#ifndef __INTEGER_HPP_
#define __INTEGER_HPP_

#include "rings.hpp"

namespace Rings {

template<typename T>
class Integer : virtual public Integral_Domain_Element {

private:

  T value;

public:

  Integer<T>();
  Integer<T>(T);
  Integer<T>(const Integer<T> & other);

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

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

  virtual bool operator == (const Ring_Element &) const override;
  virtual bool 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 Ring_Element & operator * (const Ring_Element &) const override;

  T get_value() const;

};

template<typename T>
Integer<T>::Integer() : value(0) { }

template<typename T>
Integer<T>::Integer(T v) : value(v) { }

template<typename T>
Integer<T>::Integer(const Integer<T> & other) : value(other.value) { }

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

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

template<typename T>
bool Integer<T>::has_inverse() const { return value == 1 or value == -1; }

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

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

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

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

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

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

template<typename T>
T Integer<T>::get_value() const { return value; }

template <typename T>
ostream & operator << (ostream & os, Integer<T> i) {
  os << i.get_value();
  return os;
}

}

#endif