Int128.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 <compare>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
#include "nfx/detail/datatypes/CompilerSupport.h"
 
namespace nfx::datatypes
{
    class Decimal;
 
    //=====================================================================
    // Int128 class
    //=====================================================================

    class Int128 final
    {
    public:
        //----------------------------------------------
        // Construction
        //----------------------------------------------

        inline constexpr Int128() noexcept;

        inline explicit constexpr Int128( int val ) noexcept;

        inline explicit constexpr Int128( std::int64_t val ) noexcept;

        inline explicit constexpr Int128( std::uint32_t val ) noexcept;

        inline explicit constexpr Int128( std::uint64_t val ) noexcept;

        constexpr Int128( std::uint64_t low, std::uint64_t high ) noexcept;
 
#if NFX_DATATYPES_HAS_NATIVE_INT128
        explicit constexpr Int128( NFX_DATATYPES_NATIVE_INT128 val ) noexcept;
#endif

        inline explicit Int128( std::string_view str );

        explicit Int128( float val );

        explicit Int128( double val );

        explicit Int128( const Decimal& decimal );

        constexpr Int128( const Int128& other ) noexcept = default;

        constexpr Int128( Int128&& other ) noexcept = default;
 
        //----------------------------------------------
        // Destruction
        //----------------------------------------------

        ~Int128() = default;
 
        //----------------------------------------------
        // Assignment
        //----------------------------------------------

        constexpr Int128& operator=( const Int128& other ) noexcept = default;

        constexpr Int128& operator=( Int128&& other ) noexcept = default;
 
        //----------------------------------------------
        // Comparison operators
        //----------------------------------------------

        inline std::strong_ordering operator<=>( const Int128& other ) const noexcept;

        inline bool operator==( const Int128& other ) const noexcept;
 
        //----------------------------------------------
        // Comparison with built-in integer types
        //----------------------------------------------

        inline bool operator==( int val ) const noexcept;

        inline bool operator!=( int val ) const noexcept;

        inline bool operator<( int val ) const noexcept;

        inline bool operator<=( int val ) const noexcept;

        inline bool operator>( int val ) const noexcept;

        inline bool operator>=( int val ) const noexcept;

        inline bool operator==( std::int64_t val ) const noexcept;

        bool operator!=( std::int64_t val ) const noexcept;

        inline bool operator<( std::int64_t val ) const noexcept;

        inline bool operator<=( std::int64_t val ) const noexcept;

        inline bool operator>( std::int64_t val ) const noexcept;

        inline bool operator>=( std::int64_t val ) const noexcept;

        inline bool operator==( std::uint64_t val ) const noexcept;

        inline bool operator!=( std::uint64_t val ) const noexcept;

        inline bool operator<( std::uint64_t val ) const noexcept;

        inline bool operator<=( std::uint64_t val ) const noexcept;

        inline bool operator>( std::uint64_t val ) const noexcept;

        inline bool operator>=( std::uint64_t val ) const noexcept;
 
        //----------------------------------------------
        // Comparison with built-in floating point types
        //----------------------------------------------

        inline bool operator==( float val ) const noexcept;

        inline bool operator!=( float val ) const noexcept;

        inline bool operator<( float val ) const noexcept;

        inline bool operator<=( float val ) const noexcept;

        inline bool operator>( float val ) const noexcept;

        inline bool operator>=( float val ) const noexcept;

        bool operator==( double val ) const noexcept;

        inline bool operator!=( double val ) const noexcept;

        bool operator<( double val ) const noexcept;

        inline bool operator<=( double val ) const noexcept;

        bool operator>( double val ) const noexcept;

        inline bool operator>=( double val ) const noexcept;
 
        //----------------------------------------------
        // Comparison with nfx::datatypes::Decimal
        //----------------------------------------------

        bool operator==( const Decimal& val ) const noexcept;

        inline bool operator!=( const Decimal& val ) const noexcept;

        bool operator<( const Decimal& val ) const noexcept;

        inline bool operator<=( const Decimal& val ) const noexcept;

        inline bool operator>( const Decimal& val ) const noexcept;

        inline bool operator>=( const Decimal& val ) const noexcept;
 
        //----------------------------------------------
        // Arithmetic operators
        //----------------------------------------------

        inline Int128 operator+( const Int128& other ) const noexcept;

        inline Int128 operator-( const Int128& other ) const noexcept;

        Int128 operator*( const Int128& other ) const noexcept;

        Int128 operator/( const Int128& other ) const;

        inline Int128& operator+=( const Int128& other ) noexcept;

        inline Int128& operator-=( const Int128& other ) noexcept;

        inline Int128& operator*=( const Int128& other ) noexcept;

        inline Int128& operator/=( const Int128& other );

        inline Int128& operator%=( const Int128& other );

        inline Int128 operator%( const Int128& other ) const;

        inline Int128 operator-() const noexcept;
 
        //----------------------------------------------
        // Property accessors
        //----------------------------------------------

        [[nodiscard]] std::uint64_t toLow() const noexcept;

        [[nodiscard]] std::uint64_t toHigh() const noexcept;
 
#if NFX_DATATYPES_HAS_NATIVE_INT128
        NFX_DATATYPES_NATIVE_INT128 toNative() const noexcept;
#endif
 
        //----------------------------------------------
        // Mathematical operations
        //----------------------------------------------

        [[nodiscard]] inline Int128 abs() const noexcept;

        [[nodiscard]] Int128 isqrt() const;
 
        //----------------------------------------------
        // String parsing
        //----------------------------------------------

        [[nodiscard]] static bool fromString( std::string_view str, Int128& result ) noexcept;

        [[nodiscard]] static std::optional<Int128> fromString( std::string_view str ) noexcept;
 
        //----------------------------------------------
        // Type conversion
        //----------------------------------------------

        [[nodiscard]] std::string toString() const;

        [[nodiscard]] std::array<std::int32_t, 4> toBits() const noexcept;
 
    private:
        //----------------------------------------------
        // Internal representation
        //----------------------------------------------
 
#if NFX_DATATYPES_HAS_NATIVE_INT128
        NFX_DATATYPES_NATIVE_INT128 m_value;
#else
        struct Layout
        {
            std::uint64_t lower64bits;
            std::uint64_t upper64bits;
        } m_layout;
#endif
    };
 
    //=====================================================================
    // Free functions
    //=====================================================================

    [[nodiscard]] inline Int128 abs( const Int128& value ) noexcept
    {
        return value.abs();
    }

    [[nodiscard]] inline Int128 isqrt( const Int128& value )
    {
        return value.isqrt();
    }

    [[nodiscard]] Decimal sqrt( const Int128& value );
} // namespace nfx::datatypes
 
#include "nfx/detail/datatypes/Int128.inl"