| 1 |
use crate::common::{ceil_log2_pow5, log2_pow5}; |
| 2 |
use crate::f2s; |
| 3 |
use crate::f2s_intrinsics::{ |
| 4 |
mul_pow5_div_pow2, mul_pow5_inv_div_pow2, multiple_of_power_of_2_32, multiple_of_power_of_5_32, |
| 5 |
}; |
| 6 |
use crate::parse::Error; |
| 7 |
#[cfg(feature = "no-panic")] |
| 8 |
use no_panic::no_panic; |
| 9 |
|
| 10 |
const FLOAT_EXPONENT_BIAS: usize = 127; |
| 11 |
|
| 12 |
fn floor_log2(value: u32) -> u32 { |
| 13 |
31_u32.wrapping_sub(value.leading_zeros()) |
| 14 |
} |
| 15 |
|
| 16 |
#[cfg_attr(feature = "no-panic", no_panic)] |
| 17 |
pub fn s2f(buffer: &[u8]) -> Result<f32, Error> { |
| 18 |
let len = buffer.len(); |
| 19 |
if len == 0 { |
| 20 |
return Err(Error::InputTooShort); |
| 21 |
} |
| 22 |
|
| 23 |
let mut m10digits = 0; |
| 24 |
let mut e10digits = 0; |
| 25 |
let mut dot_index = len; |
| 26 |
let mut e_index = len; |
| 27 |
let mut m10 = 0u32; |
| 28 |
let mut e10 = 0i32; |
| 29 |
let mut signed_m = false; |
| 30 |
let mut signed_e = false; |
| 31 |
|
| 32 |
let mut i = 0; |
| 33 |
if unsafe { *buffer.get_unchecked(0) } == b'-' { |
| 34 |
signed_m = true; |
| 35 |
i += 1; |
| 36 |
} |
| 37 |
|
| 38 |
while let Some(c) = buffer.get(i).copied() { |
| 39 |
if c == b'.' { |
| 40 |
if dot_index != len { |
| 41 |
return Err(Error::MalformedInput); |
| 42 |
} |
| 43 |
dot_index = i; |
| 44 |
i += 1; |
| 45 |
continue; |
| 46 |
} |
| 47 |
if c < b'0' || c > b'9' { |
| 48 |
break; |
| 49 |
} |
| 50 |
if m10digits >= 9 { |
| 51 |
return Err(Error::InputTooLong); |
| 52 |
} |
| 53 |
m10 = 10 * m10 + (c - b'0') as u32; |
| 54 |
if m10 != 0 { |
| 55 |
m10digits += 1; |
| 56 |
} |
| 57 |
i += 1; |
| 58 |
} |
| 59 |
|
| 60 |
if let Some(b'e') | Some(b'E') = buffer.get(i) { |
| 61 |
e_index = i; |
| 62 |
i += 1; |
| 63 |
match buffer.get(i) { |
| 64 |
Some(b'-') => { |
| 65 |
signed_e = true; |
| 66 |
i += 1; |
| 67 |
} |
| 68 |
Some(b'+') => i += 1, |
| 69 |
_ => {} |
| 70 |
} |
| 71 |
while let Some(c) = buffer.get(i).copied() { |
| 72 |
if c < b'0' || c > b'9' { |
| 73 |
return Err(Error::MalformedInput); |
| 74 |
} |
| 75 |
if e10digits > 3 { |
| 76 |
// TODO: Be more lenient. Return +/-Infinity or +/-0 instead. |
| 77 |
return Err(Error::InputTooLong); |
| 78 |
} |
| 79 |
e10 = 10 * e10 + (c - b'0') as i32; |
| 80 |
if e10 != 0 { |
| 81 |
e10digits += 1; |
| 82 |
} |
| 83 |
i += 1; |
| 84 |
} |
| 85 |
} |
| 86 |
|
| 87 |
if i < len { |
| 88 |
return Err(Error::MalformedInput); |
| 89 |
} |
| 90 |
if signed_e { |
| 91 |
e10 = -e10; |
| 92 |
} |
| 93 |
e10 -= if dot_index < e_index { |
| 94 |
(e_index - dot_index - 1) as i32 |
| 95 |
} else { |
| 96 |
0 |
| 97 |
}; |
| 98 |
if m10 == 0 { |
| 99 |
return Ok(if signed_m { -0.0 } else { 0.0 }); |
| 100 |
} |
| 101 |
|
| 102 |
if m10digits + e10 <= -46 || m10 == 0 { |
| 103 |
// Number is less than 1e-46, which should be rounded down to 0; return |
| 104 |
// +/-0.0. |
| 105 |
let ieee = (signed_m as u32) << (f2s::FLOAT_EXPONENT_BITS + f2s::FLOAT_MANTISSA_BITS); |
| 106 |
return Ok(f32::from_bits(ieee)); |
| 107 |
} |
| 108 |
if m10digits + e10 >= 40 { |
| 109 |
// Number is larger than 1e+39, which should be rounded to +/-Infinity. |
| 110 |
let ieee = ((signed_m as u32) << (f2s::FLOAT_EXPONENT_BITS + f2s::FLOAT_MANTISSA_BITS)) |
| 111 |
| (0xff_u32 << f2s::FLOAT_MANTISSA_BITS); |
| 112 |
return Ok(f32::from_bits(ieee)); |
| 113 |
} |
| 114 |
|
| 115 |
// Convert to binary float m2 * 2^e2, while retaining information about |
| 116 |
// whether the conversion was exact (trailing_zeros). |
| 117 |
let e2: i32; |
| 118 |
let m2: u32; |
| 119 |
let mut trailing_zeros: bool; |
| 120 |
if e10 >= 0 { |
| 121 |
// The length of m * 10^e in bits is: |
| 122 |
// log2(m10 * 10^e10) = log2(m10) + e10 log2(10) = log2(m10) + e10 + e10 * log2(5) |
| 123 |
// |
| 124 |
// We want to compute the FLOAT_MANTISSA_BITS + 1 top-most bits (+1 for |
| 125 |
// the implicit leading one in IEEE format). We therefore choose a |
| 126 |
// binary output exponent of |
| 127 |
// log2(m10 * 10^e10) - (FLOAT_MANTISSA_BITS + 1). |
| 128 |
// |
| 129 |
// We use floor(log2(5^e10)) so that we get at least this many bits; better to |
| 130 |
// have an additional bit than to not have enough bits. |
| 131 |
e2 = floor_log2(m10) |
| 132 |
.wrapping_add(e10 as u32) |
| 133 |
.wrapping_add(log2_pow5(e10) as u32) |
| 134 |
.wrapping_sub(f2s::FLOAT_MANTISSA_BITS + 1) as i32; |
| 135 |
|
| 136 |
// We now compute [m10 * 10^e10 / 2^e2] = [m10 * 5^e10 / 2^(e2-e10)]. |
| 137 |
// To that end, we use the FLOAT_POW5_SPLIT table. |
| 138 |
let j = e2 |
| 139 |
.wrapping_sub(e10) |
| 140 |
.wrapping_sub(ceil_log2_pow5(e10)) |
| 141 |
.wrapping_add(f2s::FLOAT_POW5_BITCOUNT); |
| 142 |
debug_assert!(j >= 0); |
| 143 |
m2 = mul_pow5_div_pow2(m10, e10 as u32, j); |
| 144 |
|
| 145 |
// We also compute if the result is exact, i.e., |
| 146 |
// [m10 * 10^e10 / 2^e2] == m10 * 10^e10 / 2^e2. |
| 147 |
// This can only be the case if 2^e2 divides m10 * 10^e10, which in turn |
| 148 |
// requires that the largest power of 2 that divides m10 + e10 is |
| 149 |
// greater than e2. If e2 is less than e10, then the result must be |
| 150 |
// exact. Otherwise we use the existing multiple_of_power_of_2 function. |
| 151 |
trailing_zeros = |
| 152 |
e2 < e10 || e2 - e10 < 32 && multiple_of_power_of_2_32(m10, (e2 - e10) as u32); |
| 153 |
} else { |
| 154 |
e2 = floor_log2(m10) |
| 155 |
.wrapping_add(e10 as u32) |
| 156 |
.wrapping_sub(ceil_log2_pow5(-e10) as u32) |
| 157 |
.wrapping_sub(f2s::FLOAT_MANTISSA_BITS + 1) as i32; |
| 158 |
|
| 159 |
// We now compute [m10 * 10^e10 / 2^e2] = [m10 / (5^(-e10) 2^(e2-e10))]. |
| 160 |
let j = e2 |
| 161 |
.wrapping_sub(e10) |
| 162 |
.wrapping_add(ceil_log2_pow5(-e10)) |
| 163 |
.wrapping_sub(1) |
| 164 |
.wrapping_add(f2s::FLOAT_POW5_INV_BITCOUNT); |
| 165 |
m2 = mul_pow5_inv_div_pow2(m10, -e10 as u32, j); |
| 166 |
|
| 167 |
// We also compute if the result is exact, i.e., |
| 168 |
// [m10 / (5^(-e10) 2^(e2-e10))] == m10 / (5^(-e10) 2^(e2-e10)) |
| 169 |
// |
| 170 |
// If e2-e10 >= 0, we need to check whether (5^(-e10) 2^(e2-e10)) |
| 171 |
// divides m10, which is the case iff pow5(m10) >= -e10 AND pow2(m10) >= |
| 172 |
// e2-e10. |
| 173 |
// |
| 174 |
// If e2-e10 < 0, we have actually computed [m10 * 2^(e10 e2) / |
| 175 |
// 5^(-e10)] above, and we need to check whether 5^(-e10) divides (m10 * |
| 176 |
// 2^(e10-e2)), which is the case iff pow5(m10 * 2^(e10-e2)) = pow5(m10) |
| 177 |
// >= -e10. |
| 178 |
trailing_zeros = (e2 < e10 |
| 179 |
|| (e2 - e10 < 32 && multiple_of_power_of_2_32(m10, (e2 - e10) as u32))) |
| 180 |
&& multiple_of_power_of_5_32(m10, -e10 as u32); |
| 181 |
} |
| 182 |
|
| 183 |
// Compute the final IEEE exponent. |
| 184 |
let mut ieee_e2 = i32::max(0, e2 + FLOAT_EXPONENT_BIAS as i32 + floor_log2(m2) as i32) as u32; |
| 185 |
|
| 186 |
if ieee_e2 > 0xfe { |
| 187 |
// Final IEEE exponent is larger than the maximum representable; return |
| 188 |
// +/-Infinity. |
| 189 |
let ieee = ((signed_m as u32) << (f2s::FLOAT_EXPONENT_BITS + f2s::FLOAT_MANTISSA_BITS)) |
| 190 |
| (0xff_u32 << f2s::FLOAT_MANTISSA_BITS); |
| 191 |
return Ok(f32::from_bits(ieee)); |
| 192 |
} |
| 193 |
|
| 194 |
// We need to figure out how much we need to shift m2. The tricky part is |
| 195 |
// that we need to take the final IEEE exponent into account, so we need to |
| 196 |
// reverse the bias and also special-case the value 0. |
| 197 |
let shift = if ieee_e2 == 0 { 1 } else { ieee_e2 as i32 } |
| 198 |
.wrapping_sub(e2) |
| 199 |
.wrapping_sub(FLOAT_EXPONENT_BIAS as i32) |
| 200 |
.wrapping_sub(f2s::FLOAT_MANTISSA_BITS as i32); |
| 201 |
debug_assert!(shift >= 0); |
| 202 |
|
| 203 |
// We need to round up if the exact value is more than 0.5 above the value |
| 204 |
// we computed. That's equivalent to checking if the last removed bit was 1 |
| 205 |
// and either the value was not just trailing zeros or the result would |
| 206 |
// otherwise be odd. |
| 207 |
// |
| 208 |
// We need to update trailing_zeros given that we have the exact output |
| 209 |
// exponent ieee_e2 now. |
| 210 |
trailing_zeros &= (m2 & ((1_u32 << (shift - 1)) - 1)) == 0; |
| 211 |
let last_removed_bit = (m2 >> (shift - 1)) & 1; |
| 212 |
let round_up = last_removed_bit != 0 && (!trailing_zeros || ((m2 >> shift) & 1) != 0); |
| 213 |
|
| 214 |
let mut ieee_m2 = (m2 >> shift).wrapping_add(round_up as u32); |
| 215 |
debug_assert!(ieee_m2 <= 1_u32 << (f2s::FLOAT_MANTISSA_BITS + 1)); |
| 216 |
ieee_m2 &= (1_u32 << f2s::FLOAT_MANTISSA_BITS) - 1; |
| 217 |
if ieee_m2 == 0 && round_up { |
| 218 |
// Rounding up may overflow the mantissa. |
| 219 |
// In this case we move a trailing zero of the mantissa into the |
| 220 |
// exponent. |
| 221 |
// Due to how the IEEE represents +/-Infinity, we don't need to check |
| 222 |
// for overflow here. |
| 223 |
ieee_e2 += 1; |
| 224 |
} |
| 225 |
let ieee = ((((signed_m as u32) << f2s::FLOAT_EXPONENT_BITS) | ieee_e2) |
| 226 |
<< f2s::FLOAT_MANTISSA_BITS) |
| 227 |
| ieee_m2; |
| 228 |
Ok(f32::from_bits(ieee)) |
| 229 |
} |