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

    class Decimal final
    {
        friend struct std::numeric_limits<Decimal>;
 
    public:
        //----------------------------------------------
        // Rounding modes
        //----------------------------------------------

        enum class RoundingMode : std::uint8_t
        {
            ToNearest = 0,      
            ToNearestTiesAway,  
            ToZero,             
            ToPositiveInfinity, 
            ToNegativeInfinity  
        };
 
        //----------------------------------------------
        // Construction
        //----------------------------------------------

        inline constexpr Decimal() noexcept;

        explicit Decimal( float value ) noexcept;

        explicit Decimal( double value ) noexcept;

        inline explicit Decimal( std::int32_t value ) noexcept;

        inline explicit Decimal( std::int64_t value ) noexcept;

        inline explicit Decimal( std::uint32_t value ) noexcept;

        inline explicit Decimal( std::uint64_t value ) noexcept;

        inline explicit Decimal( std::string_view str );

        inline explicit Decimal( const char* scStr );

        explicit Decimal( const Int128& val );

        Decimal( const Decimal& other ) noexcept = default;

        Decimal( Decimal&& other ) noexcept = default;
 
        //----------------------------------------------
        // Destruction
        //----------------------------------------------

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

        Decimal& operator=( const Decimal& other ) noexcept = default;

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

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

        bool operator==( const Decimal& other ) 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;

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

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

        inline bool operator<( double val ) const noexcept;

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

        inline bool operator>( double val ) const noexcept;

        inline bool operator>=( double val ) const noexcept;
 
        //----------------------------------------------
        // Comparison with built-in integer types
        //----------------------------------------------

        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::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;

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

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

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

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

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

        inline bool operator>=( std::int32_t val ) const noexcept;
 
        //----------------------------------------------
        // Comparison with nfx::datatypes::Int128
        //----------------------------------------------

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

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

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

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

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

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

        Decimal operator+( const Decimal& other );

        inline Decimal operator-( const Decimal& other );

        Decimal operator*( const Decimal& other ) const;

        Decimal operator/( const Decimal& other ) const;

        inline Decimal& operator+=( const Decimal& other );

        inline Decimal& operator-=( const Decimal& other );

        inline Decimal& operator*=( const Decimal& other );

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

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

        [[nodiscard]] std::uint8_t scale() const noexcept;

        [[nodiscard]] inline const std::uint32_t& flags() const noexcept;

        [[nodiscard]] inline std::uint32_t& flags() noexcept;

        [[nodiscard]] inline const std::array<std::uint32_t, 3>& mantissa() const noexcept;

        [[nodiscard]] inline std::array<std::uint32_t, 3>& mantissa() noexcept;
 
        //----------------------------------------------
        // Mathematical operations
        //----------------------------------------------

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

        [[nodiscard]] inline Decimal ceil() const noexcept;

        [[nodiscard]] inline Decimal floor() const noexcept;

        [[nodiscard]] Decimal round( std::int32_t decimalsPlacesCount = 0, RoundingMode mode = RoundingMode::ToNearest ) const noexcept;

        [[nodiscard]] Decimal sqrt() const;

        [[nodiscard]] inline Decimal trunc() const noexcept;
 
        //----------------------------------------------
        // String parsing
        //----------------------------------------------

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

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

        [[nodiscard]] double toDouble() const noexcept;

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

        [[nodiscard]] std::array<std::int32_t, 4> toBits() const noexcept;
 
        //----------------------------------------------
        // Utilities
        //----------------------------------------------

        [[nodiscard]] std::uint8_t decimalPlacesCount() const noexcept;
 
    private:
        //----------------------------------------------
        // Internal representation
        //----------------------------------------------

        struct Layout
        {
            std::uint32_t flags;

            std::array<std::uint32_t, 3> mantissa;
        } m_layout;
    };
 
    //=====================================================================
    // Free functions
    //=====================================================================

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

    [[nodiscard]] inline Decimal sqrt( const Decimal& value )
    {
        return value.sqrt();
    }

    [[nodiscard]] inline Decimal ceil( const Decimal& value ) noexcept
    {
        return value.ceil();
    }

    [[nodiscard]] inline Decimal floor( const Decimal& value ) noexcept
    {
        return value.floor();
    }

    [[nodiscard]] inline Decimal round( const Decimal& value, std::int32_t decimalsPlacesCount = 0,
        Decimal::RoundingMode mode = Decimal::RoundingMode::ToNearest ) noexcept
    {
        return value.round( decimalsPlacesCount, mode );
    }

    [[nodiscard]] inline Decimal trunc( const Decimal& value ) noexcept
    {
        return value.trunc();
    }
} // namespace nfx::datatypes
 
#include "nfx/detail/datatypes/Decimal.inl"