lexical-write-float 1.0.6

Efficient formatting of floats to strings.
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

//! Implements the algorithm in terms of the lexical API.

#![doc(hidden)]

#[cfg(feature = "f16")]
use lexical_util::bf16::bf16;
#[cfg(feature = "f16")]
use lexical_util::f16::f16;
use lexical_util::format::STANDARD;
use lexical_util::{to_lexical, to_lexical_with_options};

use crate::options::Options;
use crate::write::WriteFloat;

// API

const DEFAULT_OPTIONS: Options = Options::new();

// Implement `ToLexical` for numeric type.
macro_rules! float_to_lexical {
    ($($t:tt ; )*) => ($(
        impl ToLexical for $t {
            #[cfg_attr(not(feature = "compact"), inline)]
            fn to_lexical(self, bytes: &mut [u8])
                -> &mut [u8]
            {
                let count = self.write_float::<{ STANDARD }>(bytes, &DEFAULT_OPTIONS);
                &mut bytes[..count]
            }
        }

        impl ToLexicalWithOptions for $t {
            type Options = Options;
            #[cfg_attr(not(feature = "compact"), inline)]
            fn to_lexical_with_options<'a, const FORMAT: u128>(
                self,
                bytes: &'a mut [u8],
                options: &Self::Options,
            ) -> &'a mut [u8]
            {
                let count = self.write_float::<{ FORMAT }>(bytes, &options);
                &mut bytes[..count]
            }
        }
    )*)
}

to_lexical!("lexical_write_float", 1.234, f64);
to_lexical_with_options!("lexical_write_float", 1.234, f64, Options);
float_to_lexical! {
    f32 ;
    f64 ;
}
#[cfg(feature = "f16")]
float_to_lexical! {
    f16 ;
    bf16 ;
}