Constants.h

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2025 nfx
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

 
#pragma once
 
#include <array>
#include <cstdint>
#include <string_view>
 
namespace nfx::datatypes::constants
{
    //=====================================================================
    // Common constants
    //=====================================================================
 
    //----------------------------------------------
    // Bit manipulation
    //----------------------------------------------

    inline constexpr int BITS_PER_UINT8{ 8 };

    inline constexpr int BITS_PER_UINT16{ 16 };

    inline constexpr int BITS_PER_UINT32{ 32 };

    inline constexpr int BITS_PER_UINT64{ 64 };

    inline constexpr std::uint64_t UINT32_MAX_VALUE{ 0xFFFFFFFFULL };

    inline constexpr std::uint64_t BIT_MASK_ONE{ 1ULL };

    inline constexpr std::uint64_t BIT_MASK_ZERO{ 0ULL };

    inline constexpr int BITS_PER_NIBBLE{ 4 };

    inline constexpr int BITS_PER_PAIR{ 2 };
 
    //----------------------------------------------
    // Bit masks for leading zero count (binary search)
    //----------------------------------------------

    inline constexpr std::uint64_t BIT_MASK_UPPER_32{ 0xFFFFFFFF00000000ULL };

    inline constexpr std::uint64_t BIT_MASK_UPPER_16{ 0xFFFF000000000000ULL };

    inline constexpr std::uint64_t BIT_MASK_UPPER_8{ 0xFF00000000000000ULL };

    inline constexpr std::uint64_t BIT_MASK_UPPER_4{ 0xF000000000000000ULL };

    inline constexpr std::uint64_t BIT_MASK_UPPER_2{ 0xC000000000000000ULL };

    inline constexpr std::uint64_t BIT_MASK_MSB{ 0x8000000000000000ULL };
 
    //----------------------------------------------
    // Precision limits
    //----------------------------------------------

    inline constexpr std::uint8_t DOUBLE_DECIMAL_PRECISION{ 15U };
 
    //=====================================================================
    // Int128 data type constants
    //=====================================================================
 
    //----------------------------------------------
    // Numeric base
    //----------------------------------------------

    inline constexpr int INT128_BASE{ 10 };
 
    //----------------------------------------------
    // Bit indexing
    //----------------------------------------------

    inline constexpr int INT128_MAX_BIT_INDEX{ 127 };
 
    //----------------------------------------------
    // Overflow detection
    //----------------------------------------------

    inline constexpr std::uint64_t INT128_MUL10_OVERFLOW_THRESHOLD{ 0x1999999999999999ULL };

    inline constexpr double INT128_MAX_AS_DOUBLE{ 1.7014118346046923e38 };

    inline constexpr double INT128_MIN_AS_DOUBLE{ -1.7014118346046924e38 };
 
    //----------------------------------------------
    // Arithmetic
    //----------------------------------------------

    inline constexpr std::uint64_t INT128_MAX_POSITIVE_HIGH{ 0x7FFFFFFFFFFFFFFFULL };

    inline constexpr std::uint64_t INT128_MAX_POSITIVE_LOW{ 0xFFFFFFFFFFFFFFFFULL };

    inline constexpr std::uint64_t INT128_MIN_NEGATIVE_HIGH{ 0x8000000000000000ULL };

    inline constexpr std::uint64_t INT128_MIN_NEGATIVE_LOW{ 0x0000000000000000ULL };
 
    //----------------------------------------------
    // String conversion
    //----------------------------------------------

    inline constexpr size_t INT128_MAX_DIGIT_COUNT{ 39UL };

    inline constexpr size_t INT128_MAX_STRING_LENGTH{ 64UL };

    inline constexpr int INT128_ISQRT_MAX_ITERATIONS{ 100 };

    inline constexpr int DECIMAL_SQRT_MAX_ITERATIONS{ 10 };

    inline constexpr std::string_view INT128_MAX_POSITIVE_STRING{ "170141183460469231731687303715884105727" };

    inline constexpr std::string_view INT128_MAX_NEGATIVE_STRING{ "170141183460469231731687303715884105728" };
 
    //----------------------------------------------
    // std::numeric_limits constants
    //----------------------------------------------

    inline constexpr int INT128_DIGITS{ 127 };

    inline constexpr int INT128_DIGITS10{ 38 };

    inline constexpr int INT128_MAX_DIGITS10{ 0 };

    inline constexpr int INT128_RADIX{ 2 };
 
    //=====================================================================
    // Decimal data type constants
    //=====================================================================
 
    //----------------------------------------------
    // Numeric base
    //----------------------------------------------

    inline constexpr std::uint64_t DECIMAL_BASE{ 10ULL };
 
    //----------------------------------------------
    // Maximum values
    //----------------------------------------------

    inline constexpr std::uint64_t DECIMAL_96BIT_MAX_LOW{ 0xFFFFFFFFFFFFFFFFULL };

    inline constexpr std::uint64_t DECIMAL_96BIT_MAX_HIGH{ 0x00000000FFFFFFFFULL };
 
    //----------------------------------------------
    // std::numeric_limits constants
    //----------------------------------------------

    inline constexpr int DECIMAL_MANTISSA_BITS{ 96 };

    inline constexpr int DECIMAL_DIGITS10{ 28 };

    inline constexpr int DECIMAL_RADIX{ 10 };

    inline constexpr double DECIMAL_FRACTIONAL_EPSILON{ 1e-15 };
 
    //----------------------------------------------
    // Arithmetic
    //----------------------------------------------

    inline constexpr std::uint32_t DECIMAL_MAX_MANTISSA_0{ 0xFFFFFFFFU };

    inline constexpr std::uint32_t DECIMAL_MAX_MANTISSA_1{ 0xFFFFFFFFU };

    inline constexpr std::uint32_t DECIMAL_MAX_MANTISSA_2{ 0xFFFFFFFFU };

    inline constexpr std::uint32_t DECIMAL_MIN_MANTISSA_0{ 1U };

    inline constexpr std::uint32_t DECIMAL_MIN_MANTISSA_1{ 0U };

    inline constexpr std::uint32_t DECIMAL_MIN_MANTISSA_2{ 0U };

    inline constexpr std::uint8_t DECIMAL_MAXIMUM_PLACES{ 28U };

    inline constexpr std::uint8_t DECIMAL_DIVISION_EXTRA_PRECISION{ 18U };

    inline constexpr std::uint8_t DECIMAL_ROUNDING_THRESHOLD{ 5U };

    inline constexpr int DECIMAL_MANTISSA_ARRAY_SIZE{ 3 };

    inline constexpr std::string_view DECIMAL_SQRT_EPSILON{ "0.000001" };

    inline constexpr std::uint32_t DECIMAL_SCALE_MASK{ 0x00FF0000U };

    inline constexpr std::uint32_t DECIMAL_SIGN_MASK{ 0x80000000U };

    inline constexpr std::uint8_t DECIMAL_SCALE_SHIFT{ 16U };
 
    //----------------------------------------------
    // String conversion
    //----------------------------------------------

    inline constexpr size_t DECIMAL_MAX_STRING_LENGTH{ 64UL };

    inline constexpr size_t DECIMAL_STRING_BUFFER_SIZE{ 64UL };
 
    //----------------------------------------------
    // Performance optimization
    //----------------------------------------------

    inline constexpr std::uint8_t DECIMAL_POWER_TABLE_SIZE{ 20U };

    inline constexpr std::uint8_t DECIMAL_EXTENDED_POWER_MIN{ 20U };

    inline constexpr std::uint8_t DECIMAL_EXTENDED_POWER_MAX{ 28U };

    inline constexpr std::array<std::uint64_t, DECIMAL_POWER_TABLE_SIZE> DECIMAL_POWERS_OF_10{ {
        1ULL,                    // 10^0
        10ULL,                   // 10^1
        100ULL,                  // 10^2
        1000ULL,                 // 10^3
        10000ULL,                // 10^4
        100000ULL,               // 10^5
        1000000ULL,              // 10^6
        10000000ULL,             // 10^7
        100000000ULL,            // 10^8
        1000000000ULL,           // 10^9
        10000000000ULL,          // 10^10
        100000000000ULL,         // 10^11
        1000000000000ULL,        // 10^12
        10000000000000ULL,       // 10^13
        100000000000000ULL,      // 10^14
        1000000000000000ULL,     // 10^15
        10000000000000000ULL,    // 10^16
        100000000000000000ULL,   // 10^17
        1000000000000000000ULL,  // 10^18
        10000000000000000000ULL, // 10^19 (max uint64_t support)
    } };

    inline constexpr std::array<std::pair<std::uint64_t, std::uint64_t>, 9> DECIMAL_EXTENDED_POWERS_OF_10{ {
        { 0x6BC75E2D63100000ULL, 0x0000000000000005ULL }, // 10^20
        { 0x35C9ADC5DEA00000ULL, 0x0000000000000036ULL }, // 10^21
        { 0x19E0C9BAB2400000ULL, 0x000000000000021EULL }, // 10^22
        { 0x02C7E14AF6800000ULL, 0x000000000000152DULL }, // 10^23
        { 0x1BCECCEDA1000000ULL, 0x000000000000D3C2ULL }, // 10^24
        { 0x161401484A000000ULL, 0x0000000000084595ULL }, // 10^25
        { 0xDCC80CD2E4000000ULL, 0x000000000052B7D2ULL }, // 10^26
        { 0x9FD0803CE8000000ULL, 0x00000000033B2E3CULL }, // 10^27
        { 0x3E25026110000000ULL, 0x00000000204FCE5EULL }  // 10^28
    } };
} // namespace nfx::datatypes::constants