src/base/SkFloatingPoint.cpp

/*
 * Copyright 2023 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "include/private/base/SkFloatingPoint.h"

#include "include/private/base/SkAssert.h"

#include <cmath>

static inline int64_t double_to_twos_complement_bits(double x) {
    // Convert a double to its bit pattern
    int64_t bits = 0;
    static_assert(sizeof(x) == sizeof(bits));
    std::memcpy(&bits, &x, sizeof(bits));
    // Convert a sign-bit int (i.e. double interpreted as int) into a 2s complement
    // int. This also converts -0 (0x8000000000000000) to 0. Doing this to a double allows
    // it to be compared using normal C operators (<, <=, etc.)
    if (bits < 0) {
        bits &= 0x7FFFFFFFFFFFFFFF;
        bits = -bits;
    }
    return bits;
}

// Arbitrarily chosen.
constexpr static double sk_double_epsilon = 0.0000000001;

bool sk_doubles_nearly_equal_ulps(double a, double b, uint8_t max_ulps_diff) {
    // If both of these are zero (or very close), then using Units of Least Precision
    // will not be accurate and we should use sk_double_nearly_zero instead.
    SkASSERT(!(fabs(a) < sk_double_epsilon && fabs(b) < sk_double_epsilon));
    // This algorithm does not work if both inputs are NaN.
    SkASSERT(!(std::isnan(a) && std::isnan(b)));
    // If both inputs are infinity (or actually equal), this catches it.
    if (a == b) {
        return true;
    }
    int64_t aBits = double_to_twos_complement_bits(a);
    int64_t bBits = double_to_twos_complement_bits(b);

    // Find the difference in Units of Least Precision (ULPs).
    return aBits < bBits + max_ulps_diff && bBits < aBits + max_ulps_diff;
}

bool sk_double_nearly_zero(double a) {
    return a == 0 || fabs(a) < sk_double_epsilon;
}