BaseNnumber.hpp

Go to the documentation of this file.

#pragma once
 
#include "Headers/Algorithm/powi.hpp"
#include <iostream>
#include <cerrno>
#include <cassert>
 
#ifndef __NVCC__
    #define __host__
    #define __device__
#endif
 
template<typename Integer = int>
class BaseConverter {
    private:
        Integer         m_base   = 0;
        Integer         m_length = 0;
        Integer         m_max    = 0;
        mutable Integer m_register;
 
    public:
        __host__ __device__ BaseConverter() {}
        __host__ __device__ BaseConverter(Integer Base, Integer Length)
            : m_base(Base), m_length(Length), m_max(powi(Base, Length)) {}
 
        __host__ __device__ BaseConverter(BaseConverter<Integer> const& other)
            : m_base(other.base()), m_length(other.length()), m_max(other.maxVal()) {}
 
        __host__ void status(void) const {
            std::cout << "baseConverter.status()"
                      << "\n"
                      << "\tBase:   " << this->m_base << "\n"
                      << "\tLength: " << this->m_length << "\n"
                      << "\tMax:    " << this->m_max - 1 << "\n"
                      << "\tRegistered value: " << this->m_register << std::endl;
        }
        __host__ __device__ Integer base() const { return this->m_base; }
        __host__ __device__ Integer length() const { return this->m_length; }
        __host__ __device__ Integer maxVal() const { return this->m_max; }
        __host__ __device__ Integer value() const { return this->m_register; }
 
        //
        template<typename Input,
                 typename std::enable_if_t< !std::is_integral_v<Input> >* = nullptr >
        __host__ __device__ BaseConverter const& set(Input config) const {
            static_assert(std::is_integral<Input>::value == false);
            Integer num = 0, base = 1;
            for(Integer pos = 0; pos < m_length; ++pos) {
                num += config.at(m_length - 1 - pos) * base;
                base *= m_base;
            }
            this->m_register = num;
            return *this;
        }
        template<typename Input>
        __host__ __device__ BaseConverter const& set(Input num) const {
            static_assert(std::is_integral<Input>::value == true);
            this->m_register = num;
            return *this;
        }
 
        __host__ __device__ BaseConverter& setParam(Integer Base, Integer Length) {
            this->m_base   = Base;
            this->m_length = Length;
            this->m_max    = powi(Base, Length);
            return *this;
        }
 
        __host__ __device__ Integer digit(Integer const num, Integer const pos, Integer const base,
                                          Integer const length) const {
            Integer Pos
                = (pos % length + length) % length;  // taking care of negative values of 'trans'
            return (num / powi(base, Pos % length)) % base;
        }
        __host__ __device__ Integer digit(Integer const num, Integer const pos) const {
            return this->digit(num, pos, m_base, m_length);
        }
        __host__ __device__ Integer digit(Integer const pos) const {
            return this->digit(m_register, pos, m_base, m_length);
        }
 
        __host__ __device__ Integer shiftDigits(Integer const num, Integer const trans,
                                                Integer const base, Integer const length) const {
            Integer Trans
                = (trans % length + length) % length;  // taking care of negative values of 'trans'
            Integer temp = powi(base, Trans);
            return (num / temp) + (num % temp) * powi(base, length - Trans);
        }
 
        __host__ __device__ Integer shiftDigits(Integer const num, Integer const trans) const {
            return this->shiftDigits(num, trans, m_base, m_length);
        }
 
        __host__ __device__ BaseConverter const& shiftDigits(Integer const trans) const {
            this->m_register = this->shiftDigits(m_register, trans, m_base, m_length);
            return *this;
        }
 
        template<typename Input>
        __host__ __device__ Integer digitsToNumber(Input const& digits, Integer const base,
                                                   Integer const length) const {
            Integer res = 0, p = 1;
            for(int l = length - 1; l >= 0; --l) {
                res += p * digits[l];
                p *= base;
            }
            return res;
        }
        template<typename Input>
        __host__ __device__ Integer digitsToNumber(Input const& digits) const {
            return this->digitsToNumber(digits, m_base, m_length);
        }
 
        template<typename Output>
        __host__ __device__ auto printInDigits(Output& output, Integer const num,
                                               Integer const base, Integer const length) const ->
            typename std::enable_if< std::is_integral<Output>::value == false,
                                     BaseConverter const&>::type {
            static_assert(std::is_integral<Output>::value == false);
            if(num >= powi(base, length)) {
#ifndef __CUDA_ARCH__
                std::cerr << "Warning:" << __PRETTY_FUNCTION__ << "\n\t"
                          << "Input(" << num
                          << ") cannot be expressed with base " << base << " and length " << length
                          << "." << std::endl;
#endif
            }
            if(output.size() < length) output.resize(length);
            for(int l = 0; l < length; ++l) {
                output[l] = this->digit(num, length - l - 1, base, length);
            }
            return *this;
        }
        template<typename Output>
        __host__ __device__ auto printInDigits(Output& output, Integer const num) const ->
            typename std::enable_if< std::is_integral<Output>::value == false,
                                     BaseConverter const&>::type {
            static_assert(std::is_integral<Output>::value == false);
            this->printInDigits(output, num, m_base, m_length);
            return *this;
        }
        template<typename Output,
                 typename std::enable_if_t< !std::is_integral_v<Output> >* = nullptr >
        __host__ __device__ BaseConverter const& printInDigits(Output& output) const {
            static_assert(std::is_integral<Output>::value == false);
            this->printInDigits(output, m_register, m_base, m_length);
            return *this;
        }
 
        __host__ BaseConverter const& printInDigits(Integer const num, Integer const base,
                                                    Integer const length) const {
            if(num >= powi(base, length)) {
                std::cerr << "Warning(" << __func__ << "): Input(" << num
                          << ") cannot be expressed with base " << base << " and length " << length
                          << "." << std::endl;
            }
            for(int l = length - 1; l >= 0; --l) {
                std::cout << this->digit(num, l, base, length) << " ";
            }
            std::cout << std::endl;
            return *this;
        }
        // template<typename Input>
        __host__ BaseConverter const& printInDigits(Integer const num) const {
            // static_assert(std::is_integral<Input>::value == true);
            this->printInDigits(num, m_base, m_length);
            return *this;
        }
        __host__ BaseConverter const& printInDigits() const {
            this->printInDigits(m_register, m_base, m_length);
            return *this;
        }
};
 
// template<typename Integer, typename Vector>
// class generalBaseConverter {
//      Integer m_max;
//      Integer m_register;
 
//      static inline __device__ __host__ Integer powi(Integer base, Integer exponent) {
//          static_assert(std::is_integral<Integer>::value,
//                        "Base and exponent number must be integers.");
//          if(exponent < 0) {
//              std::cout << "Error(" << __func__ << "): Exponent must be non-negative."
//                        << std::endl;
//              std::exit(EXIT_FAILURE);
//          }
//          Integer res = 1;
//          for(int i = 0; i < exponent; ++i) res *= base;
//          return res;
//      }
 
//      static inline __device__ __host__ Integer MaxVal(Vector Base, Integer Length) {
//          Integer res = 1;
//          for(int i = 0; i < Length; ++i) res *= Base.at(i);
//          return res-1;
//      }
 
//  public:
//      /**
//       * @brief Construct a new BaseConverter object
//       *
//       * @param[in] Base
//       * @param[in] Length
//       */
//      generalBaseConverter(Vector Base, Integer Length)
//          : m_base(Base), m_length(Length), m_max(1) {
//          if(Base.size() < Length) {
//              std::cerr << "Base.size(" << Base.size() << ") < Length(" << Length << ")" << std::endl;
//              std::exit(EINVAL);
//          }
//          m_max = this->MaxVal(Base, Length);
//      }
 
//      /**
//      * @brief Show the status of the instance
//      * @li Base:   Base of the positional notation to which the input number will converted
//      * @li Length: Number of digits in the resulting expression
//      * @li Max:    The maximum integer representable with given Base and Length
//      * @li Registered value: An integer currently held by the instance
//      */
//      void status(void) const {
//          std::cout << "baseConverter.status()"
//                    << "\n"
//                    << "\tBase:   ";
//          for(int pos = 0; pos < m_length; ++pos) { std::cout << m_base[pos] << " "; }
//          std::cout << "\n"
//                    << "\tLength: " << this->m_length << "\n"
//                    << "\tMax:    " << this->m_max - 1 << "\n"
//                    << "\tRegistered value: " << this->m_register << std::endl;
//      }
//      Integer base(int pos) const { return this->m_base.at(pos); }
//      Integer length() const { return this->m_length; }
//      Integer Max() const { return this->m_max; }
//      Integer value() const { return this->m_register; }
 
//      /**
//       * @brief
//       *
//       * @param num    An integer to be held by the instance
//       * @param digits An array of integers
//       *               which is to be held by the instance after converted to an integer
//       *               in terms of the positional notation with base=this->base() and length=this->length()
//       * @return BaseConverter& Reference to the instance itself
//       */
//      template<typename Input>
//      generalBaseConverter& set(Input digits) {
//          Integer num = 0, base = 1;
//          for(int pos = 0; pos < m_Length; ++pos) {
//              num  += digits[pos] * base;
//              base *= m_base[pos];
//          }
//          this->m_register = num;
//          return *this;
//      }
//      generalBaseConverter& set(Integer num) {
//          this->m_register = num;
//          return *this;
//      }
 
//      /**
//      * @brief Set the base and the length of the positional notation to which the input number will converted
//      * @param Base:   Base of the positional notation to which the number will converted
//      * @param Length: Number of digits in the resulting expression
//      */
//      generalBaseConverter& setParam(Vector Base, Integer Length) {
//          this->m_base.resize(Length);
//          std::copy(Base.begin(), Base.end() + Length, this->m_base.begin());
//          this->m_length = Length;
//          this->m_max    = this->MaxVal(Base, Length);
//          return *this;
//      }
 
//      /**
//       * @brief Returns the (pos)-th digit of the input (num) in given base and length.
//       *
//       * @param[in] num    [default = this->value()] An integer the (pos)-th digit of which is to be returned.
//       * @param[in] pos    The position of digit starting from zero.
//       *                   Negative value specifies the position in the reverse order.
//       *                   For example, setting pos=-1 returns the (length-1)-th digit.
//       * @param[in] base   [default = this->base()]   Base of the positional notation.
//       * @param[in] length [default = this->length()] Length of the positional notation
//       *                   with respect to with a negative value of (pos) is interpreted.
//       * @return Integer   The (pos)-th digit of (num) in the positional notation with given (base) and (length).
//       */
//      __device__ __host__ Integer Digit(Integer const num, Integer const pos, Vector const Base,
//                                        Integer const length) const {
//          // taking care of negative values of 'pos'
//          Integer Pos = (pos % length + length) % length;
//          Integer base = 1;
//          for(int l = 0; l < Pos; ++l) base *= Base[l];
//          return (num / base) % Base[Pos];
//      }
//      __device__ __host__ Integer Digit(Integer const num, Integer const pos) const {
//          return Digit(num, pos, m_base, m_length);
//      }
//      __device__ __host__ Integer Digit(Integer const pos) const {
//          return Digit(m_register, pos, m_base, m_length);
//      }
 
//      /**
//       * @brief Converts an array of integers to the corresponding integer in terms of the positional notation with given (base) and (length)
//       *
//       * @tparam Output    Container of Integers
//       * @param[in] digits An array of Integers representing a number in the positional notation with given (base) and (length)
//       * @param[in] base   [default = this->base()]   Base of the positional notation.
//       * @param[in] length [default = this->length()] Length of the positional notation.
//       * @return Integer
//       */
//      template<typename Input>
//      __device__ __host__ Integer DigitsToNumber(Input const& digits, Vector const Base,
//                                                 Integer const length) const {
//          Integer res = 0, p = 1;
//          for(int l = length - 1; l >= 0; --l) {
//              if(digits[l] >= Base[l]) std::exit(EINVAL);
//              res += p * digits[l];
//              p *= Base[l];
//          }
//          return res;
//      }
//      template<typename Input>
//      __device__ __host__ Integer DigitsToNumber(Input const& digits) const {
//          return DigitsToNumber(digits, m_base, m_length);
//      }
 
//      /**
//       * @brief Expresses an integer (num) in the positional notation with given (base) and (length)
//       *
//       * @tparam Output     Container of Integers
//       * @param[out] output [default = std::cout]      An array to which the resulting expression is stored.
//       * @param[in]  num    [default = this->value()]  An integer to be expressed in the positional notation with given (base) and (length)
//       * @param[in]  base   [default = this->base()]   Base of the positional notation.
//       * @param[in]  length [default = this->length()] Length of the positional notation.
//       * @return BaseConverter& Reference to the instance itself
//       */
//      template<typename Output>
//      __device__ __host__ generalBaseConverter& printInDigits(Output& output, Integer const num,
//                                                       Vector const Base, Integer const Length) {
//          if(num > MaxVal(Base, length)) {
//              std::cerr << "Warning(" << __func__ << "): Input(" << num
//                        << ") cannot be expressed with base " << Base << " and length " << Length
//                        << "." << std::endl;
//          }
//          for(int l = 0; l < Length; ++l) {
//              output[l] = Digit(num, Length - l - 1, Base, Length);
//          }
//          return *this;
//      }
//      template<typename Output>
//      __device__ __host__ generalBaseConverter& printInDigits(Output& output, Integer const num) {
//          printInDigits(output, num, m_base, m_length);
//          return *this;
//      }
//      template<typename Output>
//      __device__ __host__ generalBaseConverter& printInDigits(Output& output) {
//          printInDigits(output, m_register, m_base, m_length);
//          return *this;
//      }
 
//      __device__ __host__ generalBaseConverter& printInDigits(Integer const num, Vector const Base,
//                                                       Integer const Length) {
//          if(num > MaxVal(Base, Length)) {
//              std::cerr << "Warning(" << __func__ << "): Input(" << num
//                        << ") cannot be expressed with base " << Base << " and length " << Length
//                        << "." << std::endl;
//          }
//          for(int l = Length - 1; l >= 0; --l) {
//              std::cout << Digit(num, l, Base, Length) << " ";
//          }
//          std::cout << std::endl;
//          return *this;
//      }
//      __device__ __host__ generalBaseConverter& printInDigits(Integer const num) {
//          printInDigits(num, m_base, m_length);
//          return *this;
//      }
//      __device__ __host__ generalBaseConverter& printInDigits() {
//          printInDigits(m_register, m_base, m_length);
//          return *this;
//      }
// };