BaseConverter< Integer > Class Template Reference

Provides utilities for converting an integer to the corresponding expression in the positional notation with given base and number of digits. More...

#include <BaseNnumber.hpp>

Collaboration diagram for BaseConverter< Integer >:

Public Member Functions
__host__ __device__	BaseConverter ()
__host__ __device__	BaseConverter (Integer Base, Integer Length)
	Construct a new BaseConverter object.
__host__ __device__	BaseConverter (BaseConverter< Integer > const &other)
__host__ void	status (void) const
	Show the status of the instance.
__host__ __device__ Integer	base () const
__host__ __device__ Integer	length () const
__host__ __device__ Integer	maxVal () const
__host__ __device__ Integer	value () const
template<typename Input , typename std::enable_if_t< !std::is_integral_v< Input > > * = nullptr>
__host__ __device__ BaseConverter const &	set (Input config) const
template<typename Input >
__host__ __device__ BaseConverter const &	set (Input num) const
__host__ __device__ BaseConverter &	setParam (Integer Base, Integer Length)
	Set the base and the length of the positional notation to which the input number will converted.
__host__ __device__ Integer	digit (Integer const num, Integer const pos, Integer const base, Integer const length) const
	Returns the (pos)-th digit of the input (num) in given base and length.
__host__ __device__ Integer	digit (Integer const num, Integer const pos) const
__host__ __device__ Integer	digit (Integer const pos) const
__host__ __device__ Integer	shiftDigits (Integer const num, Integer const trans, Integer const base, Integer const length) const
	Shifts a number (num) to right by (trans) in terms of the positional notation with given base and length under the periodic boundary condition.
__host__ __device__ Integer	shiftDigits (Integer const num, Integer const trans) const
__host__ __device__ BaseConverter const &	shiftDigits (Integer const trans) const
template<typename Input >
__host__ __device__ Integer	digitsToNumber (Input const &digits, Integer const base, Integer const length) const
	Converts an array of integers to the corresponding integer in terms of the positional notation with given (base) and (length)
template<typename Input >
__host__ __device__ Integer	digitsToNumber (Input const &digits) const
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
	Expresses an integer (num) in the positional notation with given (base) and (length)
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
template<typename Output , typename std::enable_if_t< !std::is_integral_v< Output > > * = nullptr>
__host__ __device__ BaseConverter const &	printInDigits (Output &output) const
__host__ BaseConverter const &	printInDigits (Integer const num, Integer const base, Integer const length) const
__host__ BaseConverter const &	printInDigits (Integer const num) const
__host__ BaseConverter const &	printInDigits () const

Private Attributes
Integer	m_base = 0
Integer	m_length = 0
Integer	m_max = 0
Integer	m_register

Detailed Description

template<typename Integer = int>
class BaseConverter< Integer >

Provides utilities for converting an integer to the corresponding expression in the positional notation with given base and number of digits.

Template Parameters

Integer

Integer class.

Constructor & Destructor Documentation

BaseConverter() [1/3]

template<typename Integer = int>

__host__ __device__ BaseConverter< Integer >::BaseConverter ( )

inline

{}

BaseConverter() [2/3]

template<typename Integer = int>

__host__ __device__ BaseConverter< Integer >::BaseConverter ( Integer  Base, Integer  Length  )

inline

Construct a new BaseConverter object.

Parameters

[in]	Base
[in]	Length

            : m_base(Base), m_length(Length), m_max(powi(Base, Length)) {}

BaseConverter() [3/3]

template<typename Integer = int>

__host__ __device__ BaseConverter< Integer >::BaseConverter ( BaseConverter< Integer > const &  other )

inline

            : m_base(other.base()), m_length(other.length()), m_max(other.maxVal()) {}

Member Function Documentation

base()

template<typename Integer = int>

__host__ __device__ Integer BaseConverter< Integer >::base ( ) const

inline

{ return this->m_base; }

digit() [1/3]

template<typename Integer = int>

__host__ __device__ Integer BaseConverter< Integer >::digit ( Integer const  num, Integer const  pos  ) const

inline

                                                                                      {
            return this->digit(num, pos, m_base, m_length);
        }

digit() [2/3]

template<typename Integer = int>

__host__ __device__ Integer BaseConverter< Integer >::digit ( Integer const  num, Integer const  pos, Integer const  base, Integer const  length  ) const

inline

Returns the (pos)-th digit of the input (num) in given base and length.

Parameters

[in]	num	[default = this->value()] An integer the (pos)-th digit of which is to be returned.
[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.
[in]	base	[default = this->base()] Base of the positional notation.
[in]	length	[default = this->length()] Length of the positional notation with respect to with a negative value of (pos) is interpreted.

Returns

Integer The (pos)-th digit of (num) in the positional notation with given (base) and (length).

                                                                      {
            Integer Pos
                = (pos % length + length) % length;  // taking care of negative values of 'trans'
            return (num / powi(base, Pos % length)) % base;
        }

digit() [3/3]

template<typename Integer = int>

__host__ __device__ Integer BaseConverter< Integer >::digit ( Integer const  pos ) const

inline

                                                                   {
            return this->digit(m_register, pos, m_base, m_length);
        }

digitsToNumber() [1/2]

template<typename Integer = int>

template<typename Input >

__host__ __device__ Integer BaseConverter< Integer >::digitsToNumber ( Input const &  digits ) const

inline

                                                                              {
            return this->digitsToNumber(digits, m_base, m_length);
        }

digitsToNumber() [2/2]

template<typename Integer = int>

template<typename Input >

__host__ __device__ Integer BaseConverter< Integer >::digitsToNumber ( Input const &  digits, Integer const  base, Integer const  length  ) const

inline

Converts an array of integers to the corresponding integer in terms of the positional notation with given (base) and (length)

Template Parameters

Output

Container of Integers

Parameters

[in]	digits	An array of Integers representing a number in the positional notation with given (base) and (length)
[in]	base	[default = this->base()] Base of the positional notation.
[in]	length	[default = this->length()] Length of the positional notation.

Returns

Integer

                                                                               {
            Integer res = 0, p = 1;
            for(int l = length - 1; l >= 0; --l) {
                res += p * digits[l];
                p *= base;
            }
            return res;
        }

length()

template<typename Integer = int>

__host__ __device__ Integer BaseConverter< Integer >::length ( ) const

inline

{ return this->m_length; }

maxVal()

template<typename Integer = int>

__host__ __device__ Integer BaseConverter< Integer >::maxVal ( ) const

inline

{ return this->m_max; }

printInDigits() [1/6]

template<typename Integer = int>

__host__ BaseConverter const & BaseConverter< Integer >::printInDigits ( ) const

inline

                                                            {
            this->printInDigits(m_register, m_base, m_length);
            return *this;
        }

printInDigits() [2/6]

template<typename Integer = int>

__host__ BaseConverter const & BaseConverter< Integer >::printInDigits ( Integer const  num ) const

inline

                                                                             {
            // static_assert(std::is_integral<Input>::value == true);
            this->printInDigits(num, m_base, m_length);
            return *this;
        }

printInDigits() [3/6]

template<typename Integer = int>

__host__ BaseConverter const & BaseConverter< Integer >::printInDigits ( Integer const  num, Integer const  base, Integer const  length  ) const

inline

                                                                                {
            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;
        }

printInDigits() [4/6]

template<typename Integer = int>

template<typename Output , typename std::enable_if_t< !std::is_integral_v< Output > > * = nullptr>

__host__ __device__ BaseConverter const & BaseConverter< Integer >::printInDigits ( Output &  output ) const

inline

                                                                                     {
            static_assert(std::is_integral<Output>::value == false);
            this->printInDigits(output, m_register, m_base, m_length);
            return *this;
        }

printInDigits() [5/6]

template<typename Integer = int>

template<typename Output >

__host__ __device__ auto BaseConverter< Integer >::printInDigits ( Output &  output, Integer const  num  ) const -> typename std::enable_if< std::is_integral<Output>::value == false, BaseConverter const&>::type

inline

                                                               {
            static_assert(std::is_integral<Output>::value == false);
            this->printInDigits(output, num, m_base, m_length);
            return *this;
        }

printInDigits() [6/6]

template<typename Integer = int>

template<typename Output >

__host__ __device__ auto BaseConverter< Integer >::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

inline

Expresses an integer (num) in the positional notation with given (base) and (length)

Template Parameters

Output

Container of Integers

Parameters

[out]	output	[default = std::cout] An array to which the resulting expression is stored.
[in]	num	[default = this->value()] An integer to be expressed in the positional notation with given (base) and (length)
[in]	base	[default = this->base()] Base of the positional notation.
[in]	length	[default = this->length()] Length of the positional notation.

Returns

BaseConverter& Reference to the instance itself

                                                               {
            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;
        }

set() [1/2]

template<typename Integer = int>

template<typename Input , typename std::enable_if_t< !std::is_integral_v< Input > > * = nullptr>

__host__ __device__ BaseConverter const & BaseConverter< Integer >::set ( Input  config ) const

inline

Parameters

num	An integer to be held by the instance
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()

Returns

BaseConverter& Reference to the instance itself

                                                                         {
            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;
        }

set() [2/2]

template<typename Integer = int>

template<typename Input >

__host__ __device__ BaseConverter const & BaseConverter< Integer >::set ( Input  num ) const

inline

                                                                      {
            static_assert(std::is_integral<Input>::value == true);
            this->m_register = num;
            return *this;
        }

setParam()

template<typename Integer = int>

__host__ __device__ BaseConverter & BaseConverter< Integer >::setParam ( Integer  Base, Integer  Length  )

inline

Set the base and the length of the positional notation to which the input number will converted.

Parameters

Base	Base of the positional notation to which the number will converted
Length	Number of digits in the resulting expression

                                                                                  {
            this->m_base   = Base;
            this->m_length = Length;
            this->m_max    = powi(Base, Length);
            return *this;
        }

shiftDigits() [1/3]

template<typename Integer = int>

__host__ __device__ Integer BaseConverter< Integer >::shiftDigits ( Integer const  num, Integer const  trans  ) const

inline

                                                                                              {
            return this->shiftDigits(num, trans, m_base, m_length);
        }

shiftDigits() [2/3]

template<typename Integer = int>

__host__ __device__ Integer BaseConverter< Integer >::shiftDigits ( Integer const  num, Integer const  trans, Integer const  base, Integer const  length  ) const

inline

Shifts a number (num) to right by (trans) in terms of the positional notation with given base and length under the periodic boundary condition.

Parameters

[in]	num	[default = this->value()] An integer to be shifted.
[in]	trans	Amount of the shift to right. The j-th digit is to be shifted to [(j+trans) % length]-th digit. Negative value means a shift in the reverse order (i.e. to left).
[in]	base	[default = this->base()] Base of the positional notation.
[in]	length	[default = this->length()] Length of the positional notation with respect to with a negative value of (trans) is interpreted.

Returns

Integer An integer corresponding to the shifted notation.

                                                                                                {
            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);
        }

shiftDigits() [3/3]

template<typename Integer = int>

__host__ __device__ BaseConverter const & BaseConverter< Integer >::shiftDigits ( Integer const  trans ) const

inline

                                                                                        {
            this->m_register = this->shiftDigits(m_register, trans, m_base, m_length);
            return *this;
        }

status()

template<typename Integer = int>

__host__ void BaseConverter< Integer >::status ( void  ) const

inline

Show the status of the instance.

• Base: Base of the positional notation to which the input number will converted
• Length: Number of digits in the resulting expression
• Max: The maximum integer representable with given Base and Length
• Registered value: An integer currently held by the instance

                                         {
            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;
        }

value()

template<typename Integer = int>

__host__ __device__ Integer BaseConverter< Integer >::value ( ) const

inline

{ return this->m_register; }

Member Data Documentation

m_base

template<typename Integer = int>

Integer BaseConverter< Integer >::m_base = 0

private

m_length

template<typename Integer = int>

Integer BaseConverter< Integer >::m_length = 0

private

m_max

template<typename Integer = int>

Integer BaseConverter< Integer >::m_max = 0

private

m_register

template<typename Integer = int>

Integer BaseConverter< Integer >::m_register

mutableprivate

---

The documentation for this class was generated from the following file:

• /Users/shoki/GitHub/Locality/Headers/Algorithm/BaseNnumber.hpp