Float16.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Serialization/Archive.h"
#include "Math/UnrealMathUtility.h"
#include "Math/Float32.h"
#include "Serialization/MemoryLayout.h"
 
template <typename T> struct TCanBulkSerialize;
 
class FFloat16
{
public:
 
    /* Float16 can store values in [-MaxF16Float,MaxF16Float] */
    constexpr static float MaxF16Float = 65504.f;
 
    uint16 Encoded = 0;
 
    [[nodiscard]] FFloat16() = default;
 
    [[nodiscard]] FFloat16(const FFloat16& FP16Value) = default;
 
    [[nodiscard]] FFloat16(float FP32Value);
 
    FFloat16& operator=(float FP32Value);
 
    FFloat16& operator=(const FFloat16& FP16Value) = default;
 
    operator float() const;
 
    void Set(float FP32Value);
    
    /*Convert from Fp32 to Fp16, round-to-nearest-even. (RTNE)
    Clamps values out of range as +-MaxF16Float */
    void SetClamped(float FP32Value)
    {
        Set( FMath::Clamp(FP32Value,-MaxF16Float,MaxF16Float) );
    }
 
    void CORE_API SetTruncate(float FP32Value);
 
    void SetZero()
    {
        Encoded = 0;
    }
    
    void SetOne()
    {
        Encoded = 0x3c00;
    }
 
    [[nodiscard]] FFloat16 GetClampedNonNegativeAndFinite() const;
    
    [[nodiscard]] FFloat16 GetClampedFinite() const;
 
    [[nodiscard]] float GetFloat() const;
 
    [[nodiscard]] bool IsNegative() const
    {
        // negative if sign bit is on
        // can be tested with int compare
        return (int16)Encoded < 0;
    }
 
    friend FArchive& operator<<(FArchive& Ar, FFloat16& V)
    {
        return Ar << V.Encoded;
    }
};
template<> struct TCanBulkSerialize<FFloat16> { enum { Value = true }; };
 
DECLARE_INTRINSIC_TYPE_LAYOUT(FFloat16);
 
UE_FORCEINLINE_HINT FFloat16::FFloat16(float FP32Value)
{
    Set(FP32Value);
}   
 
 
inline FFloat16& FFloat16::operator=(float FP32Value)
{
    Set(FP32Value);
    return *this;
}
 
 
UE_FORCEINLINE_HINT FFloat16::operator float() const
{
    return GetFloat();
}
 
 
// NOTE: Set() on values out of F16 max range store them as +-Inf
UE_FORCEINLINE_HINT void FFloat16::Set(float FP32Value)
{
    // FPlatformMath::StoreHalf follows RTNE (round-to-nearest-even) rounding default convention
    FPlatformMath::StoreHalf(&Encoded, FP32Value);
}
 
 
 
UE_FORCEINLINE_HINT float FFloat16::GetFloat() const
{
    return FPlatformMath::LoadHalf(&Encoded);
}
 
 
inline FFloat16 FFloat16::GetClampedNonNegativeAndFinite() const
{
    FFloat16 ReturnValue;
    
    if ( Encoded < 0x7c00 ) // normal and non-negative, just pass through
        ReturnValue.Encoded = Encoded;
    else if ( Encoded == 0x7c00 ) // infinity turns into largest normal
        ReturnValue.Encoded = 0x7bff;
    else // NaNs or anything negative turns into 0
        ReturnValue.Encoded = 0;
 
    return ReturnValue;
}
 
 
inline FFloat16 FFloat16::GetClampedFinite() const
{   
    FFloat16 ReturnValue;
 
    if ( (Encoded&0x7c00) == 0x7c00 )
    {
        // inf or nan
        if ( Encoded == 0x7C00 ) //+inf
        {
            ReturnValue.Encoded = 0x7bff; // max finite
        }
        else if ( Encoded == 0xFC00 ) //-inf
        {
            ReturnValue.Encoded = 0xfbff; // max finite negative
        }
        else
        {
            // nan
            ReturnValue.Encoded = 0;
        }
    }
    else
    {
        ReturnValue.Encoded = Encoded;
    }
    
    return ReturnValue;
}