The-Homebrew-Cloud/dolphin
2
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-01-25 15:31:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #202 from Tilka/mathutil

Browse Source 
MathUtil: add IntFloat/IntDouble constructors and test FlushToZero()
This commit is contained in:
Pierre Bourdon 2014-03-24 21:20:09 +01:00
commit c929c3ebc1
3 changed files with 56 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Source/Core/Common/MathUtil.cpp
View File

@ -15,8 +15,7 @@ namespace MathUtil
u32 ClassifyDouble(double dvalue)
{
// TODO: Optimize the below to be as fast as possible.
IntDouble value;
value.d = dvalue;
IntDouble value(dvalue);
u64 sign = value.i & DOUBLE_SIGN;
u64 exp = value.i & DOUBLE_EXP;
if (exp > DOUBLE_ZERO && exp < DOUBLE_EXP)
@ -55,8 +54,7 @@ u32 ClassifyDouble(double dvalue)
u32 ClassifyFloat(float fvalue)
{
// TODO: Optimize the below to be as fast as possible.
IntFloat value;
value.f = fvalue;
IntFloat value(fvalue);
u32 sign = value.i & FLOAT_SIGN;
u32 exp = value.i & FLOAT_EXP;
if (exp > FLOAT_ZERO && exp < FLOAT_EXP)

18
Source/Core/Common/MathUtil.h
View File

@ -36,35 +36,41 @@ static const u32 FLOAT_SIGN = 0x80000000,
union IntDouble {
double d;
u64 i;
explicit IntDouble(u64 _i) : i(_i) {}
explicit IntDouble(double _d) : d(_d) {}
};
union IntFloat {
float f;
u32 i;
explicit IntFloat(u32 _i) : i(_i) {}
explicit IntFloat(float _f) : f(_f) {}
};
inline bool IsINF(double d)
{
IntDouble x; x.d = d;
IntDouble x(d);
return (x.i & ~DOUBLE_SIGN) == DOUBLE_EXP;
}
inline bool IsNAN(double d)
{
IntDouble x; x.d = d;
IntDouble x(d);
return ((x.i & DOUBLE_EXP) == DOUBLE_EXP) &&
((x.i & DOUBLE_FRAC) != DOUBLE_ZERO);
}
inline bool IsQNAN(double d)
{
IntDouble x; x.d = d;
IntDouble x(d);
return ((x.i & DOUBLE_EXP) == DOUBLE_EXP) &&
((x.i & DOUBLE_QBIT) == DOUBLE_QBIT);
}
inline bool IsSNAN(double d)
{
IntDouble x; x.d = d;
IntDouble x(d);
return ((x.i & DOUBLE_EXP) == DOUBLE_EXP) &&
((x.i & DOUBLE_FRAC) != DOUBLE_ZERO) &&
((x.i & DOUBLE_QBIT) == DOUBLE_ZERO);
@ -72,7 +78,7 @@ inline bool IsSNAN(double d)
inline float FlushToZero(float f)
{
IntFloat x; x.f = f;
IntFloat x(f);
if ((x.i & FLOAT_EXP) == 0)
{
x.i &= FLOAT_SIGN; // turn into signed zero
@ -82,7 +88,7 @@ inline float FlushToZero(float f)
inline double FlushToZero(double d)
{
IntDouble x; x.d = d;
IntDouble x(d);
if ((x.i & DOUBLE_EXP) == 0)
{
x.i &= DOUBLE_SIGN; // turn into signed zero

43
Source/UnitTests/Common/MathUtilTest.cpp
View File

@ -4,6 +4,7 @@
#include <gtest/gtest.h>
#include <limits>
#include <random>
#include "Common/MathUtil.h"
@ -29,7 +30,7 @@ TEST(MathUtil, Clamp)
TEST(MathUtil, IsINF)
{
EXPECT_TRUE(MathUtil::IsINF( std::numeric_limits<double>::infinity()));
EXPECT_TRUE(MathUtil::IsINF(+std::numeric_limits<double>::infinity()));
EXPECT_TRUE(MathUtil::IsINF(-std::numeric_limits<double>::infinity()));
}
@ -63,3 +64,43 @@ TEST(MathUtil, Log2)
EXPECT_EQ(3, Log2(15));
EXPECT_EQ(63, Log2(0xFFFFFFFFFFFFFFFFull));
}
TEST(MathUtil, FlushToZero)
{
// To test the software implementation we need to make sure FTZ and DAZ are disabled.
// Using volatile here to ensure the compiler doesn't constant-fold it,
// we want the multiplication to occur at test runtime.
volatile float s = std::numeric_limits<float>::denorm_min();
volatile double d = std::numeric_limits<double>::denorm_min();
EXPECT_LT(0, s * 2);
EXPECT_LT(0, d * 2);
EXPECT_EQ(+0, MathUtil::FlushToZero(+std::numeric_limits<double>::denorm_min()));
EXPECT_EQ(-0, MathUtil::FlushToZero(-std::numeric_limits<double>::denorm_min()));
EXPECT_EQ(+0, MathUtil::FlushToZero(+std::numeric_limits<double>::min() / 2));
EXPECT_EQ(-0, MathUtil::FlushToZero(-std::numeric_limits<double>::min() / 2));
EXPECT_EQ(std::numeric_limits<double>::min(), MathUtil::FlushToZero(std::numeric_limits<double>::min()));
EXPECT_EQ(std::numeric_limits<double>::max(), MathUtil::FlushToZero(std::numeric_limits<double>::max()));
EXPECT_EQ(+std::numeric_limits<double>::infinity(), MathUtil::FlushToZero(+std::numeric_limits<double>::infinity()));
EXPECT_EQ(-std::numeric_limits<double>::infinity(), MathUtil::FlushToZero(-std::numeric_limits<double>::infinity()));
// Test all subnormals as well as an equally large set of random normal floats.
std::default_random_engine engine(0);
std::uniform_int_distribution<u32> dist(0x00800000u, 0x7fffffffu);
for (u32 i = 0; i <= 0x007fffffu; ++i)
{
MathUtil::IntFloat x(i);
EXPECT_EQ(+0, MathUtil::FlushToZero(x.f));
x.i = i | 0x80000000u;
EXPECT_EQ(-0, MathUtil::FlushToZero(x.f));
x.i = dist(engine);
MathUtil::IntFloat y(MathUtil::FlushToZero(x.f));
EXPECT_EQ(x.i, y.i);
x.i |= 0x80000000u;
y.f = MathUtil::FlushToZero(x.f);
EXPECT_EQ(x.i, y.i);
}
}