ryu/pretty/mod.rs
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 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
mod exponent;
mod mantissa;
use self::exponent::{write_exponent2, write_exponent3};
use self::mantissa::{write_mantissa, write_mantissa_long};
use crate::common;
use crate::d2s::{self, d2d, DOUBLE_EXPONENT_BITS, DOUBLE_MANTISSA_BITS};
use crate::f2s::{f2d, FLOAT_EXPONENT_BITS, FLOAT_MANTISSA_BITS};
use core::ptr;
#[cfg(feature = "no-panic")]
use no_panic::no_panic;
/// Print f64 to the given buffer and return number of bytes written.
///
/// At most 24 bytes will be written.
///
/// ## Special cases
///
/// This function **does not** check for NaN or infinity. If the input
/// number is not a finite float, the printed representation will be some
/// correctly formatted but unspecified numerical value.
///
/// Please check [`is_finite`] yourself before calling this function, or
/// check [`is_nan`] and [`is_infinite`] and handle those cases yourself.
///
/// [`is_finite`]: https://doc.rust-lang.org/std/primitive.f64.html#method.is_finite
/// [`is_nan`]: https://doc.rust-lang.org/std/primitive.f64.html#method.is_nan
/// [`is_infinite`]: https://doc.rust-lang.org/std/primitive.f64.html#method.is_infinite
///
/// ## Safety
///
/// The `result` pointer argument must point to sufficiently many writable bytes
/// to hold Ryū's representation of `f`.
///
/// ## Example
///
/// ```
/// use std::{mem::MaybeUninit, slice, str};
///
/// let f = 1.234f64;
///
/// unsafe {
/// let mut buffer = [MaybeUninit::<u8>::uninit(); 24];
/// let len = ryu::raw::format64(f, buffer.as_mut_ptr() as *mut u8);
/// let slice = slice::from_raw_parts(buffer.as_ptr() as *const u8, len);
/// let print = str::from_utf8_unchecked(slice);
/// assert_eq!(print, "1.234");
/// }
/// ```
#[must_use]
#[cfg_attr(feature = "no-panic", no_panic)]
pub unsafe fn format64(f: f64, result: *mut u8) -> usize {
let bits = f.to_bits();
let sign = ((bits >> (DOUBLE_MANTISSA_BITS + DOUBLE_EXPONENT_BITS)) & 1) != 0;
let ieee_mantissa = bits & ((1u64 << DOUBLE_MANTISSA_BITS) - 1);
let ieee_exponent =
(bits >> DOUBLE_MANTISSA_BITS) as u32 & ((1u32 << DOUBLE_EXPONENT_BITS) - 1);
let mut index = 0isize;
if sign {
*result = b'-';
index += 1;
}
if ieee_exponent == 0 && ieee_mantissa == 0 {
ptr::copy_nonoverlapping(b"0.0".as_ptr(), result.offset(index), 3);
return sign as usize + 3;
}
let v = d2d(ieee_mantissa, ieee_exponent);
let length = d2s::decimal_length17(v.mantissa) as isize;
let k = v.exponent as isize;
let kk = length + k; // 10^(kk-1) <= v < 10^kk
debug_assert!(k >= -324);
if 0 <= k && kk <= 16 {
// 1234e7 -> 12340000000.0
write_mantissa_long(v.mantissa, result.offset(index + length));
for i in length..kk {
*result.offset(index + i) = b'0';
}
*result.offset(index + kk) = b'.';
*result.offset(index + kk + 1) = b'0';
index as usize + kk as usize + 2
} else if 0 < kk && kk <= 16 {
// 1234e-2 -> 12.34
write_mantissa_long(v.mantissa, result.offset(index + length + 1));
ptr::copy(result.offset(index + 1), result.offset(index), kk as usize);
*result.offset(index + kk) = b'.';
index as usize + length as usize + 1
} else if -5 < kk && kk <= 0 {
// 1234e-6 -> 0.001234
*result.offset(index) = b'0';
*result.offset(index + 1) = b'.';
let offset = 2 - kk;
for i in 2..offset {
*result.offset(index + i) = b'0';
}
write_mantissa_long(v.mantissa, result.offset(index + length + offset));
index as usize + length as usize + offset as usize
} else if length == 1 {
// 1e30
*result.offset(index) = b'0' + v.mantissa as u8;
*result.offset(index + 1) = b'e';
index as usize + 2 + write_exponent3(kk - 1, result.offset(index + 2))
} else {
// 1234e30 -> 1.234e33
write_mantissa_long(v.mantissa, result.offset(index + length + 1));
*result.offset(index) = *result.offset(index + 1);
*result.offset(index + 1) = b'.';
*result.offset(index + length + 1) = b'e';
index as usize
+ length as usize
+ 2
+ write_exponent3(kk - 1, result.offset(index + length + 2))
}
}
/// Print f32 to the given buffer and return number of bytes written.
///
/// At most 16 bytes will be written.
///
/// ## Special cases
///
/// This function **does not** check for NaN or infinity. If the input
/// number is not a finite float, the printed representation will be some
/// correctly formatted but unspecified numerical value.
///
/// Please check [`is_finite`] yourself before calling this function, or
/// check [`is_nan`] and [`is_infinite`] and handle those cases yourself.
///
/// [`is_finite`]: https://doc.rust-lang.org/std/primitive.f32.html#method.is_finite
/// [`is_nan`]: https://doc.rust-lang.org/std/primitive.f32.html#method.is_nan
/// [`is_infinite`]: https://doc.rust-lang.org/std/primitive.f32.html#method.is_infinite
///
/// ## Safety
///
/// The `result` pointer argument must point to sufficiently many writable bytes
/// to hold Ryū's representation of `f`.
///
/// ## Example
///
/// ```
/// use std::{mem::MaybeUninit, slice, str};
///
/// let f = 1.234f32;
///
/// unsafe {
/// let mut buffer = [MaybeUninit::<u8>::uninit(); 16];
/// let len = ryu::raw::format32(f, buffer.as_mut_ptr() as *mut u8);
/// let slice = slice::from_raw_parts(buffer.as_ptr() as *const u8, len);
/// let print = str::from_utf8_unchecked(slice);
/// assert_eq!(print, "1.234");
/// }
/// ```
#[must_use]
#[cfg_attr(feature = "no-panic", no_panic)]
pub unsafe fn format32(f: f32, result: *mut u8) -> usize {
let bits = f.to_bits();
let sign = ((bits >> (FLOAT_MANTISSA_BITS + FLOAT_EXPONENT_BITS)) & 1) != 0;
let ieee_mantissa = bits & ((1u32 << FLOAT_MANTISSA_BITS) - 1);
let ieee_exponent = (bits >> FLOAT_MANTISSA_BITS) & ((1u32 << FLOAT_EXPONENT_BITS) - 1);
let mut index = 0isize;
if sign {
*result = b'-';
index += 1;
}
if ieee_exponent == 0 && ieee_mantissa == 0 {
ptr::copy_nonoverlapping(b"0.0".as_ptr(), result.offset(index), 3);
return sign as usize + 3;
}
let v = f2d(ieee_mantissa, ieee_exponent);
let length = common::decimal_length9(v.mantissa) as isize;
let k = v.exponent as isize;
let kk = length + k; // 10^(kk-1) <= v < 10^kk
debug_assert!(k >= -45);
if 0 <= k && kk <= 13 {
// 1234e7 -> 12340000000.0
write_mantissa(v.mantissa, result.offset(index + length));
for i in length..kk {
*result.offset(index + i) = b'0';
}
*result.offset(index + kk) = b'.';
*result.offset(index + kk + 1) = b'0';
index as usize + kk as usize + 2
} else if 0 < kk && kk <= 13 {
// 1234e-2 -> 12.34
write_mantissa(v.mantissa, result.offset(index + length + 1));
ptr::copy(result.offset(index + 1), result.offset(index), kk as usize);
*result.offset(index + kk) = b'.';
index as usize + length as usize + 1
} else if -6 < kk && kk <= 0 {
// 1234e-6 -> 0.001234
*result.offset(index) = b'0';
*result.offset(index + 1) = b'.';
let offset = 2 - kk;
for i in 2..offset {
*result.offset(index + i) = b'0';
}
write_mantissa(v.mantissa, result.offset(index + length + offset));
index as usize + length as usize + offset as usize
} else if length == 1 {
// 1e30
*result.offset(index) = b'0' + v.mantissa as u8;
*result.offset(index + 1) = b'e';
index as usize + 2 + write_exponent2(kk - 1, result.offset(index + 2))
} else {
// 1234e30 -> 1.234e33
write_mantissa(v.mantissa, result.offset(index + length + 1));
*result.offset(index) = *result.offset(index + 1);
*result.offset(index + 1) = b'.';
*result.offset(index + length + 1) = b'e';
index as usize
+ length as usize
+ 2
+ write_exponent2(kk - 1, result.offset(index + length + 2))
}
}