SkFloatingPoint.cpp File Reference

#include "include/private/base/SkFloatingPoint.h"
#include <algorithm>
#include <cmath>
#include <cstring>
#include <limits>

Go to the source code of this file.

Functions
static double	magnitude (double a)
bool	sk_doubles_nearly_equal_ulps (double a, double b, uint8_t maxUlpsDiff)
bool	sk_double_nearly_zero (double a)

Function Documentation

magnitude()

static double magnitude ( double  a )

static

Definition at line 19 of file SkFloatingPoint.cpp.

                                  {
    static constexpr int64_t extractMagnitude =
            0b0'11111111111'0000000000000000000000000000000000000000000000000000;
    int64_t bits;
    memcpy(&bits, &a, sizeof(bits));
    bits &= extractMagnitude;
    double out;
    memcpy(&out, &bits, sizeof(out));
    return out;
}

sk_double_nearly_zero()

bool sk_double_nearly_zero

(

double

a

)

Definition at line 54 of file SkFloatingPoint.cpp.

                                     {
    return a == 0 || fabs(a) < std::numeric_limits<float>::epsilon();
}

sk_doubles_nearly_equal_ulps()

bool sk_doubles_nearly_equal_ulps	(	double	a,
		double	b,
		uint8_t	maxUlpsDiff
	)

Definition at line 30 of file SkFloatingPoint.cpp.

                                                                           {
 
    // The maximum magnitude to construct the ulp tolerance. The proper magnitude for
    // subnormal numbers is minMagnitude, which is 2^-1021, so if a and b are subnormal (having a
    // magnitude of 0) use minMagnitude. If a or b are infinity or nan, then maxMagnitude will be
    // +infinity. This means the tolerance will also be infinity, but the expression b - a below
    // will either be NaN or infinity, so a tolerance of infinity doesn't matter.
    static constexpr double minMagnitude = std::numeric_limits<double>::min();
    const double maxMagnitude = std::max(std::max(magnitude(a), minMagnitude), magnitude(b));
 
    // Given a magnitude, this is the factor that generates the ulp for that magnitude.
    // In numbers, 2 ^ (-precision + 1) = 2 ^ -52.
    static constexpr double ulpFactor = std::numeric_limits<double>::epsilon();
 
    // The tolerance in ULPs given the maxMagnitude. Because the return statement must use <
    // for comparison instead of <= to correctly handle infinities, bump maxUlpsDiff up to get
    // the full maxUlpsDiff range.
    const double tolerance = maxMagnitude * (ulpFactor * (maxUlpsDiff + 1));
 
    // The expression a == b is mainly for handling infinities, but it also catches the exact
    // equals.
    return a == b || std::abs(b - a) < tolerance;
}