Struct malachite_float::ComparableFloatRef

source · 
pub struct ComparableFloatRef<'a>(pub &'a Float);
Expand description

ComparableFloatRef is a wrapper around a Float, taking the Float be reference.

See the ComparableFloat documentation for details.

Tuple Fields§

§0: &'a Float

Methods from Deref<Target = Float>§

source

pub fn abs_negative_zero_ref(&self) -> Float

If self is negative zero, returns positive zero; otherwise, returns self, taking self by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::{ComparableFloat, Float};

assert_eq!(
    ComparableFloat(Float::NAN.abs_negative_zero_ref()),
    ComparableFloat(Float::NAN)
);
assert_eq!(Float::INFINITY.abs_negative_zero_ref(), Float::INFINITY);
assert_eq!(Float::NEGATIVE_INFINITY.abs_negative_zero_ref(), Float::NEGATIVE_INFINITY);
assert_eq!(
    ComparableFloat(Float::ZERO.abs_negative_zero_ref()),
    ComparableFloat(Float::ZERO)
);
assert_eq!(
    ComparableFloat(Float::NEGATIVE_ZERO.abs_negative_zero_ref()),
    ComparableFloat(Float::ZERO)
);
assert_eq!(Float::ONE.abs_negative_zero_ref(), Float::ONE);
assert_eq!(Float::NEGATIVE_ONE.abs_negative_zero_ref(), Float::NEGATIVE_ONE);
source

pub fn is_nan(&self) -> bool

Determines whether a Float is NaN.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{NaN, One};
use malachite_float::Float;

assert_eq!(Float::NAN.is_nan(), true);
assert_eq!(Float::ONE.is_nan(), false);
source

pub fn is_finite(&self) -> bool

Determines whether a Float is finite.

NaN is not finite.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{Infinity, NaN, One};
use malachite_float::Float;

assert_eq!(Float::NAN.is_finite(), false);
assert_eq!(Float::INFINITY.is_finite(), false);
assert_eq!(Float::ONE.is_finite(), true);
source

pub fn is_infinite(&self) -> bool

Determines whether a Float is infinite.

NaN is not infinite.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{Infinity, NaN, One};
use malachite_float::Float;

assert_eq!(Float::NAN.is_infinite(), false);
assert_eq!(Float::INFINITY.is_infinite(), true);
assert_eq!(Float::ONE.is_infinite(), false);
source

pub fn is_positive_zero(&self) -> bool

Determines whether a Float is positive zero.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.is_positive_zero(), false);
assert_eq!(Float::INFINITY.is_positive_zero(), false);
assert_eq!(Float::ONE.is_positive_zero(), false);
assert_eq!(Float::ZERO.is_positive_zero(), true);
assert_eq!(Float::NEGATIVE_ZERO.is_positive_zero(), false);
source

pub fn is_negative_zero(&self) -> bool

Determines whether a Float is negative zero.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.is_negative_zero(), false);
assert_eq!(Float::INFINITY.is_negative_zero(), false);
assert_eq!(Float::ONE.is_negative_zero(), false);
assert_eq!(Float::ZERO.is_negative_zero(), false);
assert_eq!(Float::NEGATIVE_ZERO.is_negative_zero(), true);
source

pub fn is_zero(&self) -> bool

Determines whether a Float is zero (positive or negative).

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.is_zero(), false);
assert_eq!(Float::INFINITY.is_zero(), false);
assert_eq!(Float::ONE.is_zero(), false);
assert_eq!(Float::ZERO.is_zero(), true);
assert_eq!(Float::NEGATIVE_ZERO.is_zero(), true);
source

pub fn is_normal(&self) -> bool

Determines whether a Float is normal, that is, finite and nonzero.

There is no notion of subnormal Floats.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.is_normal(), false);
assert_eq!(Float::INFINITY.is_normal(), false);
assert_eq!(Float::ZERO.is_normal(), false);
assert_eq!(Float::NEGATIVE_ZERO.is_normal(), false);
assert_eq!(Float::ONE.is_normal(), true);
source

pub fn is_sign_positive(&self) -> bool

Determines whether a Float’s sign is positive.

A NaN has no sign, so this function returns false when given a NaN.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::Float;

assert_eq!(Float::NAN.is_sign_positive(), false);
assert_eq!(Float::INFINITY.is_sign_positive(), true);
assert_eq!(Float::NEGATIVE_INFINITY.is_sign_positive(), false);
assert_eq!(Float::ZERO.is_sign_positive(), true);
assert_eq!(Float::NEGATIVE_ZERO.is_sign_positive(), false);
assert_eq!(Float::ONE.is_sign_positive(), true);
assert_eq!(Float::NEGATIVE_ONE.is_sign_positive(), false);
source

pub fn is_sign_negative(&self) -> bool

Determines whether a Float’s sign is negative.

A NaN has no sign, so this function returns false when given a NaN.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::Float;

assert_eq!(Float::NAN.is_sign_negative(), false);
assert_eq!(Float::INFINITY.is_sign_negative(), false);
assert_eq!(Float::NEGATIVE_INFINITY.is_sign_negative(), true);
assert_eq!(Float::ZERO.is_sign_negative(), false);
assert_eq!(Float::NEGATIVE_ZERO.is_sign_negative(), true);
assert_eq!(Float::ONE.is_sign_negative(), false);
assert_eq!(Float::NEGATIVE_ONE.is_sign_negative(), true);
source

pub fn classify(&self) -> FpCategory

Classifies a Float into one of several categories.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::Float;
use std::num::FpCategory;

assert_eq!(Float::NAN.classify(), FpCategory::Nan);
assert_eq!(Float::INFINITY.classify(), FpCategory::Infinite);
assert_eq!(Float::NEGATIVE_INFINITY.classify(), FpCategory::Infinite);
assert_eq!(Float::ZERO.classify(), FpCategory::Zero);
assert_eq!(Float::NEGATIVE_ZERO.classify(), FpCategory::Zero);
assert_eq!(Float::ONE.classify(), FpCategory::Normal);
assert_eq!(Float::NEGATIVE_ONE.classify(), FpCategory::Normal);
source

pub fn to_non_nan(&self) -> Option<Float>

Turns a NaN into a None and wraps any non-NaN Float with a Some. The Float is taken by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples
use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.to_non_nan(), None);
assert_eq!(Float::INFINITY.to_non_nan(), Some(Float::INFINITY));
assert_eq!(Float::ZERO.to_non_nan(), Some(Float::ZERO));
assert_eq!(Float::NEGATIVE_ZERO.to_non_nan(), Some(Float::NEGATIVE_ZERO));
assert_eq!(Float::ONE.to_non_nan(), Some(Float::ONE));
source

pub fn to_finite(&self) -> Option<Float>

Turns any Float that’s NaN or infinite into a None and wraps any finite Float with a Some. The Float is taken by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples
use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.to_finite(), None);
assert_eq!(Float::INFINITY.to_finite(), None);
assert_eq!(Float::ZERO.to_finite(), Some(Float::ZERO));
assert_eq!(Float::NEGATIVE_ZERO.to_finite(), Some(Float::NEGATIVE_ZERO));
assert_eq!(Float::ONE.to_finite(), Some(Float::ONE));
source

pub fn complexity(&self) -> u64

Determines a Float’s complexity. The complexity is defined as follows:

$$ f(\text{NaN}) = f(\pm\infty) = f(\pm 0.0) = 1, $$

and, if $x$ is finite and nonzero,

$$ f(x) = \max(|\lfloor \log_2 x\rfloor|, p), $$

where $p$ is the precision of $x$.

Informally, the complexity is proportional to the number of characters you would need to write the Float out without using exponents.

See also the Float implementation of SignificantBits.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{NaN, One};
use malachite_float::Float;

assert_eq!(Float::NAN.complexity(), 1);
assert_eq!(Float::ONE.complexity(), 1);
assert_eq!(Float::one_prec(100).complexity(), 100);
assert_eq!(Float::from(std::f64::consts::PI).complexity(), 53);
assert_eq!(Float::power_of_2(100u64).complexity(), 100);
assert_eq!(Float::power_of_2(-100i64).complexity(), 100);
source

pub fn to_significand(&self) -> Option<Natural>

Gets the significand of a Float, taking the Float by value.

The significand is the smallest positive integer which is some power of 2 times the Float, and whose number of significant bits is a multiple of the limb width. If the Float is NaN, infinite, or zero, then None is returned.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.to_significand(), None);
assert_eq!(Float::INFINITY.to_significand(), None);
assert_eq!(Float::ZERO.to_significand(), None);

assert_eq!(Float::ONE.to_significand(), Some(Natural::power_of_2(63)));
assert_eq!(
    Float::from(std::f64::consts::PI).to_significand().unwrap(),
    14488038916154245120u64
);
source

pub fn significand_ref(&self) -> Option<&Natural>

Returns a reference to the significand of a Float.

The significand is the smallest positive integer which is some power of 2 times the Float, and whose number of significant bits is a multiple of the limb width. If the Float is NaN, infinite, or zero, then None is returned.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.significand_ref(), None);
assert_eq!(Float::INFINITY.significand_ref(), None);
assert_eq!(Float::ZERO.significand_ref(), None);

assert_eq!(*Float::ONE.significand_ref().unwrap(), Natural::power_of_2(63));
assert_eq!(
    *Float::from(std::f64::consts::PI).significand_ref().unwrap(),
    14488038916154245120u64
);
source

pub fn get_exponent(&self) -> Option<i64>

Returns a Float’s exponent.

$$ f(\text{NaN}) = f(\pm\infty) = f(\pm 0.0) = \text{None}, $$

and, if $x$ is finite and nonzero,

$$ f(x) = \operatorname{Some}(\lfloor \log_2 x \rfloor + 1). $$

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.get_exponent(), None);
assert_eq!(Float::INFINITY.get_exponent(), None);
assert_eq!(Float::ZERO.get_exponent(), None);

assert_eq!(Float::ONE.get_exponent(), Some(1));
assert_eq!(Float::from(std::f64::consts::PI).get_exponent(), Some(2));
assert_eq!(Float::power_of_2(100u64).get_exponent(), Some(101));
assert_eq!(Float::power_of_2(-100i64).get_exponent(), Some(-99));
source

pub fn get_prec(&self) -> Option<u64>

Returns a Float’s precision. The precision is a positive integer denoting how many of the Float’s bits are significant.

Only Floats that are finite and nonzero have a precision. For other Floats, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples
use malachite_base::num::basic::traits::{Infinity, NaN, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.get_prec(), None);
assert_eq!(Float::INFINITY.get_prec(), None);
assert_eq!(Float::ZERO.get_prec(), None);

assert_eq!(Float::ONE.get_prec(), Some(1));
assert_eq!(Float::one_prec(100).get_prec(), Some(100));
assert_eq!(Float::from(std::f64::consts::PI).get_prec(), Some(53));
source

pub fn ulp(&self) -> Option<Float>

Gets a Float’s ulp (unit in last place, or unit of least precision).

If the Float is positive, its ulp is the distance to the next-largest Float with the same precision; if it is negative, the next-smallest. (This definition works even if the Float is the largest in its binade.)

If the Float is NaN, infinite, or zero, then None is returned.

$$ f(\text{NaN}) = f(\pm\infty) = f(\pm 0.0) = \text{None}, $$

and, if $x$ is finite and nonzero,

$$ f(x) = \operatorname{Some}(2^{\lfloor \log_2 x \rfloor-p+1}), $$ where $p$ is the precision of $x$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples
use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, NegativeOne, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.ulp(), None);
assert_eq!(Float::INFINITY.ulp(), None);
assert_eq!(Float::ZERO.ulp(), None);

let s = Float::ONE.ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("1.0"));

let s = Float::one_prec(100).ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("2.0e-30"));

let s = Float::from(std::f64::consts::PI).ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("4.0e-16"));

let s = Float::power_of_2(100u64).ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("1.0e30"));

let s = Float::power_of_2(-100i64).ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("8.0e-31"));

let s = Float::NEGATIVE_ONE.ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("1.0"));
source

pub fn sci_mantissa_and_exponent_round<T: PrimitiveFloat>( &self, rm: RoundingMode ) -> Option<(T, i64, Ordering)>

Returns a Float’s scientific mantissa and exponent, rounding according to the specified rounding mode. An Ordering is also returned, indicating whether the mantissa and exponent represent a value that is less than, equal to, or greater than the original value.

When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a float. The conversion might not be exact, so we round to the nearest float using the provided rounding mode. If the rounding mode is Exact but the conversion is not exact, None is returned. $$ f(x, r) \approx \left (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor\right ). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use std::cmp::Ordering;

let test = |x: Float, rm: RoundingMode, out: Option<(f32, i64, Ordering)>| {
    assert_eq!(
        x.sci_mantissa_and_exponent_round(rm)
            .map(|(m, e, o)| (NiceFloat(m), e, o)),
        out.map(|(m, e, o)| (NiceFloat(m), e, o))
    );
};
test(Float::from(3u32), RoundingMode::Floor, Some((1.5, 1, Ordering::Equal)));
test(Float::from(3u32), RoundingMode::Down, Some((1.5, 1, Ordering::Equal)));
test(Float::from(3u32), RoundingMode::Ceiling, Some((1.5, 1, Ordering::Equal)));
test(Float::from(3u32), RoundingMode::Up, Some((1.5, 1, Ordering::Equal)));
test(Float::from(3u32), RoundingMode::Nearest, Some((1.5, 1, Ordering::Equal)));
test(Float::from(3u32), RoundingMode::Exact, Some((1.5, 1, Ordering::Equal)));

let x = Float::from(std::f64::consts::PI);
test(x.clone(), RoundingMode::Floor, Some((1.5707963, 1, Ordering::Less)));
test(x.clone(), RoundingMode::Down, Some((1.5707963, 1, Ordering::Less)));
test(x.clone(), RoundingMode::Ceiling, Some((1.5707964, 1, Ordering::Greater)));
test(x.clone(), RoundingMode::Up, Some((1.5707964, 1, Ordering::Greater)));
test(x.clone(), RoundingMode::Nearest, Some((1.5707964, 1, Ordering::Greater)));
test(x.clone(), RoundingMode::Exact, None);

test(
    Float::from(1000000000u32),
    RoundingMode::Nearest,
    Some((1.8626451, 29, Ordering::Equal)),
);
test(
    Float::from(Natural::from(10u32).pow(52)),
    RoundingMode::Nearest,
    Some((1.670478, 172, Ordering::Greater)),
);

test(Float::from(Natural::from(10u32).pow(52)), RoundingMode::Exact, None);

Trait Implementations§

source§

impl<'a> Clone for ComparableFloatRef<'a>

source§

fn clone(&self) -> ComparableFloatRef<'a>

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl<'a> Debug for ComparableFloatRef<'a>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<'a> Deref for ComparableFloatRef<'a>

source§

fn deref(&self) -> &Float

Allows a ComparableFloatRef to dereference to a Float.

use malachite_base::num::basic::traits::One;
use malachite_float::{ComparableFloatRef, Float};

let x = Float::ONE;
let y = ComparableFloatRef(&x);
assert_eq!(*y, Float::ONE);
§

type Target = Float

The resulting type after dereferencing.
source§

impl<'a> Display for ComparableFloatRef<'a>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl<'a> Hash for ComparableFloatRef<'a>

source§

fn hash<H: Hasher>(&self, state: &mut H)

Computes a hash of a ComparableFloatRef.

The hash is compatible with ComparableFloatRef equality: all NaNs hash to the same value.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl<'a> LowerHex for ComparableFloatRef<'a>

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.
source§

impl<'a> Ord for ComparableFloatRef<'a>

source§

fn cmp(&self, other: &ComparableFloatRef<'a>) -> Ordering

Compares two ComparableFloatRefs.

This implementation does not follow the IEEE 754 standard. This is how ComparableFloatRefs are ordered, least to greatest:

  • Negative infinity
  • Negative nonzero finite floats
  • Negative zero
  • NaN
  • Positive zero
  • Positive nonzero finite floats
  • Positive infinity

For different comparison behavior that follows the IEEE 754 standard, consider just using Float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, OneHalf, Zero
};
use malachite_float::{ComparableFloatRef, Float};
use std::cmp::Ordering;
use std::str::FromStr;

assert_eq!(
    ComparableFloatRef(&Float::NAN).partial_cmp(&ComparableFloatRef(&Float::NAN)),
    Some(Ordering::Equal)
);
assert!(ComparableFloatRef(&Float::ZERO) > ComparableFloatRef(&Float::NEGATIVE_ZERO));
assert!(ComparableFloatRef(&Float::ONE) < ComparableFloatRef(&Float::one_prec(100)));
assert!(ComparableFloatRef(&Float::INFINITY) > ComparableFloatRef(&Float::ONE));
assert!(ComparableFloatRef(&Float::NEGATIVE_INFINITY) < ComparableFloatRef(&Float::ONE));
assert!(ComparableFloatRef(&Float::ONE_HALF) < ComparableFloatRef(&Float::ONE));
assert!(ComparableFloatRef(&Float::ONE_HALF) > ComparableFloatRef(&Float::NEGATIVE_ONE));
1.21.0 · source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl<'a> OrdAbs for ComparableFloatRef<'a>

source§

fn cmp_abs(&self, other: &ComparableFloatRef<'a>) -> Ordering

Compares the absolute values of two ComparableFloatRefs.

This implementation does not follow the IEEE 754 standard. This is how ComparableFloatRefs are ordered by absolute value, from least to greatest:

  • NaN
  • Positive and negative zero
  • Nonzero finite floats
  • Positive and negative infinity

For different comparison behavior that follows the IEEE 754 standard, consider just using Float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, OneHalf, Zero
};
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_float::{ComparableFloatRef, Float};
use std::cmp::Ordering;
use std::str::FromStr;

assert_eq!(
    ComparableFloatRef(&Float::NAN).partial_cmp_abs(&ComparableFloatRef(&Float::NAN)),
    Some(Ordering::Equal)
);
assert_eq!(
    ComparableFloatRef(&Float::ZERO)
        .partial_cmp_abs(&ComparableFloatRef(&Float::NEGATIVE_ZERO)),
    Some(Ordering::Equal)
);
assert!(ComparableFloatRef(&Float::ONE).lt_abs(&ComparableFloatRef(&Float::one_prec(100))));
assert!(ComparableFloatRef(&Float::INFINITY).gt_abs(&ComparableFloatRef(&Float::ONE)));
assert!(
    ComparableFloatRef(&Float::NEGATIVE_INFINITY).gt_abs(&ComparableFloatRef(&Float::ONE))
);
assert!(ComparableFloatRef(&Float::ONE_HALF).lt_abs(&ComparableFloatRef(&Float::ONE)));
assert!(
    ComparableFloatRef(&Float::ONE_HALF).lt_abs(&ComparableFloatRef(&Float::NEGATIVE_ONE))
);
source§

impl<'a, 'b> PartialEq<ComparableFloatRef<'b>> for ComparableFloatRef<'a>

source§

fn eq(&self, other: &ComparableFloatRef<'b>) -> bool

Compares two ComparableFloatRefs for equality.

This implementation ignores the IEEE 754 standard in favor of an equality operation that respects the expected properties of symmetry, reflexivity, and transitivity. Using ComparableFloatRef, NaNs are equal to themselves. There is a single, unique NaN; there’s no concept of signalling NaNs. Positive and negative zero are two distinct values, not equal to each other. ComparableFloatRefs with different precisions are unequal.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples
use malachite_base::num::basic::traits::{NaN, NegativeZero, One, Two, Zero};
use malachite_float::{ComparableFloatRef, Float};

assert_eq!(ComparableFloatRef(&Float::NAN), ComparableFloatRef(&Float::NAN));
assert_eq!(ComparableFloatRef(&Float::ZERO), ComparableFloatRef(&Float::ZERO));
assert_eq!(
    ComparableFloatRef(&Float::NEGATIVE_ZERO),
    ComparableFloatRef(&Float::NEGATIVE_ZERO)
);
assert_ne!(ComparableFloatRef(&Float::ZERO), ComparableFloatRef(&Float::NEGATIVE_ZERO));

assert_eq!(ComparableFloatRef(&Float::ONE), ComparableFloatRef(&Float::ONE));
assert_ne!(ComparableFloatRef(&Float::ONE), ComparableFloatRef(&Float::TWO));
assert_ne!(ComparableFloatRef(&Float::ONE), ComparableFloatRef(&Float::one_prec(100)));
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<'a> PartialOrd for ComparableFloatRef<'a>

source§

fn partial_cmp(&self, other: &ComparableFloatRef<'_>) -> Option<Ordering>

Compares two ComparableFloatRefs.

See the documentation for the Ord implementation.

1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl<'a> PartialOrdAbs for ComparableFloatRef<'a>

source§

fn partial_cmp_abs(&self, other: &ComparableFloatRef<'_>) -> Option<Ordering>

Compares the absolute values of two ComparableFloatRefs.

See the documentation for the Ord implementation.

source§

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another. Read more
source§

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
source§

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another. Read more
source§

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another. Read more
source§

impl<'a> Eq for ComparableFloatRef<'a>

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T, U> ExactFrom<T> for U
where U: TryFrom<T>,

source§

fn exact_from(value: T) -> U

source§

impl<T, U> ExactInto<U> for T
where U: ExactFrom<T>,

source§

fn exact_into(self) -> U

source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> OverflowingInto<U> for T
where U: OverflowingFrom<T>,

source§

fn overflowing_into(self) -> (U, bool)

source§

impl<T, U> RoundingInto<U> for T
where U: RoundingFrom<T>,

source§

fn rounding_into(self, rm: RoundingMode) -> (U, Ordering)

source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T, U> SaturatingInto<U> for T
where U: SaturatingFrom<T>,

source§

fn saturating_into(self) -> U

source§

impl<T> ToDebugString for T
where T: Debug,

source§

fn to_debug_string(&self) -> String

Returns the String produced by Ts Debug implementation.

Examples
use malachite_base::strings::ToDebugString;

assert_eq!([1, 2, 3].to_debug_string(), "[1, 2, 3]");
assert_eq!(
    [vec![2, 3], vec![], vec![4]].to_debug_string(),
    "[[2, 3], [], [4]]"
);
assert_eq!(Some(5).to_debug_string(), "Some(5)");
source§

impl<T> ToLowerHexString for T
where T: LowerHex,

source§

fn to_lower_hex_string(&self) -> String

Returns the String produced by Ts LowerHex implementation.

Examples
use malachite_base::strings::ToLowerHexString;

assert_eq!(50u64.to_lower_hex_string(), "32");
assert_eq!((-100i16).to_lower_hex_string(), "ff9c");
source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for T
where T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

source§

impl<T, U> WrappingInto<U> for T
where U: WrappingFrom<T>,

source§

fn wrapping_into(self) -> U