Struct LispFloat

pub(crate) struct LispFloat(GcHeap<f64>);

A wrapper type for floats to work around issues with Eq. Rust only allows types to be used in match statements if they derive Eq. Even if you never actually use that field in a match. So we need a float wrapper that implements that trait.

Tuple Fields

0: GcHeap<f64>

Implementations

impl LispFloat

pub fn new(float: f64, constant: bool) -> Self

Methods from Deref<Target = f64>

pub const RADIX: u32 = 2u32

pub const MANTISSA_DIGITS: u32 = 53u32

pub const DIGITS: u32 = 15u32

pub const EPSILON: f64 = 2.2204460492503131E-16f64

pub const MIN: f64 = -1.7976931348623157E+308f64

pub const MIN_POSITIVE: f64 = 2.2250738585072014E-308f64

pub const MAX: f64 = 1.7976931348623157E+308f64

pub const MIN_EXP: i32 = -1_021i32

pub const MAX_EXP: i32 = 1_024i32

pub const MIN_10_EXP: i32 = -307i32

pub const MAX_10_EXP: i32 = 308i32

pub const NAN: f64 = NaN_f64

pub const INFINITY: f64 = +Inf_f64

pub const NEG_INFINITY: f64 = -Inf_f64

pub fn total_cmp(&self, other: &f64) -> Ordering

Returns the ordering between self and other.

Unlike the standard partial comparison between floating point numbers, this comparison always produces an ordering in accordance to the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard. The values are ordered in the following sequence:

• negative quiet NaN
• negative signaling NaN
• negative infinity
• negative numbers
• negative subnormal numbers
• negative zero
• positive zero
• positive subnormal numbers
• positive numbers
• positive infinity
• positive signaling NaN
• positive quiet NaN.

The ordering established by this function does not always agree with the PartialOrd and PartialEq implementations of f64. For example, they consider negative and positive zero equal, while total_cmp doesn’t.

The interpretation of the signaling NaN bit follows the definition in the IEEE 754 standard, which may not match the interpretation by some of the older, non-conformant (e.g. MIPS) hardware implementations.

Example

struct GoodBoy {
    name: String,
    weight: f64,
}

let mut bois = vec![
    GoodBoy { name: "Pucci".to_owned(), weight: 0.1 },
    GoodBoy { name: "Woofer".to_owned(), weight: 99.0 },
    GoodBoy { name: "Yapper".to_owned(), weight: 10.0 },
    GoodBoy { name: "Chonk".to_owned(), weight: f64::INFINITY },
    GoodBoy { name: "Abs. Unit".to_owned(), weight: f64::NAN },
    GoodBoy { name: "Floaty".to_owned(), weight: -5.0 },
];

bois.sort_by(|a, b| a.weight.total_cmp(&b.weight));

// `f64::NAN` could be positive or negative, which will affect the sort order.
if f64::NAN.is_sign_negative() {
    assert!(bois.into_iter().map(|b| b.weight)
        .zip([f64::NAN, -5.0, 0.1, 10.0, 99.0, f64::INFINITY].iter())
        .all(|(a, b)| a.to_bits() == b.to_bits()))
} else {
    assert!(bois.into_iter().map(|b| b.weight)
        .zip([-5.0, 0.1, 10.0, 99.0, f64::INFINITY, f64::NAN].iter())
        .all(|(a, b)| a.to_bits() == b.to_bits()))
}

Trait Implementations

impl<'new> CloneIn<'new, &'new LispFloat> for LispFloat

fn clone_in<const C: bool>(&self, bk: &'new Block<C>) -> Gc<&'new Self>

impl Debug for LispFloat

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

Formats the value using the given formatter.

impl Deref for LispFloat

type Target = f64

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for LispFloat

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

Formats the value using the given formatter.

impl<'ob> From<&LispFloat> for Gc<NumberType<'ob>>

fn from(x: &LispFloat) -> Self

Converts to this type from the input type.

impl<'ob> From<&'ob LispFloat> for Gc<ObjectType<'ob>>

fn from(x: &'ob LispFloat) -> Self

Converts to this type from the input type.

impl GcMoveable for LispFloat

type Value = NonNull<LispFloat>

fn move_value(&self, to_space: &Bump) -> Option<(Self::Value, bool)>

impl PartialEq for LispFloat

fn eq(&self, other: &LispFloat) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RootedDeref for LispFloat

type Target = RootedLispFloat

fn rooted_deref(rooted: &Rt<Self>) -> &Self::Target

fn rooted_derefmut(rooted: &mut Rt<Self>) -> &mut Self::Target

impl TaggedPtr for &LispFloat

const TAG: Tag = Tag::Float

Tag value. This is only applicable to base values. Use Int for sum types.

type Ptr = LispFloat

The type of object being pointed to. This will be different for all implementors.

unsafe fn from_obj_ptr(ptr: *const u8) -> Self

Given an untyped pointer, reinterpret to self.

fn get_ptr(self) -> *const Self::Ptr

Get the underlying pointer.

unsafe fn tag_ptr(ptr: *const Self::Ptr) -> Gc<Self>

Given a pointer to Ptr return a Tagged pointer.

fn untag(val: Gc<Self>) -> Self

Remove the tag from the Gc<T> and return the inner type. If it is base type then it will only have a single possible value and can be untagged without checks, but sum types need to create all values they can hold. We use tagged base types to let us reinterpret bits without actually modify them.

fn tag(self) -> Gc<Self>

Given the type, return a tagged version of it. When using a sum type or an immediate value like i64, we override this method to set the proper tag.

impl Trace for LispFloat

fn trace(&self, state: &mut GcState)

impl<'ob> TryFrom<Gc<ObjectType<'ob>>> for &'ob LispFloat

type Error = TypeError

The type returned in the event of a conversion error.

fn try_from(obj: Gc<ObjectType<'ob>>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'old, 'new> WithLifetime<'new> for &'old LispFloat

type Out = &'new LispFloat

unsafe fn with_lifetime(self) -> Self::Out

impl Eq for LispFloat

impl GcPtr for &LispFloat

impl StructuralPartialEq for LispFloat