lexical_parse_float/
table_binary.rs
1#![cfg(feature = "power-of-two")]
4#![cfg(not(feature = "compact"))]
5#![doc(hidden)]
6
7use lexical_util::num::Float;
8
9#[cfg(not(feature = "radix"))]
10use crate::table_decimal::*;
11
12#[inline(always)]
22#[cfg(not(feature = "radix"))]
23pub const fn get_small_int_power(exponent: usize, radix: u32) -> u64 {
24 match radix {
26 2 => get_small_int_power2(exponent),
27 4 => get_small_int_power4(exponent),
28 5 => get_small_int_power5(exponent),
29 8 => get_small_int_power8(exponent),
30 10 => get_small_int_power10(exponent),
31 16 => get_small_int_power16(exponent),
32 32 => get_small_int_power32(exponent),
33 _ => unreachable!(),
34 }
35}
36
37#[inline(always)]
39#[cfg(not(feature = "radix"))]
40pub fn get_small_f32_power(exponent: usize, radix: u32) -> f32 {
41 match radix {
42 2 => get_small_f32_power2(exponent),
43 4 => get_small_f32_power4(exponent),
44 8 => get_small_f32_power8(exponent),
45 10 => get_small_f32_power10(exponent),
46 16 => get_small_f32_power16(exponent),
47 32 => get_small_f32_power32(exponent),
48 _ => unreachable!(),
49 }
50}
51
52#[inline(always)]
59#[cfg(not(feature = "radix"))]
60pub fn get_small_f64_power(exponent: usize, radix: u32) -> f64 {
61 match radix {
62 2 => get_small_f64_power2(exponent),
63 4 => get_small_f64_power4(exponent),
64 8 => get_small_f64_power8(exponent),
65 10 => get_small_f64_power10(exponent),
66 16 => get_small_f64_power16(exponent),
67 32 => get_small_f64_power32(exponent),
68 _ => unreachable!(),
69 }
70}
71
72#[inline(always)]
79pub const fn get_small_int_power2(exponent: usize) -> u64 {
80 1 << exponent
81}
82
83#[inline(always)]
85pub fn get_small_f32_power2(exponent: usize) -> f32 {
86 debug_assert!(exponent as i32 <= f32::EXPONENT_BIAS - f32::MANTISSA_SIZE);
88 let shift = (f32::EXPONENT_BIAS - f32::MANTISSA_SIZE) as u32;
89 let bits = (exponent as u32 + shift) << f32::MANTISSA_SIZE;
90 f32::from_bits(bits)
91}
92
93#[inline(always)]
95pub fn get_small_f64_power2(exponent: usize) -> f64 {
96 debug_assert!(exponent as i32 <= f64::EXPONENT_BIAS - f64::MANTISSA_SIZE);
98 let shift = (f64::EXPONENT_BIAS - f64::MANTISSA_SIZE) as u64;
99 let bits = (exponent as u64 + shift) << f64::MANTISSA_SIZE;
100 f64::from_bits(bits)
101}
102
103#[inline(always)]
105pub const fn get_small_int_power4(exponent: usize) -> u64 {
106 get_small_int_power2(2 * exponent)
107}
108
109#[inline(always)]
111pub fn get_small_f32_power4(exponent: usize) -> f32 {
112 get_small_f32_power2(2 * exponent)
113}
114
115#[inline(always)]
117pub fn get_small_f64_power4(exponent: usize) -> f64 {
118 get_small_f64_power2(2 * exponent)
119}
120
121#[inline(always)]
123pub const fn get_small_int_power8(exponent: usize) -> u64 {
124 get_small_int_power2(3 * exponent)
125}
126
127#[inline(always)]
129pub fn get_small_f32_power8(exponent: usize) -> f32 {
130 get_small_f32_power2(3 * exponent)
131}
132
133#[inline(always)]
135pub fn get_small_f64_power8(exponent: usize) -> f64 {
136 get_small_f64_power2(3 * exponent)
137}
138
139#[inline(always)]
141pub const fn get_small_int_power16(exponent: usize) -> u64 {
142 get_small_int_power2(4 * exponent)
143}
144
145#[inline(always)]
147pub fn get_small_f32_power16(exponent: usize) -> f32 {
148 get_small_f32_power2(4 * exponent)
149}
150
151#[inline(always)]
153pub fn get_small_f64_power16(exponent: usize) -> f64 {
154 get_small_f64_power2(4 * exponent)
155}
156
157#[inline(always)]
159pub const fn get_small_int_power32(exponent: usize) -> u64 {
160 get_small_int_power2(5 * exponent)
161}
162
163#[inline(always)]
165pub fn get_small_f32_power32(exponent: usize) -> f32 {
166 get_small_f32_power2(5 * exponent)
167}
168
169#[inline(always)]
171pub fn get_small_f64_power32(exponent: usize) -> f64 {
172 get_small_f64_power2(5 * exponent)
173}