SkPathOpsTypes.cpp File Reference

#include "src/pathops/SkPathOpsTypes.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkTemplates.h"
#include "src/base/SkFloatBits.h"
#include <algorithm>
#include <cstdint>
#include <cstring>

Go to the source code of this file.

Functions
static bool	arguments_denormalized (float a, float b, int epsilon)
static bool	equal_ulps (float a, float b, int epsilon, int depsilon)
static bool	equal_ulps_no_normal_check (float a, float b, int epsilon, int depsilon)
static bool	equal_ulps_pin (float a, float b, int epsilon, int depsilon)
static bool	d_equal_ulps (float a, float b, int epsilon)
static bool	not_equal_ulps (float a, float b, int epsilon)
static bool	not_equal_ulps_pin (float a, float b, int epsilon)
static bool	d_not_equal_ulps (float a, float b, int epsilon)
static bool	less_ulps (float a, float b, int epsilon)
static bool	less_or_equal_ulps (float a, float b, int epsilon)
bool	AlmostBequalUlps (float a, float b)
bool	AlmostPequalUlps (float a, float b)
bool	AlmostDequalUlps (float a, float b)
bool	AlmostDequalUlps (double a, double b)
bool	AlmostEqualUlps (float a, float b)
bool	AlmostEqualUlpsNoNormalCheck (float a, float b)
bool	AlmostEqualUlps_Pin (float a, float b)
bool	NotAlmostEqualUlps (float a, float b)
bool	NotAlmostEqualUlps_Pin (float a, float b)
bool	NotAlmostDequalUlps (float a, float b)
bool	RoughlyEqualUlps (float a, float b)
bool	AlmostBetweenUlps (float a, float b, float c)
bool	AlmostLessUlps (float a, float b)
bool	AlmostLessOrEqualUlps (float a, float b)
int	UlpsDistance (float a, float b)

Function Documentation

AlmostBequalUlps()

bool AlmostBequalUlps	(	float	a,
		float	b
	)

Definition at line 113 of file SkPathOpsTypes.cpp.

                                        {
    const int UlpsEpsilon = 2;
    return equal_ulps(a, b, UlpsEpsilon, UlpsEpsilon);
}

AlmostBetweenUlps()

bool AlmostBetweenUlps	(	float	a,
		float	b,
		float	c
	)

Definition at line 174 of file SkPathOpsTypes.cpp.

                                                  {
    const int UlpsEpsilon = 2;
    return a <= c ? less_or_equal_ulps(a, b, UlpsEpsilon) && less_or_equal_ulps(b, c, UlpsEpsilon)
        : less_or_equal_ulps(b, a, UlpsEpsilon) && less_or_equal_ulps(c, b, UlpsEpsilon);
}

AlmostDequalUlps() [1/2]

bool AlmostDequalUlps	(	double	a,
		double	b
	)

Definition at line 128 of file SkPathOpsTypes.cpp.

                                          {
    if (fabs(a) < SK_ScalarMax && fabs(b) < SK_ScalarMax) {
        return AlmostDequalUlps(SkDoubleToScalar(a), SkDoubleToScalar(b));
    }
    // We allow divide-by-zero here. It only happens if one of a,b is zero, and the other is NaN.
    // (Otherwise, we'd hit the condition above). Thus, if std::max returns 0, we compute NaN / 0,
    // which will produce NaN. The comparison will return false, which is the correct answer.
    return sk_ieee_double_divide(fabs(a - b), std::max(fabs(a), fabs(b))) < FLT_EPSILON * 16;
}

AlmostDequalUlps() [2/2]

bool AlmostDequalUlps	(	float	a,
		float	b
	)

Definition at line 123 of file SkPathOpsTypes.cpp.

                                        {
    const int UlpsEpsilon = 16;
    return d_equal_ulps(a, b, UlpsEpsilon);
}

AlmostEqualUlps()

bool AlmostEqualUlps	(	float	a,
		float	b
	)

Definition at line 138 of file SkPathOpsTypes.cpp.

                                       {
    const int UlpsEpsilon = 16;
    return equal_ulps(a, b, UlpsEpsilon, UlpsEpsilon);
}

AlmostEqualUlps_Pin()

bool AlmostEqualUlps_Pin	(	float	a,
		float	b
	)

Definition at line 148 of file SkPathOpsTypes.cpp.

                                           {
    const int UlpsEpsilon = 16;
    return equal_ulps_pin(a, b, UlpsEpsilon, UlpsEpsilon);
}

AlmostEqualUlpsNoNormalCheck()

bool AlmostEqualUlpsNoNormalCheck	(	float	a,
		float	b
	)

Definition at line 143 of file SkPathOpsTypes.cpp.

                                                    {
    const int UlpsEpsilon = 16;
    return equal_ulps_no_normal_check(a, b, UlpsEpsilon, UlpsEpsilon);
}

AlmostLessOrEqualUlps()

bool AlmostLessOrEqualUlps	(	float	a,
		float	b
	)

Definition at line 185 of file SkPathOpsTypes.cpp.

                                             {
    const int UlpsEpsilon = 16;
    return less_or_equal_ulps(a, b, UlpsEpsilon);
}

AlmostLessUlps()

bool AlmostLessUlps	(	float	a,
		float	b
	)

Definition at line 180 of file SkPathOpsTypes.cpp.

                                      {
    const int UlpsEpsilon = 16;
    return less_ulps(a, b, UlpsEpsilon);
}

AlmostPequalUlps()

bool AlmostPequalUlps	(	float	a,
		float	b
	)

Definition at line 118 of file SkPathOpsTypes.cpp.

                                        {
    const int UlpsEpsilon = 8;
    return equal_ulps(a, b, UlpsEpsilon, UlpsEpsilon);
}

arguments_denormalized()

static bool arguments_denormalized ( float  a, float  b, int  epsilon  )

static

Definition at line 18 of file SkPathOpsTypes.cpp.

                                                                  {
    float denormalizedCheck = FLT_EPSILON * epsilon / 2;
    return fabsf(a) <= denormalizedCheck && fabsf(b) <= denormalizedCheck;
}

d_equal_ulps()

static bool d_equal_ulps ( float  a, float  b, int  epsilon  )

static

Definition at line 55 of file SkPathOpsTypes.cpp.

                                                        {
    int aBits = SkFloatAs2sCompliment(a);
    int bBits = SkFloatAs2sCompliment(b);
    // Find the difference in ULPs.
    return aBits < bBits + epsilon && bBits < aBits + epsilon;
}

d_not_equal_ulps()

static bool d_not_equal_ulps ( float  a, float  b, int  epsilon  )

static

Definition at line 85 of file SkPathOpsTypes.cpp.

                                                            {
    int aBits = SkFloatAs2sCompliment(a);
    int bBits = SkFloatAs2sCompliment(b);
    // Find the difference in ULPs.
    return aBits >= bBits + epsilon || bBits >= aBits + epsilon;
}

equal_ulps()

static bool equal_ulps ( float  a, float  b, int  epsilon, int  depsilon  )

static

Definition at line 25 of file SkPathOpsTypes.cpp.

                                                                    {
    if (arguments_denormalized(a, b, depsilon)) {
        return true;
    }
    int aBits = SkFloatAs2sCompliment(a);
    int bBits = SkFloatAs2sCompliment(b);
    // Find the difference in ULPs.
    return aBits < bBits + epsilon && bBits < aBits + epsilon;
}

equal_ulps_no_normal_check()

static bool equal_ulps_no_normal_check ( float  a, float  b, int  epsilon, int  depsilon  )

static

Definition at line 35 of file SkPathOpsTypes.cpp.

                                                                                    {
    int aBits = SkFloatAs2sCompliment(a);
    int bBits = SkFloatAs2sCompliment(b);
    // Find the difference in ULPs.
    return aBits < bBits + epsilon && bBits < aBits + epsilon;
}

equal_ulps_pin()

static bool equal_ulps_pin ( float  a, float  b, int  epsilon, int  depsilon  )

static

Definition at line 42 of file SkPathOpsTypes.cpp.

                                                                        {
    if (!SkIsFinite(a, b)) {
        return false;
    }
    if (arguments_denormalized(a, b, depsilon)) {
        return true;
    }
    int aBits = SkFloatAs2sCompliment(a);
    int bBits = SkFloatAs2sCompliment(b);
    // Find the difference in ULPs.
    return aBits < bBits + epsilon && bBits < aBits + epsilon;
}

less_or_equal_ulps()

static bool less_or_equal_ulps ( float  a, float  b, int  epsilon  )

static

Definition at line 102 of file SkPathOpsTypes.cpp.

                                                              {
    if (arguments_denormalized(a, b, epsilon)) {
        return a < b + FLT_EPSILON * epsilon;
    }
    int aBits = SkFloatAs2sCompliment(a);
    int bBits = SkFloatAs2sCompliment(b);
    // Find the difference in ULPs.
    return aBits < bBits + epsilon;
}

less_ulps()

static bool less_ulps ( float  a, float  b, int  epsilon  )

static

Definition at line 92 of file SkPathOpsTypes.cpp.

                                                     {
    if (arguments_denormalized(a, b, epsilon)) {
        return a <= b - FLT_EPSILON * epsilon;
    }
    int aBits = SkFloatAs2sCompliment(a);
    int bBits = SkFloatAs2sCompliment(b);
    // Find the difference in ULPs.
    return aBits <= bBits - epsilon;
}

not_equal_ulps()

static bool not_equal_ulps ( float  a, float  b, int  epsilon  )

static

Definition at line 62 of file SkPathOpsTypes.cpp.

                                                          {
    if (arguments_denormalized(a, b, epsilon)) {
        return false;
    }
    int aBits = SkFloatAs2sCompliment(a);
    int bBits = SkFloatAs2sCompliment(b);
    // Find the difference in ULPs.
    return aBits >= bBits + epsilon || bBits >= aBits + epsilon;
}

not_equal_ulps_pin()

static bool not_equal_ulps_pin ( float  a, float  b, int  epsilon  )

static

Definition at line 72 of file SkPathOpsTypes.cpp.

                                                              {
    if (!SkIsFinite(a, b)) {
        return false;
    }
    if (arguments_denormalized(a, b, epsilon)) {
        return false;
    }
    int aBits = SkFloatAs2sCompliment(a);
    int bBits = SkFloatAs2sCompliment(b);
    // Find the difference in ULPs.
    return aBits >= bBits + epsilon || bBits >= aBits + epsilon;
}

NotAlmostDequalUlps()

bool NotAlmostDequalUlps	(	float	a,
		float	b
	)

Definition at line 163 of file SkPathOpsTypes.cpp.

                                           {
    const int UlpsEpsilon = 16;
    return d_not_equal_ulps(a, b, UlpsEpsilon);
}

NotAlmostEqualUlps()

bool NotAlmostEqualUlps	(	float	a,
		float	b
	)

Definition at line 153 of file SkPathOpsTypes.cpp.

                                          {
    const int UlpsEpsilon = 16;
    return not_equal_ulps(a, b, UlpsEpsilon);
}

NotAlmostEqualUlps_Pin()

bool NotAlmostEqualUlps_Pin	(	float	a,
		float	b
	)

Definition at line 158 of file SkPathOpsTypes.cpp.

                                              {
    const int UlpsEpsilon = 16;
    return not_equal_ulps_pin(a, b, UlpsEpsilon);
}

RoughlyEqualUlps()

bool RoughlyEqualUlps	(	float	a,
		float	b
	)

Definition at line 168 of file SkPathOpsTypes.cpp.

                                        {
    const int UlpsEpsilon = 256;
    const int DUlpsEpsilon = 1024;
    return equal_ulps(a, b, UlpsEpsilon, DUlpsEpsilon);
}

UlpsDistance()

int UlpsDistance	(	float	a,
		float	b
	)

Definition at line 190 of file SkPathOpsTypes.cpp.

                                   {
    int32_t floatIntA, floatIntB;
    memcpy(&floatIntA, &a, sizeof(int32_t));
    memcpy(&floatIntB, &b, sizeof(int32_t));
    // Different signs means they do not match.
    if ((floatIntA < 0) != (floatIntB < 0)) {
        // Check for equality to make sure +0 == -0
        return a == b ? 0 : SK_MaxS32;
    }
    // Find the difference in ULPs.
    return SkTAbs(floatIntA - floatIntB);
}