#include "include/private/base/SkAttributes.h"
#include "include/private/base/SkMath.h"
#include <cmath>
#include <cstdint>
#include <limits>
#include <type_traits>

Macros
#define	sk_float_round(x) (float)sk_double_round((double)(x))

#define	SK_CHECK_NAN(resultVal)

#define	sk_float_floor2int(x) sk_float_saturate2int(std::floor(x))

#define	sk_float_round2int(x) sk_float_saturate2int(sk_float_round(x))

#define	sk_float_ceil2int(x) sk_float_saturate2int(std::ceil(x))

#define	sk_float_floor2int_no_saturate(x) ((int)std::floor(x))

#define	sk_float_round2int_no_saturate(x) ((int)sk_float_round(x))

#define	sk_float_ceil2int_no_saturate(x) ((int)std::ceil(x))

#define	sk_double_round(x) (std::floor((x) + 0.5))

#define	sk_double_floor2int(x) ((int)std::floor(x))

#define	sk_double_round2int(x) ((int)std::round(x))

#define	sk_double_ceil2int(x) ((int)std::ceil(x))

Functions
static constexpr int	sk_float_sgn (float x)

static constexpr float	sk_float_degrees_to_radians (float degrees)

static constexpr float	sk_float_radians_to_degrees (float radians)

template<typename T , std::enable_if_t< std::is_floating_point_v< T >, bool > = true>
static constexpr bool	SkIsNaN (T x)

template<typename T , typename... Pack, std::enable_if_t< std::is_floating_point_v< T >, bool > = true>
static bool	SkIsFinite (T x, Pack... values)

template<typename T , std::enable_if_t< std::is_floating_point_v< T >, bool > = true>
static bool	SkIsFinite (const T array[], int count)

static constexpr int	sk_float_saturate2int (float x)

static constexpr int	sk_double_saturate2int (double x)

static constexpr int64_t	sk_float_saturate2int64 (float x)

static constexpr float	sk_double_to_float (double x)

static constexpr float	sk_float_midpoint (float a, float b)

static float	sk_float_rsqrt_portable (float x)

static float	sk_float_rsqrt (float x)

static constexpr float	sk_ieee_float_divide (float numer, float denom)

static constexpr double	sk_ieee_double_divide (double numer, double denom)

bool	sk_double_nearly_zero (double a)

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

Variables
constexpr float	SK_FloatSqrt2 = 1.41421356f

constexpr float	SK_FloatPI = 3.14159265f

constexpr double	SK_DoublePI = 3.14159265358979323846264338327950288

constexpr int	SK_MaxS32FitsInFloat = 2147483520

constexpr int	SK_MinS32FitsInFloat = -SK_MaxS32FitsInFloat

constexpr int64_t	SK_MaxS64FitsInFloat = SK_MaxS64 >> (63-24) << (63-24)

constexpr int64_t	SK_MinS64FitsInFloat = -SK_MaxS64FitsInFloat

constexpr float	SK_FloatNaN = std::numeric_limits<float>::quiet_NaN()

constexpr float	SK_FloatInfinity = std::numeric_limits<float>::infinity()

constexpr float	SK_FloatNegativeInfinity = -SK_FloatInfinity

constexpr double	SK_DoubleNaN = std::numeric_limits<double>::quiet_NaN()

Macro Definition Documentation

◆ SK_CHECK_NAN

#define SK_CHECK_NAN ( resultVal )

Definition at line 83 of file SkFloatingPoint.h.

◆ sk_double_ceil2int

#define sk_double_ceil2int ( x ) ((int)std::ceil(x))

Definition at line 129 of file SkFloatingPoint.h.

◆ sk_double_floor2int

#define sk_double_floor2int ( x ) ((int)std::floor(x))

Definition at line 127 of file SkFloatingPoint.h.

◆ sk_double_round

#define sk_double_round ( x ) (std::floor((x) + 0.5))

Definition at line 126 of file SkFloatingPoint.h.

◆ sk_double_round2int

#define sk_double_round2int ( x ) ((int)std::round(x))

Definition at line 128 of file SkFloatingPoint.h.

◆ sk_float_ceil2int

#define sk_float_ceil2int ( x ) sk_float_saturate2int(std::ceil(x))

Definition at line 120 of file SkFloatingPoint.h.

◆ sk_float_ceil2int_no_saturate

#define sk_float_ceil2int_no_saturate ( x ) ((int)std::ceil(x))

Definition at line 124 of file SkFloatingPoint.h.

◆ sk_float_floor2int

#define sk_float_floor2int ( x ) sk_float_saturate2int(std::floor(x))

Definition at line 118 of file SkFloatingPoint.h.

◆ sk_float_floor2int_no_saturate

#define sk_float_floor2int_no_saturate ( x ) ((int)std::floor(x))

Definition at line 122 of file SkFloatingPoint.h.

◆ sk_float_round

#define sk_float_round ( x ) (float)sk_double_round((double)(x))

Definition at line 38 of file SkFloatingPoint.h.

◆ sk_float_round2int

#define sk_float_round2int ( x ) sk_float_saturate2int(sk_float_round(x))

Definition at line 119 of file SkFloatingPoint.h.

◆ sk_float_round2int_no_saturate

#define sk_float_round2int_no_saturate ( x ) ((int)sk_float_round(x))

Definition at line 123 of file SkFloatingPoint.h.

Function Documentation

◆ 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_double_saturate2int()

static constexpr int sk_double_saturate2int ( double x )

staticconstexpr

Return the closest int for the given double. Returns SK_MaxS32 for NaN.

Definition at line 99 of file SkFloatingPoint.h.

                                                      {
    SK_CHECK_NAN(SK_MaxS32)
    x = x < SK_MaxS32 ? x : SK_MaxS32;
    x = x > SK_MinS32 ? x : SK_MinS32;
    return (int)x;
}

◆ sk_double_to_float()

static constexpr float sk_double_to_float ( double x )

staticconstexpr

Definition at line 135 of file SkFloatingPoint.h.

                                                    {
    return static_cast<float>(x);
}

◆ sk_doubles_nearly_equal_ulps()

bool sk_doubles_nearly_equal_ulps	(	double	a,
		double	b,
		uint8_t	maxUlpsDiff = `16`
	)

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;
}

◆ sk_float_degrees_to_radians()

static constexpr float sk_float_degrees_to_radians ( float degrees )

staticconstexpr

Definition at line 27 of file SkFloatingPoint.h.

                                                                  {
    return degrees * (SK_FloatPI / 180);
}

◆ sk_float_midpoint()

static constexpr float sk_float_midpoint	(	float	a,
		float	b
	)

staticconstexpr

Definition at line 146 of file SkFloatingPoint.h.

                                                           {
    // Use double math to avoid underflow and overflow.
    return static_cast<float>(0.5 * (static_cast<double>(a) + b));
}

◆ sk_float_radians_to_degrees()

static constexpr float sk_float_radians_to_degrees ( float radians )

staticconstexpr

Definition at line 31 of file SkFloatingPoint.h.

                                                                  {
    return radians * (180 / SK_FloatPI);
}

◆ sk_float_rsqrt()

static float sk_float_rsqrt ( float x )

inlinestatic

Definition at line 152 of file SkFloatingPoint.h.

152{ return 1.0f / std::sqrt(x); }

skvx::sqrt

SIN Vec< N, float > sqrt(const Vec< N, float > &x)

Definition: SkVx.h:706

◆ sk_float_rsqrt_portable()

static float sk_float_rsqrt_portable ( float x )

inlinestatic

Definition at line 151 of file SkFloatingPoint.h.

151{ return 1.0f / std::sqrt(x); }

◆ sk_float_saturate2int()

static constexpr int sk_float_saturate2int ( float x )

staticconstexpr

Return the closest int for the given float. Returns SK_MaxS32FitsInFloat for NaN.

Definition at line 89 of file SkFloatingPoint.h.

                                                    {
    SK_CHECK_NAN(SK_MaxS32FitsInFloat)
    x = x < SK_MaxS32FitsInFloat ? x : SK_MaxS32FitsInFloat;
    x = x > SK_MinS32FitsInFloat ? x : SK_MinS32FitsInFloat;
    return (int)x;
}

◆ sk_float_saturate2int64()

static constexpr int64_t sk_float_saturate2int64 ( float x )

staticconstexpr

Return the closest int64_t for the given float. Returns SK_MaxS64FitsInFloat for NaN.

Definition at line 109 of file SkFloatingPoint.h.

                                                          {
    SK_CHECK_NAN(SK_MaxS64FitsInFloat)
    x = x < SK_MaxS64FitsInFloat ? x : SK_MaxS64FitsInFloat;
    x = x > SK_MinS64FitsInFloat ? x : SK_MinS64FitsInFloat;
    return (int64_t)x;
}

◆ sk_float_sgn()

static constexpr int sk_float_sgn ( float x )

staticconstexpr

Definition at line 23 of file SkFloatingPoint.h.

                                           {
    return (0.0f < x) - (x < 0.0f);
}

◆ sk_ieee_double_divide()

static constexpr double sk_ieee_double_divide	(	double	numer,
		double	denom
	)

staticconstexpr

Definition at line 166 of file SkFloatingPoint.h.

                                                                          {
    return numer / denom;
}

◆ sk_ieee_float_divide()

static constexpr float sk_ieee_float_divide	(	float	numer,
		float	denom
	)

staticconstexpr

Definition at line 161 of file SkFloatingPoint.h.

                                                                      {
    return numer / denom;
}

◆ SkIsFinite() [1/2]

template<typename T , std::enable_if_t< std::is_floating_point_v< T >, bool > = true>

static bool SkIsFinite	(	const T	array[],
		int	count
	)

inlinestatic

Definition at line 58 of file SkFloatingPoint.h.

                                                          {
    T x = array[0];
    T prod = x - x;
    for (int i = 1; i < count; ++i) {
        prod *= array[i];
    }
    // At this point, `prod` will either be NaN or 0.
    return prod == prod;
}

◆ SkIsFinite() [2/2]

template<typename T , typename... Pack, std::enable_if_t< std::is_floating_point_v< T >, bool > = true>

static bool SkIsFinite	(	T	x,
		Pack...	values
	)

inlinestatic

Definition at line 50 of file SkFloatingPoint.h.

                                                   {
    T prod = x - x;
    prod = (prod * ... * values);
    // At this point, `prod` will either be NaN or 0.
    return prod == prod;
}

◆ SkIsNaN()

template<typename T , std::enable_if_t< std::is_floating_point_v< T >, bool > = true>

static constexpr bool SkIsNaN ( T x )

inlinestaticconstexpr

Definition at line 41 of file SkFloatingPoint.h.

                                          {
    return x != x;
}

Variable Documentation

◆ SK_DoubleNaN

constexpr double SK_DoubleNaN = std::numeric_limits<double>::quiet_NaN()

inlineconstexpr

Definition at line 143 of file SkFloatingPoint.h.

◆ SK_DoublePI

constexpr double SK_DoublePI = 3.14159265358979323846264338327950288

inlineconstexpr

Definition at line 21 of file SkFloatingPoint.h.

◆ SK_FloatInfinity

constexpr float SK_FloatInfinity = std::numeric_limits<float>::infinity()

inlineconstexpr

Definition at line 140 of file SkFloatingPoint.h.

◆ SK_FloatNaN

constexpr float SK_FloatNaN = std::numeric_limits<float>::quiet_NaN()

inlineconstexpr

Definition at line 139 of file SkFloatingPoint.h.

◆ SK_FloatNegativeInfinity

constexpr float SK_FloatNegativeInfinity = -SK_FloatInfinity

inlineconstexpr

Definition at line 141 of file SkFloatingPoint.h.

◆ SK_FloatPI

constexpr float SK_FloatPI = 3.14159265f

inlineconstexpr

Definition at line 20 of file SkFloatingPoint.h.

◆ SK_FloatSqrt2

constexpr float SK_FloatSqrt2 = 1.41421356f

inlineconstexpr

Definition at line 19 of file SkFloatingPoint.h.

◆ SK_MaxS32FitsInFloat

constexpr int SK_MaxS32FitsInFloat = 2147483520

inlineconstexpr

Definition at line 68 of file SkFloatingPoint.h.

◆ SK_MaxS64FitsInFloat

constexpr int64_t SK_MaxS64FitsInFloat = SK_MaxS64 >> (63-24) << (63-24)

inlineconstexpr

Definition at line 72 of file SkFloatingPoint.h.

◆ SK_MinS32FitsInFloat

constexpr int SK_MinS32FitsInFloat = -SK_MaxS32FitsInFloat

inlineconstexpr

Definition at line 69 of file SkFloatingPoint.h.

◆ SK_MinS64FitsInFloat

constexpr int64_t SK_MinS64FitsInFloat = -SK_MaxS64FitsInFloat

inlineconstexpr

Definition at line 73 of file SkFloatingPoint.h.

Macros

Functions

Variables

Macro Definition Documentation

◆ SK_CHECK_NAN

◆ sk_double_ceil2int

◆ sk_double_floor2int

◆ sk_double_round

◆ sk_double_round2int

◆ sk_float_ceil2int

◆ sk_float_ceil2int_no_saturate

◆ sk_float_floor2int

◆ sk_float_floor2int_no_saturate

◆ sk_float_round

◆ sk_float_round2int

◆ sk_float_round2int_no_saturate

Function Documentation

◆ sk_double_nearly_zero()

◆ sk_double_saturate2int()

◆ sk_double_to_float()

◆ sk_doubles_nearly_equal_ulps()

◆ sk_float_degrees_to_radians()

◆ sk_float_midpoint()

◆ sk_float_radians_to_degrees()

◆ sk_float_rsqrt()

◆ sk_float_rsqrt_portable()

◆ sk_float_saturate2int()

◆ sk_float_saturate2int64()

◆ sk_float_sgn()

◆ sk_ieee_double_divide()

◆ sk_ieee_float_divide()

◆ SkIsFinite() [1/2]

◆ SkIsFinite() [2/2]

◆ SkIsNaN()

Variable Documentation

◆ SK_DoubleNaN

◆ SK_DoublePI

◆ SK_FloatInfinity

◆ SK_FloatNaN

◆ SK_FloatNegativeInfinity

◆ SK_FloatPI

◆ SK_FloatSqrt2

◆ SK_MaxS32FitsInFloat

◆ SK_MaxS64FitsInFloat

◆ SK_MinS32FitsInFloat

◆ SK_MinS64FitsInFloat