nanval 0.2.1

A no_std, zero-dependency crate for the creation and handling of NaN-tagged 64-bit floating-point values.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Trait for functions that can accept any sized+copy 64-bit value.
use super::cons::*;

/// Trait for functions that accept any 64-bit value, used throughout this crate.
/// 
/// Since the trait is only `impl`d as the input of functions,
/// monomorphization will cause a N×M relation of structs implementing this trait,
/// with the various functions consuming this trait; at the time of writing this,
/// that would be `5×19`, yielding `95` functions for rustc to emit... which is acceptable.
/// 
/// **Note:** It is *highly* recommended to refer to this traits methods in static-form; ie: `IntoRawBits64::XXX`.
pub trait IntoRawBits64: Copy + Clone + Sized {
    /// Returns the raw bits that `self` contains.
    fn as_raw_bits_64(&self) -> u64;
    
    /// Returns the raw bits that `self` contains, but without the sign-bit.
    #[inline(always)]
    fn as_raw_bits_64_without_sign(&self) -> u64 {
        self.as_raw_bits_64() & !SIGN_BIT
    }
    
    /// Checks if the value is a floating point number.
    #[inline(always)]
    fn is_float(&self) -> bool {
        crate::is_float(*self)
    }
    
    /// Checks if the value is a NaN-tagged value.
    #[inline(always)]
    fn is_nanval(&self) -> bool {
        crate::is_nanval(*self)
    }
    
    /// Checks if the value is a floating point number representing infinity.
    #[inline(always)]
    fn is_nan(&self) -> bool {
        self.as_raw_bits_64() == NAN_BITS
    }
    
    /// Checks if the value is a floating point number representing infinity.
    #[inline(always)]
    fn is_infinity(&self) -> bool {
        self.as_raw_bits_64_without_sign() == POS_INF_BITS
    }
    
    /// Checks if the value is a floating point number representing positive infinity.
    #[inline(always)]
    fn is_positive_infinity(&self) -> bool {
        self.as_raw_bits_64() == POS_INF_BITS
    }
    
    /// Checks if the value is a floating point number representing negative infinity.
    #[inline(always)]
    fn is_negative_infinity(&self) -> bool {
        self.as_raw_bits_64() == NEG_INF_BITS
    }
    
    /// Returns the value as a floating point number, checking if it is one.
    #[inline(always)]
    fn unwrap_float(&self) -> Option<f64> {
        crate::unwrap_float(self.as_raw_bits_64())
    }
    
    /// Returns the value as a floating point number, *without* checking if it is one.
    #[inline(always)]
    fn unwrap_float_unchecked(&self) -> f64 {
        crate::unwrap_float_unchecked(self.as_raw_bits_64())
    }
}

impl IntoRawBits64 for [core::primitive::u8; 8] {
    #[inline(always)]
    fn as_raw_bits_64(&self) -> u64 {
        core::primitive::u64::from_ne_bytes(*self)
    }
}

impl IntoRawBits64 for core::primitive::f64 {
    #[inline(always)]
    fn as_raw_bits_64(&self) -> u64 {
        self.to_bits()
    }
    
    #[inline(always)]
    fn unwrap_float_unchecked(&self) -> f64 {
        *self
    }
}

impl IntoRawBits64 for core::primitive::u64 {
    #[inline(always)]
    fn as_raw_bits_64(&self) -> u64 {
        *self
    }
}

impl IntoRawBits64 for core::num::NonZeroU64 {
    #[inline(always)]
    fn as_raw_bits_64(&self) -> u64 {
        self.get()
    }
}

impl IntoRawBits64 for &[core::primitive::u8] {
    #[inline(always)]
    fn as_raw_bits_64(&self) -> u64 {
        match self.len() >= 8 {
            true => {
                let bytes = self[0..=3].try_into().unwrap();
                core::primitive::u64::from_ne_bytes(bytes)
            },
            false => panic!("not enough bytes to transmute into a u64")
        }
    }
}