almostequal.h

Go to the documentation of this file.

/*
* Copyright 2016 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "gwnavruntime/base/types.h"

namespace Kaim
{

namespace AlmostEqualImpl
{

inline bool IsNan(KyUInt32 ui32)
{
    const KyUInt32 ExponentMask = 0x7F800000;
    const KyUInt32 FractionMask = 0x007FFFFF;
    return (ui32 & ExponentMask) == ExponentMask && (ui32 & FractionMask) != 0;
}

inline KyUInt32 Biased(const KyUInt32& ui32)
{
    return (0x80000000 & ui32) ? ~ui32 + 1 : 0x80000000 | ui32;
}

// ULP stands for Unit of Least precision
inline KyUInt32 DistanceULP(const KyUInt32& a, const KyUInt32& b)
{
    const KyUInt32 biased_a = Biased(a);
    const KyUInt32 biased_b = Biased(b);
    return (biased_a >= biased_b) ? (biased_a - biased_b) : (biased_b - biased_a);
}

// We use a Union to reinterpret a KyFloat32 into a KyUInt32.
// Using reinterpret_cast<KyUInt32*>(&float_variable) does NOT work because of strict_aliasing compiler optimizations.
// In theory, the C++ standard does not state that using a Union works, but the C99 standard does.
// The only C++ standard way of doing this seems to involve memcpy(), it also seems that the memcpy() call can be optimized aggressively by the compiler.
// We still use a Union there, because it's simpler and it just work with all the compilers we support.
union U
{
    KyFloat32 f32;
    KyUInt32 ui32;
};

};

inline KyUInt32 DistanceULP(KyFloat32 a, KyFloat32 b)
{
    AlmostEqualImpl::U ua;
    ua.f32 = a;
    AlmostEqualImpl::U ub;
    ub.f32 = b;
    return AlmostEqualImpl::DistanceULP(ua.ui32, ub.ui32);
}

inline bool AlmostEqual(KyFloat32 a, KyFloat32 b)
{
    return DistanceULP(a, b) <= 4;
}

inline bool AlmostEqual(KyFloat32 a, KyFloat32 b, KyUInt32 maxUlps)
{
    return DistanceULP(a, b) <= maxUlps;
}

inline bool AlmostEqual_nan(KyFloat32 a, KyFloat32 b)
{
    AlmostEqualImpl::U ua;
    ua.f32 = a;
    AlmostEqualImpl::U ub;
    ub.f32 = b;

    if (AlmostEqualImpl::IsNan(ua.ui32) || AlmostEqualImpl::IsNan(ub.ui32))
        return false;

    return DistanceULP(a, b) <= 4;
}


}