Integer.hpp

#pragma once

#include <compare>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <string_view>

#include <boost/multiprecision/fwd.hpp>
#include <boost/multiprecision/gmp.hpp>

#include "fintamath/core/IArithmetic.hpp"
#include "fintamath/core/MathObjectClass.hpp"
#include "fintamath/numbers/INumber.hpp"

namespace fintamath {

class Integer : public INumberCRTP<Integer> {
  FINTAMATH_CLASS_BODY(Integer, INumber)

public:
  using Backend = boost::multiprecision::mpz_int;

public:
  Integer() = default;

  Integer(std::integral auto rhs) : backend(rhs) {}

  Integer(Backend inBackend);

  explicit Integer(std::string_view str);

  std::string toString() const override;

  int sign() const;

  const Backend &getBackend() const noexcept;

  template <std::integral T>
  explicit operator T() const {
    return backend.convert_to<T>();
  }

  Integer &operator%=(const Integer &rhs);

  Integer &operator&=(const Integer &rhs);

  Integer &operator|=(const Integer &rhs);

  Integer &operator^=(const Integer &rhs);

  Integer &operator<<=(const Integer &rhs);

  Integer &operator>>=(const Integer &rhs);

  Integer operator%(const Integer &rhs) const;

  Integer operator&(const Integer &rhs) const;

  Integer operator|(const Integer &rhs) const;

  Integer operator^(const Integer &rhs) const;

  Integer operator<<(const Integer &rhs) const;

  Integer operator>>(const Integer &rhs) const;

  Integer operator~() const;

  Integer &operator++();

  Integer &operator--();

  Integer operator++(int);

  Integer operator--(int);

protected:
  bool equals(const Integer &rhs) const override;

  std::strong_ordering compare(const Integer &rhs) const override;

  Integer &add(const Integer &rhs) override;

  Integer &substract(const Integer &rhs) override;

  Integer &multiply(const Integer &rhs) override;

  std::unique_ptr<IArithmetic> multiplyAbstract(const IArithmetic &rhs) const override;

  Integer &divide(const Integer &rhs) override;

  std::unique_ptr<IArithmetic> divideAbstract(const IArithmetic &rhs) const override;

  Integer &negate() override;

  Integer &mod(const Integer &rhs);

  Integer &bitAnd(const Integer &rhs);

  Integer &bitOr(const Integer &rhs);

  Integer &bitXor(const Integer &rhs);

  Integer &bitLeftShift(const Integer &rhs);

  Integer &bitRightShift(const Integer &rhs);

  Integer &bitNot();

  Integer &increase();

  Integer &decrease();

private:
  Backend backend;
};

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer &operator%=(Integer &lhs, const Rhs &rhs) {
  return lhs %= Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer &operator&=(Integer &lhs, const Rhs &rhs) {
  return lhs &= Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer &operator|=(Integer &lhs, const Rhs &rhs) {
  return lhs |= Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer &operator^=(Integer &lhs, const Rhs &rhs) {
  return lhs ^= Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer &operator<<=(Integer &lhs, const Rhs &rhs) {
  return lhs <<= Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer &operator>>=(Integer &lhs, const Rhs &rhs) {
  return lhs >>= Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer operator%(const Integer &lhs, const Rhs &rhs) {
  return lhs % Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Lhs>
Integer operator%(const Lhs &lhs, const Integer &rhs) {
  return Integer(lhs) % rhs;
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer operator&(const Integer &lhs, const Rhs &rhs) {
  return lhs & Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Lhs>
Integer operator&(const Lhs &lhs, const Integer &rhs) {
  return Integer(lhs) & rhs;
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer operator|(const Integer &lhs, const Rhs &rhs) {
  return lhs | Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Lhs>
Integer operator|(const Lhs &lhs, const Integer &rhs) {
  return Integer(lhs) | rhs;
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer operator^(const Integer &lhs, const Rhs &rhs) {
  return lhs ^ Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Lhs>
Integer operator^(const Lhs &lhs, const Integer &rhs) {
  return Integer(lhs) ^ rhs;
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer operator<<(const Integer &lhs, const Rhs &rhs) {
  return lhs << Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Lhs>
Integer operator<<(const Lhs &lhs, const Integer &rhs) {
  return Integer(lhs) << rhs;
}

template <ConvertibleToAndNotSameAs<Integer> Rhs>
Integer operator>>(const Integer &lhs, const Rhs &rhs) {
  return lhs >> Integer(rhs);
}

template <ConvertibleToAndNotSameAs<Integer> Lhs>
Integer operator>>(const Lhs &lhs, const Integer &rhs) {
  return Integer(lhs) >> rhs;
}

}

template <>
struct std::hash<fintamath::Integer> {
  size_t operator()(const fintamath::Integer &rhs) const noexcept {
    using fintamath::detail::Hash;

    return Hash<fintamath::Integer::Backend>{}(rhs.getBackend());
  }
};