float.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_VALUE_FLOAT_H
#define pRC_CORE_VALUE_FLOAT_H
 
#include <prc/core/basic/functions/identity.hpp>
#include <prc/core/basic/functions/unit.hpp>
#include <prc/core/basic/functions/zero.hpp>
#include <prc/core/functors/add.hpp>
#include <prc/core/functors/div.hpp>
#include <prc/core/functors/mul.hpp>
#include <prc/core/functors/sub.hpp>
#include <prc/core/log/log.hpp>
#include <prc/core/value/bfloat16.hpp>
#include <prc/core/value/value.hpp>
 
namespace pRC
{
    template<Size W>
    class Float
    {
    public:
        using Fundamental = Conditional<W == 16, BFloat16,
            Conditional<W == 32, float,
                Conditional<W == 64, double, Undefined>>>;
 
        static constexpr Size Width = W;
        template<Size C>
        using ChangeSize = Float<C>;
 
    public:
        ~Float()
            requires IsDefined<Fundamental>
        = default;
        constexpr Float(Float const &) = default;
        constexpr Float(Float &&) = default;
        constexpr Float &operator=(Float const &) & = default;
        constexpr Float &operator=(Float &&) & = default;
        constexpr Float() = default;
 
        template<class U>
            requires IsConstructible<Fundamental, U>
        constexpr Float(U const basic)
            : mValue(basic)
        {
        }
 
        template<IsValue U>
        constexpr Float(U const &value)
            : mValue(value())
        {
        }
 
        constexpr Float(Zero<> const)
            : Float(zero<Float>())
        {
        }
 
        constexpr Float(Unit<> const)
            : Float(unit<Float>())
        {
        }
 
        constexpr Float(Identity<> const)
            : Float(identity<Float>())
        {
        }
 
        template<class U>
            requires IsAssignable<Fundamental, U>
        constexpr auto &operator=(U const basic) &
        {
            mValue = basic;
            return *this;
        }
 
        template<IsValue U>
        constexpr auto &operator=(U const &value) &
        {
            mValue = value();
            return *this;
        }
 
        constexpr auto &operator=(Zero<> const) &
        {
            return *this = zero<Float>();
        }
 
        constexpr auto &operator=(Unit<> const) &
        {
            return *this = unit<Float>();
        }
 
        constexpr auto &operator=(Identity<> const) &
        {
            return *this = identity<Float>();
        }
 
        constexpr decltype(auto) operator()() &&
        {
            return move(mValue);
        }
 
        constexpr decltype(auto) operator()() const &&
        {
            return move(mValue);
        }
 
        constexpr auto &operator()() &
        {
            return mValue;
        }
 
        constexpr auto &operator()() const &
        {
            return mValue;
        }
 
        explicit constexpr operator Fundamental() const
        {
            return mValue;
        }
 
        template<class X>
            requires IsInvocable<Add, Float &, X>
        constexpr auto &operator+=(X &&rhs) &
        {
            return *this = *this + forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Sub, Float &, X>
        constexpr auto &operator-=(X &&rhs) &
        {
            return *this = *this - forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Mul, Float &, X>
        constexpr auto &operator*=(X &&rhs) &
        {
            return *this = *this * forward<X>(rhs);
        }
 
        template<class X>
            requires IsInvocable<Div, Float &, X>
        constexpr auto &operator/=(X &&rhs) &
        {
            return *this = *this / forward<X>(rhs);
        }
 
    private:
        Fundamental mValue;
    };
 
    Float(Float<16>::Fundamental const) -> Float<16>;
    Float(Float<32>::Fundamental const) -> Float<32>;
    Float(Float<64>::Fundamental const) -> Float<64>;
}
#endif // pRC_CORE_VALUE_FLOAT_H