Skip to content

Commit 0d2876e

Browse files
tgross35tgross35
committed
float: Add f16 parsing and printing
1 parent 4f305a3 commit 0d2876e

File tree

11 files changed

+352
-17
lines changed

11 files changed

+352
-17
lines changed

‎library/core/src/fmt/float.rs

+2-8
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ macro_rules! impl_general_format {
2020
}
2121
}
2222

23+
impl_general_format! { f16 }
2324
impl_general_format! { f32 f64 }
2425

2526
// Don't inline this so callers don't use the stack space this function
@@ -227,17 +228,10 @@ macro_rules! floating {
227228
};
228229
}
229230

231+
floating! { f16 }
230232
floating! { f32 }
231233
floating! { f64 }
232234

233-
#[stable(feature = "rust1", since = "1.0.0")]
234-
impl Debug for f16 {
235-
#[inline]
236-
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
237-
write!(f, "{:#06x}", self.to_bits())
238-
}
239-
}
240-
241235
#[stable(feature = "rust1", since = "1.0.0")]
242236
impl Debug for f128 {
243237
#[inline]

‎library/core/src/num/dec2flt/float.rs

+42
Original file line numberDiff line numberDiff line change
@@ -193,6 +193,48 @@ pub trait RawFloat:
193193
}
194194
}
195195

196+
impl RawFloat for f16 {
197+
type Int = u16;
198+
199+
const INFINITY: Self = Self::INFINITY;
200+
const NEG_INFINITY: Self = Self::NEG_INFINITY;
201+
const NAN: Self = Self::NAN;
202+
const NEG_NAN: Self = -Self::NAN;
203+
204+
const BITS: u32 = 16;
205+
const MANTISSA_BITS: u32 = Self::MANTISSA_DIGITS;
206+
const EXPONENT_MASK: Self::Int = Self::EXP_MASK;
207+
const MANTISSA_MASK: Self::Int = Self::MAN_MASK;
208+
209+
const MIN_EXPONENT_ROUND_TO_EVEN: i32 = -22;
210+
const MAX_EXPONENT_ROUND_TO_EVEN: i32 = 5;
211+
212+
#[inline]
213+
fn from_u64(v: u64) -> Self {
214+
debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
215+
v as _
216+
}
217+
218+
#[inline]
219+
fn from_u64_bits(v: u64) -> Self {
220+
Self::from_bits((v & 0xFF) as u16)
221+
}
222+
223+
fn pow10_fast_path(exponent: usize) -> Self {
224+
#[allow(clippy::use_self)]
225+
const TABLE: [f16; 8] = [1e0, 1e1, 1e2, 1e3, 1e4, 0.0, 0.0, 0.];
226+
TABLE[exponent & 15]
227+
}
228+
229+
fn to_bits(self) -> Self::Int {
230+
self.to_bits()
231+
}
232+
233+
fn classify(self) -> FpCategory {
234+
self.classify()
235+
}
236+
}
237+
196238
impl RawFloat for f32 {
197239
type Int = u32;
198240

‎library/core/src/num/dec2flt/mod.rs

+2
Original file line numberDiff line numberDiff line change
@@ -171,6 +171,8 @@ macro_rules! from_str_float_impl {
171171
}
172172
};
173173
}
174+
175+
from_str_float_impl!(f16);
174176
from_str_float_impl!(f32);
175177
from_str_float_impl!(f64);
176178

‎library/core/src/num/flt2dec/decoder.rs

+6
Original file line numberDiff line numberDiff line change
@@ -45,6 +45,12 @@ pub trait DecodableFloat: RawFloat + Copy {
4545
fn min_pos_norm_value() -> Self;
4646
}
4747

48+
impl DecodableFloat for f16 {
49+
fn min_pos_norm_value() -> Self {
50+
f16::MIN_POSITIVE
51+
}
52+
}
53+
4854
impl DecodableFloat for f32 {
4955
fn min_pos_norm_value() -> Self {
5056
f32::MIN_POSITIVE

‎library/core/tests/lib.rs

+1
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,7 @@
5151
#![feature(error_generic_member_access)]
5252
#![feature(exact_size_is_empty)]
5353
#![feature(extern_types)]
54+
#![feature(f16)]
5455
#![feature(float_minimum_maximum)]
5556
#![feature(flt2dec)]
5657
#![feature(fmt_internals)]

‎library/core/tests/num/dec2flt/float.rs

+16
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,21 @@
11
use core::num::dec2flt::float::RawFloat;
22

3+
#[test]
4+
fn test_f16_integer_decode() {
5+
assert_eq!(3.14159265359f16.integer_decode(), (1608, -9, 1));
6+
assert_eq!((-8573.5918555f16).integer_decode(), (1072, 3, -1));
7+
assert_eq!(2f16.powf(4.0).integer_decode(), (1024, -6, 1));
8+
assert_eq!(0f16.integer_decode(), (0, -25, 1));
9+
assert_eq!((-0f16).integer_decode(), (0, -25, -1));
10+
assert_eq!(f16::INFINITY.integer_decode(), (1024, 6, 1));
11+
assert_eq!(f16::NEG_INFINITY.integer_decode(), (1024, 6, -1));
12+
13+
// Ignore the "sign" (quiet / signalling flag) of NAN.
14+
// It can vary between runtime operations and LLVM folding.
15+
let (nan_m, nan_p, _nan_s) = f16::NAN.integer_decode();
16+
assert_eq!((nan_m, nan_p), (1536, 6));
17+
}
18+
319
#[test]
420
fn test_f32_integer_decode() {
521
assert_eq!(3.14159265359f32.integer_decode(), (13176795, -22, 1));

‎library/core/tests/num/dec2flt/lemire.rs

+24
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,10 @@
11
use core::num::dec2flt::lemire::compute_float;
22

3+
// fn compute_float16(q: i64, w: u64) -> (i32, u64) {
4+
// let fp = compute_float::<f16>(q, w);
5+
// (fp.p_biased, fp.m)
6+
// }
7+
38
fn compute_float32(q: i64, w: u64) -> (i32, u64) {
49
let fp = compute_float::<f32>(q, w);
510
(fp.p_biased, fp.m)
@@ -10,6 +15,25 @@ fn compute_float64(q: i64, w: u64) -> (i32, u64) {
1015
(fp.p_biased, fp.m)
1116
}
1217

18+
// #[test]
19+
// fn compute_float_f16_rounding() {
20+
// // These test near-halfway cases for single-precision floats.
21+
// assert_eq!(compute_float16(0, 16777216), (151, 0));
22+
// assert_eq!(compute_float16(0, 16777217), (151, 0));
23+
// assert_eq!(compute_float16(0, 16777218), (151, 1));
24+
// assert_eq!(compute_float16(0, 16777219), (151, 2));
25+
// assert_eq!(compute_float16(0, 16777220), (151, 2));
26+
27+
// // These are examples of the above tests, with
28+
// // digits from the exponent shifted to the mantissa.
29+
// assert_eq!(compute_float16(-10, 167772160000000000), (151, 0));
30+
// assert_eq!(compute_float16(-10, 167772170000000000), (151, 0));
31+
// assert_eq!(compute_float16(-10, 167772180000000000), (151, 1));
32+
// // Let's check the lines to see if anything is different in table...
33+
// assert_eq!(compute_float16(-10, 167772190000000000), (151, 2));
34+
// assert_eq!(compute_float16(-10, 167772200000000000), (151, 2));
35+
// }
36+
1337
#[test]
1438
fn compute_float_f32_rounding() {
1539
// These test near-halfway cases for single-precision floats.

‎library/core/tests/num/dec2flt/mod.rs

+136-4
Original file line numberDiff line numberDiff line change
@@ -11,19 +11,92 @@ mod parse;
1111
// Requires a *polymorphic literal*, i.e., one that can serve as f64 as well as f32.
1212
macro_rules! test_literal {
1313
($x: expr) => {{
14+
let x16: f16 = $x;
1415
let x32: f32 = $x;
1516
let x64: f64 = $x;
1617
let inputs = &[stringify!($x).into(), format!("{:?}", x64), format!("{:e}", x64)];
18+
1719
for input in inputs {
18-
assert_eq!(input.parse(), Ok(x64));
19-
assert_eq!(input.parse(), Ok(x32));
20+
assert_eq!(input.parse(), Ok(x64), "failed f64 {input}");
21+
assert_eq!(input.parse(), Ok(x32), "failed f32 {input}");
22+
assert_eq!(input.parse(), Ok(x16), "failed f16 {input}");
23+
2024
let neg_input = format!("-{input}");
21-
assert_eq!(neg_input.parse(), Ok(-x64));
22-
assert_eq!(neg_input.parse(), Ok(-x32));
25+
assert_eq!(neg_input.parse(), Ok(-x64), "failed f64 {neg_input}");
26+
assert_eq!(neg_input.parse(), Ok(-x32), "failed f32 {neg_input}");
27+
assert_eq!(neg_input.parse(), Ok(-x16), "failed f16 {neg_input}");
2328
}
2429
}};
2530
}
2631

32+
// #[test]
33+
// fn foo() {
34+
// use core::num::dec2flt::float::RawFloat;
35+
// use core::num::dec2flt::parse::parse_number;
36+
37+
// fn x<F: RawFloat + std::fmt::Display>(r: &str) {
38+
// let mut s = r.as_bytes();
39+
// let c = s[0];
40+
// let negative = c == b'-';
41+
// if c == b'-' || c == b'+' {
42+
// s = &s[1..];
43+
// }
44+
// let mut num = parse_number(s).unwrap();
45+
// num.negative = negative;
46+
// if let Some(value) = num.try_fast_path::<F>() {
47+
// // return Ok(value);
48+
// println!("fast path {value}");
49+
// return;
50+
// }
51+
52+
// let q = num.exponent;
53+
// let w = num.mantissa;
54+
55+
// println!(
56+
// "float {r} {q} {w} {q:#066b} {w:#066b} sm10 {} lg10 {} ty {} chk {}",
57+
// F::SMALLEST_POWER_OF_TEN,
58+
// F::LARGEST_POWER_OF_TEN,
59+
// std::any::type_name::<F>(),
60+
// if w == 0 || q < F::SMALLEST_POWER_OF_TEN as i64 {
61+
// "lt small 10"
62+
// } else if q > F::LARGEST_POWER_OF_TEN as i64 {
63+
// "gt big 10"
64+
// } else {
65+
// ""
66+
// }
67+
// );
68+
// }
69+
70+
// // test_literal2!(1e-20);
71+
// // test_literal2!(1e-30);
72+
// // test_literal2!(1e-40);
73+
// // test_literal2!(1e-50);
74+
// // test_literal2!(1e-60);
75+
// // test_literal2!(1e-63);
76+
// // test_literal2!(1e-64);
77+
// // test_literal2!(1e-65);
78+
// // test_literal2!(1e-66);
79+
// // test_literal2!(1e-70);
80+
// // test_literal2!(1e-70);
81+
// // test_literal2!(1e-70);
82+
// // test_literal2!(1e-70);
83+
// // test_literal2!(2.225073858507201136057409796709131975934819546351645648023426109724822222021076945516529523908135087914149158913039621106870086438694594645527657207407820621743379988141063267329253552286881372149012981122451451889849057222307285255133155755015914397476397983411801999323962548289017107081850690630666655994938275772572015763062690663332647565300009245888316433037779791869612049497390377829704905051080609940730262937128958950003583799967207254304360284078895771796150945516748243471030702609144621572289880258182545180325707018860872113128079512233426288368622321503775666622503982534335974568884423900265498198385487948292206894721689831099698365846814022854243330660339850886445804001034933970427567186443383770486037861622771738545623065874679014086723327636718749999999999999999999999999999999999999e-308);
84+
// // test_literal2!(1.175494140627517859246175898662808184331245864732796240031385942718174675986064769972472277004271745681762695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-38);
85+
// // panic!();
86+
// }
87+
88+
// #[test]
89+
// fn foobar() {
90+
// use core::num::dec2flt::float::RawFloat;
91+
// panic!(
92+
// "{} {} {} {}",
93+
// <f32 as RawFloat>::LARGEST_POWER_OF_TEN,
94+
// <f32 as RawFloat>::SMALLEST_POWER_OF_TEN,
95+
// <f64 as RawFloat>::LARGEST_POWER_OF_TEN,
96+
// <f64 as RawFloat>::SMALLEST_POWER_OF_TEN,
97+
// )
98+
// }
99+
27100
#[test]
28101
fn ordinary() {
29102
test_literal!(1.0);
@@ -34,6 +107,65 @@ fn ordinary() {
34107
test_literal!(2.2250738585072014e-308);
35108
}
36109

110+
#[test]
111+
fn stats() {
112+
// use
113+
use core::num::dec2flt::float::RawFloat;
114+
dbg!(
115+
f16::BITS,
116+
f16::MANTISSA_BITS,
117+
f16::MANTISSA_EXPLICIT_BITS,
118+
f16::EXPONENT_BITS,
119+
f16::MAX_EXPONENT_FAST_PATH,
120+
f16::MIN_EXPONENT_FAST_PATH,
121+
f16::MIN_EXPONENT_ROUND_TO_EVEN,
122+
f16::MAX_EXPONENT_ROUND_TO_EVEN,
123+
f16::MINIMUM_EXPONENT,
124+
f16::MAXIMUM_EXPONENT,
125+
f16::EXPONENT_BIAS,
126+
f16::INFINITE_POWER,
127+
f16::LARGEST_POWER_OF_TEN,
128+
f16::SMALLEST_POWER_OF_TEN,
129+
f16::MAX_MANTISSA_FAST_PATH
130+
);
131+
dbg!(
132+
f32::BITS,
133+
f32::MANTISSA_BITS,
134+
f32::MANTISSA_EXPLICIT_BITS,
135+
f32::EXPONENT_BITS,
136+
f32::MAX_EXPONENT_FAST_PATH,
137+
f32::MIN_EXPONENT_FAST_PATH,
138+
f32::MIN_EXPONENT_ROUND_TO_EVEN,
139+
f32::MAX_EXPONENT_ROUND_TO_EVEN,
140+
f32::MINIMUM_EXPONENT,
141+
f32::MAXIMUM_EXPONENT,
142+
f32::EXPONENT_BIAS,
143+
f32::INFINITE_POWER,
144+
f32::LARGEST_POWER_OF_TEN,
145+
f32::SMALLEST_POWER_OF_TEN,
146+
f32::MAX_MANTISSA_FAST_PATH
147+
);
148+
dbg!(
149+
f64::BITS,
150+
f64::MANTISSA_BITS,
151+
f64::MANTISSA_EXPLICIT_BITS,
152+
f64::EXPONENT_BITS,
153+
f64::MAX_EXPONENT_FAST_PATH,
154+
f64::MIN_EXPONENT_FAST_PATH,
155+
f64::MIN_EXPONENT_ROUND_TO_EVEN,
156+
f64::MAX_EXPONENT_ROUND_TO_EVEN,
157+
f64::MINIMUM_EXPONENT,
158+
f64::MAXIMUM_EXPONENT,
159+
f64::EXPONENT_BIAS,
160+
f64::INFINITE_POWER,
161+
f64::LARGEST_POWER_OF_TEN,
162+
f64::SMALLEST_POWER_OF_TEN,
163+
f64::MAX_MANTISSA_FAST_PATH
164+
);
165+
166+
panic!();
167+
}
168+
37169
#[test]
38170
fn special_code_paths() {
39171
test_literal!(36893488147419103229.0); // 2^65 - 3, triggers half-to-even with even significand

‎library/core/tests/num/dec2flt/parse.rs

+19-2
Original file line numberDiff line numberDiff line change
@@ -10,22 +10,39 @@ fn new_dec(e: i64, m: u64) -> Decimal {
1010
fn missing_pieces() {
1111
let permutations = &[".e", "1e", "e4", "e", ".12e", "321.e", "32.12e+", "12.32e-"];
1212
for &s in permutations {
13+
assert_eq!(dec2flt::<f16>(s), Err(pfe_invalid()));
14+
assert_eq!(dec2flt::<f32>(s), Err(pfe_invalid()));
1315
assert_eq!(dec2flt::<f64>(s), Err(pfe_invalid()));
1416
}
1517
}
1618

1719
#[test]
1820
fn invalid_chars() {
1921
let invalid = "r,?<j";
20-
let error = Err(pfe_invalid());
2122
let valid_strings = &["123", "666.", ".1", "5e1", "7e-3", "0.0e+1"];
23+
2224
for c in invalid.chars() {
2325
for s in valid_strings {
2426
for i in 0..s.len() {
2527
let mut input = String::new();
2628
input.push_str(s);
2729
input.insert(i, c);
28-
assert!(dec2flt::<f64>(&input) == error, "did not reject invalid {:?}", input);
30+
31+
assert_eq!(
32+
dec2flt::<f16>(&input),
33+
Err(pfe_invalid()),
34+
"f16 did not reject invalid {input:?}",
35+
);
36+
assert_eq!(
37+
dec2flt::<f32>(&input),
38+
Err(pfe_invalid()),
39+
"f32 did not reject invalid {input:?}",
40+
);
41+
assert_eq!(
42+
dec2flt::<f64>(&input),
43+
Err(pfe_invalid()),
44+
"f64 did not reject invalid {input:?}",
45+
);
2946
}
3047
}
3148
}

0 commit comments

Comments
 (0)