diff --git a/.drone.jsonnet b/.drone.jsonnet index 6c68476c..b332f86d 100644 --- a/.drone.jsonnet +++ b/.drone.jsonnet @@ -362,13 +362,6 @@ local windows_pipeline(name, image, environment, arch = "amd64") = "clang-13", ), - linux_pipeline( - "Linux 22.04 Clang 14 UBSAN", - "cppalliance/droneubuntu2204:1", - { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + ubsan, - "clang-14", - ), - linux_pipeline( "Linux 22.04 Clang 14 ASAN", "cppalliance/droneubuntu2204:1", @@ -408,12 +401,6 @@ local windows_pipeline(name, image, environment, arch = "amd64") = ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-18 main"], ), - macos_pipeline( - "MacOS 12.4 Xcode 13.4.1 UBSAN", - { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,20,2b' } + ubsan, - xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64", - ), - macos_pipeline( "MacOS 12.4 Xcode 13.4.1 ASAN", { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,17,20,2b' } + asan, diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 9b22f758..659b7a03 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -35,22 +35,43 @@ jobs: matrix: include: - toolset: gcc-7 - cxxstd: "03,11,14,17" - address_model: 32,64 + cxxstd: "14,17" + address_model: 64 + os: ubuntu-latest + container: ubuntu:18.04 + install: + - g++-7-multilib + - toolset: gcc-7 + cxxstd: "14,17" + address_model: 32 os: ubuntu-latest container: ubuntu:18.04 install: - g++-7-multilib - toolset: gcc-8 - cxxstd: "03,11,14,17,2a" - address_model: 32,64 + cxxstd: "14,17,2a" + address_model: 64 + os: ubuntu-latest + container: ubuntu:18.04 + install: + - g++-8-multilib + - toolset: gcc-8 + cxxstd: "14,17,2a" + address_model: 32 os: ubuntu-latest container: ubuntu:18.04 install: - g++-8-multilib - toolset: gcc-9 - cxxstd: "03,11,14,17,2a" - address_model: 32,64 + cxxstd: "17,2a" + address_model: 32 + os: ubuntu-latest + container: ubuntu:20.04 + install: + - g++-9-multilib + - toolset: gcc-9 + cxxstd: "17,2a" + address_model: 64 os: ubuntu-latest container: ubuntu:20.04 install: @@ -536,7 +557,7 @@ jobs: shell: cmd run: | cd ../boost-root - b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release link=static,shared embed-manifest-via=linker + b2 -j3 libs/%LIBRARY%/test toolset=${{matrix.toolset}} cxxstd=${{matrix.cxxstd}} address-model=${{matrix.addrmd}} variant=debug,release link=static,shared embed-manifest-via=linker define="BOOST_DECIMAL_GHA_MSVC" posix-cmake-subdir: strategy: diff --git a/include/boost/decimal/detail/config.hpp b/include/boost/decimal/detail/config.hpp index 02ad865c..7f144901 100644 --- a/include/boost/decimal/detail/config.hpp +++ b/include/boost/decimal/detail/config.hpp @@ -84,12 +84,16 @@ #endif // Include intrinsics if available -#if defined(_MSC_VER) +#if defined(_MSC_VER) && defined(_M_X64) # ifndef BOOST_DECIMAL_BUILD_MODULE # include # endif # if defined(_WIN64) # define BOOST_DECIMAL_HAS_MSVC_64BIT_INTRINSICS +# ifndef _M_ARM64 +# include +# define BOOST_DECIMAL_HAS_MSVC_X64_INTRINSICS +# endif # else # define BOOST_DECIMAL_HAS_MSVC_32BIT_INTRINSICS # endif @@ -98,6 +102,7 @@ # elif defined(BOOST_DECIMAL_HAS_MSVC_64BIT_INTRINSICS) # define BOOST_DECIMAL_ADD_CARRY _addcarry_u64 # endif +# define BOOST_DECIMAL_SUB_BORROW _subborrow_u64 #elif defined(__x86_64__) # ifndef BOOST_DECIMAL_BUILD_MODULE # include @@ -108,6 +113,7 @@ # else # define BOOST_DECIMAL_ADD_CARRY _addcarry_u64 # endif +# define BOOST_DECIMAL_SUB_BORROW _subborrow_u64 #elif defined(__ARM_NEON__) # ifndef BOOST_DECIMAL_BUILD_MODULE # include @@ -354,4 +360,24 @@ typedef unsigned __int128 uint128_t; # endif #endif +#ifdef _MSC_VER +# define BOOST_DECIMAL_ASSUME(expr) __assume(expr) +#elif defined(__clang__) +# define BOOST_DECIMAL_ASSUME(expr) __builtin_assume(expr) +#elif defined(__GNUC__) +# if __GNUC__ >= 5 && __GNUC__ < 13 +# define BOOST_DECIMAL_ASSUME(expr) if (expr) {} else { __builtin_unreachable(); } +# else +# define BOOST_DECIMAL_ASSUME(expr) __attribute__((assume(expr))) +# endif +#elif defined(__has_cpp_attribute) +# if __has_cpp_attribute(assume) +# define BOOST_DECIMAL_ASSUME(expr) [[assume(expr)]] +# else +# define BOOST_DECIMAL_ASSUME(expr) BOOST_DECIMAL_ASSERT(expr) +# endif +#else +# define BOOST_DECIMAL_ASSUME(expr) BOOST_DECIMAL_ASSERT(expr) +#endif + #endif // BOOST_DECIMAL_DETAIL_CONFIG_HPP diff --git a/include/boost/decimal/detail/integer_search_trees.hpp b/include/boost/decimal/detail/integer_search_trees.hpp index a8a319d8..3b2107b9 100644 --- a/include/boost/decimal/detail/integer_search_trees.hpp +++ b/include/boost/decimal/detail/integer_search_trees.hpp @@ -11,6 +11,7 @@ #include #include #include +#include #ifndef BOOST_DECIMAL_BUILD_MODULE #include @@ -255,6 +256,56 @@ constexpr auto num_digits(const uint128_t& x) noexcept -> int #endif // Has int128 +// Check benchmark_uints.cpp for timing +#if defined(__aarch64__) && defined(__APPLE__) + +constexpr auto num_digits(const u128& x) noexcept -> int +{ + int msb {}; + if (x.high != 0) + { + msb = 64 + (64 - countl_zero(x.high)); + } + else + { + msb = 64 - countl_zero(x.low); + } + + const auto estimated_digits {(msb * 1000) / 3322 + 1}; + + if (x >= impl::emulated_u128_pow10[estimated_digits]) + { + return estimated_digits != 39 ? estimated_digits + 1 : estimated_digits; + } + else if (estimated_digits > 1 && x < impl::emulated_u128_pow10[estimated_digits - 1]) + { + return estimated_digits - 1; + } + else + { + return estimated_digits; + } +} + +#else + +constexpr int num_digits(const u128& x) noexcept +{ + int guess {}; + if (x.high != UINT64_C(0)) + { + guess = num_digits(x.high) + 19; + } + else + { + return num_digits(x.low); + } + + return x >= impl::emulated_u128_pow10[guess] && guess != 39 ? guess + 1 : guess; +} + +#endif + // Specializations with pruned branches for constructors // Since we already have partial information we can greatly speed things up in this case template diff --git a/include/boost/decimal/detail/io.hpp b/include/boost/decimal/detail/io.hpp index 9fa9c3df..83923db0 100644 --- a/include/boost/decimal/detail/io.hpp +++ b/include/boost/decimal/detail/io.hpp @@ -13,6 +13,7 @@ #include #include #include +#include #include #if !defined(BOOST_DECIMAL_DISABLE_CLIB) @@ -45,7 +46,7 @@ auto operator>>(std::basic_istream& is, DecimalType& d) { auto first = buffer; auto t_first = t_buffer; - auto t_buffer_end = t_buffer + std::strlen(t_buffer); + const auto t_buffer_end = t_buffer + detail::generic_strlen(t_buffer); while (t_first != t_buffer_end) { diff --git a/include/boost/decimal/detail/power_tables.hpp b/include/boost/decimal/detail/power_tables.hpp index b51dd2c9..911dc709 100644 --- a/include/boost/decimal/detail/power_tables.hpp +++ b/include/boost/decimal/detail/power_tables.hpp @@ -9,6 +9,7 @@ #include #include #include +#include #ifndef BOOST_DECIMAL_BUILD_MODULE #include @@ -75,6 +76,52 @@ BOOST_DECIMAL_CONSTEXPR_VARIABLE uint128 emulated_128_pow10[] = static_assert(sizeof(emulated_128_pow10) == sizeof(uint128) * 40, "Should have 10^0 to 10^39"); +BOOST_DECIMAL_CONSTEXPR_VARIABLE u128 emulated_u128_pow10[] = +{ + u128 {UINT64_C(0), UINT64_C(1)}, + u128 {UINT64_C(0), UINT64_C(10)}, + u128 {UINT64_C(0), UINT64_C(100)}, + u128 {UINT64_C(0), UINT64_C(1000)}, + u128 {UINT64_C(0), UINT64_C(10000)}, + u128 {UINT64_C(0), UINT64_C(100000)}, + u128 {UINT64_C(0), UINT64_C(1000000)}, + u128 {UINT64_C(0), UINT64_C(10000000)}, + u128 {UINT64_C(0), UINT64_C(100000000)}, + u128 {UINT64_C(0), UINT64_C(1000000000)}, + u128 {UINT64_C(0), UINT64_C(10000000000)}, + u128 {UINT64_C(0), UINT64_C(100000000000)}, + u128 {UINT64_C(0), UINT64_C(1000000000000)}, + u128 {UINT64_C(0), UINT64_C(10000000000000)}, + u128 {UINT64_C(0), UINT64_C(100000000000000)}, + u128 {UINT64_C(0), UINT64_C(1000000000000000)}, + u128 {UINT64_C(0), UINT64_C(10000000000000000)}, + u128 {UINT64_C(0), UINT64_C(100000000000000000)}, + u128 {UINT64_C(0), UINT64_C(1000000000000000000)}, + u128 {UINT64_C(0), UINT64_C(10000000000000000000)}, + u128 {UINT64_C(5), UINT64_C(7766279631452241920)}, + u128 {UINT64_C(54), UINT64_C(3875820019684212736)}, + u128 {UINT64_C(542), UINT64_C(1864712049423024128)}, + u128 {UINT64_C(5421), UINT64_C(200376420520689664)}, + u128 {UINT64_C(54210), UINT64_C(2003764205206896640)}, + u128 {UINT64_C(542101), UINT64_C(1590897978359414784)}, + u128 {UINT64_C(5421010), UINT64_C(15908979783594147840)}, + u128 {UINT64_C(54210108), UINT64_C(11515845246265065472)}, + u128 {UINT64_C(542101086), UINT64_C(4477988020393345024)}, + u128 {UINT64_C(5421010862), UINT64_C(7886392056514347008)}, + u128 {UINT64_C(54210108624), UINT64_C(5076944270305263616)}, + u128 {UINT64_C(542101086242), UINT64_C(13875954555633532928)}, + u128 {UINT64_C(5421010862427), UINT64_C(9632337040368467968)}, + u128 {UINT64_C(54210108624275), UINT64_C(4089650035136921600)}, + u128 {UINT64_C(542101086242752), UINT64_C(4003012203950112768)}, + u128 {UINT64_C(5421010862427522), UINT64_C(3136633892082024448)}, + u128 {UINT64_C(54210108624275221), UINT64_C(12919594847110692864)}, + u128 {UINT64_C(542101086242752217), UINT64_C(68739955140067328)}, + u128 {UINT64_C(5421010862427522170), UINT64_C(687399551400673280)}, + u128 {UINT64_C(17316620476856118468), UINT64_C(6873995514006732800)}, +}; + +static_assert(sizeof(emulated_128_pow10) == sizeof(uint128) * 40, "Should have 10^0 to 10^39"); + #ifdef BOOST_DECIMAL_HAS_INT128 BOOST_DECIMAL_CONSTEXPR_VARIABLE uint128_t builtin_128_pow10[] = { diff --git a/include/boost/decimal/detail/strlen.hpp b/include/boost/decimal/detail/strlen.hpp new file mode 100644 index 00000000..cb067600 --- /dev/null +++ b/include/boost/decimal/detail/strlen.hpp @@ -0,0 +1,37 @@ +// Copyright 2025 Matt Borland +// Distributed under the Boost Software License, Version 1.0. +// https://www.boost.org/LICENSE_1_0.txt + +#ifndef BOOST_DECIMAL_DETAIL_STRLEN_HPP +#define BOOST_DECIMAL_DETAIL_STRLEN_HPP + +#include + +#ifndef BOOST_DECIMAL_BUILD_MODULE + +#include + +#endif + +namespace boost { +namespace decimal { +namespace detail { + +template +constexpr std::ptrdiff_t generic_strlen(T* ptr) +{ + std::ptrdiff_t dist {}; + while (*ptr != static_cast(0)) + { + ++dist; + ++ptr; + } + + return dist; +} + +} // namespace detail +} // namespace decimal +} // namespace boost + +#endif // BOOST_DECIMAL_DETAIL_STRLEN_HPP diff --git a/include/boost/decimal/detail/u128.hpp b/include/boost/decimal/detail/u128.hpp new file mode 100644 index 00000000..c9ce3a50 --- /dev/null +++ b/include/boost/decimal/detail/u128.hpp @@ -0,0 +1,2913 @@ +// Copyright 2023 Matt Borland +// Distributed under the Boost Software License, Version 1.0. +// https://www.boost.org/LICENSE_1_0.txt +// +// If the architecture (e.g. 32-bit x86) does not have __int128 we need to emulate it + +#ifndef BOOST_DECIMAL_DETAIL_U128_HPP +#define BOOST_DECIMAL_DETAIL_U128_HPP + +#include +#include +#include +#include + +#ifndef BOOST_DECIMAL_BUILD_MODULE + +#include +#include +#include +#include + +#if !defined(BOOST_DECIMAL_DISABLE_IOSTREAM) +#include +#include +#include +#endif + +#endif // BOOST_DECIMAL_BUILD_MODULE + +// This is used frequently enough that I'd rather not have this spaghetti everytime +// These older clang and GCC versions return incorrect numerical results or sometimes hang +#define BOOST_DECIMAL_OLD_NON_GNU_COMPILER ((defined(__clang__) && __clang_major__ < 11) || \ + (defined(__GNUC__) && !defined(__clang__) && \ + (__GNUC__ < 10 || (defined(__STRICT_ANSI__) && __GNUC__ >= 10)))) + +namespace boost { +namespace decimal { +namespace detail { + +namespace impl { + +template +struct signed_integer +{ + static constexpr bool value = std::is_signed::value && std::is_integral::value; +}; + +template +static constexpr bool is_signed_integer_v = signed_integer::value; + +template +struct unsigned_integer +{ + static constexpr bool value = std::is_unsigned::value && std::is_integral::value; +}; + +template +static constexpr bool is_unsigned_integer_v = unsigned_integer::value; + +} + +struct + #ifdef BOOST_DECIMAL_HAS_INT128 + alignas(alignof(unsigned __int128)) + #else + alignas(16) + #endif +u128 +{ +private: + + static constexpr std::uint64_t low_word_mask {~UINT64_C(0)}; + +public: + + #ifdef BOOST_DECIMAL_ENDIAN_BIG_BYTE + # if defined(__GNUC__) + # pragma GCC diagnostic push + # pragma GCC diagnostic ignored "-Wreorder" + # define BOOST_DECIMAL_PUSHED_BIG_WARNING + # endif + #endif // Big endian + + #if BOOST_DECIMAL_ENDIAN_LITTLE_BYTE + std::uint64_t low {}; + std::uint64_t high {}; + #else + std::uint64_t high {}; + std::uint64_t low {}; + #endif + + // Constructors + constexpr u128() noexcept = default; + constexpr u128(const u128& other) noexcept = default; + constexpr u128(u128&& other) noexcept = default; + constexpr u128& operator=(const u128& other) noexcept = default; + constexpr u128& operator=(u128&& other) noexcept = default; + + // Direct construction of the number + constexpr u128(const std::uint64_t hi, const std::uint64_t lo) noexcept : low{lo}, high{hi} {} + + // Signed arithmetic constructors + template , bool> = true> + explicit constexpr u128(const SignedInteger value) noexcept : low {static_cast(value)}, high {value < 0 ? UINT64_MAX : UINT64_C(0)} {} + + #ifdef BOOST_DECIMAL_HAS_INT128 + explicit constexpr u128(const __int128 value) noexcept : + low {static_cast(value & low_word_mask)}, + high {static_cast(static_cast(value) >> 64U)} {} + #endif // BOOST_DECIMAL_HAS_INT128 + + // Unsigned arithmetic constructors + template , bool> = true> + explicit constexpr u128(const UnsignedInteger value) noexcept : low {static_cast(value)}, high {UINT64_C(0)} {} + + #ifdef BOOST_DECIMAL_HAS_INT128 + explicit constexpr u128(const unsigned __int128 value) noexcept : + low {static_cast(value & low_word_mask)}, + high {static_cast(value >> 64U)} {} + #endif // BOOST_DECIMAL_HAS_INT128 + + #ifdef BOOST_DECIMAL_PUSHED_BIG_WARNING + # pragma GCC diagnostic pop + # undef BOOST_DECIMAL_PUSHED_BIG_WARNING + #endif + + // Signed assignment operators + template , bool> = true> + constexpr u128& operator=(SignedInteger value) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator=(__int128 value) noexcept; + #endif // BOOST_DECIMAL_HAS_INT128 + + // Unsigned assignment operators + template , bool> = true> + constexpr u128& operator=(UnsignedInteger value) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator=(unsigned __int128 value) noexcept; + #endif + + // Bool conversion is not explicit so we can do stuff like if (num) + constexpr operator bool() const noexcept { return low || high; } + + // Conversion to signed integer types + template , bool> = true> + explicit constexpr operator SignedInteger() const noexcept { return static_cast(low); } + + #ifdef BOOST_DECIMAL_HAS_INT128 + explicit constexpr operator __int128() const noexcept { return (static_cast<__int128>(high) << 64) + low; } + #endif // BOOST_DECIMAL_HAS_INT128 + + // Conversion to unsigned integer types + template , bool> = true> + explicit constexpr operator UnsignedInteger() const noexcept { return static_cast(low); } + + #ifdef BOOST_DECIMAL_HAS_INT128 + explicit constexpr operator unsigned __int128() const noexcept { return (static_cast(high) << 64U) + low; } + #endif // BOOST_DECIMAL_HAS_INT128 + + // Conversion to float + // This is basically the same as ldexp(static_cast(high), 64) + static_cast(low), + // but can be constexpr at C++11 instead of C++26 + explicit constexpr operator float() const noexcept; + explicit constexpr operator double() const noexcept; + explicit constexpr operator long double() const noexcept; + + #ifdef BOOST_DECIMAL_HAS_FLOAT128 + explicit constexpr operator __float128() const noexcept; + #endif // BOOST_DECIMAL_HAS_FLOAT128 + + // Prefix and postfix increment + constexpr u128& operator++() noexcept; + constexpr u128& operator++(int) noexcept; + + // Compound Addition Operators + template , bool> = true> + constexpr u128& operator+=(SignedInteger rhs) noexcept; + + template , bool> = true> + constexpr u128& operator+=(UnsignedInteger rhs) noexcept; + + constexpr u128& operator+=(u128 rhs) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator+=(__int128 rhs) noexcept; + constexpr u128& operator+=(unsigned __int128 rhs) noexcept; + #endif // BOOST_DECIMAL_HAS_INT128 + + // Compound Subtraction Operators + template , bool> = true> + constexpr u128& operator-=(SignedInteger rhs) noexcept; + + template , bool> = true> + constexpr u128& operator-=(UnsignedInteger rhs) noexcept; + + constexpr u128& operator-=(u128 rhs) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator-=(__int128 rhs) noexcept; + constexpr u128& operator-=(unsigned __int128 rhs) noexcept; + #endif // BOOST_DECIMAL_HAS_INT128 + + // Compound Multiplication Operators + template , bool> = true> + constexpr u128& operator*=(SignedInteger rhs) noexcept; + + template , bool> = true> + constexpr u128& operator*=(UnsignedInteger rhs) noexcept; + + constexpr u128& operator*=(u128 rhs) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator*=(__int128 rhs) noexcept; + constexpr u128& operator*=(unsigned __int128 rhs) noexcept; + #endif // BOOST_DECIMAL_HAS_INT128 + + // Compound Division Operators + template , bool> = true> + constexpr u128& operator/=(SignedInteger rhs) noexcept; + + template , bool> = true> + constexpr u128& operator/=(UnsignedInteger rhs) noexcept; + + constexpr u128& operator/=(u128 rhs) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator/=(__int128 rhs) noexcept; + constexpr u128& operator/=(unsigned __int128 rhs) noexcept; + #endif // BOOST_DECIMAL_HAS_INT128 + + // Compound Modulo Operators + template , bool> = true> + constexpr u128& operator%=(SignedInteger rhs) noexcept; + + template , bool> = true> + constexpr u128& operator%=(UnsignedInteger rhs) noexcept; + + constexpr u128& operator%=(u128 rhs) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator%=(__int128 rhs) noexcept; + constexpr u128& operator%=(unsigned __int128 rhs) noexcept; + #endif // BOOST_DECIMAL_HAS_INT128 + + // Compound And + template , bool> = true> + constexpr u128& operator&=(SignedInteger rhs) noexcept; + + template , bool> = true> + constexpr u128& operator&=(UnsignedInteger rhs) noexcept; + + constexpr u128& operator&=(u128 rhs) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator&=(__int128 rhs) noexcept; + constexpr u128& operator&=(unsigned __int128 rhs) noexcept; + #endif + + // Compound Or + template , bool> = true> + constexpr u128& operator|=(SignedInteger rhs) noexcept; + + template , bool> = true> + constexpr u128& operator|=(UnsignedInteger rhs) noexcept; + + constexpr u128& operator|=(u128 rhs) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator|=(__int128 rhs) noexcept; + constexpr u128& operator|=(unsigned __int128 rhs) noexcept; + #endif + + // Compound XOR + template , bool> = true> + constexpr u128& operator^=(SignedInteger rhs) noexcept; + + template , bool> = true> + constexpr u128& operator^=(UnsignedInteger rhs) noexcept; + + constexpr u128& operator^=(u128 rhs) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator^=(__int128 rhs) noexcept; + constexpr u128& operator^=(unsigned __int128 rhs) noexcept; + #endif + + // Compound Left Shift + template , bool> = true> + constexpr u128& operator<<=(SignedInteger rhs) noexcept; + + template , bool> = true> + constexpr u128& operator<<=(UnsignedInteger rhs) noexcept; + + constexpr u128& operator<<=(u128 rhs) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator<<=(__int128 rhs) noexcept; + constexpr u128& operator<<=(unsigned __int128 rhs) noexcept; + #endif + + // Compound Right Shift + template , bool> = true> + constexpr u128& operator>>=(SignedInteger rhs) noexcept; + + template , bool> = true> + constexpr u128& operator>>=(UnsignedInteger rhs) noexcept; + + constexpr u128& operator>>=(u128 rhs) noexcept; + + #ifdef BOOST_DECIMAL_HAS_INT128 + constexpr u128& operator>>=(__int128 rhs) noexcept; + constexpr u128& operator>>=(unsigned __int128 rhs) noexcept; + #endif +}; + +// Signed assignment operators +template , bool>> +constexpr u128& u128::operator=(const SignedInteger value) noexcept +{ + low = static_cast(value); + high = value < 0 ? UINT64_MAX : UINT64_C(0); + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator=(const __int128 value) noexcept +{ + low = static_cast(value & low_word_mask); high = static_cast(static_cast(value) >> 64U); return *this; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +// Unsigned assignment operators +template , bool>> +constexpr u128& u128::operator=(const UnsignedInteger value) noexcept { low = static_cast(value); high = UINT64_C(0); return *this; } + +#ifdef BOOST_DECIMAL_HAS_INT128 +constexpr u128& u128::operator=(const unsigned __int128 value) noexcept { low = static_cast(value & low_word_mask); high = static_cast(value >> 64U); return *this; } +#endif + +//===================================== +// Float Conversion Operators +//===================================== + +// The most correct way to do this would be std::ldexp(static_cast(high), 64) + static_cast(low); +// Since std::ldexp is not constexpr until C++23 we can work around this by multiplying the high word +// by 0xFFFFFFFF in order to generally replicate what ldexp is doing in the constexpr context. +// We also avoid pulling in for the __float128 case where we would need ldexpq +namespace impl { + +template +static constexpr T offset_value_v = static_cast(std::numeric_limits::max()); + +} + +constexpr u128::operator float() const noexcept +{ + return static_cast(high) * impl::offset_value_v + static_cast(low); +} + +constexpr u128::operator double() const noexcept +{ + return static_cast(high) * impl::offset_value_v + static_cast(low); +} + +constexpr u128::operator long double() const noexcept +{ + return static_cast(high) * impl::offset_value_v + static_cast(low); +} + +#ifdef BOOST_DECIMAL_HAS_FLOAT128 + +constexpr u128::operator __float128() const noexcept +{ + return static_cast<__float128>(high) * impl::offset_value_v<__float128> + static_cast<__float128>(low); +} + +#endif // BOOST_DECIMAL_HAS_FLOAT128 + +//===================================== +// Increment Operators +//===================================== + +constexpr u128& u128::operator++() noexcept +{ + if (++low == UINT64_C(0)) + { + ++high; + } + + return *this; +} + +constexpr u128& u128::operator++(int) noexcept +{ + return ++(*this); +} + +//===================================== +// Unary Operators +//===================================== + +constexpr u128 operator+(const u128 value) noexcept +{ + return value; +} + +constexpr u128 operator-(const u128 value) noexcept +{ + return u128{~value.high + static_cast(value.low == UINT64_C(0)), ~value.low + UINT64_C(1)}; +} + +//===================================== +// Equality Operators +//===================================== + +constexpr bool operator==(const u128 lhs, const bool rhs) noexcept +{ + return lhs.high == UINT64_C(0) && lhs.low == static_cast(rhs); +} + +constexpr bool operator==(const bool lhs, const u128 rhs) noexcept +{ + return rhs.high == UINT64_C(0) && rhs.low == static_cast(lhs); +} + +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wsign-conversion" +#elif defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wsign-conversion" +#endif + +template , bool> = true> +constexpr bool operator==(const u128 lhs, const SignedInteger rhs) noexcept +{ + return rhs >= 0 && lhs.high == UINT64_C(0) && lhs.low == static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator==(const SignedInteger lhs, const u128 rhs) noexcept +{ + return lhs >= 0 && rhs.high == UINT64_C(0) && rhs.low == static_cast(lhs); +} + +template , bool> = true> +constexpr bool operator==(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return lhs.high == UINT64_C(0) && lhs.low == static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator==(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return rhs.high == UINT64_C(0) && rhs.low == static_cast(lhs); +} + +constexpr bool operator==(const u128 lhs, const u128 rhs) noexcept +{ + // Intel and ARM like the values in opposite directions + + #if defined(__aarch64__) || defined(_M_ARM64) + + return lhs.low == rhs.low && lhs.high == rhs.high; + + #else + + return lhs.high == rhs.high && lhs.low == rhs.low; + + #endif +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr bool operator==(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs == static_cast(rhs); +} + +constexpr bool operator==(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) == rhs; +} + +constexpr bool operator==(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs == static_cast(rhs); +} + +constexpr bool operator==(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) == rhs; +} + +#endif + +//===================================== +// Inequality Operators +//===================================== + +constexpr bool operator!=(const u128 lhs, const bool rhs) noexcept +{ + return lhs.high != UINT64_C(0) || lhs.low != static_cast(rhs); +} + +constexpr bool operator!=(const bool lhs, const u128 rhs) noexcept +{ + return rhs.high != UINT64_C(0) || rhs.low != static_cast(lhs); +} + +template , bool> = true> +constexpr bool operator!=(const u128 lhs, const SignedInteger rhs) noexcept +{ + return rhs < 0 || lhs.high != UINT64_C(0) || lhs.low != static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator!=(const SignedInteger lhs, const u128 rhs) noexcept +{ + return lhs < 0 || rhs.high != UINT64_C(0) || rhs.low != static_cast(lhs); +} + +template , bool> = true> +constexpr bool operator!=(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return lhs.high != UINT64_C(0) || lhs.low != static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator!=(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return rhs.high != UINT64_C(0) || rhs.low != static_cast(lhs); +} + +constexpr bool operator!=(const u128 lhs, const u128 rhs) noexcept +{ + #if defined(__aarch64__) || defined(_M_ARM64) + + return lhs.low != rhs.low || lhs.high != rhs.high; + + #else + + return lhs.high != rhs.high || lhs.low != rhs.low; + + #endif +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr bool operator!=(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs != static_cast(rhs); +} + +constexpr bool operator!=(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) != rhs; +} + +constexpr bool operator!=(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs != static_cast(rhs); +} + +constexpr bool operator!=(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) != rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Less than Operators +//===================================== + +template , bool> = true> +constexpr bool operator<(const u128 lhs, const SignedInteger rhs) noexcept +{ + return rhs > 0 && lhs.high == UINT64_C(0) && lhs.low < static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator<(const SignedInteger lhs, const u128 rhs) noexcept +{ + return lhs < 0 || rhs.high > UINT64_C(0) || static_cast(lhs) < rhs.low; +} + +template , bool> = true> +constexpr bool operator<(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return lhs.high == UINT64_C(0) && lhs.low < static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator<(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return rhs.high > UINT64_C(0) || static_cast(lhs) < rhs.low; +} + +constexpr bool operator<(const u128 lhs, const u128 rhs) noexcept +{ + return lhs.high == rhs.high ? lhs.low < rhs.low : lhs.high < rhs.high; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr bool operator<(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs < static_cast(rhs); +} + +constexpr bool operator<(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) < rhs; +} + +constexpr bool operator<(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs < static_cast(rhs); +} + +constexpr bool operator<(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) < rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Less-equal Operators +//===================================== + +template , bool> = true> +constexpr bool operator<=(const u128 lhs, const SignedInteger rhs) noexcept +{ + return rhs > 0 && lhs.high == UINT64_C(0) && lhs.low <= static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator<=(const SignedInteger lhs, const u128 rhs) noexcept +{ + return lhs < 0 || rhs.high > UINT64_C(0) || static_cast(lhs) <= rhs.low; +} + +template , bool> = true> +constexpr bool operator<=(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return lhs.high == UINT64_C(0) && lhs.low <= static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator<=(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return rhs.high > UINT64_C(0) || static_cast(lhs) <= rhs.low; +} + +constexpr bool operator<=(const u128 lhs, const u128 rhs) noexcept +{ + return lhs.high == rhs.high ? lhs.low < rhs.low : lhs.high < rhs.high; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr bool operator<=(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs <= static_cast(rhs); +} + +constexpr bool operator<=(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) <= rhs; +} + +constexpr bool operator<=(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs <= static_cast(rhs); +} + +constexpr bool operator<=(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) <= rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Greater Than Operators +//===================================== + +template , bool> = true> +constexpr bool operator>(const u128 lhs, const SignedInteger rhs) noexcept +{ + return rhs < 0 || lhs.high > UINT64_C(0) || lhs.low > static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator>(const SignedInteger lhs, const u128 rhs) noexcept +{ + return lhs > 0 && rhs.high == UINT64_C(0) && static_cast(lhs) > rhs.low; +} + +template , bool> = true> +constexpr bool operator>(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return lhs.high > UINT64_C(0) || lhs.low > static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator>(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return rhs.high == UINT64_C(0) && static_cast(lhs) > rhs.low; +} + +constexpr bool operator>(const u128 lhs, const u128 rhs) noexcept +{ + return lhs.high == rhs.high ? rhs.low < lhs.low : rhs.high < lhs.high; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr bool operator>(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs > static_cast(rhs); +} + +constexpr bool operator>(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) > rhs; +} + +constexpr bool operator>(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs > static_cast(rhs); +} + +constexpr bool operator>(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) > rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Greater-equal Operators +//===================================== + +template , bool> = true> +constexpr bool operator>=(const u128 lhs, const SignedInteger rhs) noexcept +{ + return rhs < 0 || lhs.high > UINT64_C(0) || lhs.low >= static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator>=(const SignedInteger lhs, const u128 rhs) noexcept +{ + return lhs > 0 && rhs.high == UINT64_C(0) && static_cast(lhs) >= rhs.low; +} + +template , bool> = true> +constexpr bool operator>=(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return lhs.high > UINT64_C(0) || lhs.low >= static_cast(rhs); +} + +template , bool> = true> +constexpr bool operator>=(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return rhs.high == UINT64_C(0) && static_cast(lhs) >= rhs.low; +} + +constexpr bool operator>=(const u128 lhs, const u128 rhs) noexcept +{ + return lhs.high == rhs.high ? rhs.low <= lhs.low : rhs.high <= lhs.high; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr bool operator>=(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs >= static_cast(rhs); +} + +constexpr bool operator>=(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) >= rhs; +} + +constexpr bool operator>=(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs >= static_cast(rhs); +} + +constexpr bool operator>=(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) >= rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Not Operator +//===================================== + +constexpr u128 operator~(const u128 rhs) noexcept +{ + return {~rhs.high, ~rhs.low}; +} + +//===================================== +// Or Operator +//===================================== + +template , bool> = true> +constexpr u128 operator|(const u128 lhs, const SignedInteger rhs) noexcept +{ + return {lhs.high | (rhs < 0 ? ~UINT64_C(0) : UINT64_C(0)), lhs.low | static_cast(rhs)}; +} + +template , bool> = true> +constexpr u128 operator|(const SignedInteger lhs, const u128 rhs) noexcept +{ + return {rhs.high | (lhs < 0 ? ~UINT64_C(0) : UINT64_C(0)), rhs.low | static_cast(lhs)}; +} + +template , bool> = true> +constexpr u128 operator|(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return {lhs.high, lhs.low | static_cast(rhs)}; +} + +template , bool> = true> +constexpr u128 operator|(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return {rhs.high, rhs.low | static_cast(lhs)}; +} + +constexpr u128 operator|(const u128 lhs, const u128 rhs) noexcept +{ + return {lhs.high | rhs.high, lhs.low | rhs.low}; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128 operator|(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs | static_cast(rhs); +} + +constexpr u128 operator|(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) | rhs; +} + +constexpr u128 operator|(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs | static_cast(rhs); +} + +constexpr u128 operator|(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) | rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Compound OR Operator +//===================================== + +template , bool>> +constexpr u128& u128::operator|=(const SignedInteger rhs) noexcept +{ + *this = *this | rhs; + return *this; +} + +template , bool>> +constexpr u128& u128::operator|=(const UnsignedInteger rhs) noexcept +{ + *this = *this | rhs; + return *this; +} + +constexpr u128& u128::operator|=(const u128 rhs) noexcept +{ + *this = *this | rhs; + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator|=(const __int128 rhs) noexcept +{ + *this = *this | rhs; + return *this; +} + +constexpr u128& u128::operator|=(const unsigned __int128 rhs) noexcept +{ + *this = *this | rhs; + return *this; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// And Operator +//===================================== + +template , bool> = true> +constexpr u128 operator&(const u128 lhs, const SignedInteger rhs) noexcept +{ + return {lhs.high & (rhs < 0 ? ~UINT64_C(0) : UINT64_C(0)), lhs.low & static_cast(rhs)}; +} + +template , bool> = true> +constexpr u128 operator&(const SignedInteger lhs, const u128 rhs) noexcept +{ + return {rhs.high & (lhs < 0 ? ~UINT64_C(0) : UINT64_C(0)), rhs.low & static_cast(lhs)}; +} + +template , bool> = true> +constexpr u128 operator&(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return {lhs.high, lhs.low & static_cast(rhs)}; +} + +template , bool> = true> +constexpr u128 operator&(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return {rhs.high, rhs.low & static_cast(lhs)}; +} + +constexpr u128 operator&(const u128 lhs, const u128 rhs) noexcept +{ + return {lhs.high & rhs.high, lhs.low & rhs.low}; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128 operator&(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs & static_cast(rhs); +} + +constexpr u128 operator&(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) & rhs; +} + +constexpr u128 operator&(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs & static_cast(rhs); +} + +constexpr u128 operator&(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) & rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Compound And Operator +//===================================== + +template , bool>> +constexpr u128& u128::operator&=(const SignedInteger rhs) noexcept +{ + *this = *this & rhs; + return *this; +} + +template , bool>> +constexpr u128& u128::operator&=(const UnsignedInteger rhs) noexcept +{ + *this = *this & rhs; + return *this; +} + +constexpr u128& u128::operator&=(const u128 rhs) noexcept +{ + *this = *this & rhs; + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator&=(const __int128 rhs) noexcept +{ + *this = *this & rhs; + return *this; +} + +constexpr u128& u128::operator&=(const unsigned __int128 rhs) noexcept +{ + *this = *this & rhs; + return *this; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Xor Operator +//===================================== + +template , bool> = true> +constexpr u128 operator^(const u128 lhs, const SignedInteger rhs) noexcept +{ + return {lhs.high ^ (rhs < 0 ? ~UINT64_C(0) : UINT64_C(0)), lhs.low ^ static_cast(rhs)}; +} + +template , bool> = true> +constexpr u128 operator^(const SignedInteger lhs, const u128 rhs) noexcept +{ + return {rhs.high ^ (lhs < 0 ? ~UINT64_C(0) : UINT64_C(0)), rhs.low ^ static_cast(lhs)}; +} + +template , bool> = true> +constexpr u128 operator^(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return {lhs.high, lhs.low ^ static_cast(rhs)}; +} + +template , bool> = true> +constexpr u128 operator^(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return {rhs.high, rhs.low ^ static_cast(lhs)}; +} + +constexpr u128 operator^(const u128 lhs, const u128 rhs) noexcept +{ + return {lhs.high ^ rhs.high, lhs.low ^ rhs.low}; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128 operator^(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs ^ static_cast(rhs); +} + +constexpr u128 operator^(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) ^ rhs; +} + +constexpr u128 operator^(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs ^ static_cast(rhs); +} + +constexpr u128 operator^(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) ^ rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Compound XOR Operator +//===================================== + +template , bool>> +constexpr u128& u128::operator^=(const SignedInteger rhs) noexcept +{ + *this = *this ^ rhs; + return *this; +} + +template , bool>> +constexpr u128& u128::operator^=(const UnsignedInteger rhs) noexcept +{ + *this = *this ^ rhs; + return *this; +} + +constexpr u128& u128::operator^=(const u128 rhs) noexcept +{ + *this = *this ^ rhs; + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator^=(const __int128 rhs) noexcept +{ + *this = *this ^ rhs; + return *this; +} + +constexpr u128& u128::operator^=(const unsigned __int128 rhs) noexcept +{ + *this = *this ^ rhs; + return *this; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Left Shift Operator +//===================================== + +template ::value, bool> = true> +constexpr u128 operator<<(const u128 lhs, const Integer rhs) noexcept +{ + if (rhs < 0 || rhs >= 128) + { + return {0, 0}; + } + + if (rhs == 0) + { + return lhs; + } + + if (rhs == 64) + { + return {lhs.low, 0}; + } + + if (rhs > 64) + { + return {lhs.low << (rhs - 64), 0}; + } + + return { + (lhs.high << rhs) | (lhs.low >> (64 - rhs)), + lhs.low << rhs + }; +} + +template ::value && (sizeof(Integer) * 8 > 16), bool> = true> +constexpr Integer operator<<(const Integer lhs, const u128 rhs) noexcept +{ + constexpr auto bit_width = sizeof(Integer) * 8; + + if (rhs.high > UINT64_C(0) || rhs.low >= bit_width) + { + return 0; + } + + return lhs << rhs.low; +} + +template && (sizeof(SignedInteger) * 8 <= 16), bool> = true> +constexpr int operator<<(const SignedInteger lhs, const u128 rhs) noexcept +{ + constexpr auto bit_width = sizeof(SignedInteger) * 8; + + if (rhs.high > UINT64_C(0) || rhs.low >= bit_width) + { + return 0; + } + + return static_cast(lhs) << rhs.low; +} + +template && (sizeof(UnsignedInteger) * 8 <= 16), bool> = true> +constexpr unsigned operator<<(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + constexpr auto bit_width = sizeof(UnsignedInteger) * 8; + + if (rhs.high > UINT64_C(0) || rhs.low >= bit_width) + { + return 0; + } + + return static_cast(lhs) << rhs.low; +} + +constexpr u128 operator<<(const u128 lhs, const u128 rhs) noexcept +{ + if (rhs >= 128) + { + return {0, 0}; + } + + if (rhs.low == 0) + { + return lhs; + } + + if (rhs.low == 64) + { + return {lhs.low, 0}; + } + + if (rhs.low > 64) + { + return {lhs.low << (rhs.low - 64), 0}; + } + + return { + (lhs.high << rhs.low) | (lhs.low >> (64 - rhs.low)), + lhs.low << rhs.low + }; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128 operator<<(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs << static_cast(rhs); +} + +constexpr __int128 operator<<(const __int128 lhs, const u128 rhs) noexcept +{ + return lhs << static_cast<__int128>(rhs); +} + +constexpr u128 operator<<(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs << static_cast(rhs); +} + +constexpr unsigned __int128 operator<<(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return lhs << static_cast(rhs); +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Compound Left Shift Operator +//===================================== + +template , bool>> +constexpr u128& u128::operator<<=(const SignedInteger rhs) noexcept +{ + *this = *this << rhs; + return *this; +} + +template , bool>> +constexpr u128& u128::operator<<=(const UnsignedInteger rhs) noexcept +{ + *this = *this << rhs; + return *this; +} + +constexpr u128& u128::operator<<=(const u128 rhs) noexcept +{ + *this = *this << rhs; + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator<<=(const __int128 rhs) noexcept +{ + *this = *this << rhs; + return *this; +} + +constexpr u128& u128::operator<<=(const unsigned __int128 rhs) noexcept +{ + *this = *this << rhs; + return *this; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Right Shift Operator +//===================================== + +template ::value, bool> = true> +constexpr u128 operator>>(const u128 lhs, const Integer rhs) noexcept +{ + if (rhs < 0 || rhs >= 128) + { + return {0, 0}; + } + + if (rhs == 0) + { + return lhs; + } + + if (rhs == 64) + { + return {0, lhs.high}; + } + + if (rhs > 64) + { + return {0, lhs.high >> (rhs - 64)}; + } + + return { + lhs.high >> rhs, + (lhs.low >> rhs) | (lhs.high << (64 - rhs)) + }; +} + +template ::value && (sizeof(Integer) * 8 > 16), bool> = true> +constexpr Integer operator>>(const Integer lhs, const u128 rhs) noexcept +{ + constexpr auto bit_width = sizeof(Integer) * 8; + + if (rhs.high > UINT64_C(0) || rhs.low >= bit_width) + { + return 0; + } + + return lhs >> rhs.low; +} + +template && (sizeof(SignedInteger) * 8 <= 16), bool> = true> +constexpr int operator>>(const SignedInteger lhs, const u128 rhs) noexcept +{ + constexpr auto bit_width = sizeof(SignedInteger) * 8; + + if (rhs.high > UINT64_C(0) || rhs.low >= bit_width) + { + return 0; + } + + return static_cast(lhs) >> rhs.low; +} + +template && (sizeof(UnsignedInteger) * 8 <= 16), bool> = true> +constexpr unsigned operator>>(UnsignedInteger lhs, const u128 rhs) noexcept +{ + constexpr auto bit_width = sizeof(UnsignedInteger) * 8; + + if (rhs.high > UINT64_C(0) || rhs.low >= bit_width) + { + return 0; + } + + return static_cast(lhs) >> rhs.low; +} + +constexpr u128 operator>>(const u128 lhs, const u128 rhs) noexcept +{ + if (rhs >= 128) + { + return {0, 0}; + } + + if (rhs.low == 0) + { + return lhs; + } + + if (rhs.low == 64) + { + return {0, lhs.high}; + } + + if (rhs.low > 64) + { + return {0, lhs.high >> (rhs.low - UINT64_C(64))}; + } + + return { + lhs.high >> rhs.low, + (lhs.low >> rhs.low) | (lhs.high << (UINT64_C(64) - rhs.low)) + }; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128 operator>>(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs >> static_cast(rhs); +} + +constexpr __int128 operator>>(const __int128 lhs, const u128 rhs) noexcept +{ + return lhs >> static_cast<__int128>(rhs); +} + +constexpr u128 operator>>(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs >> static_cast(rhs); +} + +constexpr unsigned __int128 operator>>(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return lhs >> static_cast(rhs); +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Compound Right Shift Operator +//===================================== + +template , bool>> +constexpr u128& u128::operator>>=(const SignedInteger rhs) noexcept +{ + *this = *this >> rhs; + return *this; +} + +template , bool>> +constexpr u128& u128::operator>>=(const UnsignedInteger rhs) noexcept +{ + *this = *this >> rhs; + return *this; +} + +constexpr u128& u128::operator>>=(const u128 rhs) noexcept +{ + *this = *this >> rhs; + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator>>=(const __int128 rhs) noexcept +{ + *this = *this >> rhs; + return *this; +} + +constexpr u128& u128::operator>>=(const unsigned __int128 rhs) noexcept +{ + *this = *this >> rhs; + return *this; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Addition Operator +//===================================== + +namespace impl { + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_add(const u128 lhs, const std::uint64_t rhs) noexcept +{ + u128 temp {lhs.high, lhs.low + rhs}; + + if (temp.low < lhs.low) + { + ++temp.high; + } + + return temp; +} + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_add(const u128 lhs, const u128 rhs) noexcept +{ + u128 temp {lhs.high + rhs.high, lhs.low + rhs.low}; + + if (temp.low < lhs.low) + { + ++temp.high; + } + + return temp; +} + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_sub(const u128 lhs, const u128 rhs) noexcept +{ + #if defined(__x86_64__) && defined(BOOST_DECIMAL_HAS_INT128) && !defined(BOOST_DECIMAL_OLD_NON_GNU_COMPILER) + + return static_cast(static_cast(lhs) - static_cast(rhs)); + + #else + + u128 temp {lhs.high - rhs.high, lhs.low - rhs.low}; + + // Check for carry + if (lhs.low < rhs.low) + { + --temp.high; + } + + return temp; + + #endif +} + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_sub(const u128 lhs, const std::uint64_t rhs) noexcept +{ + u128 temp {lhs.high, lhs.low - rhs}; + + // Check for carry + if (lhs.low < rhs) + { + --temp.high; + } + + return temp; +} + +} // namespace impl + +template || std::is_same::value, bool> = true> +constexpr u128 operator+(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return impl::default_add(lhs, rhs); +} + +// Since unsigned addition is trivially commutative we just reverse the order of the operands into the impl functions +template , bool> = true> +constexpr u128 operator+(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return impl::default_add(rhs, lhs); +} + +template , bool> = true> +constexpr u128 operator+(const u128 lhs, const SignedInteger rhs) noexcept +{ + if (rhs > 0) + { + return impl::default_add(lhs, static_cast(rhs)); + } + else + { + const auto unsigned_rhs {detail::make_positive_unsigned(rhs)}; + return impl::default_sub(lhs, unsigned_rhs); + } +} + +// -a + b == b - a +// a + b == b + a +template , bool> = true> +constexpr u128 operator+(const SignedInteger lhs, const u128 rhs) noexcept +{ + if (lhs > 0) + { + return impl::default_add(rhs, static_cast(lhs)); + } + else + { + const auto unsigned_lhs {detail::make_positive_unsigned(lhs)}; + return impl::default_sub(rhs, unsigned_lhs); + } +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128 operator+(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs + static_cast(rhs); +} + +constexpr u128 operator+(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) + rhs; +} + +constexpr u128 operator+(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs + static_cast(rhs); +} + +constexpr u128 operator+(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) + rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Compound Addition Operator +//===================================== + +template , bool>> +constexpr u128& u128::operator+=(const UnsignedInteger rhs) noexcept +{ + *this = *this + rhs; + return *this; +} + +template , bool>> +constexpr u128& u128::operator+=(const SignedInteger rhs) noexcept +{ + *this = *this + rhs; + return *this; +} + +constexpr u128& u128::operator+=(const u128 rhs) noexcept +{ + *this = *this + rhs; + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator+=(const __int128 rhs) noexcept +{ + *this = *this + rhs; + return *this; +} + +constexpr u128& u128::operator+=(const unsigned __int128 rhs) noexcept +{ + *this = *this + rhs; + return *this; +} + +#endif + +//===================================== +// Subtraction Operator +//===================================== + +template || std::is_same::value, bool> = true> +constexpr u128 operator-(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return impl::default_sub(lhs, rhs); +} + +template , bool> = true> +constexpr u128 operator-(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + // The only real viable way to do this is to promote lhs and perform 128-bit sub + return u128{UINT64_C(0), lhs} - rhs; +} + +template , bool> = true> +constexpr u128 operator-(const u128 lhs, const SignedInteger rhs) noexcept +{ + if (rhs < 0) + { + return impl::default_add(lhs, static_cast(-rhs)); + } + else + { + return impl::default_sub(lhs, static_cast(rhs)); + } +} + +template , bool> = true> +constexpr u128 operator-(const SignedInteger lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) - rhs; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128 operator-(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs - static_cast(rhs); +} + +constexpr u128 operator-(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) - rhs; +} + +constexpr u128 operator-(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs - static_cast(rhs); +} + +constexpr u128 operator-(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) - rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Compound Subtraction Operator +//===================================== + +template , bool>> +constexpr u128& u128::operator-=(const SignedInteger rhs) noexcept +{ + *this = *this - rhs; + return *this; +} + +template , bool>> +constexpr u128& u128::operator-=(const UnsignedInteger rhs) noexcept +{ + *this = *this - rhs; + return *this; +} + +constexpr u128& u128::operator-=(const u128 rhs) noexcept +{ + *this = *this - rhs; + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator-=(const __int128 rhs) noexcept +{ + *this = *this - rhs; + return *this; +} + +constexpr u128& u128::operator-=(const unsigned __int128 rhs) noexcept +{ + *this = *this - rhs; + return *this; +} + +#endif + +//===================================== +// Multiplication Operator +//===================================== + +#if defined(__GNUC__) && __GNUC__ >= 8 +# pragma GCC diagnostic ignored "-Wclass-memaccess" +#endif + +namespace impl { + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 shift_left_32(const std::uint64_t low) noexcept +{ + return {low >> 32, low << 32}; +} + +#if (defined(__x86_64__) || (defined(__aarch64__) && !defined(__APPLE__)) || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__))) && defined(BOOST_DECIMAL_HAS_INT128) \ + && !defined(BOOST_DECIMAL_OLD_NON_GNU_COMPILER) + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_mul(const u128 lhs, const u128 rhs) noexcept +{ + #ifndef BOOST_DECIMAL_NO_CONSTEVAL_DETECTION + + if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(lhs)) + { + return static_cast(static_cast(lhs) * static_cast(rhs)); + } + else + { + unsigned __int128 new_lhs {}; + unsigned __int128 new_rhs {}; + + std::memcpy(&new_lhs, &lhs, sizeof(new_lhs)); + std::memcpy(&new_rhs, &rhs, sizeof(new_rhs)); + + const auto res {new_lhs * new_rhs}; + + u128 new_res {}; + std::memcpy(&new_res, &res, sizeof(new_res)); + + return new_res; + } + + #else + + return static_cast(static_cast(lhs) * static_cast(rhs)); + + #endif +} + +#else + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_mul(const u128 lhs, const u128 rhs) noexcept +{ + const auto a = static_cast(lhs.low >> 32); + const auto b = static_cast(lhs.low & UINT32_MAX); + const auto c = static_cast(rhs.low >> 32); + const auto d = static_cast(rhs.low & UINT32_MAX); + + u128 result { lhs.high * rhs.low + lhs.low * rhs.high + a * c, b * d }; + result += shift_left_32(a * d) + shift_left_32(b * c); + + return result; +} + +#endif // x64 + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_mul(const u128 lhs, const std::uint64_t rhs) noexcept +{ + const auto c = static_cast(rhs >> 32); + const auto d = static_cast(rhs & UINT32_MAX); + const auto a = static_cast(lhs.low >> 32); + const auto b = static_cast(lhs.low & UINT32_MAX); + + u128 result{lhs.high * rhs, b * d}; + result += shift_left_32(a * d) + shift_left_32(b * c); + + return result; +} + +constexpr u128 default_signed_mul(const u128 lhs, const std::int64_t rhs) noexcept +{ + const bool isneg {rhs < 0}; + const auto abs_rhs {detail::make_positive_unsigned(rhs)}; + + auto res {default_mul(lhs, abs_rhs)}; + + if (isneg) + { + res.high = ~res.high; + res.low = ~res.low; + + ++res.low; + if (res.low == UINT64_C(0)) + { + ++res.high; + } + } + + return res; +} + +} // namespace impl + +template || std::is_same::value, bool> = true> +constexpr u128 operator*(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return impl::default_mul(lhs, rhs); +} + +template , bool> = true> +constexpr u128 operator*(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + return impl::default_mul(rhs, static_cast(lhs)); +} + +template , bool> = true> +constexpr u128 operator*(const u128 lhs, const SignedInteger rhs) noexcept +{ + return impl::default_signed_mul(lhs, static_cast(rhs)); +} + +template , bool> = true> +constexpr u128 operator*(const SignedInteger lhs, const u128 rhs) noexcept +{ + return impl::default_signed_mul(rhs, static_cast(lhs)); +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128 operator*(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs * static_cast(rhs); +} + +constexpr u128 operator*(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) * rhs; +} + +constexpr u128 operator*(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs * static_cast(rhs); +} + +constexpr u128 operator*(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) * rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Compound Multiplication Operator +//===================================== + +template , bool>> +constexpr u128& u128::operator*=(const SignedInteger rhs) noexcept +{ + *this = *this * rhs; + return *this; +} + +template , bool>> +constexpr u128& u128::operator*=(const UnsignedInteger rhs) noexcept +{ + *this = *this * rhs; + return *this; +} + +constexpr u128& u128::operator*=(const u128 rhs) noexcept +{ + *this = *this * rhs; + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator*=(const __int128 rhs) noexcept +{ + *this = *this * rhs; + return *this; +} + +constexpr u128& u128::operator*=(const unsigned __int128 rhs) noexcept +{ + *this = *this * rhs; + return *this; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Division Operator +//===================================== + +namespace impl { + +using wide_integer_uint128 = ::boost::decimal::math::wide_integer::uint128_t; + +constexpr auto u128_to_wide_integer(const u128& src) -> wide_integer_uint128 +{ + wide_integer_uint128 dst { }; + + using local_limb_type = typename wide_integer_uint128::limb_type; + + static_assert(sizeof(local_limb_type) == static_cast(UINT8_C(4)) && std::is_same::value, "Error: Configuration of external wide-integer limbs not OK"); + + auto& rep = dst.representation(); + + rep[0] = static_cast(src.low); + rep[1] = static_cast(src.low >> 32U); + rep[2] = static_cast(src.high); + rep[3] = static_cast(src.high >> 32U); + + return dst; +} + +constexpr auto wide_integer_to_u128(const wide_integer_uint128& src) -> u128 +{ + u128 dst {}; + + const auto& rep = src.crepresentation(); + + dst.low = static_cast(rep[0]) | (static_cast(rep[1]) << 32); + dst.high = static_cast(rep[2]) | (static_cast(rep[3]) << 32U); + + return dst; +} + +// Adapted from ckormanyos/wide-integer +// +// Use Knuth's long division algorithm. +// The loop-ordering of indices in Knuth's original +// algorithm has been reversed due to the data format +// used here. Several optimizations and combinations +// of logic have been carried out in the source code. +// +// See also: +// D.E. Knuth, "The Art of Computer Programming, Volume 2: +// Seminumerical Algorithms", Addison-Wesley (1998), +// Section 4.3.1 Algorithm D and Exercise 16. + +template +constexpr void divide_knuth_core(std::uint32_t (&u)[u_size], + std::uint32_t (&v)[v_size], + std::uint32_t (&q)[q_size]) noexcept +{ + const auto d { u_size - v_size - 1 }; + + for (int j = d; j >= 0; --j) + { + const auto next_digits{ (static_cast(u[j + v_size]) << 32) | static_cast(u[j + v_size - 1]) }; + const auto div{ v[v_size - 1] }; + BOOST_DECIMAL_ASSUME(div != 0); + auto q_hat{ next_digits / div }; + auto r_hat{ next_digits % div }; + + while ((q_hat >> 32) != 0 || ( q_hat * v[v_size - 2] > (r_hat << 32 | u[j + v_size - 2]))) + { + --q_hat; + r_hat += v[v_size - 1]; + if (r_hat >> 32 != 0) + { + break; + } + } + + std::int64_t k{}; + std::int64_t t{}; + + for (std::size_t i = 0; i < v_size; ++i) + { + const auto product{ static_cast(q_hat) * static_cast(v[i]) }; + t = u[i + j] - k - product; + u[i + j] = static_cast(t); + k = static_cast(product >> 32) - (t >> 32); + } + + t = static_cast(u[j + v_size]) - k; + u[j + v_size] = static_cast(t); + q[j] = static_cast(q_hat); + + if (t < 0) + { + --q[j]; + k = 0; + + for (std::size_t i = 0; i < v_size; ++i) + { + t = static_cast(u[i + j]) + k + static_cast(v[i]); + u[i + j] = static_cast(t); + k = t >> 32; + } + + u[j + v_size] += static_cast(k); + } + } +} + +constexpr void div_mod_impl(const u128& lhs, const std::uint64_t rhs, u128& quotient, u128& remainder) noexcept +{ + BOOST_DECIMAL_ASSUME(rhs != 0); + + // If rhs is greater than 2^32 the result is trivial to find + if (rhs >= UINT32_MAX) + { + #if !defined(BOOST_DECIMAL_NO_CONSTEVAL_DETECTION) && defined(BOOST_DECIMAL_HAS_MSVC_X64_INTRINSICS) + if (!BOOST_DECIMAL_IS_CONSTANT_EVALUATED(rhs)) + { + quotient.low = _udiv128(lhs.high, lhs.low, rhs, &remainder.low); + } + else + #endif + { + remainder.low = (lhs.high << 32U) | (lhs.low >> 32U); + auto res = remainder.low / rhs; + remainder.low = (remainder.low % rhs) << 32 | lhs.low; + res = (res << 32) | (remainder.low / rhs); + remainder.low %= rhs; + } + } + else + { + const auto rhs32 = static_cast(rhs); + + auto current = static_cast(lhs.high >> 32U); + quotient.high = static_cast(static_cast(static_cast(current / rhs32)) << 32U); + remainder.low = static_cast(current % rhs32); + + current = static_cast(remainder.low << 32U) | static_cast(lhs.high); + quotient.high |= static_cast(current / rhs32); + remainder.low = static_cast(current % rhs32); + + current = static_cast(remainder.low << 32U) | static_cast(lhs.low >> 32U); + quotient.low = static_cast(static_cast(static_cast(current / rhs32)) << 32U); + remainder.low = static_cast(current % rhs32); + + current = remainder.low << 32U | static_cast(lhs.low); + quotient.low |= static_cast(current / rhs32); + remainder.low = static_cast(current % rhs32); + } +} + +BOOST_DECIMAL_FORCE_INLINE constexpr void div_mod_impl(const u128& lhs, const u128& rhs, u128& quotient, u128& remainder) noexcept +{ + // Mash-Up: Use Knuth long-division from wide-integer (requires limb-conversions on input/output). + if (rhs.high == UINT64_C(0) && rhs.low < UINT64_C(0x100000000)) + { + const auto rhs32 = static_cast(rhs.low); + + auto current = static_cast(lhs.high >> 32U); + quotient.high = static_cast(static_cast(static_cast(current / rhs32)) << 32U); + remainder.low = static_cast(current % rhs32); + + current = static_cast(remainder.low << 32U) | static_cast(lhs.high); + quotient.high |= static_cast(current / rhs32); + remainder.low = static_cast(current % rhs32); + + current = static_cast(remainder.low << 32U) | static_cast(lhs.low >> 32U); + quotient.low = static_cast(static_cast(static_cast(current / rhs32)) << 32U); + remainder.low = static_cast(current % rhs32); + + current = remainder.low << 32U | static_cast(lhs.low); + quotient.low |= static_cast(current / rhs32); + remainder.low = static_cast(current % rhs32); + + remainder.high = UINT64_C(0); + } + #ifdef BOOST_DECIMAL_HAS_MSVC_X64_INTRINSICS + else if (rhs.high == UINT64_C(0)) + { + // Since low is at least 2^32 the quotient will be less than 2^64 + quotient.low = _udiv128(lhs.high, lhs.low, rhs.low, &remainder.low); + } + #endif + else + { + auto lhs_wide = u128_to_wide_integer(lhs); + + wide_integer_uint128 rem_wide { }; + + lhs_wide.eval_divide_knuth(u128_to_wide_integer(rhs), rem_wide); + + remainder = wide_integer_to_u128(rem_wide); + quotient = wide_integer_to_u128(lhs_wide); + } +} + +#if (defined(__x86_64__) || (defined(__aarch64__) && !defined(__APPLE__)) || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__))) && defined(BOOST_DECIMAL_HAS_INT128) \ + && !defined(BOOST_DECIMAL_OLD_NON_GNU_COMPILER) + +// This is unconditionally better on ARM64, PPC64LE, and S390X +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_div(const u128 lhs, const std::uint64_t rhs) noexcept +{ + return static_cast(static_cast(lhs) / rhs); +} + +#elif defined(BOOST_DECIMAL_HAS_INT128) + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_div(const u128 lhs, const std::uint64_t rhs) noexcept +{ + #ifndef BOOST_DECIMAL_NO_CONSTEVAL_DETECTION + + if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(rhs)) + { + return static_cast(static_cast(lhs) / rhs); + } + else if (lhs.high != 0) + { + // TODO(mborland): Can we abbreviate Knuth division for this case? + u128 quotient {}; + u128 remainder {}; + impl::div_mod_impl(lhs, u128{0, rhs}, quotient, remainder); + return quotient; + } + else + { + return {0, lhs.low / rhs}; + } + + #else + + return static_cast(static_cast(lhs) / rhs); + + #endif +} + +#else + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_div(const u128 lhs, const std::uint64_t rhs) noexcept +{ + #ifndef BOOST_DECIMAL_NO_CONSTEVAL_DETECTION + + if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(rhs)) + { + u128 quotient{}; + u128 remainder{}; + impl::div_mod_impl(lhs, rhs, quotient, remainder); + return quotient; + } + if (rhs == 0) + { + return { 0,0 }; + } + else if (lhs.high != 0) + { + u128 quotient{}; + u128 remainder{}; + impl::div_mod_impl(lhs, rhs, quotient, remainder); + return quotient; + } + else + { + return { 0, lhs.low / rhs }; + } + + #else + + u128 quotient{}; + u128 remainder{}; + impl::div_mod_impl(lhs, u128{ 0, rhs }, quotient, remainder); + return quotient; + + #endif +} + +#endif + +} + +template , bool> = true> +constexpr u128 operator/(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return impl::default_div(lhs, static_cast(rhs)); +} + +template , bool> = true> +constexpr u128 operator/(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + if (rhs.high != 0) + { + return {0, 0}; + } + else + { + return {0, lhs / rhs.low}; + } +} + +constexpr u128 operator/(const u128 lhs, const u128 rhs) noexcept +{ + // On ARM64 and PPC64LE this is unconditionally better + // On x64 this is only better when both lhs and rhs are two word numbers + #if defined(__aarch64__) || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) || defined(__s390x__) \ + && !defined(BOOST_DECIMAL_OLD_NON_GNU_COMPILER) + + return static_cast(static_cast(lhs) / static_cast(rhs)); + + #else + + BOOST_DECIMAL_ASSERT_MSG(rhs != 0, "Division by zero"); + + // The is best x64 path assuming the user has consteval detection + #if !defined(BOOST_DECIMAL_NO_CONSTEVAL_DETECTION) && defined(BOOST_DECIMAL_HAS_INT128) && !defined(BOOST_DECIMAL_OLD_NON_GNU_COMPILER) + + if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(rhs)) + { + return static_cast(static_cast(lhs) / static_cast(rhs)); + } + else if (lhs.high != 0 && rhs.high != 0) + { + unsigned __int128 new_lhs {}; + unsigned __int128 new_rhs {}; + + std::memcpy(&new_lhs, &lhs, sizeof(new_lhs)); + std::memcpy(&new_rhs, &rhs, sizeof(new_rhs)); + + const auto res {new_lhs / new_rhs}; + + u128 new_res {}; + std::memcpy(&new_res, &res, sizeof(new_res)); + + return new_res; + } + else if (rhs > lhs) + { + return {0, 0}; + } + else + { + u128 quotient {}; + u128 remainder {}; + impl::div_mod_impl(lhs, rhs, quotient, remainder); + return quotient; + } + + #else + + if (lhs.high != 0 && rhs.high != 0) + { + #if defined(BOOST_DECIMAL_HAS_INT128) && !defined(BOOST_DECIMAL_OLD_NON_GNU_COMPILER) + + return static_cast(static_cast(lhs) / static_cast(rhs)); + + #else + + u128 quotient {}; + u128 remainder {}; + impl::div_mod_impl(lhs, rhs, quotient, remainder); + return quotient; + + #endif + } + else if ((lhs.high == 0 && rhs.high != 0) || rhs.low == 0) + { + return {0, 0}; + } + else if (lhs.high == 0) + { + return { 0, lhs.low / rhs.low }; + } + else + { + u128 quotient {}; + u128 remainder {}; + impl::div_mod_impl(lhs, rhs, quotient, remainder); + return quotient; + } + + #endif + + #endif +} + +template , bool> = true> +constexpr u128 operator/(const u128 lhs, const SignedInteger rhs) noexcept +{ + return rhs > 0 ? lhs / static_cast(rhs) : lhs / static_cast(rhs); +} + +template , bool> = true> +constexpr u128 operator/(const SignedInteger lhs, const u128 rhs) noexcept +{ + return lhs > 0 ? static_cast(lhs) / rhs : static_cast(lhs) / rhs; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128 operator/(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs / static_cast(rhs); +} + +constexpr u128 operator/(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) / rhs; +} + +constexpr u128 operator/(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs / static_cast(rhs); +} + +constexpr u128 operator/(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) / rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Compound Division Operator +//===================================== + +template , bool>> +constexpr u128& u128::operator/=(const SignedInteger rhs) noexcept +{ + *this = *this / rhs; + return *this; +} + +template , bool>> +constexpr u128& u128::operator/=(const UnsignedInteger rhs) noexcept +{ + *this = *this / rhs; + return *this; +} + +constexpr u128& u128::operator/=(const u128 rhs) noexcept +{ + *this = *this / rhs; + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator/=(const __int128 rhs) noexcept +{ + *this = *this / rhs; + return *this; +} + +constexpr u128& u128::operator/=(const unsigned __int128 rhs) noexcept +{ + *this = *this / rhs; + return *this; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Modulo Operator +//===================================== + +namespace impl { + +#if defined(__aarch64__) || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) || defined(__s390x__) \ + && !defined(BOOST_DECIMAL_OLD_NON_GNU_COMPILER) + +// This is unconditionally better on ARM64, PPC64LE, and S390X +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_mod(const u128 lhs, const std::uint64_t rhs) noexcept +{ + return static_cast(static_cast(lhs) % rhs); +} + +#elif defined(BOOST_DECIMAL_HAS_INT128) + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_mod(const u128 lhs, const std::uint64_t rhs) noexcept +{ + #ifndef BOOST_DECIMAL_NO_CONSTEVAL_DETECTION + + if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(rhs)) + { + return static_cast(static_cast(lhs) % rhs); + } + else if (lhs.high != 0) + { + // TODO(mborland): Can we abbreviate Knuth division for this case? + u128 quotient {}; + u128 remainder {}; + impl::div_mod_impl(lhs, u128{0, rhs}, quotient, remainder); + return remainder; + } + else + { + return {0, lhs.low % rhs}; + } + + #else + + return static_cast(static_cast(lhs) % rhs); + + #endif +} + +#else + +BOOST_DECIMAL_FORCE_INLINE constexpr u128 default_mod(const u128 lhs, const std::uint64_t rhs) noexcept +{ + #ifndef BOOST_DECIMAL_NO_CONSTEVAL_DETECTION + + if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(rhs)) + { + u128 quotient{}; + u128 remainder{}; + impl::div_mod_impl(lhs, rhs, quotient, remainder); + return remainder; + } + else if (rhs == 0) + { + return { 0, 0 }; + } + else if (lhs.high != 0) + { + u128 quotient{}; + u128 remainder{}; + impl::div_mod_impl(lhs, rhs, quotient, remainder); + return remainder; + } + else + { + return { 0, lhs.low % rhs }; + } + + #else + + u128 quotient{}; + u128 remainder{}; + impl::div_mod_impl(lhs, u128{ 0, rhs }, quotient, remainder); + return remainder; + + #endif +} + +#endif + +} // namespace impl + +constexpr u128 operator%(const u128 lhs, const u128 rhs) noexcept +{ + // On ARM64 and PPC64LE this is unconditionally better + // On x64 this is only better when both lhs and rhs are two word numbers + #if defined(__aarch64__) || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) || defined(__s390x__) + + return static_cast(static_cast(lhs) % static_cast(rhs)); + + #else + + BOOST_DECIMAL_ASSERT_MSG(rhs != 0, "Division by zero"); + + // The is best x64 path assuming the user has consteval detection + #if !defined(BOOST_DECIMAL_NO_CONSTEVAL_DETECTION) && defined(BOOST_DECIMAL_HAS_INT128) + + if (BOOST_DECIMAL_IS_CONSTANT_EVALUATED(rhs)) + { + return static_cast(static_cast(lhs) % static_cast(rhs)); + } + else if (lhs.high != 0 && rhs.high != 0) + { + unsigned __int128 new_lhs {}; + unsigned __int128 new_rhs {}; + + std::memcpy(&new_lhs, &lhs, sizeof(new_lhs)); + std::memcpy(&new_rhs, &rhs, sizeof(new_rhs)); + + const auto res {new_lhs % new_rhs}; + + u128 new_res {}; + std::memcpy(&new_res, &res, sizeof(new_res)); + + return new_res; + } + else if (rhs > lhs) + { + return lhs; + } + else + { + u128 quotient {}; + u128 remainder {}; + impl::div_mod_impl(lhs, rhs, quotient, remainder); + return remainder; + } + + #else + + if (lhs.high != 0 && rhs.high != 0) + { + #ifdef BOOST_DECIMAL_HAS_INT128 + + return static_cast(static_cast(lhs) % static_cast(rhs)); + + #else + + u128 quotient {}; + u128 remainder {}; + impl::div_mod_impl(lhs, rhs, quotient, remainder); + return remainder; + + #endif + } + else if (rhs > lhs) + { + return lhs; + } + else + { + u128 quotient {}; + u128 remainder {}; + impl::div_mod_impl(lhs, rhs, quotient, remainder); + return remainder; + } + + #endif + + #endif +} + +template , bool> = true> +constexpr u128 operator%(const u128 lhs, const UnsignedInteger rhs) noexcept +{ + return impl::default_mod(lhs, static_cast(rhs)); +} + +template , bool> = true> +constexpr u128 operator%(const UnsignedInteger lhs, const u128 rhs) noexcept +{ + if (rhs.high != 0) + { + return {0, static_cast(lhs)}; + } + else + { + if (rhs.low == 0) + { + return {0, 0}; + } + else + { + return {0, lhs % rhs.low}; + } + } +} + +template , bool> = true> +constexpr u128 operator%(const u128 lhs, const SignedInteger rhs) noexcept +{ + if (rhs > 0) + { + return impl::default_mod(lhs, static_cast(rhs)); + } + else + { + return lhs % static_cast(rhs); + } +} + +template , bool> = true> +constexpr u128 operator%(const SignedInteger lhs, const u128 rhs) noexcept +{ + if (lhs > 0) + { + if (rhs.high == 0) + { + return {0, static_cast(lhs) % rhs.low}; + } + else + { + return {0, static_cast(lhs)}; + } + } + else + { + return static_cast(lhs) % rhs; + } +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128 operator%(const u128 lhs, const __int128 rhs) noexcept +{ + return lhs % static_cast(rhs); +} + +constexpr u128 operator%(const __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) % rhs; +} + +constexpr u128 operator%(const u128 lhs, const unsigned __int128 rhs) noexcept +{ + return lhs % static_cast(rhs); +} + +constexpr u128 operator%(const unsigned __int128 lhs, const u128 rhs) noexcept +{ + return static_cast(lhs) % rhs; +} + +#endif // BOOST_DECIMAL_HAS_INT128 + +//===================================== +// Compound Modulo Operator +//===================================== + +template , bool>> +constexpr u128& u128::operator%=(const SignedInteger rhs) noexcept +{ + *this = *this % rhs; + return *this; +} + +template , bool>> +constexpr u128& u128::operator%=(const UnsignedInteger rhs) noexcept +{ + *this = *this % rhs; + return *this; +} + +constexpr u128& u128::operator%=(const u128 rhs) noexcept +{ + *this = *this % rhs; + return *this; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +constexpr u128& u128::operator%=(const __int128 rhs) noexcept +{ + *this = *this % rhs; + return *this; +} + +constexpr u128& u128::operator%=(const unsigned __int128 rhs) noexcept +{ + *this = *this % rhs; + return *this; +} + +#if defined(__clang__) +# pragma clang diagnostic pop +#elif defined(__GNUC__) +# pragma GCC diagnostic pop +#endif + +#endif // BOOST_DECIMAL_HAS_INT128 + +#if !defined(BOOST_DECIMAL_DISABLE_IOSTREAM) + +namespace impl { + +inline char* u128_to_dec(char (&buffer)[ 64 ], u128 v) +{ + char* p = buffer + 64; + *--p = '\0'; + + do + { + *--p = "0123456789"[ static_cast(v % UINT64_C(10)) ]; + v /= UINT64_C(10); + } while ( v != 0 ); + + return p; +} + +inline char* u128_to_hex(char (&buffer)[ 64 ], u128 v, bool upper_case) +{ + const auto alphabet = upper_case ? "0123456789ABCDEF" : "0123456789abcdef"; + + char* p = buffer + 64; + *--p = '\0'; + + do + { + const auto last_byte = v.low & 0xF; + *--p = alphabet[ static_cast(last_byte)]; + v >>= 4; + } while (v != 0); + + return p; +} + +inline char* u128_to_octal(char (&buffer)[ 64 ], u128 v) +{ + char* p = buffer + 64; + *--p = '\0'; + + do + { + const auto last_octet = v.low & 0x7; + *--p = "01234567"[ static_cast(last_octet)]; + v >>= 3; + } while (v != 0); + + return p; +} + +static constexpr unsigned char uchar_values[] = +{ + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255, + 255, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 255, 255, 255, 255, 255, + 255, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 +}; + +static_assert(sizeof(uchar_values) == 256, "uchar_values should represent all 256 values of unsigned char"); + +constexpr unsigned char digit_from_char(char val) noexcept +{ + return uchar_values[static_cast(val)]; +} + +template +void base_to_u128(char (&buffer)[N], u128& v, unsigned base) +{ + const char* end = buffer + N; + char* next = buffer; + + const unsigned char first_digit = digit_from_char(*next); + + if (static_cast(first_digit) >= base) + { + return; + } + + unsigned char current_digit = first_digit; + while (next < end && current_digit != 255) + { + v = static_cast(v * base + current_digit); + ++next; + current_digit = digit_from_char(*next); + } +} + +} // namespace impl + +template +std::basic_ostream& operator<<(std::basic_ostream& os, u128 v) +{ + char buffer[64]; + + auto os_flags {os.flags()}; + + switch (os_flags & std::ios::basefield) + { + case std::ios::dec: + os << impl::u128_to_dec(buffer, v); + break; + case std::ios::hex: + os << impl::u128_to_hex(buffer, v, os_flags & std::ios::uppercase); + break; + case std::ios::oct: + os << impl::u128_to_octal(buffer, v); + break; + // LCOV_EXCL_START + default: + BOOST_DECIMAL_UNREACHABLE; + // LCOV_EXCL_STOP + } + + return os; +} + +#ifdef _MSC_VER +# pragma warning (push) +# pragma warning (disable: 4127) // conditional expression is constant +#endif + +template +std::basic_istream& operator>>(std::basic_istream& is, u128& v) +{ + charT t_buffer[1024] {}; + is >> t_buffer; + + char buffer[1024 * (sizeof(charT) / sizeof(char))] {}; + + BOOST_DECIMAL_IF_CONSTEXPR (!std::is_same::value) + { + auto first = buffer; + auto t_first = t_buffer; + const auto t_buffer_end = t_buffer + generic_strlen(t_buffer); + + while (t_first != t_buffer_end) + { + *first++ = static_cast(*t_first++); + } + } + else + { + static_assert(sizeof(buffer) == sizeof(t_buffer), "Need to be equivalent"); + std::memcpy(buffer, t_buffer, sizeof(t_buffer)); + } + + convert_string_to_c_locale(buffer); + + auto is_flags {is.flags()}; + + switch (is_flags & std::ios::basefield) + { + case std::ios::dec: + impl::base_to_u128(buffer, v, 10U); + break; + case std::ios::hex: + impl::base_to_u128(buffer, v, 16U); + break; + case std::ios::oct: + impl::base_to_u128(buffer, v, 8U); + break; + // LCOV_EXCL_START + default: + BOOST_DECIMAL_UNREACHABLE; + // LCOV_EXCL_STOP + } + + return is; +} + +#ifdef _MSC_VER +# pragma warning (pop) +#endif + +#endif // BOOST_DECIMAL_DISABLE_IOSTREAM + +template <> +constexpr int countl_zero(u128 x) noexcept +{ + if (x.high == 0) + { + return 64 + countl_zero(x.low); + } + + return countl_zero(x.high); +} + +} // namespace detail +} // namespace decimal +} // namespace boost + + +// Non-standard libraries may add specializations for library-provided types +template <> +#ifdef _MSC_VER +class std::numeric_limits +#else +struct std::numeric_limits +#endif +{ + +#ifdef _MSC_VER +public: +#endif + + // Member constants + static constexpr bool is_specialized = true; + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + + // These members were deprecated in C++23 + #if ((!defined(_MSC_VER) && (__cplusplus <= 202002L)) || (defined(_MSC_VER) && (_MSVC_LANG <= 202002L))) + static constexpr std::float_denorm_style has_denorm = std::denorm_absent; + static constexpr bool has_denorm_loss = false; + #endif + + static constexpr std::float_round_style round_style = std::round_toward_zero; + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + static constexpr int digits = 128; + static constexpr int digits10 = 38; + static constexpr int max_digits10 = 0; + static constexpr int radix = 2; + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + static constexpr bool traps = std::numeric_limits::traps; + static constexpr bool tinyness_before = false; + + // Member functions + static constexpr auto (min) () -> boost::decimal::detail::u128 { return {0, 0}; } + static constexpr auto lowest () -> boost::decimal::detail::u128 { return {0, 0}; } + static constexpr auto (max) () -> boost::decimal::detail::u128 { return {UINT64_MAX, UINT64_MAX}; } + static constexpr auto epsilon () -> boost::decimal::detail::u128 { return {0, 0}; } + static constexpr auto round_error () -> boost::decimal::detail::u128 { return {0, 0}; } + static constexpr auto infinity () -> boost::decimal::detail::u128 { return {0, 0}; } + static constexpr auto quiet_NaN () -> boost::decimal::detail::u128 { return {0, 0}; } + static constexpr auto signaling_NaN() -> boost::decimal::detail::u128 { return {0, 0}; } + static constexpr auto denorm_min () -> boost::decimal::detail::u128 { return {0, 0}; } +}; + +#undef BOOST_DECIMAL_OLD_NON_GNU_COMPILER + +#endif // BOOST_DECIMAL_DETAIL_U128_HPP diff --git a/test/Jamfile b/test/Jamfile index bfcac416..ec5a50f9 100644 --- a/test/Jamfile +++ b/test/Jamfile @@ -42,6 +42,7 @@ project : requirements [ requires cxx14_decltype_auto cxx14_generic_lambdas cxx14_return_type_deduction cxx14_variable_templates cxx14_constexpr ] ; +run-fail benchmark_uints.cpp ; run-fail benchmarks.cpp ; run compare_dec128_and_fast.cpp ; compile-fail concepts_test.cpp ; @@ -156,6 +157,7 @@ run test_tanh.cpp ; run test_tgamma.cpp ; run test_to_chars.cpp ; run test_to_string.cpp ; +run test_u128.cpp ; run test_zeta.cpp ; # Run the examples too diff --git a/test/benchmark_uints.cpp b/test/benchmark_uints.cpp new file mode 100644 index 00000000..c13aa00a --- /dev/null +++ b/test/benchmark_uints.cpp @@ -0,0 +1,670 @@ +// Copyright 2025 Matt Borland +// Distributed under the Boost Software License, Version 1.0. +// https://www.boost.org/LICENSE_1_0.txt + +#define BOOST_DECIMAL_BENCHMARK_U128 + +#include + +#ifdef BOOST_DECIMAL_BENCHMARK_U128 + +#if __has_include(<__msvc_int128.hpp>) +#include <__msvc_int128.hpp> +#define BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128 +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +constexpr unsigned N = 20'000'000; +constexpr unsigned K = 5; + +using namespace boost::decimal; +using namespace std::chrono_literals; + +#ifdef __clang__ +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wfloat-equal" +# pragma clang diagnostic ignored "-Wold-style-cast" +# define BOOST_DECIMAL_NO_INLINE __attribute__ ((__noinline__)) +#elif defined(_MSC_VER) +# define BOOST_DECIMAL_NO_INLINE __declspec(noinline) +#elif defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wfloat-equal" +# pragma GCC diagnostic ignored "-Wold-style-cast" +# define BOOST_DECIMAL_NO_INLINE __attribute__ ((__noinline__)) +# if __GNUC__ >= 11 +# pragma GCC diagnostic ignored "-Wstringop-overread" +# endif +#endif + +// 0 = 1 word +// 1 = 2 words +// 2 = 2 word / 1 word alternating +// 3 = 1 word / 2 word alternating +// 4 = Random width + +template +std::vector generate_random_vector(std::size_t size = N, unsigned seed = 42U) +{ + if (seed == 0) + { + std::random_device rd; + seed = rd(); + } + + std::mt19937_64 gen(seed); + std::uniform_int_distribution dist(UINT64_C(0), UINT64_MAX); + std::uniform_int_distribution size_dist(0, 1); + + std::vector result(size); + for (std::size_t i = 0; i < size; ++i) + { + switch (words) + { + case 0: + result[i] = T{dist(gen)}; + break; + + case 1: + result[i] = T{dist(gen), dist(gen)}; + break; + + case 2: + if (i % 2 == 0) + { + result[i] = T{dist(gen), dist(gen)}; + } + else + { + result[i] = T{dist(gen)}; + } + break; + + case 3: + if (i % 2 == 1) + { + result[i] = T{dist(gen), dist(gen)}; + } + else + { + result[i] = T{dist(gen)}; + } + break; + + case 4: + if (size_dist(gen) == 1) + { + result[i] = T{dist(gen), dist(gen)}; + } + else + { + result[i] = T{dist(gen)}; + } + break; + + default: + BOOST_DECIMAL_UNREACHABLE; + } + } + + return result; +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +template +std::vector generate_random_builtin_vector(std::size_t size = N, unsigned seed = 42U) +{ + if (seed == 0) + { + std::random_device rd; + seed = rd(); + } + + std::mt19937_64 gen(seed); + std::uniform_int_distribution dist(UINT64_C(0), UINT64_MAX); + std::uniform_int_distribution size_dist(0, 1); + + std::vector result(size); + for (std::size_t i = 0; i < size; ++i) + { + switch (words) + { + case 0: + result[i] = dist(gen); + break; + + case 1: + result[i] = static_cast(boost::decimal::detail::u128{dist(gen), dist(gen)}); + break; + + case 2: + if (i % 2 == 0) + { + result[i] = static_cast(boost::decimal::detail::u128{dist(gen), dist(gen)}); + } + else + { + result[i] = dist(gen); + } + break; + + case 3: + if (i % 2 == 1) + { + result[i] = static_cast(boost::decimal::detail::u128{dist(gen), dist(gen)}); + } + else + { + result[i] = dist(gen); + } + break; + + case 4: + if (size_dist(gen) == 1) + { + result[i] = static_cast(boost::decimal::detail::u128{dist(gen), dist(gen)}); + } + else + { + result[i] = dist(gen); + } + break; + + default: + BOOST_DECIMAL_UNREACHABLE; + } + } + return result; +} + +#endif + +#ifdef BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128 + +template +std::vector generate_random_builtin_vector(std::size_t size = N, unsigned seed = 42U) +{ + if (seed == 0) + { + std::random_device rd; + seed = rd(); + } + + std::mt19937_64 gen(seed); + std::uniform_int_distribution dist(UINT64_C(0), UINT64_MAX); + std::uniform_int_distribution size_dist(0, 1); + + std::vector result(size); + for (std::size_t i = 0; i < size; ++i) + { + switch (words) + { + case 0: + result[i] = dist(gen); + break; + + case 1: + result[i] = static_cast(dist(gen)) << 64U | dist(gen); + break; + + case 2: + if (i % 2 == 0) + { + result[i] = static_cast(dist(gen)) << 64U | dist(gen); + } + else + { + result[i] = dist(gen); + } + break; + + case 3: + if (i % 2 == 1) + { + result[i] = static_cast(dist(gen)) << 64U | dist(gen); + } + else + { + result[i] = dist(gen); + } + break; + + case 4: + if (size_dist(gen) == 1) + { + result[i] = static_cast(dist(gen)) << 64U | dist(gen); + } + else + { + result[i] = dist(gen); + } + break; + + default: + BOOST_DECIMAL_UNREACHABLE; + } + } + return result; +} + +#endif + +template +BOOST_DECIMAL_NO_INLINE void test_comparisons(const std::vector& data_vec, const char* label) +{ + const auto t1 = std::chrono::steady_clock::now(); + std::size_t s = 0; // discard variable + + for (std::size_t k {}; k < K; ++k) + { + for (std::size_t i {}; i < data_vec.size() - 1U; ++i) + { + const auto val1 = data_vec[i]; + const auto val2 = data_vec[i + 1]; + s += static_cast(val1 > val2); + s += static_cast(val1 >= val2); + s += static_cast(val1 < val2); + s += static_cast(val1 <= val2); + s += static_cast(val1 == val2); + s += static_cast(val1 != val2); + } + } + + const auto t2 = std::chrono::steady_clock::now(); + + std::cout << "comp<" << std::left << std::setw(11) << label << ">: " << std::setw( 10 ) << ( t2 - t1 ) / 1us << " us (s=" << s << ")\n"; +} + +template +BOOST_DECIMAL_NO_INLINE void test_two_element_operation(const std::vector& data_vec, Func op, const char* operation, const char* type) +{ + const auto t1 = std::chrono::steady_clock::now(); + std::size_t s = 0; // discard variable + + for (std::size_t k {}; k < K; ++k) + { + for (std::size_t i {}; i < data_vec.size() - 1U; ++i) + { + const auto val1 = data_vec[i]; + const auto val2 = data_vec[i + 1]; + s += static_cast(op(val1, val2)); + } + } + + const auto t2 = std::chrono::steady_clock::now(); + + std::cout << operation << " <" << std::left << std::setw(11) << type << ">: " << std::setw( 10 ) << ( t2 - t1 ) / 1us << " us (s=" << s << ")\n"; +} + +template +BOOST_DECIMAL_NO_INLINE void test_digit_counting(const std::vector& data_vec, const char* label) +{ + const auto t1 = std::chrono::steady_clock::now(); + std::size_t s = 0; // discard variable + + for (std::size_t k {}; k < K; ++k) + { + for (std::size_t i {}; i < data_vec.size(); ++i) + { + const auto val1 = data_vec[i]; + s += static_cast(boost::decimal::detail::num_digits(val1)); + } + } + + const auto t2 = std::chrono::steady_clock::now(); + + std::cout << "digits<" << std::left << std::setw(11) << label << ">: " << std::setw( 10 ) << ( t2 - t1 ) / 1us << " us (s=" << s << ")\n"; +} + +int main() +{ + using namespace boost::decimal::detail; + + // Two word operations + { + std::cout << "\n---------------------------\n"; + std::cout << "Two Word Operations\n"; + std::cout << "---------------------------\n\n"; + + const auto old_vector = generate_random_vector<0, uint128>(); + const auto new_vector = generate_random_vector<0, u128>(); + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + const auto builtin_vector = generate_random_builtin_vector<0>(); + test_comparisons(builtin_vector, "builtin"); + #endif + + test_comparisons(old_vector, "old"); + test_comparisons(new_vector, "new"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::plus<>(), "add", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::plus<>(), "add", "Old"); + test_two_element_operation(new_vector, std::plus<>(), "add", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::minus<>(), "sub", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::minus<>(), "sub", "Old"); + test_two_element_operation(new_vector, std::minus<>(), "sub", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::multiplies<>(), "mul", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::multiplies<>(), "mul", "Old"); + test_two_element_operation(new_vector, std::multiplies<>(), "mul", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::divides<>(), "div", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::divides<>(), "div", "Old"); + test_two_element_operation(new_vector, std::divides<>(), "div", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + // test_digit_counting(builtin_vector, "builtin"); + #endif + + // test_digit_counting(old_vector, "old"); + // test_digit_counting(new_vector, "new"); + } + // Single word operations + { + std::cout << "\n---------------------------\n"; + std::cout << "One Word Operations\n"; + std::cout << "---------------------------\n\n"; + + const auto old_vector = generate_random_vector<1, uint128>(); + const auto new_vector = generate_random_vector<1, u128>(); + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + const auto builtin_vector = generate_random_builtin_vector<1>(); + test_comparisons(builtin_vector, "builtin"); + #endif + + test_comparisons(old_vector, "old"); + test_comparisons(new_vector, "new"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::plus<>(), "add", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::plus<>(), "add", "Old"); + test_two_element_operation(new_vector, std::plus<>(), "add", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::minus<>(), "sub", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::minus<>(), "sub", "Old"); + test_two_element_operation(new_vector, std::minus<>(), "sub", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::multiplies<>(), "mul", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::multiplies<>(), "mul", "Old"); + test_two_element_operation(new_vector, std::multiplies<>(), "mul", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::divides<>(), "div", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::divides<>(), "div", "Old"); + test_two_element_operation(new_vector, std::divides<>(), "div", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + // test_digit_counting(builtin_vector, "builtin"); + #endif + + // test_digit_counting(old_vector, "old"); + // test_digit_counting(new_vector, "new"); + } + { + // Two word and one word operations Even = 2, odd = 1 + + std::cout << "\n---------------------------\n"; + std::cout << "Two-One Word Operations\n"; + std::cout << "---------------------------\n\n"; + + const auto old_vector = generate_random_vector<2, uint128>(); + const auto new_vector = generate_random_vector<2, u128>(); + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + const auto builtin_vector = generate_random_builtin_vector<2>(); + test_comparisons(builtin_vector, "builtin"); + #endif + + test_comparisons(old_vector, "old"); + test_comparisons(new_vector, "new"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::plus<>(), "add", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::plus<>(), "add", "Old"); + test_two_element_operation(new_vector, std::plus<>(), "add", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::minus<>(), "sub", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::minus<>(), "sub", "Old"); + test_two_element_operation(new_vector, std::minus<>(), "sub", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::multiplies<>(), "mul", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::multiplies<>(), "mul", "Old"); + test_two_element_operation(new_vector, std::multiplies<>(), "mul", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::divides<>(), "div", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::divides<>(), "div", "Old"); + test_two_element_operation(new_vector, std::divides<>(), "div", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + // test_digit_counting(builtin_vector, "builtin"); + #endif + + // test_digit_counting(old_vector, "old"); + // test_digit_counting(new_vector, "new"); + } + { + // Two word and one word operations Even = 1, odd = 2 + + std::cout << "\n---------------------------\n"; + std::cout << "One-Two Word Operations\n"; + std::cout << "---------------------------\n\n"; + + const auto old_vector = generate_random_vector<3, uint128>(); + const auto new_vector = generate_random_vector<3, u128>(); + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + const auto builtin_vector = generate_random_builtin_vector<3>(); + test_comparisons(builtin_vector, "builtin"); + #endif + + test_comparisons(old_vector, "old"); + test_comparisons(new_vector, "new"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::plus<>(), "add", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::plus<>(), "add", "Old"); + test_two_element_operation(new_vector, std::plus<>(), "add", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::minus<>(), "sub", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::minus<>(), "sub", "Old"); + test_two_element_operation(new_vector, std::minus<>(), "sub", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::multiplies<>(), "mul", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::multiplies<>(), "mul", "Old"); + test_two_element_operation(new_vector, std::multiplies<>(), "mul", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::divides<>(), "div", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::divides<>(), "div", "Old"); + test_two_element_operation(new_vector, std::divides<>(), "div", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + // test_digit_counting(builtin_vector, "builtin"); + #endif + + // test_digit_counting(old_vector, "old"); + // test_digit_counting(new_vector, "new"); + } + { + // Two word and one word operations Even = 1, odd = 2 + + std::cout << "\n---------------------------\n"; + std::cout << "Random Width Operations\n"; + std::cout << "---------------------------\n\n"; + + const auto old_vector = generate_random_vector<4, uint128>(); + const auto new_vector = generate_random_vector<4, u128>(); + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + const auto builtin_vector = generate_random_builtin_vector<4>(); + test_comparisons(builtin_vector, "builtin"); + #endif + + test_comparisons(old_vector, "old"); + test_comparisons(new_vector, "new"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::plus<>(), "add", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::plus<>(), "add", "Old"); + test_two_element_operation(new_vector, std::plus<>(), "add", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::minus<>(), "sub", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::minus<>(), "sub", "Old"); + test_two_element_operation(new_vector, std::minus<>(), "sub", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::multiplies<>(), "mul", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::multiplies<>(), "mul", "Old"); + test_two_element_operation(new_vector, std::multiplies<>(), "mul", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::divides<>(), "div", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::divides<>(), "div", "Old"); + test_two_element_operation(new_vector, std::divides<>(), "div", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + test_two_element_operation(builtin_vector, std::modulus<>(), "mod", "Builtin"); + #endif + + test_two_element_operation(old_vector, std::modulus<>(), "mod", "Old"); + test_two_element_operation(new_vector, std::modulus<>(), "mod", "New"); + + std::cout << std::endl; + + #if defined(BOOST_DECIMAL_HAS_INT128) || defined(BOOST_DECIMAL_HAS_MSVC_INTERNAL_U128) + // test_digit_counting(builtin_vector, "builtin"); + #endif + + // test_digit_counting(old_vector, "old"); + // test_digit_counting(new_vector, "new"); + } + + return 1; +} + +#else + +int main() +{ + std::cerr << "Benchmarks not run" << std::endl; + return 1; +} + +#endif // BOOST_DECIMAL_BENCHMARK_U128 diff --git a/test/test_u128.cpp b/test/test_u128.cpp new file mode 100644 index 00000000..46db1c9b --- /dev/null +++ b/test/test_u128.cpp @@ -0,0 +1,1904 @@ +// Copyright 2025 Matt Borland +// Distributed under the Boost Software License, Version 1.0. +// https://www.boost.org/LICENSE_1_0.txt + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(__clang__) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wold-style-cast" +# pragma clang diagnostic ignored "-Wundef" +# pragma clang diagnostic ignored "-Wconversion" +# pragma clang diagnostic ignored "-Wsign-conversion" +# pragma clang diagnostic ignored "-Wfloat-equal" +# pragma clang diagnostic ignored "-Wsign-compare" +# pragma clang diagnostic ignored "-Woverflow" + +# if (__clang_major__ >= 10 && !defined(__APPLE__)) || __clang_major__ >= 13 +# pragma clang diagnostic ignored "-Wdeprecated-copy" +# endif + +#elif defined(__GNUC__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wold-style-cast" +# pragma GCC diagnostic ignored "-Wundef" +# pragma GCC diagnostic ignored "-Wconversion" +# pragma GCC diagnostic ignored "-Wsign-conversion" +# pragma GCC diagnostic ignored "-Wsign-compare" +# pragma GCC diagnostic ignored "-Wfloat-equal" +# pragma GCC diagnostic ignored "-Woverflow" + +#elif defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable : 4389) +# pragma warning(disable : 4127) +#endif + +template +constexpr IntType get_max() +{ + return std::numeric_limits::max(); +} + +template +constexpr IntType get_min() +{ + return std::numeric_limits::min(); +} + +#include + +// Used defined seed for repeatability +static std::mt19937_64 rng(42); + +constexpr std::size_t N = 1024; + +void test_traits() +{ + using namespace boost::decimal::detail::impl; + + static_assert(is_signed_integer_v && !is_unsigned_integer_v, "Wrong answer"); + static_assert(is_signed_integer_v && !is_unsigned_integer_v, "Wrong answer"); + static_assert(is_signed_integer_v && !is_unsigned_integer_v, "Wrong answer"); + static_assert(is_signed_integer_v && !is_unsigned_integer_v, "Wrong answer"); + + static_assert(!is_signed_integer_v && is_unsigned_integer_v, "Wrong answer"); + static_assert(!is_signed_integer_v && is_unsigned_integer_v, "Wrong answer"); + static_assert(!is_signed_integer_v && is_unsigned_integer_v, "Wrong answer"); + static_assert(!is_signed_integer_v && is_unsigned_integer_v, "Wrong answer"); + + static_assert(!is_signed_integer_v && !is_unsigned_integer_v, "Wrong answer"); + static_assert(!is_signed_integer_v && !is_unsigned_integer_v, "Wrong answer"); + static_assert(!is_signed_integer_v && !is_unsigned_integer_v, "Wrong answer"); +} + +void test_numeric_limits() +{ + using namespace boost::decimal::detail; + + static_assert(std::numeric_limits::is_specialized, "incorrect"); + static_assert(!std::numeric_limits::is_signed, "incorrect"); + static_assert(std::numeric_limits::is_integer, "incorrect"); + static_assert(std::numeric_limits::is_exact, "incorrect"); + static_assert(!std::numeric_limits::has_infinity, "incorrect"); + static_assert(!std::numeric_limits::has_quiet_NaN, "incorrect"); + static_assert(!std::numeric_limits::has_signaling_NaN, "incorrect"); + + static_assert(std::numeric_limits::round_style == std::round_toward_zero, "incorrect"); + static_assert(!std::numeric_limits::is_iec559, "incorrect"); + static_assert(std::numeric_limits::is_bounded, "incorrect"); + static_assert(std::numeric_limits::is_modulo, "incorrect"); + static_assert(std::numeric_limits::digits == sizeof(u128) * 8U, "incorrect"); + static_assert(std::numeric_limits::digits10 == static_cast(std::numeric_limits::digits * 0.30102999566398119521), "incorrect"); + static_assert(std::numeric_limits::max_digits10 == std::numeric_limits::max_digits10, "incorrect"); + static_assert(std::numeric_limits::radix == std::numeric_limits::radix, "incorrect"); + static_assert(std::numeric_limits::min_exponent == std::numeric_limits::min_exponent, "incorrect"); + static_assert(std::numeric_limits::min_exponent10 == std::numeric_limits::min_exponent10, "incorrect"); + static_assert(std::numeric_limits::max_exponent == std::numeric_limits::max_exponent, "incorrect"); + static_assert(std::numeric_limits::max_exponent10 == std::numeric_limits::max_exponent10, "incorrect"); + static_assert(std::numeric_limits::traps == std::numeric_limits::traps, "incorrect"); + static_assert(std::numeric_limits::tinyness_before == std::numeric_limits::tinyness_before, "incorrect"); + + static_assert(std::numeric_limits::min() == std::numeric_limits::min(), "incorrect"); + static_assert(std::numeric_limits::lowest() == std::numeric_limits::lowest(), "incorrect"); + + #ifndef BOOST_DECIMAL_HAS_INT128 + + constexpr u128 two128 {std::numeric_limits::max(), std::numeric_limits::max()}; + BOOST_TEST(std::numeric_limits::max() == two128); + + #else + + unsigned __int128 max_value {std::numeric_limits::max()}; + max_value <<= 64U; + max_value |= std::numeric_limits::max(); + BOOST_TEST(std::numeric_limits::max() == max_value); + + #endif + + static_assert(std::numeric_limits::epsilon() == std::numeric_limits::epsilon(), "incorrect"); + static_assert(std::numeric_limits::round_error() == std::numeric_limits::round_error(), "incorrect"); + static_assert(std::numeric_limits::infinity() == std::numeric_limits::infinity(), "incorrect"); + static_assert(std::numeric_limits::quiet_NaN() == std::numeric_limits::quiet_NaN(), "incorrect"); + static_assert(std::numeric_limits::signaling_NaN() == std::numeric_limits::signaling_NaN(), "incorrect"); + static_assert(std::numeric_limits::denorm_min() == std::numeric_limits::denorm_min(), "incorrect"); +} + +void test_ostream_operator() +{ + { + std::stringstream out; + constexpr boost::decimal::detail::u128 small_num {0, 15}; + out << small_num; + BOOST_TEST_CSTR_EQ(out.str().c_str(), "15"); + + std::stringstream out_hex_upper; + std::stringstream out_hex_lower; + out_hex_upper << std::hex << std::uppercase << small_num; + out_hex_lower << std::hex << small_num; + BOOST_TEST_CSTR_EQ(out_hex_upper.str().c_str(), "F"); + BOOST_TEST_CSTR_EQ(out_hex_lower.str().c_str(), "f"); + + std::stringstream out_oct; + out_oct << std::oct << small_num; + BOOST_TEST_CSTR_EQ(out_oct.str().c_str(), "17"); + } + + { + std::stringstream out; + constexpr boost::decimal::detail::u128 big_num {0xF, 0}; + + out << big_num; + BOOST_TEST_CSTR_EQ(out.str().c_str(), "276701161105643274240"); + + std::stringstream out_hex_upper; + std::stringstream out_hex_lower; + out_hex_upper << std::hex << std::uppercase << big_num; + out_hex_lower << std::hex << big_num; + BOOST_TEST_CSTR_EQ(out_hex_upper.str().c_str(), "F0000000000000000"); + BOOST_TEST_CSTR_EQ(out_hex_lower.str().c_str(), "f0000000000000000"); + + std::stringstream out_oct; + out_oct << std::oct << big_num; + BOOST_TEST_CSTR_EQ(out_oct.str().c_str(), "36000000000000000000000"); + } +} + +void test_istream_operator() +{ + { + std::stringstream in; + in.str("15"); + boost::decimal::detail::u128 num; + in >> num; + BOOST_TEST_EQ(num.low, UINT64_C(15)); + + num = 0; + std::stringstream hex_upper; + hex_upper.str("F"); + hex_upper >> std::hex; + hex_upper >> num; + BOOST_TEST_EQ(num.low, UINT64_C(15)); + + num = 0; + std::stringstream hex_lower; + hex_lower.str("f"); + hex_lower >> std::hex; + hex_lower >> num; + BOOST_TEST_EQ(num.low, UINT64_C(15)); + + num = 0; + std::stringstream octal_lower; + octal_lower.str("17"); + octal_lower >> std::oct; + octal_lower >> num; + BOOST_TEST_EQ(num.low, UINT64_C(15)); + + num = 0; + auto wide_str = L"15"; + std::wstringstream wide_dec; + wide_dec.str(wide_str); + wide_dec >> num; + BOOST_TEST_EQ(num.low, UINT64_C(15)); + } + + { + constexpr boost::decimal::detail::u128 res {0xF, 0}; + + std::stringstream in; + in.str("276701161105643274240"); + boost::decimal::detail::u128 num; + in >> num; + BOOST_TEST_EQ(num, res); + + num = 0; + std::stringstream hex_upper; + hex_upper.str("F0000000000000000"); + hex_upper >> std::hex; + hex_upper >> num; + BOOST_TEST_EQ(num, res); + + num = 0; + std::stringstream hex_lower; + hex_lower.str("f0000000000000000"); + hex_lower >> std::hex; + hex_lower >> num; + BOOST_TEST_EQ(num, res); + + num = 0; + std::stringstream octal_lower; + octal_lower.str("36000000000000000000000"); + octal_lower >> std::oct; + octal_lower >> num; + BOOST_TEST_EQ(num, res); + + num = 0; + auto wide_str = L"276701161105643274240"; + std::wstringstream wide_dec; + wide_dec.str(wide_str); + wide_dec >> num; + BOOST_TEST_EQ(num, res); + } +} + +#ifdef BOOST_DECIMAL_HAS_INT128 + +// We reduce the max end of the 128 bit types as they can cause a stack overflow in boost.random + +template <> +constexpr unsigned __int128 get_max() +{ + return static_cast(UINT64_MAX) << 64 | UINT64_MAX / 32; +} + +template <> +constexpr unsigned __int128 get_min() +{ + return 0; +} + +template <> +constexpr __int128 get_max<__int128>() +{ + return static_cast<__int128>((static_cast(1) << 127) - 1) / 32; +} + +template <> +constexpr __int128 get_min<__int128>() +{ + return -get_max<__int128>() - 1; +} + +template +void test_arithmetic_constructor() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + unsigned __int128 emulated_bits; + std::memcpy(&emulated_bits, &emulated_value, sizeof(unsigned __int128)); + + BOOST_TEST(emulated_bits == builtin_value); + } +} + +template +void test_assignment_operators() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + unsigned __int128 builtin_value; + builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {}; + emulated_value = value; + + unsigned __int128 emulated_bits; + std::memcpy(&emulated_bits, &emulated_value, sizeof(unsigned __int128)); + + BOOST_TEST(emulated_bits == builtin_value); + } +} + +template +void test_integer_conversion_operators() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + unsigned __int128 builtin_value; + builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {}; + emulated_value = value; + + const auto builtin_value_return = static_cast(builtin_value); + const auto emulated_value_return = static_cast(emulated_value); + + BOOST_TEST_EQ(builtin_value_return, emulated_value_return); + + // Hits the implicit bool conversion + if (builtin_value) + { + BOOST_TEST(emulated_value); + } + } +} + +template +void test_float_conversion_operators() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + // Float128 won't have numerics limit defined all the time, + // Plus this affords some additional tolerance + constexpr FloatType error_tol {std::is_same::value ? + static_cast(std::numeric_limits::epsilon()) : + static_cast(std::numeric_limits::epsilon())}; + + for (std::size_t i {}; i < N; ++i) + { + const auto value {dist(rng)}; + unsigned __int128 builtin_value; + builtin_value = value; + boost::decimal::detail::u128 emulated_value {}; + emulated_value = value; + + const auto builtin_value_return = static_cast(builtin_value); + const auto emulated_value_return = static_cast(emulated_value); + FloatType distance = builtin_value_return - emulated_value_return; + + // We don't want to pull in quad math for a simple abs calculation... + distance = distance < 0 ? -distance : distance; + + BOOST_TEST(distance < error_tol); + } +} + +template +void test_unary_plus() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + emulated_value = +emulated_value; + + unsigned __int128 emulated_bits; + std::memcpy(&emulated_bits, &emulated_value, sizeof(unsigned __int128)); + + BOOST_TEST(emulated_bits == builtin_value); + } +} + +template +void test_unary_minus() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + builtin_value = -builtin_value; + boost::decimal::detail::u128 emulated_value {value}; + emulated_value = -emulated_value; + + unsigned __int128 emulated_bits; + std::memcpy(&emulated_bits, &emulated_value, sizeof(unsigned __int128)); + + BOOST_TEST(emulated_bits == builtin_value); + } +} + +template +void test_operator_equality() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + // Always equal + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + BOOST_TEST(((value == emulated_value) == (emulated_value == value)) == + ((value == builtin_value) == (builtin_value == value))); + } + + // Potentially equal + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + BOOST_TEST(((value2 == emulated_value) == (emulated_value == value2)) == + ((value2 == builtin_value) == (builtin_value == value2))); + } + + boost::decimal::detail::u128 bool_val {dist(rng)}; + BOOST_TEST((true == bool_val) == (bool_val == true)); +} + +template +void test_operator_inequality() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + // Always equal + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + BOOST_TEST(((value != emulated_value) == (emulated_value != value)) == + ((value != builtin_value) == (builtin_value != value))); + } + + // Potentially equal + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + BOOST_TEST(((value2 != emulated_value) == (emulated_value != value2)) == + ((value2 != builtin_value) == (builtin_value != value2))); + } + + boost::decimal::detail::u128 bool_val {dist(rng)}; + BOOST_TEST((true != bool_val) == (bool_val != true)); +} + +template +void test_operator_less() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + // Some platforms get this wrong where for example -99 < 340282366920938463463374607431768211408 evaluates to false + #ifdef _MSC_VER + #pragma warning(push) + #pragma warning(disable:4127) + #endif + + BOOST_DECIMAL_IF_CONSTEXPR (std::is_signed::value) + { + if (value == value2 && value < 0) + { + continue; + } + } + + #ifdef _MSC_VER + #pragma warning(pop) + #endif + + BOOST_TEST(((value2 < emulated_value) == (value2 < builtin_value)) == + ((emulated_value < value2) == (builtin_value < value2))); + } +} + +template +void test_operator_le() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + // Some platforms get this wrong where for example -99 < 340282366920938463463374607431768211408 evaluates to false + #ifdef _MSC_VER + #pragma warning(push) + #pragma warning(disable:4127) + #endif + + BOOST_DECIMAL_IF_CONSTEXPR (std::is_signed::value) + { + if (value == value2 && value < 0) + { + continue; + } + } + + #ifdef _MSC_VER + #pragma warning(pop) + #endif + + BOOST_TEST(((value2 <= emulated_value) == (value2 <= builtin_value)) == + ((emulated_value <= value2) == (builtin_value <= value2))); + } +} + +template +void test_operator_greater() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + // Some platforms get this wrong where for example -99 < 340282366920938463463374607431768211408 evaluates to false + #ifdef _MSC_VER + #pragma warning(push) + #pragma warning(disable:4127) + #endif + + BOOST_DECIMAL_IF_CONSTEXPR (std::is_signed::value) + { + if (value == value2 && value < 0) + { + continue; + } + } + + #ifdef _MSC_VER + #pragma warning(pop) + #endif + + BOOST_TEST(((value2 > emulated_value) == (value2 > builtin_value)) == + ((emulated_value > value2) == (builtin_value > value2))); + } +} + +template +void test_operator_ge() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + // Some platforms get this wrong where for example -99 < 340282366920938463463374607431768211408 evaluates to false + #ifdef _MSC_VER + #pragma warning(push) + #pragma warning(disable:4127) + #endif + + BOOST_DECIMAL_IF_CONSTEXPR (std::is_signed::value) + { + if (value == value2 && value < 0) + { + continue; + } + } + + #ifdef _MSC_VER + #pragma warning(pop) + #endif + + BOOST_TEST(((value2 >= emulated_value) == (value2 >= builtin_value)) == + ((emulated_value >= value2) == (builtin_value >= value2))); + } +} + +template +void test_operator_not() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + BOOST_TEST(~emulated_value == ~builtin_value); + } +} + +template +void test_operator_or() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + auto check_1_value {emulated_value}; + check_1_value |= value2; + + BOOST_TEST(check_1_value == (builtin_value | value2)); + BOOST_TEST((value2 | emulated_value) == (value2 | builtin_value)); + } +} + +template +void test_operator_and() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + auto check_1_value {emulated_value}; + check_1_value &= value2; + + BOOST_TEST(check_1_value == (builtin_value & value2)); + BOOST_TEST((value2 & emulated_value) == (value2 & builtin_value)); + } +} + +template +void test_operator_xor() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + auto check_1_value {emulated_value}; + check_1_value ^= value2; + + BOOST_TEST(check_1_value == (builtin_value ^ value2)); + BOOST_TEST((value2 ^ emulated_value) == (value2 ^ builtin_value)); + } +} + +template +void test_operator_left_shift() +{ + boost::random::uniform_int_distribution dist(static_cast(0), + get_max()); + + boost::random::uniform_int_distribution shift_dist(0, sizeof(IntType) * CHAR_BIT - 1); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const unsigned shift_value {shift_dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + auto check_1_value {emulated_value}; + check_1_value <<= shift_value; + BOOST_TEST(check_1_value == (builtin_value << shift_value)); + + emulated_value = shift_value; + builtin_value = shift_value; + BOOST_TEST((value << emulated_value) == (value << builtin_value)); + } +} + +template +void test_operator_right_shift() +{ + boost::random::uniform_int_distribution dist(static_cast(0), + get_max()); + + boost::random::uniform_int_distribution shift_dist(0, sizeof(IntType) * CHAR_BIT - 1); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const unsigned shift_value {shift_dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + auto check_1_value {emulated_value}; + check_1_value >>= shift_value; + BOOST_TEST(check_1_value == (builtin_value >> shift_value)); + + emulated_value = shift_value; + builtin_value = shift_value; + BOOST_TEST((value >> emulated_value) == (value >> builtin_value)); + } +} + +template +void test_operator_add() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + + auto check_1_value {emulated_value}; + check_1_value += value2; + BOOST_TEST(check_1_value == (builtin_value + value2)); + BOOST_TEST((value2 + emulated_value) == (value2 + builtin_value)); + } +} + +template +void test_operator_sub() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + auto check_1_value {emulated_value}; + check_1_value -= value2; + BOOST_TEST(check_1_value == (builtin_value - value2)); + BOOST_TEST((value2 - emulated_value) == (value2 - builtin_value)); + } +} + +template = true> +void test_operator_mul() +{ + const auto root_max {static_cast(std::sqrt(get_max()))}; + const auto root_min {std::is_unsigned::value ? 0 : -root_max}; + + boost::random::uniform_int_distribution dist(root_min, root_max); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + auto check_1_value {emulated_value}; + check_1_value *= value2; + BOOST_TEST(check_1_value == (builtin_value * value2)); + BOOST_TEST((value2 * emulated_value) == (value2 * builtin_value)); + } +} + +template sizeof(std::uint64_t)), bool> = true> +void test_operator_mul() +{ + constexpr auto root_max {UINT64_MAX}; + const auto root_min {std::is_same::value ? 0 : -root_max}; + + boost::random::uniform_int_distribution dist(root_min, root_max); + + for (std::size_t i {}; i < N; ++i) + { + const IntType value {dist(rng)}; + const IntType value2 {dist(rng)}; + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + auto check_1_value {emulated_value}; + check_1_value *= value2; + BOOST_TEST(check_1_value == (builtin_value * value2)); + BOOST_TEST((value2 * emulated_value) == (value2 * builtin_value)); + } +} + +template +void test_operator_div() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + IntType value {0}; + IntType value2 {0}; + + while (value == 0) + { + value = dist(rng); + } + while (value2 == 0) + { + value2 = dist(rng); + } + + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + auto check_1_value {emulated_value}; + check_1_value /= value2; + BOOST_TEST(check_1_value == (builtin_value / value2)); + BOOST_TEST((value2 / emulated_value) == (value2 / builtin_value)); + } +} + +template +void test_operator_mod() +{ + boost::random::uniform_int_distribution dist(get_min(), + get_max()); + + for (std::size_t i {}; i < N; ++i) + { + IntType value {0}; + IntType value2 {0}; + + while (value == 0) + { + value = dist(rng); + } + while (value2 == 0) + { + value2 = dist(rng); + } + + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + auto check_1_value {emulated_value}; + check_1_value %= value2; + BOOST_TEST(check_1_value == (builtin_value % value2)); + BOOST_TEST((value2 % emulated_value) == (value2 % builtin_value)); + } +} + +template +void test_spot_operator_div(IntType value, IntType value2) +{ + unsigned __int128 builtin_value = static_cast(value); + boost::decimal::detail::u128 emulated_value {value}; + + BOOST_TEST((emulated_value / value2) == (builtin_value / value2)); + BOOST_TEST((value2 / emulated_value) == (value2 / builtin_value)); +} + +void test_digit_counting() +{ + unsigned __int128 builtin_val = 1; + boost::decimal::detail::u128 emulated_val {1}; + + for (int i {}; i < 38; ++i) + { + BOOST_TEST_EQ(boost::decimal::detail::num_digits(builtin_val), + boost::decimal::detail::num_digits(emulated_val)); + + builtin_val *= 10U; + emulated_val *= 10U; + } +} + +int main() +{ + test_traits(); + + test_numeric_limits(); + + std::cerr << "constructors" << std::endl; + + test_arithmetic_constructor(); + test_arithmetic_constructor(); + test_arithmetic_constructor(); + test_arithmetic_constructor(); + test_arithmetic_constructor<__int128>(); + + test_arithmetic_constructor(); + test_arithmetic_constructor(); + test_arithmetic_constructor(); + test_arithmetic_constructor(); + test_arithmetic_constructor(); + + std::cerr << "assignment" << std::endl; + + test_assignment_operators(); + test_assignment_operators(); + test_assignment_operators(); + test_assignment_operators(); + test_arithmetic_constructor<__int128>(); + + test_assignment_operators(); + test_assignment_operators(); + test_assignment_operators(); + test_assignment_operators(); + test_arithmetic_constructor(); + + std::cerr << "integer conversion" << std::endl; + + test_integer_conversion_operators(); + test_integer_conversion_operators(); + test_integer_conversion_operators(); + test_integer_conversion_operators(); + test_arithmetic_constructor<__int128>(); + + test_integer_conversion_operators(); + test_integer_conversion_operators(); + test_integer_conversion_operators(); + test_integer_conversion_operators(); + test_arithmetic_constructor(); + + std::cerr << "float conversion" << std::endl; + + test_float_conversion_operators(); + test_float_conversion_operators(); + test_float_conversion_operators(); + + #ifdef BOOST_DECIMAL_HAS_FLOAT128 + test_float_conversion_operators<__float128>(); + #endif + + std::cerr << "unary" << std::endl; + + test_unary_plus(); + test_unary_minus(); + + std::cerr << "equality" << std::endl; + + test_operator_equality(); + test_operator_equality(); + test_operator_equality(); + test_operator_equality(); + test_operator_equality<__int128>(); + + test_operator_equality(); + test_operator_equality(); + test_operator_equality(); + test_operator_equality(); + test_operator_equality(); + + std::cerr << "inequality" << std::endl; + + test_operator_inequality(); + test_operator_inequality(); + test_operator_inequality(); + test_operator_inequality(); + test_operator_inequality<__int128>(); + + test_operator_inequality(); + test_operator_inequality(); + test_operator_inequality(); + test_operator_inequality(); + test_operator_inequality(); + + std::cerr << "less" << std::endl; + + test_operator_less(); + test_operator_less(); + test_operator_less(); + test_operator_less(); + test_operator_less<__int128>(); + + test_operator_less(); + test_operator_less(); + test_operator_less(); + test_operator_less(); + test_operator_less(); + + std::cerr << "le" << std::endl; + + test_operator_le(); + test_operator_le(); + test_operator_le(); + test_operator_le(); + test_operator_le<__int128>(); + + test_operator_le(); + test_operator_le(); + test_operator_le(); + test_operator_le(); + test_operator_le(); + + std::cerr << "greater" << std::endl; + + test_operator_greater(); + test_operator_greater(); + test_operator_greater(); + test_operator_greater(); + test_operator_greater<__int128>(); + + test_operator_greater(); + test_operator_greater(); + test_operator_greater(); + test_operator_greater(); + test_operator_greater(); + + std::cerr << "ge" << std::endl; + + test_operator_ge(); + test_operator_ge(); + test_operator_ge(); + test_operator_ge(); + test_operator_ge<__int128>(); + + test_operator_ge(); + test_operator_ge(); + test_operator_ge(); + test_operator_ge(); + test_operator_ge(); + + std::cerr << "or" << std::endl; + + test_operator_not(); + + test_operator_or(); + test_operator_or(); + test_operator_or(); + test_operator_or(); + test_operator_or<__int128>(); + + test_operator_or(); + test_operator_or(); + test_operator_or(); + test_operator_or(); + test_operator_or(); + + std::cerr << "and" << std::endl; + + test_operator_and(); + test_operator_and(); + test_operator_and(); + test_operator_and(); + test_operator_and<__int128>(); + + test_operator_and(); + test_operator_and(); + test_operator_and(); + test_operator_and(); + test_operator_and(); + + std::cerr << "xor" << std::endl; + + test_operator_xor(); + test_operator_xor(); + test_operator_xor(); + test_operator_xor(); + test_operator_xor<__int128>(); + + test_operator_xor(); + test_operator_xor(); + test_operator_xor(); + test_operator_xor(); + test_operator_xor(); + + std::cerr << "leftshift" << std::endl; + + #ifndef UBSAN + + test_operator_left_shift(); + test_operator_left_shift(); + test_operator_left_shift(); + test_operator_left_shift(); + test_operator_left_shift<__int128>(); + + #endif + + test_operator_left_shift(); + test_operator_left_shift(); + test_operator_left_shift(); + test_operator_left_shift(); + test_operator_left_shift(); + + std::cerr << "rightshift" << std::endl; + + #ifndef UBSAN + + test_operator_right_shift(); + test_operator_right_shift(); + test_operator_right_shift(); + test_operator_right_shift(); + test_operator_right_shift<__int128>(); + + #endif + + test_operator_right_shift(); + test_operator_right_shift(); + test_operator_right_shift(); + test_operator_right_shift(); + test_operator_right_shift(); + + std::cerr << "add" << std::endl; + + test_operator_add(); + test_operator_add(); + test_operator_add(); + test_operator_add(); + test_operator_add<__int128>(); + + test_operator_add(); + test_operator_add(); + test_operator_add(); + test_operator_add(); + test_operator_add(); + + std::cerr << "sub" << std::endl; + + test_operator_sub(); + test_operator_sub(); + test_operator_sub(); + test_operator_sub(); + test_operator_sub<__int128>(); + + test_operator_sub(); + test_operator_sub(); + test_operator_sub(); + test_operator_sub(); + test_operator_sub(); + + std::cerr << "mul" << std::endl; + + test_operator_mul(); + test_operator_mul(); + test_operator_mul(); + test_operator_mul(); + test_operator_mul<__int128>(); + + test_operator_mul(); + test_operator_mul(); + test_operator_mul(); + test_operator_mul(); + test_operator_mul(); + + std::cerr << "div" << std::endl; + + test_operator_div(); + test_operator_div(); + test_operator_div(); + test_operator_div(); + test_operator_div<__int128>(); + + test_operator_div(); + test_operator_div(); + test_operator_div(); + test_operator_div(); + test_operator_div(); + + test_spot_operator_div(1, -94); + + std::cerr << "mod" << std::endl; + + test_operator_mod(); + test_operator_mod(); + test_operator_mod(); + test_operator_mod(); + test_operator_mod<__int128>(); + + test_operator_mod(); + test_operator_mod(); + test_operator_mod(); + test_operator_mod(); + test_operator_mod(); + + std::cerr << "stream" << std::endl; + + test_ostream_operator(); + test_istream_operator(); + + std::cerr << "count" << std::endl; + + test_digit_counting(); + + return boost::report_errors(); +} + +#else + +using boost::decimal::detail::uint128; + +template +void test_arithmetic_constructor() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + uint128 builtin_value { value }; + boost::decimal::detail::u128 emulated_value{ value }; + + BOOST_TEST(builtin_value.high == emulated_value.high && builtin_value.low == emulated_value.low); + } +} + +template +void test_assignment_operators() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + uint128 builtin_value; + builtin_value = value; + boost::decimal::detail::u128 emulated_value{}; + emulated_value = value; + + BOOST_TEST(builtin_value.high == emulated_value.high && builtin_value.low == emulated_value.low); + } +} + +template +void test_integer_conversion_operators() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + uint128 builtin_value; + builtin_value = value; + boost::decimal::detail::u128 emulated_value{}; + emulated_value = value; + + const auto builtin_value_return = static_cast(builtin_value); + const auto emulated_value_return = static_cast(emulated_value); + + BOOST_TEST_EQ(builtin_value_return, emulated_value_return); + + // Hits the implicit bool conversion + if (builtin_value) + { + BOOST_TEST(emulated_value); + } + } +} + +template +void test_float_conversion_operators() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const auto value{ dist(rng) }; + uint128 builtin_value; + builtin_value = value; + boost::decimal::detail::u128 emulated_value{}; + emulated_value = value; + + const auto builtin_value_return = static_cast(builtin_value); + const auto emulated_value_return = static_cast(emulated_value); + + BOOST_TEST(std::abs(builtin_value_return - emulated_value_return) < std::numeric_limits::epsilon()); + } +} + +template +void test_unary_plus() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + uint128 builtin_value = value; + boost::decimal::detail::u128 emulated_value{ value }; + emulated_value = +emulated_value; + + BOOST_TEST(builtin_value.high == emulated_value.high && builtin_value.low == builtin_value.low); + } +} + +template +void test_unary_minus() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + uint128 builtin_value = value; + builtin_value = -builtin_value; + boost::decimal::detail::u128 emulated_value{ value }; + emulated_value = -emulated_value; + + BOOST_TEST(builtin_value.high == emulated_value.high && builtin_value.low == builtin_value.low); + } +} + +template +void test_operator_equality() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + // Always equal + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + boost::decimal::detail::u128 emulated_value{ value }; + + BOOST_TEST(((value == emulated_value) == (emulated_value == value)) == (value == value)); + } + + // Potentially equal + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + boost::decimal::detail::u128 emulated_value{ value }; + + BOOST_TEST(((value2 == emulated_value) == (value2 == value)) == + ((emulated_value == value2) == (value == value2))); + } + + boost::decimal::detail::u128 bool_val{ dist(rng) }; + BOOST_TEST((true == bool_val) == (bool_val == true)); +} + +template +void test_operator_inequality() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + // Always equal + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + boost::decimal::detail::u128 emulated_value{ value }; + + BOOST_TEST(((value != emulated_value) == (emulated_value != value)) == !(value != value)); + } + + // Potentially equal + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + boost::decimal::detail::u128 emulated_value{ value }; + + BOOST_TEST(((value2 != emulated_value) == (value2 != value)) == + ((emulated_value != value2) == (value != value2))); + } + + boost::decimal::detail::u128 bool_val{ dist(rng) }; + BOOST_TEST((true == bool_val) == (bool_val == true)); +} + +template +void test_operator_less() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + boost::decimal::detail::u128 emulated_value{ value }; + + if (value2 >= 0) + { + BOOST_TEST(((value2 < emulated_value) == (value2 < value)) == + ((emulated_value < value2) == (value < value2))); + } + else if (value2 < value) + { + BOOST_TEST((value2 < emulated_value) == (value2 < value)); + } + else + { + BOOST_TEST((value2 < emulated_value) != (value2 < value)); + } + } +} + +template +void test_operator_le() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + boost::decimal::detail::u128 emulated_value{ value }; + + if (value2 >= 0) + { + BOOST_TEST(((value2 <= emulated_value) == (value2 <= value)) == + ((emulated_value <= value2) == (value <= value2))); + } + else if (value2 <= value) + { + BOOST_TEST((value2 <= emulated_value) == (value2 <= value)); + } + else + { + BOOST_TEST((value2 <= emulated_value) != (value2 <= value)); + } + } +} + +template +void test_operator_greater() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + boost::decimal::detail::u128 emulated_value{ value }; + + if (value2 >= 0) + { + BOOST_TEST(((value2 > emulated_value) == (value2 > value)) == + ((emulated_value > value2) == (value > value2))); + } + else if (value2 > value) + { + BOOST_TEST((value2 > emulated_value) != (value2 > value)); + } + else + { + BOOST_TEST((value2 > emulated_value) == (value2 > value)); + } + } +} + +template +void test_operator_ge() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + boost::decimal::detail::u128 emulated_value{ value }; + + if (value2 >= 0) + { + BOOST_TEST(((value2 >= emulated_value) == (value2 >= value)) == + ((emulated_value >= value2) == (value >= value2))); + } + else if (value2 >= value) + { + BOOST_TEST((value2 >= emulated_value) != (value2 >= value)); + } + else + { + BOOST_TEST((value2 >= emulated_value) == (value2 >= value)); + } + } +} + +template +void test_operator_not() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + uint128 builtin_value{ value }; + builtin_value = ~builtin_value; + boost::decimal::detail::u128 emulated_value{ value }; + emulated_value = ~emulated_value; + + BOOST_TEST(builtin_value.high == emulated_value.high && builtin_value.low == emulated_value.low); + } +} + + +template +void test_operator_and() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + boost::decimal::detail::u128 emulated_value{ value }; + + BOOST_TEST((emulated_value.low & value2) == (value & value2)); + BOOST_TEST((value2 & value) == (value2 & emulated_value.low)); + } +} + +template +void test_operator_xor() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + boost::decimal::detail::u128 emulated_value{ value }; + + BOOST_TEST((emulated_value.low | value2) == (value | value2)); + BOOST_TEST((value2 | value) == (value2 | emulated_value.low)); + } +} + + +template +void test_operator_add() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + uint128 builtin_value{ value }; + boost::decimal::detail::u128 emulated_value{ value }; + + const auto builtin_res_left = builtin_value + value2; + const auto builtin_res_right = value2 + builtin_value; + + const auto emulated_res_left = emulated_value + value2; + const auto emulated_res_right = value2 + emulated_value; + + BOOST_TEST(emulated_res_left.high == builtin_res_left.high && emulated_res_left.low == builtin_res_left.low); + BOOST_TEST(emulated_res_right.high == builtin_res_right.high && emulated_res_right.low == builtin_res_right.low); + } +} + +template +void test_operator_sub() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), + std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + uint128 builtin_value{ value }; + boost::decimal::detail::u128 emulated_value{ value }; + + // uint128 does not have all direction subtraction operators implemented + + //const auto builtin_res_left = builtin_value - value2; + const auto builtin_res_right = value2 - builtin_value; + + //const auto emulated_res_left = emulated_value - value2; + const auto emulated_res_right = value2 - emulated_value; + + //BOOST_TEST(emulated_res_left.high == builtin_res_left.high && emulated_res_left.low == builtin_res_left.low); + BOOST_TEST(emulated_res_right.high == builtin_res_right.high && emulated_res_right.low == builtin_res_right.low); + } +} + +template +void test_operator_mul() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + const IntType value2{ dist(rng) }; + uint128 builtin_value{ value }; + boost::decimal::detail::u128 emulated_value{ value }; + + + const auto builtin_res_left = builtin_value * static_cast(value2); + const auto emulated_res_left = emulated_value * static_cast(value2); + + BOOST_TEST(emulated_res_left.high == builtin_res_left.high && emulated_res_left.low == builtin_res_left.low); + + } +} + +template +void test_operator_div() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + IntType value2{ dist(rng) }; + + while (value2 == 0) + { + value2 = dist(rng); + } + + uint128 builtin_value{ static_cast(value), static_cast(value) }; + boost::decimal::detail::u128 emulated_value{ static_cast(value), static_cast(value) }; + + + const auto builtin_res_left = builtin_value / static_cast(value2); + const auto emulated_res_left = emulated_value / static_cast(value2); + + BOOST_TEST(emulated_res_left.high == builtin_res_left.high && emulated_res_left.low == builtin_res_left.low); + + } +} + +template +void test_operator_mod() +{ + boost::random::uniform_int_distribution dist(std::numeric_limits::min(), std::numeric_limits::max()); + + for (std::size_t i{}; i < N; ++i) + { + const IntType value{ dist(rng) }; + IntType value2{ dist(rng) }; + + while (value2 == 0) + { + value2 = dist(rng); + } + + uint128 builtin_value{ static_cast(value), static_cast(value) }; + boost::decimal::detail::u128 emulated_value{ static_cast(value), static_cast(value) }; + + + const auto builtin_res_left = builtin_value % static_cast(value2); + const auto emulated_res_left = emulated_value % static_cast(value2); + + BOOST_TEST(emulated_res_left.high == builtin_res_left.high && emulated_res_left.low == builtin_res_left.low); + + } +} + +int main() +{ + test_traits(); + + test_numeric_limits(); + + test_arithmetic_constructor(); + test_arithmetic_constructor(); + test_arithmetic_constructor(); + test_arithmetic_constructor(); + + test_arithmetic_constructor(); + test_arithmetic_constructor(); + test_arithmetic_constructor(); + test_arithmetic_constructor(); + + test_assignment_operators(); + test_assignment_operators(); + test_assignment_operators(); + test_assignment_operators(); + + test_assignment_operators(); + test_assignment_operators(); + test_assignment_operators(); + test_assignment_operators(); + + test_integer_conversion_operators(); + test_integer_conversion_operators(); + test_integer_conversion_operators(); + test_integer_conversion_operators(); + + test_integer_conversion_operators(); + test_integer_conversion_operators(); + test_integer_conversion_operators(); + test_integer_conversion_operators(); + + test_float_conversion_operators(); + test_float_conversion_operators(); + test_float_conversion_operators(); + + test_unary_plus(); + test_unary_minus(); + + test_operator_equality(); + test_operator_equality(); + test_operator_equality(); + test_operator_equality(); + + test_operator_equality(); + test_operator_equality(); + test_operator_equality(); + test_operator_equality(); + + test_operator_inequality(); + test_operator_inequality(); + test_operator_inequality(); + test_operator_inequality(); + + test_operator_inequality(); + test_operator_inequality(); + test_operator_inequality(); + test_operator_inequality(); + + test_operator_less(); + test_operator_less(); + test_operator_less(); + test_operator_less(); + + test_operator_less(); + test_operator_less(); + test_operator_less(); + test_operator_less(); + + test_operator_le(); + test_operator_le(); + test_operator_le(); + test_operator_le(); + + test_operator_le(); + test_operator_le(); + test_operator_le(); + test_operator_le(); + + test_operator_greater(); + test_operator_greater(); + test_operator_greater(); + test_operator_greater(); + + test_operator_greater(); + test_operator_greater(); + test_operator_greater(); + test_operator_greater(); + + test_operator_ge(); + test_operator_ge(); + test_operator_ge(); + test_operator_ge(); + + test_operator_ge(); + test_operator_ge(); + test_operator_ge(); + test_operator_ge(); + + test_operator_not(); + test_operator_not(); + test_operator_not(); + test_operator_not(); + + test_operator_not(); + test_operator_not(); + test_operator_not(); + test_operator_not(); + + test_operator_and(); + test_operator_and(); + test_operator_and(); + test_operator_and(); + + test_operator_and(); + test_operator_and(); + test_operator_and(); + test_operator_and(); + + test_operator_xor(); + test_operator_xor(); + test_operator_xor(); + test_operator_xor(); + + test_operator_xor(); + test_operator_xor(); + test_operator_xor(); + test_operator_xor(); + + test_operator_add(); + test_operator_add(); + test_operator_add(); + test_operator_add(); + + test_operator_add(); + test_operator_add(); + test_operator_add(); + test_operator_add(); + + test_operator_sub(); + test_operator_sub(); + test_operator_sub(); + test_operator_sub(); + + test_operator_sub(); + test_operator_sub(); + test_operator_sub(); + test_operator_sub(); + + test_operator_mul(); + test_operator_mul(); + test_operator_mul(); + test_operator_mul(); + + test_operator_mul(); + test_operator_mul(); + test_operator_mul(); + test_operator_mul(); + + test_operator_div(); + test_operator_div(); + test_operator_div(); + test_operator_div(); + + test_operator_div(); + test_operator_div(); + test_operator_div(); + test_operator_div(); + + test_operator_mod(); + test_operator_mod(); + test_operator_mod(); + test_operator_mod(); + + test_operator_mod(); + test_operator_mod(); + test_operator_mod(); + test_operator_mod(); + + test_ostream_operator(); + test_istream_operator(); + + return boost::report_errors(); +} + +#endif diff --git a/test/test_zeta.cpp b/test/test_zeta.cpp index d36b0225..0f027eb7 100644 --- a/test/test_zeta.cpp +++ b/test/test_zeta.cpp @@ -8,6 +8,10 @@ #include +// Github actions MSVC is broken with chrono +// Drone and local run just fine +#ifndef BOOST_DECIMAL_GHA_MSVC + #if defined(__clang__) # pragma clang diagnostic push # pragma clang diagnostic ignored "-Wold-style-cast" @@ -441,3 +445,12 @@ int main() template auto my_zero() -> DecimalType& { using decimal_type = DecimalType; static decimal_type val_zero { 0 }; return val_zero; } template auto my_nan () -> DecimalType& { using decimal_type = DecimalType; static decimal_type val_nan { std::numeric_limits::quiet_NaN() }; return val_nan; } template auto my_inf () -> DecimalType& { using decimal_type = DecimalType; static decimal_type val_inf { std::numeric_limits::infinity() }; return val_inf; } + +#else + +int main() +{ + return 0; +} + +#endif