Aesi.h

Go to the documentation of this file.

 
#ifndef AESI_MULTIPRECISION
#define AESI_MULTIPRECISION
 
#include "Aeu.h"
 
namespace {
    enum class Sign { Zero = 0, Positive = 1, Negative = -1 };
 
    template <typename Char> requires (std::is_same_v<Char, char> || std::is_same_v<Char, wchar_t>)
    Sign traverseDashes(const Char* ptr, std::size_t);
 
    template <>
    inline Sign traverseDashes(const char* ptr, std::size_t size) {
        std::byte positive { 1 };
        for(std::size_t i = 0; i < size; ++i)
            if(ptr[i] == '-') positive ^= std::byte {1};
        return positive == std::byte {1} ? Sign::Positive : Sign::Negative;
    }
 
    template <>
    inline Sign traverseDashes(const wchar_t* ptr, std::size_t size) {
        std::byte positive { 1 };
        for(std::size_t i = 0; i < size; ++i)
            if(ptr[i] == L'-') positive ^= std::byte {1};
        return positive == std::byte {1} ? Sign::Positive : Sign::Negative;
    }
}
template <std::size_t bitness = 512> requires (bitness % blockBitLength == 0)
class Aesi final {
    /* -------------------------- @name Class members. ----------------------- */
    Sign sign;
 
    using Base = Aeu<bitness>;
    Base base;
    /* ----------------------------------------------------------------------- */
 
    gpu constexpr Aesi(Sign withSign, Base withBase): sign { withSign }, base { withBase } {}
 
public:
    /* --------------------- @name Different constructors. ------------------- */
    constexpr Aesi() noexcept = default;
 
    constexpr ~Aesi() noexcept = default;
 
    constexpr Aesi(const Aesi& copy) noexcept = default;
 
    template <typename Integral> requires (std::is_integral_v<Integral>)
    gpu constexpr Aesi(Integral value) noexcept {
        using enum Sign;
        if(value < 0) {
            base = Base(static_cast<unsigned long long>(-value));
            sign = Negative;
        } else if(value > 0) {
            base = Base(static_cast<unsigned long long>(value));
            sign = Positive;
        } else {
            base = {};
            sign = Zero;
        }
    }
 
    template <typename Char> requires (std::is_same_v<Char, char> || std::is_same_v<Char, wchar_t>)
    gpu constexpr Aesi(const Char* ptr, std::size_t size) noexcept : base(ptr, size) {
        if(!base.isZero())
            sign = traverseDashes(ptr, size);
        else sign = Sign::Zero;
    }
 
    template <typename Char, std::size_t arrayLength> requires (arrayLength > 1 && (std::is_same_v<Char, char> || std::is_same_v<Char, wchar_t>))
    gpu constexpr Aesi(const Char (&literal)[arrayLength]) noexcept : Aesi(literal, arrayLength) {}
 
    template <typename String, typename Char = typename String::value_type> requires (std::is_same_v<std::basic_string<Char>,
        std::decay_t<String>> || std::is_same_v<std::basic_string_view<Char>, std::decay_t<String>>)
    gpu constexpr Aesi(String&& stringView) noexcept : Aesi(stringView.data(), stringView.size()) {}
 
    template <typename String, typename Char = typename String::value_type> requires (std::is_same_v<std::basic_string<Char>,
        std::decay_t<String>> || std::is_same_v<std::basic_string_view<Char>, std::decay_t<String>>)
    gpu constexpr Aesi(const String& stringView) noexcept : Aesi(stringView.data(), stringView.size()) {}
 
    explicit gpu constexpr Aesi(const Aeu<bitness>& value) : sign(Sign::Positive), base(value) {}
 
 
#ifdef AESI_GMP_INTEGRATION
    constexpr Aesi(const mpz_class& number) {
        using enum Sign;
        if(number == 0) {
            base = {};
            sign = Zero;
        } else {
            base = number;
            if(number < 0)
                sign = Negative;
            else sign = Positive;
        }
    }
#endif
 
    template <typename Integral> requires (std::is_signed_v<Integral>)
    gpu constexpr Aesi& operator=(Integral value) noexcept {
        return *this = Aesi(value);
    }
 
    constexpr Aesi& operator=(const Aesi& other) noexcept = default;
    /* ----------------------------------------------------------------------- */
 
 
    /* --------------------- @name Arithmetic operators. --------------------- */
    /* ------------------------- @name Unary operators. -------------------------- */
        gpu constexpr auto operator+() const noexcept -> Aesi { return *this; }
 
        [[nodiscard]]
        gpu constexpr auto operator-() const noexcept -> Aesi { Aesi copy = *this; copy.inverse(); return copy; }
 
        gpu constexpr auto operator++() noexcept -> Aesi& {
            using enum Sign;
            if(sign == Negative) {
                --base; if(base.isZero()) sign = Zero;
            } else if(sign == Positive) {
                ++base;
            } else { base = 1u; sign = Positive; }
            return *this;
        }
 
        gpu constexpr auto operator++(int) & noexcept -> Aesi { Aesi old = *this; operator++(); return old; }
 
        gpu constexpr auto operator--() noexcept -> Aesi& {
            using enum Sign;
            if(sign == Negative) {
                ++base;
            } else if(sign == Positive) {
                --base; if(base.isZero()) sign = Zero;
            } else { base = 1u; sign = Negative; }
            return *this;
        }
 
        gpu constexpr auto operator--(int) & noexcept -> Aesi { Aesi old = *this; operator--(); return old; }
    /* --------------------------------------------------------------------------- */
 
    /* ------------------------ @name Addition operators. ------------------------ */
        [[nodiscard]]
        gpu constexpr friend auto operator+(const Aesi& addition, const Aesi& addendum) noexcept -> Aesi {
            Aesi result = addition; result += addendum; return result;
        }
 
        gpu constexpr friend auto operator+=(Aesi& addition, const Aesi& addendum) noexcept -> Aesi& {
            using enum Sign;
            Sign& lSign = addition.sign; const Sign& rSign = addendum.sign;
            Base& lBase = addition.base; const Base& rBase = addendum.base;
 
            if(rSign == Zero)
                return addition;
            else if(lSign == Zero)
                return addition = addendum;
            else if(lSign == rSign) {
                lBase += rBase;
                return addition;
            }
 
            if(lSign == Positive) {
                switch(lBase.compareTo(rBase)) {
                    using enum Comparison;
                    case greater: {
                        lBase -= rBase;
                        return addition;
                    }
                    case less: {
                        lBase = rBase - lBase;
                        lSign = Negative;
                        return addition;
                    }
                    default: {
                        lSign = Zero;
                        return addition;
                    }
                }
            } else {
                switch(const auto ratio = lBase.compareTo(rBase)) {
                    using enum Comparison;
                    case greater: {
                        lBase -= rBase;
                        return addition;
                    }
                    case less: {
                        lBase = rBase - lBase;
                        lSign = Positive;
                        return addition;
                    }
                    default: {
                        lSign = Zero;
                        return addition;
                    }
                }
            }
        }
    /* --------------------------------------------------------------------------- */
 
    /* ----------------------- @name Subtraction operators. ---------------------- */
        [[nodiscard]]
        gpu constexpr friend auto operator-(const Aesi& subtraction, const Aesi& subtrahend) noexcept -> Aesi {
            Aesi result = subtraction; result -= subtrahend; return result;
        }
 
        gpu constexpr friend auto operator-=(Aesi& subtraction, const Aesi& subtrahend) noexcept -> Aesi& {
            using enum Sign;
            Sign& lSign = subtraction.sign; const Sign& rSign = subtrahend.sign;
            Base& lBase = subtraction.base; const Base& rBase = subtrahend.base;
 
            if(rSign == Zero)
                return subtraction;
            if(lSign == Zero) {
                subtraction = subtrahend;
                subtraction.inverse();
                return subtraction;
            }
 
            if(lSign == Positive) {
                if(rSign == Positive) {
                    switch(lBase.compareTo(rBase)) {
                        using enum Comparison;
                        case greater: {
                            lBase -= rBase;
                            return subtraction;
                        }
                        case less: {
                            lBase = rBase - lBase;
                            lSign = Negative;
                            return subtraction;
                        }
                        default: {
                            lSign = Zero;
                            return subtraction;
                        }
                    }
                } else {
                    lBase += rBase;
                    return subtraction;
                }
            } else {
                if(rSign == Negative) {
                    switch(lBase.compareTo(rBase)) {
                        using enum Comparison;
                        case greater: {
                            lBase -= rBase;
                            return subtraction;
                        }
                        case less: {
                            lBase = rBase - lBase;
                            lSign = Positive;
                            return subtraction;
                        }
                        default: {
                            lSign = Zero;
                            return subtraction;
                        }
                    }
                } else {
                    lBase += rBase;
                    return subtraction;
                }
            }
        }
    /* --------------------------------------------------------------------------- */
 
    /* --------------------- @name Multiplication operators. --------------------- */
        template <typename Integral> requires (std::is_integral_v<Integral>) [[nodiscard]]
        gpu constexpr friend auto operator*(const Aesi& multiplication, Integral factor) noexcept -> Aesi {
            Aesi result = multiplication; result *= factor; return result;
        }
 
        [[nodiscard]]
        gpu constexpr friend auto operator*(const Aesi& multiplication, const Aesi& factor) noexcept -> Aesi {
            Aesi result = multiplication; result *= factor; return result;
        }
 
        template <typename Integral> requires (std::is_integral_v<Integral>)
        gpu constexpr friend auto operator*=(Aesi& multiplication, Integral factor) noexcept -> Aesi& {
            using enum Sign;
            if(factor == 0) {
                multiplication.sign = Zero;
            } else {
                if(factor < 0) {
                    multiplication.inverse();
                    factor = static_cast<Integral>(-factor);
                }
                multiplication.base *= static_cast<unsigned long long>(factor);
            }
            return multiplication;
        }
 
        gpu constexpr friend auto operator*=(Aesi& multiplication, const Aesi& factor) noexcept -> Aesi& {
            using enum Sign;
            if(factor.isZero()) {
                multiplication.sign = Zero;
            } else {
                if(factor.isNegative())
                    multiplication.inverse();
                multiplication.base *= factor.base;
            }
            return multiplication;
        }
    /* --------------------------------------------------------------------------- */
 
    /* ------------------------ @name Division operators. ------------------------ */
        template <typename Integral> requires (std::is_integral_v<Integral>) [[nodiscard]]
        gpu constexpr friend auto operator/(const Aesi& division, Integral divisor) noexcept -> Aesi {
            Aesi result = division; result /= divisor; return result;
        }
 
        [[nodiscard]]
        gpu constexpr friend auto operator/(const Aesi& division, const Aesi& divisor) noexcept -> Aesi {
            Aesi result = division; result /= divisor; return result;
        }
 
        template <typename Integral> requires (std::is_integral_v<Integral>)
        gpu constexpr friend auto operator/=(Aesi& division, Integral divisor) noexcept -> Aesi& {
            using enum Sign;
            if(divisor == 0) {
                division.sign = Zero;
            } else {
                if(divisor < 0) {
                    division.inverse();
                    divisor = static_cast<Integral>(-divisor);
                }
                division.base /= static_cast<unsigned long long>(divisor);
                if(division.base.isZero()) division.sign = Zero;
            }
            return division;
        }
 
        gpu constexpr friend auto operator/=(Aesi& division, const Aesi& divisor) noexcept -> Aesi& {
            using enum Sign;
            if(divisor.isZero()) {
                division.sign = Zero;
            } else {
                if(divisor.isNegative())
                    division.inverse();
                division.base /= divisor.base;
                if(division.base.isZero()) division.sign = Zero;
            }
            return division;
        }
    /* --------------------------------------------------------------------------- */
 
    /* ------------------------- @name Modulo operators. ------------------------- */
        template <typename Integral> requires (std::is_integral_v<Integral>) [[nodiscard]]
        gpu constexpr friend auto operator%(const Aesi& modulation, Integral modulo) noexcept -> Aesi {
            Aesi result = modulation; result %= modulo; return result;
        }
 
        [[nodiscard]]
        gpu constexpr friend auto operator%(const Aesi& modulation, const Aesi& modulo)  noexcept -> Aesi {
            Aesi result = modulation; result %= modulo; return result;
        }
 
        template <typename Integral> requires (std::is_integral_v<Integral>)
        gpu constexpr friend auto operator%=(Aesi& modulation, Integral modulo) noexcept -> Aesi& {
            using enum Sign;
            if(modulo == 0) {
                modulation.sign = Zero;
            } else {
                if(modulo < 0) {
                    modulation.inverse();
                    modulo = static_cast<Integral>(-modulo);
                }
                modulation.base %= static_cast<unsigned long long>(modulo);
            }
            return modulation;
        }
 
        gpu constexpr friend auto operator%=(Aesi& modulation, const Aesi& modulo) noexcept -> Aesi& {
            if(modulo.isZero())
                return modulation;
 
            if(modulo.isNegative())
                modulation.inverse();
            modulation.base %= modulo.base;
            if(modulation.base.isZero())
                modulation.sign = Sign::Zero;
 
            return modulation;
        }
    /* --------------------------------------------------------------------------- */
    /* ----------------------------------------------------------------------- */
 
    /* --------------------- @name Comparison operators. --------------------- */
    /* ------------------------ @name Equality operators. ------------------------ */
        template <typename Integral> requires (std::is_integral_v<Integral>)
        gpu constexpr friend auto operator==(const Aesi& our, Integral integral) noexcept -> bool {
            return our.compareTo(integral) == Comparison::equal;
        }
 
        template <std::size_t otherBitness>
        gpu constexpr friend auto operator==(const Aesi& our, const Aesi<otherBitness>& other) noexcept -> bool {
            if constexpr (bitness == otherBitness) {
                return our.compareTo(other) == Comparison::equal;
            } else {
                return our.precisionCast<otherBitness>() == other;
            }
        }
 
#ifdef AESI_GMP_INTEGRATION
        template <typename T, typename U>
        constexpr friend auto operator==(const Aesi& our, const __gmp_expr<T, U>& other) noexcept -> bool {
            return our == Aesi(mpz_class(other));
        }
#endif
    /* --------------------------------------------------------------------------- */
 
 
    /* ----------------------- @name Comparison operators. ----------------------- */
        template <typename Integral> requires (std::is_integral_v<Integral>)
        gpu constexpr auto compareTo(Integral integral) const noexcept -> Comparison {
            using enum Sign; using enum Comparison;
            if(integral == 0) {
                switch(sign) {
                    case Positive:
                        return greater;
                    case Negative:
                        return less;
                    default:
                        return equal;
                }
            } else if(integral < 0) {
                if(sign == Negative)
                    switch(base.compareTo(static_cast<uint64_t>(-static_cast<int64_t>(integral)))) {
                        using enum Comparison;
                        case greater:
                            return less;
                        case less:
                            return greater;
                        default:
                            return equal;
                    }
                else return greater;
            } else {
                if(sign == Positive)
                    return base.compareTo(static_cast<uint64_t>(static_cast<int64_t>(integral)));
                return less;
            }
        }
 
        template <std::size_t otherBitness = bitness> [[nodiscard]]
        gpu constexpr auto compareTo(const Aesi<otherBitness>& value) const noexcept -> Comparison {
            return precisionCast<otherBitness>().compareTo(value);
        }
 
        [[nodiscard]]
        gpu constexpr auto compareTo(const Aesi& value) const noexcept -> Comparison {
            using enum Sign; using enum Comparison;
            if(value.isZero()) {
                switch(sign) {
                    case Positive:
                        return greater;
                    case Negative:
                        return less;
                    default:
                        return equal;
                }
            }
 
            if(value.isNegative()) {
                if(sign == Negative)
                    switch(base.compareTo(value.base)) {
                        case greater:
                            return less;
                        case less:
                            return greater;
                        default:
                            return equal;
                    }
                return greater;
            }
 
            if(sign == Positive)
                return base.compareTo(value.base);
            return less;
        }
    /* --------------------------------------------------------------------------- */
 
    /* ------------------------ @name Spaceship operators. ----------------------- */
#if (defined(__CUDACC__) || __cplusplus < 202002L || defined (PRE_CPP_20)) && !defined DOXYGEN_SKIP
        gpu constexpr auto operator!=(const Aeu<bitness>& value) const noexcept -> bool {
            return !this->operator==(value);
        }
        gpu constexpr auto operator<(const Aeu<bitness>& value) const noexcept -> bool {
            return this->compareTo(value) == Comparison::less;
        }
        gpu constexpr auto operator<=(const Aeu<bitness>& value) const noexcept -> bool {
            return !this->operator>(value);
        }
        gpu constexpr auto operator>(const Aeu<bitness>& value) const noexcept -> bool {
            return this->compareTo(value) == Comparison::greater;
        }
        gpu constexpr auto operator>=(const Aeu<bitness>& value) const noexcept -> bool {
            return !this->operator<(value);
        }
#else
        gpu constexpr auto operator<=>(const Aesi& other) const noexcept -> std::strong_ordering {
            switch(this->compareTo(other)) {
                using enum Comparison;
                case less:
                    return std::strong_ordering::less;
                case greater:
                    return std::strong_ordering::greater;
                case equal:
                    return std::strong_ordering::equal;
                default:
                    return std::strong_ordering::equivalent;
            }
        }
 
        template <typename Object>
        gpu constexpr auto operator<=>(const Object& other) const noexcept -> std::strong_ordering {
            switch(this->compareTo(other)) {
                using enum Comparison;
                case less:
                    return std::strong_ordering::less;
                case greater:
                    return std::strong_ordering::greater;
                case equal:
                    return std::strong_ordering::equal;
                default:
                    return std::strong_ordering::equivalent;
            }
        }
#endif
    /* --------------------------------------------------------------------------- */
    /* ----------------------------------------------------------------------- */
 
    /* ---------------------- @name Supporting methods. ---------------------- */
    gpu constexpr auto setBit(std::size_t index, bool bit) noexcept -> void { return base.setBit(index, bit); }
 
    [[nodiscard]]
    gpu constexpr auto getBit(std::size_t index) const noexcept -> bool { return base.getBit(index); }
 
    gpu constexpr auto setByte(std::size_t index, byte byte) noexcept -> void { return base.setByte(index, byte); }
 
    [[nodiscard]]
    gpu constexpr auto getByte(std::size_t index) const noexcept -> byte { return base.getByte(index); }
 
    gpu constexpr auto setBlock(std::size_t index, block block) noexcept -> void { return base.setBlock(index, block); }
 
    [[nodiscard]]
    gpu constexpr auto getBlock(std::size_t index) const noexcept -> block { return base.getBlock(index); }
 
    [[nodiscard]]
    gpu constexpr auto byteCount() const noexcept -> std::size_t { return base.byteCount(); }
 
    [[nodiscard]]
    gpu constexpr auto bitCount() const noexcept -> std::size_t { return base.bitCount(); }
 
    [[nodiscard]]
    gpu constexpr auto isOdd() const noexcept -> bool { return base.isOdd(); }
 
    [[nodiscard]]
    gpu constexpr auto isEven() const noexcept -> bool { return base.isEven(); }
 
    [[nodiscard]]
    gpu constexpr auto isZero() const noexcept -> bool { return sign == Sign::Zero; }
 
    [[nodiscard]]
    gpu constexpr auto isPositive() const noexcept -> bool { return sign == Sign::Positive; }
 
    [[nodiscard]]
    gpu constexpr auto isNegative() const noexcept -> bool { return sign == Sign::Negative; }
 
    [[nodiscard]]
    gpu constexpr auto filledBlocksNumber() const noexcept -> std::size_t { return base.filledBlocksNumber(); }
 
    [[nodiscard]]
    gpu static constexpr auto getBitness() noexcept -> std::size_t { return bitness; }
 
    [[nodiscard]]
    gpu static constexpr auto totalBlocksNumber() noexcept -> std::size_t { return Aeu<bitness>::totalBlocksNumber(); }
 
    gpu constexpr auto swap(Aesi& other) noexcept -> void {
        Sign tSign = sign; sign = other.sign; other.sign = tSign;
        base.swap(other.base);
    }
 
    gpu constexpr auto inverse() noexcept -> void {
        using enum Sign;
        sign = (sign == Zero ? Zero : (sign == Negative ? Positive : Negative));
    }
    /* ----------------------------------------------------------------------- */
 
    /* -------------- @name Public arithmetic and number theory. ------------- */
    gpu static constexpr auto divide(const Aesi& number, const Aesi& divisor, Aesi& quotient, Aesi& remainder) noexcept -> void {
        using enum Sign;
        if(number.sign == Zero || divisor.sign == Zero) {
            quotient.sign = Zero;
            remainder.sign = Zero;
            return;
        }
 
        Base::divide(number.base, divisor.base, quotient.base, remainder.base);
        if(number.sign == Positive) {
            if(divisor.sign == Positive) {
                quotient.sign = Positive;
                remainder.sign = Positive;
            } else {
                quotient.sign = Negative;
                remainder.sign = Positive;
            }
        } else {
            if(divisor.sign == Positive) {
                quotient.sign = Negative;
                remainder.sign = Negative;
            } else {
                quotient.sign = Positive;
                remainder.sign = Negative;
            }
        }
 
        if(quotient.base.isZero())
            quotient.sign = Zero;
        if(remainder.base.isZero())
            remainder.sign = Zero;
    }
 
    [[nodiscard]]
    gpu constexpr auto squareRoot() const noexcept -> Aesi {
        using enum Sign;
        if(sign == Positive)
            return Aesi { Positive, base.squareRoot() };
        return Aesi { 0 };
    }
 
    [[nodiscard]]
    gpu static constexpr auto power2(std::size_t power) noexcept -> Aesi {
        using enum Sign;
        Aesi result { Positive, Aeu<bitness>::power2(power) };
        if(result.base.isZero())
            result.sign = Zero;
        return result;
    }
    /* ----------------------------------------------------------------------- */
 
    template <typename Integral> requires (std::is_integral_v<Integral>) [[nodiscard]]
    gpu constexpr auto integralCast() const noexcept -> Integral {
        using enum Sign;
        if(sign == Zero)
            return Integral(0);
 
        if constexpr (std::is_signed_v<Integral>) {
            if(sign == Negative)
                return base.template integralCast<Integral>() * -1;
        }
 
        return base.template integralCast<Integral>();
    }
 
    template <std::size_t newBitness> requires (newBitness != bitness) [[nodiscard]]
    gpu constexpr auto precisionCast() const noexcept -> Aesi<newBitness> {
        using enum Sign;
        if(sign != Zero) {
            Aesi<newBitness> result = 1;
 
            const std::size_t blockBoarder = (newBitness > bitness ? totalBlocksNumber() : Aesi<newBitness>::totalBlocksNumber());
            for(std::size_t blockIdx = 0; blockIdx < blockBoarder; ++blockIdx)
                result.setBlock(blockIdx, getBlock(blockIdx));
 
            if(sign == Negative)
                result.inverse();
 
            return result;
        }
 
        return Aesi<newBitness> {};
    }
 
    gpu constexpr auto unsignedCast() const noexcept -> Aeu<bitness> { return base; }
 
    /* ----------------- @name Public input-output operators. ---------------- */
    template <byte notation, bool hexUppercase = false, typename Char> requires (std::is_same_v<Char, char> || (std::is_same_v<Char, wchar_t> && (notation == 2 || notation == 8 || notation == 10 || notation == 16)))
    gpu constexpr auto getString(Char* buffer, std::size_t bufferSize, bool showBase = false) const noexcept -> std::size_t {
        using enum Sign;
 
        if(sign != Zero) {
            if(sign == Negative && bufferSize > 0) {
                *buffer++ = [] { if constexpr (std::is_same_v<Char, char>) { return '-'; } else { return L'-'; } } ();
                --bufferSize;
            }
            return base.template getString<notation, hexUppercase, Char>(buffer, bufferSize, showBase);
        }
 
        if(showBase) {
            switch(notation) {
                case 2: {
                    if(bufferSize < 3) return 0;
                    buffer[0] = [] { if constexpr (std::is_same_v<Char, char>) { return '0'; } else { return L'0'; } } ();
                    buffer[1] = [] { if constexpr (std::is_same_v<Char, char>) { return 'b'; } else { return L'b'; } } ();
                    buffer[2] = buffer[0];
                    return 3;
                }
                case 8: {
                    if(bufferSize < 3) return 0;
                    buffer[0] = [] { if constexpr (std::is_same_v<Char, char>) { return '0'; } else { return L'0'; } } ();
                    buffer[1] = [] { if constexpr (std::is_same_v<Char, char>) { return 'o'; } else { return L'o'; } } ();
                    buffer[2] = buffer[0];
                    return 3;
                }
                case 16: {
                    if(bufferSize < 3) return 0;
                    buffer[0] = [] { if constexpr (std::is_same_v<Char, char>) { return '0'; } else { return L'0'; } } ();
                    buffer[1] = [] { if constexpr (std::is_same_v<Char, char>) { return 'x'; } else { return L'x'; } } ();
                    buffer[2] = buffer[0];
                    return 3;
                }
                default: {
                    if(bufferSize < 1) return 0;
                    buffer[0] = [] { if constexpr (std::is_same_v<Char, char>) { return '0'; } else { return L'0'; } } ();
                    return 1;
                }
            }
        }
 
        buffer[0] = [] { if constexpr (std::is_same_v<Char, char>) { return '0'; } else { return L'0'; } } ();
        return 1;
    }
 
    template <typename Char> requires (std::is_same_v<Char, char> || std::is_same_v<Char, wchar_t>)
    friend constexpr auto operator<<(std::basic_ostream<Char>& os, const Aesi& number) -> std::basic_ostream<Char>& {
        using enum Sign;
        if(number.sign != Zero) {
            if(number.sign == Negative)
                os << [] { if constexpr (std::is_same_v<Char, char>) { return '-'; } else { return L'-'; } } ();
            return os << number.base;
        }
        return os << '0';
    }
    /* ----------------------------------------------------------------------- */
 
#if defined __CUDACC__ || defined DOXYGEN_SKIP
    __device__ constexpr auto tryAtomicSet(const Aesi& value) noexcept -> void {
        base.tryAtomicSet(value.base);
        sign = value.sign; /* TODO: Make enum substitution using existing CUDA atomics */
    }
 
    __device__ constexpr auto tryAtomicExchange(const Aesi& value) noexcept -> void {
        base.tryAtomicExchange(value.base);
        sign = value.sign; /* TODO: Make enum substitution using existing CUDA atomics */
    }
#endif
};
 
/* -------------------------------------------- @name Type-definitions  ------------------------------------------- */
using Aesi128 = Aesi<128>;
 
using Aesi256 = Aesi<256>;
 
using Aesi512 = Aesi<512>;
 
using Aesi768 = Aesi<768>;
 
using Aesi1024 = Aesi<1024>;
 
using Aesi1536 = Aesi<1536>;
 
using Aesi2048 = Aesi<2048>;
 
using Aesi3072 = Aesi<3072>;
 
using Aesi4096 = Aesi<4096>;
 
using Aesi6144 = Aesi<6144>;
 
using Aesi8192 = Aesi<8192>;
/* ---------------------------------------------------------------------------------------------------------------- */
 
/* ------------------------------------------ @name Integral conversions  ----------------------------------------- */
template <std::size_t bitness, typename Integral> requires (std::is_integral_v<Integral>)
gpu constexpr auto operator+(Integral number, const Aesi<bitness>& value) noexcept { return Aesi<bitness>(number) + value; }
 
template <std::size_t bitness, typename Integral> requires (std::is_integral_v<Integral>)
gpu constexpr auto operator-(Integral number, const Aesi<bitness>& value) noexcept { return Aesi<bitness>(number) - value; }
 
template <std::size_t bitness, typename Integral> requires (std::is_integral_v<Integral>)
gpu constexpr auto operator*(Integral number, const Aesi<bitness>& value) noexcept { return Aesi<bitness>(number) * value; }
 
template <std::size_t bitness, typename Integral> requires (std::is_integral_v<Integral>)
gpu constexpr auto operator/(Integral number, const Aesi<bitness>& value) noexcept { return Aesi<bitness>(number) / value; }
 
template <std::size_t bitness, typename Integral> requires (std::is_integral_v<Integral>)
gpu constexpr auto operator%(Integral number, const Aesi<bitness>& value) noexcept { return Aesi<bitness>(number) % value; }
 
template <std::size_t bitness, typename Integral> requires (std::is_integral_v<Integral>)
gpu constexpr auto operator^(Integral number, const Aesi<bitness>& value) noexcept { return Aesi<bitness>(number) ^ value; }
 
template <std::size_t bitness, typename Integral> requires (std::is_integral_v<Integral>)
gpu constexpr auto operator&(Integral number, const Aesi<bitness>& value) noexcept { return Aesi<bitness>(number) & value; }
 
template <std::size_t bitness, typename Integral> requires (std::is_integral_v<Integral>)
gpu constexpr auto operator|(Integral number, const Aesi<bitness>& value) noexcept { return Aesi<bitness>(number) | value; }
/* ---------------------------------------------------------------------------------------------------------------- */
 
#endif //AESI_MULTIPRECISION