//! Utilities to compare floating-point numbers.

use float_cmp::ApproxEq;

// The following are copied from cairo/src/{cairo-fixed-private.h,

// cairo-fixed-type-private.h}

const CAIRO_FIXED_FRAC_BITS: u64 = 8;

const CAIRO_MAGIC_NUMBER_FIXED: f64 = (1u64 << (52 - CAIRO_FIXED_FRAC_BITS)) as f64 * 1.5;

const CAIRO_FIXED_MAX: i32 = i32::MAX;

const CAIRO_FIXED_MIN: i32 = i32::MIN;

/// The double that corresponds to (the number one in fixed-point representation)

const CAIRO_FIXED_ONE_DOUBLE: f64 = (1 << CAIRO_FIXED_FRAC_BITS) as f64;

/// The largest representable fixed-point number, as a double.  This is a bit over 8 million.

pub const CAIRO_FIXED_MAX_DOUBLE: f64 = (CAIRO_FIXED_MAX as f64) / CAIRO_FIXED_ONE_DOUBLE;

/// The most negative representable fixed-point number, as a double.  This is a bit less than -8 million.

pub const CAIRO_FIXED_MIN_DOUBLE: f64 = (CAIRO_FIXED_MIN as f64) / CAIRO_FIXED_ONE_DOUBLE;

/// Implements a method to check whether two `f64` numbers would have

/// the same fixed-point representation in Cairo.

///

/// This generally means that the absolute difference between them,

/// when taken as floating-point numbers, is less than the smallest

/// representable fraction that Cairo can represent in fixed-point.

///

/// Implementation detail: Cairo fixed-point numbers use 24 bits for

/// the integral part, and 8 bits for the fractional part.  That is,

/// the smallest fraction they can represent is 1/256.

pub trait FixedEqCairo {

    #[allow(dead_code)] // https://github.com/rust-lang/rust/issues/120770

    fn fixed_eq_cairo(&self, other: &Self) -> bool;

}

impl FixedEqCairo for f64 {

        // FIXME: Here we have the same problem as Cairo itself: we

        // don't check for overflow in the conversion of double to

        // fixed-point.

}

/// Checks whether two floating-point numbers are approximately equal,

/// considering Cairo's limitations on numeric representation.

///

/// Cairo uses fixed-point numbers internally.  We implement this

/// trait for `f64`, so that two numbers can be considered "close

/// enough to equal" if their absolute difference is smaller than the

/// smallest fixed-point fraction that Cairo can represent.

///

/// Note that this trait is reliable even if the given numbers are

/// outside of the range that Cairo's fixed-point numbers can

/// represent.  In that case, we check for the absolute difference,

/// and finally allow a difference of 1 unit-in-the-last-place (ULP)

/// for very large f64 values.

pub trait ApproxEqCairo: ApproxEq {

    fn approx_eq_cairo(self, other: Self) -> bool;

}

impl ApproxEqCairo for f64 {

}

// Macro for usage in unit tests

#[doc(hidden)]

#[macro_export]

macro_rules! assert_approx_eq_cairo {

    ($left:expr, $right:expr) => {{

        match ($left, $right) {

                        r#"assertion failed: `(left == right)`

  left: `{:?}`,

 right: `{:?}`"#,

                        l, r

                    )

                }

            }

        }

    }};

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    #[test]

        // 0 == 1/256 - cairo can represent it, so not equal

        // 1 == 1 + 1/256 - cairo can represent it, so not equal

        // 0 == 1/256 - cairo can represent it, so not equal

        // 1 == 1 - 1/256 - cairo can represent it, so not equal

        // 0 == 1/512 - cairo approximates to 0, so equal

        // 1 == 1 + 1/512 - cairo approximates to 1, so equal

        // 0 == -1/512 - cairo approximates to 0, so equal

        // 1 == 1 - 1/512 - cairo approximates to 1, so equal

        // This is 2^53 compared to (2^53 + 2).  When represented as

        // f64, they are 1 unit-in-the-last-place (ULP) away from each

        // other, since the mantissa has 53 bits (52 bits plus 1

        // "hidden" bit).  The first number is an exact double, and

        // the second one is the next biggest double.  We consider a

        // difference of 1 ULP to mean that numbers are "equal", to

        // account for slight imprecision in floating-point

        // calculations.  Most of the time, for small values, we will

        // be using the cairo_smallest_fraction from the

        // implementation of approx_eq_cairo() above.  For large

        // values, we want the ULPs.

        //

        // In the second assertion, we compare 2^53 with (2^53 + 4).  Those are

        // 2 ULPs away, and we don't consider them equal.

    #[test]

        assert_approx_eq_cairo!(42_f64, 42_f64);

    #[test]

    #[should_panic]

        assert_approx_eq_cairo!(3_f64, 42_f64);

}