use num_bigint::BigUint;
use std::fmt::{self, Alignment, Formatter};
const SPACE_PADDING: &str = concat!(
" ",
" ",
);
const ZERO_PADDING: &str = concat!(
"00000000000000000000000000000000",
"00000000000000000000000000000000",
);
mod private {
pub trait SealedSigned: Copy {
fn to_i128(self) -> i128;
}
pub trait SealedUnsigned: Copy {
fn to_u128(self) -> u128;
}
pub trait SealedFixed: Copy {
const FRACTION_BITS: u32;
const EXPONENT_BITS: u32;
const EXPONENT_BIAS: i32;
const HEX_FRACTION_BITS: u32;
const HEX_MIN_NORMAL_EXPONENT: i32;
fn bits(self) -> u128;
}
}
pub trait SignedValue: private::SealedSigned {}
pub trait UnsignedValue: private::SealedUnsigned {}
pub trait FixedValue: private::SealedFixed {}
macro_rules! impl_signed_value {
($($ty:ty),+ $(,)?) => {
$(
impl private::SealedSigned for $ty {
fn to_i128(self) -> i128 {
self as i128
}
}
impl SignedValue for $ty {}
)+
};
}
macro_rules! impl_unsigned_value {
($($ty:ty),+ $(,)?) => {
$(
impl private::SealedUnsigned for $ty {
fn to_u128(self) -> u128 {
self as u128
}
}
impl UnsignedValue for $ty {}
)+
};
}
impl_signed_value!(i8, i16, i32, i64, isize);
impl_unsigned_value!(u8, u16, u32, u64, usize);
impl private::SealedFixed for f32 {
const FRACTION_BITS: u32 = 23;
const EXPONENT_BITS: u32 = 8;
const EXPONENT_BIAS: i32 = 127;
const HEX_FRACTION_BITS: u32 = 52;
const HEX_MIN_NORMAL_EXPONENT: i32 = -1022;
fn bits(self) -> u128 {
self.to_bits() as u128
}
}
impl FixedValue for f32 {}
impl private::SealedFixed for f64 {
const FRACTION_BITS: u32 = 52;
const EXPONENT_BITS: u32 = 11;
const EXPONENT_BIAS: i32 = 1023;
const HEX_FRACTION_BITS: u32 = 52;
const HEX_MIN_NORMAL_EXPONENT: i32 = -1022;
fn bits(self) -> u128 {
self.to_bits() as u128
}
}
impl FixedValue for f64 {}
impl private::SealedFixed for f128::f128 {
const FRACTION_BITS: u32 = 112;
const EXPONENT_BITS: u32 = 15;
const EXPONENT_BIAS: i32 = 16383;
const HEX_FRACTION_BITS: u32 = 112;
const HEX_MIN_NORMAL_EXPONENT: i32 = -16382;
fn bits(self) -> u128 {
u128::from_ne_bytes(self.into_inner())
}
}
impl FixedValue for f128::f128 {}
pub fn signed<T: SignedValue>(value: T) -> Signed<T> {
Signed {
value,
space_sign: false,
}
}
#[derive(Clone, Copy)]
pub struct Signed<T: SignedValue> {
value: T,
space_sign: bool,
}
impl<T: SignedValue> Signed<T> {
pub fn space_sign(mut self) -> Self {
self.space_sign = true;
self
}
}
impl<T: SignedValue> fmt::Display for Signed<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
let value = self.value.to_i128();
write_integer(
f,
value.unsigned_abs(),
value.is_negative(),
self.space_sign,
Base::Decimal,
)
}
}
pub fn unsigned<T: UnsignedValue>(value: T) -> Unsigned<T> {
Unsigned { value }
}
#[derive(Clone, Copy)]
pub struct Unsigned<T: UnsignedValue> {
value: T,
}
impl<T: UnsignedValue> fmt::Display for Unsigned<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_integer(f, self.value.to_u128(), false, false, Base::Decimal)
}
}
impl<T: UnsignedValue> fmt::Octal for Unsigned<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_integer(f, self.value.to_u128(), false, false, Base::Octal)
}
}
impl<T: UnsignedValue> fmt::LowerHex for Unsigned<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_integer(f, self.value.to_u128(), false, false, Base::LowerHex)
}
}
impl<T: UnsignedValue> fmt::UpperHex for Unsigned<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_integer(f, self.value.to_u128(), false, false, Base::UpperHex)
}
}
pub fn fixed<T: FixedValue>(value: T) -> Fixed<T> {
Fixed {
value,
space_sign: false,
}
}
#[derive(Clone, Copy)]
pub struct Fixed<T: FixedValue> {
value: T,
space_sign: bool,
}
impl<T: FixedValue> Fixed<T> {
pub fn space_sign(mut self) -> Self {
self.space_sign = true;
self
}
}
impl<T: FixedValue> fmt::Display for Fixed<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_fixed(
f,
FloatParts::from_value(self.value),
self.space_sign,
false,
)
}
}
pub fn fixed_upper<T: FixedValue>(value: T) -> FixedUpper<T> {
FixedUpper {
value,
space_sign: false,
}
}
#[derive(Clone, Copy)]
pub struct FixedUpper<T: FixedValue> {
value: T,
space_sign: bool,
}
impl<T: FixedValue> FixedUpper<T> {
pub fn space_sign(mut self) -> Self {
self.space_sign = true;
self
}
}
impl<T: FixedValue> fmt::Display for FixedUpper<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_fixed(f, FloatParts::from_value(self.value), self.space_sign, true)
}
}
pub fn scientific<T: FixedValue>(value: T) -> Scientific<T> {
Scientific {
value,
space_sign: false,
}
}
#[derive(Clone, Copy)]
pub struct Scientific<T: FixedValue> {
value: T,
space_sign: bool,
}
impl<T: FixedValue> Scientific<T> {
pub fn space_sign(mut self) -> Self {
self.space_sign = true;
self
}
}
impl<T: FixedValue> fmt::LowerExp for Scientific<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_scientific(
f,
FloatParts::from_value(self.value),
self.space_sign,
false,
)
}
}
impl<T: FixedValue> fmt::UpperExp for Scientific<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_scientific(f, FloatParts::from_value(self.value), self.space_sign, true)
}
}
pub fn general<T: FixedValue>(value: T) -> General<T> {
General {
value,
space_sign: false,
}
}
#[derive(Clone, Copy)]
pub struct General<T: FixedValue> {
value: T,
space_sign: bool,
}
impl<T: FixedValue> General<T> {
pub fn space_sign(mut self) -> Self {
self.space_sign = true;
self
}
}
impl<T: FixedValue> fmt::Display for General<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_general(
f,
FloatParts::from_value(self.value),
self.space_sign,
false,
)
}
}
pub fn general_upper<T: FixedValue>(value: T) -> GeneralUpper<T> {
GeneralUpper {
value,
space_sign: false,
}
}
#[derive(Clone, Copy)]
pub struct GeneralUpper<T: FixedValue> {
value: T,
space_sign: bool,
}
impl<T: FixedValue> GeneralUpper<T> {
pub fn space_sign(mut self) -> Self {
self.space_sign = true;
self
}
}
impl<T: FixedValue> fmt::Display for GeneralUpper<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_general(f, FloatParts::from_value(self.value), self.space_sign, true)
}
}
pub fn hex_float<T: FixedValue>(value: T) -> HexFloat<T> {
HexFloat {
value,
space_sign: false,
}
}
#[derive(Clone, Copy)]
pub struct HexFloat<T: FixedValue> {
value: T,
space_sign: bool,
}
impl<T: FixedValue> HexFloat<T> {
pub fn space_sign(mut self) -> Self {
self.space_sign = true;
self
}
}
impl<T: FixedValue> fmt::LowerHex for HexFloat<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_hex_float::<T>(
f,
FloatParts::from_value(self.value),
self.space_sign,
false,
)
}
}
impl<T: FixedValue> fmt::UpperHex for HexFloat<T> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write_hex_float::<T>(f, FloatParts::from_value(self.value), self.space_sign, true)
}
}
pub fn byte_string(value: &[i8]) -> ByteString<'_> {
ByteString { value }
}
#[derive(Clone, Copy)]
pub struct ByteString<'a> {
value: &'a [i8],
}
impl fmt::Display for ByteString<'_> {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
let bytes: &[u8] = bytemuck::cast_slice(self.value);
let selected = match f.precision() {
Some(0) => &bytes[..0],
Some(precision) => {
let within_precision = &bytes[..bytes.len().min(precision)];
if let Some(nul) = within_precision.iter().position(|&byte| byte == 0) {
&within_precision[..nul]
} else if bytes.len() >= precision {
&bytes[..precision]
} else {
return Err(fmt::Error);
}
}
None => {
let nul = bytes.iter().position(|&byte| byte == 0).ok_or(fmt::Error)?;
&bytes[..nul]
}
};
let text = std::str::from_utf8(selected).map_err(|_| fmt::Error)?;
let padding = f.width().unwrap_or_default().saturating_sub(selected.len());
let (left_spaces, right_spaces) = match f.align().unwrap_or(Alignment::Right) {
Alignment::Left => (0, padding),
Alignment::Right => (padding, 0),
Alignment::Center => (padding / 2, padding - padding / 2),
};
write_repeated(f, SPACE_PADDING, left_spaces)?;
f.write_str(text)?;
write_repeated(f, SPACE_PADDING, right_spaces)
}
}
#[derive(Clone, Copy)]
enum FloatParts {
Finite {
negative: bool,
significand: u128,
binary_exponent: i32,
},
Infinite {
negative: bool,
},
Nan {
negative: bool,
},
}
impl FloatParts {
fn from_value<T: FixedValue>(value: T) -> Self {
Self::from_ieee_bits(
value.bits(),
T::FRACTION_BITS,
T::EXPONENT_BITS,
T::EXPONENT_BIAS,
)
}
fn from_ieee_bits(
bits: u128,
fraction_bits: u32,
exponent_bits: u32,
exponent_bias: i32,
) -> Self {
let negative = bits >> (fraction_bits + exponent_bits) != 0;
let exponent_mask = (1_u128 << exponent_bits) - 1;
let exponent_field = (bits >> fraction_bits) & exponent_mask;
let fraction_mask = (1_u128 << fraction_bits) - 1;
let fraction = bits & fraction_mask;
if exponent_field == exponent_mask {
return if fraction == 0 {
Self::Infinite { negative }
} else {
Self::Nan { negative }
};
}
let (significand, unbiased_exponent) = if exponent_field == 0 {
(fraction, 1 - exponent_bias)
} else {
(
(1_u128 << fraction_bits) | fraction,
exponent_field as i32 - exponent_bias,
)
};
Self::Finite {
negative,
significand,
binary_exponent: unbiased_exponent - fraction_bits as i32,
}
}
}
fn write_fixed(
f: &mut Formatter<'_>,
parts: FloatParts,
space_sign: bool,
uppercase: bool,
) -> fmt::Result {
let (negative, body, finite) = match parts {
FloatParts::Finite {
negative,
significand,
binary_exponent,
} => (
negative,
fixed_body(
significand,
binary_exponent,
f.precision().unwrap_or(6),
f.alternate(),
),
true,
),
FloatParts::Infinite { negative } => (
negative,
if uppercase { "INF" } else { "inf" }.to_owned(),
false,
),
FloatParts::Nan { negative } => (
negative,
if uppercase { "NAN" } else { "nan" }.to_owned(),
false,
),
};
write_float_field(f, negative, &body, finite, space_sign)
}
fn write_scientific(
f: &mut Formatter<'_>,
parts: FloatParts,
space_sign: bool,
uppercase: bool,
) -> fmt::Result {
let (negative, body, finite) = match parts {
FloatParts::Finite {
negative,
significand,
binary_exponent,
} => (
negative,
scientific_body(
significand,
binary_exponent,
f.precision().unwrap_or(6),
f.alternate(),
uppercase,
),
true,
),
FloatParts::Infinite { negative } => (
negative,
if uppercase { "INF" } else { "inf" }.to_owned(),
false,
),
FloatParts::Nan { negative } => (
negative,
if uppercase { "NAN" } else { "nan" }.to_owned(),
false,
),
};
write_float_field(f, negative, &body, finite, space_sign)
}
fn write_general(
f: &mut Formatter<'_>,
parts: FloatParts,
space_sign: bool,
uppercase: bool,
) -> fmt::Result {
let (negative, body, finite) = match parts {
FloatParts::Finite {
negative,
significand,
binary_exponent,
} => (
negative,
general_body(
significand,
binary_exponent,
f.precision().unwrap_or(6).max(1),
f.alternate(),
uppercase,
),
true,
),
FloatParts::Infinite { negative } => (
negative,
if uppercase { "INF" } else { "inf" }.to_owned(),
false,
),
FloatParts::Nan { negative } => (
negative,
if uppercase { "NAN" } else { "nan" }.to_owned(),
false,
),
};
write_float_field(f, negative, &body, finite, space_sign)
}
fn write_hex_float<T: FixedValue>(
f: &mut Formatter<'_>,
parts: FloatParts,
space_sign: bool,
uppercase: bool,
) -> fmt::Result {
match parts {
FloatParts::Finite {
negative,
significand,
binary_exponent,
} => {
let body = hex_float_body(
significand,
binary_exponent,
T::HEX_FRACTION_BITS,
T::HEX_MIN_NORMAL_EXPONENT,
f.precision(),
f.alternate(),
uppercase,
);
write_hex_float_field(f, negative, &body, space_sign, uppercase)
}
FloatParts::Infinite { negative } => write_float_field(
f,
negative,
if uppercase { "INF" } else { "inf" },
false,
space_sign,
),
FloatParts::Nan { negative } => write_float_field(
f,
negative,
if uppercase { "NAN" } else { "nan" },
false,
space_sign,
),
}
}
fn hex_float_body(
significand: u128,
binary_exponent: i32,
fraction_bits: u32,
minimum_normal_exponent: i32,
precision: Option<usize>,
alternate: bool,
uppercase: bool,
) -> String {
debug_assert_eq!(fraction_bits % 4, 0);
let (mantissa, displayed_exponent) = if significand == 0 {
(0, 0)
} else {
let highest_bit = (u128::BITS - 1 - significand.leading_zeros()) as i32;
let highest_exponent = highest_bit + binary_exponent;
if highest_exponent >= minimum_normal_exponent {
let shift = fraction_bits as i32 - highest_bit;
debug_assert!(shift >= 0);
(significand << shift as usize, highest_exponent)
} else {
let shift = binary_exponent + fraction_bits as i32 - minimum_normal_exponent;
debug_assert!(shift >= 0);
(significand << shift as usize, minimum_normal_exponent)
}
};
let exact_fraction_digits = fraction_bits as usize / 4;
let (digits, fractional_digits) = match precision {
Some(requested) if requested < exact_fraction_digits => {
let discarded_bits = (exact_fraction_digits - requested) * 4;
let mut rounded = mantissa >> discarded_bits;
let discarded_mask = (1_u128 << discarded_bits) - 1;
let discarded = mantissa & discarded_mask;
let halfway = 1_u128 << (discarded_bits - 1);
if discarded > halfway || (discarded == halfway && rounded & 1 != 0) {
rounded += 1;
}
(
padded_hex_digits(rounded, requested + 1, uppercase),
requested,
)
}
Some(requested) => {
let mut digits = padded_hex_digits(mantissa, exact_fraction_digits + 1, uppercase);
digits.extend(std::iter::repeat_n('0', requested - exact_fraction_digits));
(digits, requested)
}
None => {
let mut digits = padded_hex_digits(mantissa, exact_fraction_digits + 1, uppercase);
while digits.len() > 1 && digits.ends_with('0') {
digits.pop();
}
let fractional_digits = digits.len() - 1;
(digits, fractional_digits)
}
};
let mut body = String::with_capacity(digits.len() + 10);
body.push_str(&digits[..1]);
if fractional_digits != 0 || alternate {
body.push('.');
}
body.push_str(&digits[1..]);
body.push(if uppercase { 'P' } else { 'p' });
if displayed_exponent < 0 {
body.push('-');
} else {
body.push('+');
}
body.push_str(&displayed_exponent.unsigned_abs().to_string());
body
}
fn padded_hex_digits(value: u128, width: usize, uppercase: bool) -> String {
let digits = if uppercase {
format!("{value:X}")
} else {
format!("{value:x}")
};
if digits.len() >= width {
return digits;
}
let mut padded = String::with_capacity(width);
padded.extend(std::iter::repeat_n('0', width - digits.len()));
padded.push_str(&digits);
padded
}
fn write_hex_float_field(
f: &mut Formatter<'_>,
negative: bool,
body: &str,
space_sign: bool,
uppercase: bool,
) -> fmt::Result {
let sign = if negative {
"-"
} else if f.sign_plus() {
"+"
} else if space_sign {
" "
} else {
""
};
let prefix = if uppercase { "0X" } else { "0x" };
let content_width = sign.len() + prefix.len() + body.len();
let padding = f.width().unwrap_or_default().saturating_sub(content_width);
let alignment = f.align().unwrap_or(Alignment::Right);
let zero_padding = f.sign_aware_zero_pad() && alignment == Alignment::Right;
let (left_spaces, right_spaces) = if zero_padding {
(0, 0)
} else {
match alignment {
Alignment::Left => (0, padding),
Alignment::Right => (padding, 0),
Alignment::Center => (padding / 2, padding - padding / 2),
}
};
write_repeated(f, SPACE_PADDING, left_spaces)?;
f.write_str(sign)?;
f.write_str(prefix)?;
if zero_padding {
write_repeated(f, ZERO_PADDING, padding)?;
}
f.write_str(body)?;
write_repeated(f, SPACE_PADDING, right_spaces)
}
fn write_float_field(
f: &mut Formatter<'_>,
negative: bool,
body: &str,
finite: bool,
space_sign: bool,
) -> fmt::Result {
let sign = if negative {
"-"
} else if f.sign_plus() {
"+"
} else if space_sign {
" "
} else {
""
};
let content_width = sign.len() + body.len();
let padding = f.width().unwrap_or_default().saturating_sub(content_width);
let alignment = f.align().unwrap_or(Alignment::Right);
let zero_padding = finite && f.sign_aware_zero_pad() && alignment == Alignment::Right;
let (left_spaces, right_spaces) = if zero_padding {
(0, 0)
} else {
match alignment {
Alignment::Left => (0, padding),
Alignment::Right => (padding, 0),
Alignment::Center => (padding / 2, padding - padding / 2),
}
};
write_repeated(f, SPACE_PADDING, left_spaces)?;
f.write_str(sign)?;
if zero_padding {
write_repeated(f, ZERO_PADDING, padding)?;
}
f.write_str(body)?;
write_repeated(f, SPACE_PADDING, right_spaces)
}
fn scientific_body(
significand: u128,
binary_exponent: i32,
precision: usize,
alternate: bool,
uppercase: bool,
) -> String {
let (digits, decimal_exponent) =
rounded_significant_digits(significand, binary_exponent, precision + 1);
scientific_body_from_digits(&digits, decimal_exponent, alternate, uppercase)
}
fn rounded_significant_digits(
significand: u128,
binary_exponent: i32,
significant_digits: usize,
) -> (String, i32) {
debug_assert_ne!(significant_digits, 0);
let mut decimal_exponent = if significand == 0 {
0
} else {
decimal_exponent(significand, binary_exponent)
};
let rounded = if decimal_exponent <= 0 {
let decimal_shift = significant_digits - 1 + (-decimal_exponent) as usize;
scale_and_round(significand, binary_exponent, decimal_shift)
} else if significant_digits > decimal_exponent as usize {
scale_and_round(
significand,
binary_exponent,
significant_digits - 1 - decimal_exponent as usize,
)
} else {
scale_down_and_round(
significand,
binary_exponent,
decimal_exponent as usize + 1 - significant_digits,
)
};
let expected_digits = significant_digits;
let mut digits = rounded.to_str_radix(10);
match digits.len().cmp(&expected_digits) {
std::cmp::Ordering::Greater => {
decimal_exponent += 1;
digits.pop();
}
std::cmp::Ordering::Less => {
digits.insert_str(0, &"0".repeat(expected_digits - digits.len()));
}
std::cmp::Ordering::Equal => {}
}
(digits, decimal_exponent)
}
fn scientific_body_from_digits(
digits: &str,
decimal_exponent: i32,
alternate: bool,
uppercase: bool,
) -> String {
let precision = digits.len() - 1;
let mut body = String::with_capacity(digits.len() + 8);
body.push_str(&digits[..1]);
if precision != 0 || alternate {
body.push('.');
}
body.push_str(&digits[1..]);
body.push(if uppercase { 'E' } else { 'e' });
if decimal_exponent < 0 {
body.push('-');
} else {
body.push('+');
}
let exponent_digits = decimal_exponent.unsigned_abs().to_string();
if exponent_digits.len() < 2 {
body.push('0');
}
body.push_str(&exponent_digits);
body
}
fn general_body(
significand: u128,
binary_exponent: i32,
precision: usize,
alternate: bool,
uppercase: bool,
) -> String {
let (digits, decimal_exponent) =
rounded_significant_digits(significand, binary_exponent, precision);
let use_scientific =
decimal_exponent < -4 || (decimal_exponent >= 0 && decimal_exponent as usize >= precision);
if use_scientific {
let mut body = scientific_body_from_digits(&digits, decimal_exponent, alternate, uppercase);
if !alternate {
trim_scientific_fraction(&mut body);
}
body
} else {
let fractional_digits = (precision as i32 - (decimal_exponent + 1)) as usize;
let mut body = fixed_body(significand, binary_exponent, fractional_digits, alternate);
if !alternate {
trim_fixed_fraction(&mut body);
}
body
}
}
fn trim_fixed_fraction(body: &mut String) {
if let Some(point) = body.find('.') {
while body.as_bytes().last() == Some(&b'0') {
body.pop();
}
if body.len() == point + 1 {
body.pop();
}
}
}
fn trim_scientific_fraction(body: &mut String) {
let exponent = body
.find(['e', 'E'])
.expect("scientific body always has an exponent marker");
let suffix = body.split_off(exponent);
trim_fixed_fraction(body);
body.push_str(&suffix);
}
fn decimal_exponent(significand: u128, binary_exponent: i32) -> i32 {
debug_assert_ne!(significand, 0);
let highest_binary_exponent =
(u128::BITS - 1 - significand.leading_zeros()) as i32 + binary_exponent;
let mut exponent =
(f64::from(highest_binary_exponent) * std::f64::consts::LOG10_2).floor() as i32;
while compare_with_power_of_ten(significand, binary_exponent, exponent).is_lt() {
exponent -= 1;
}
while !compare_with_power_of_ten(significand, binary_exponent, exponent + 1).is_lt() {
exponent += 1;
}
exponent
}
fn compare_with_power_of_ten(
significand: u128,
binary_exponent: i32,
decimal_exponent: i32,
) -> std::cmp::Ordering {
let mut left = BigUint::from(significand);
let mut right = BigUint::from(1_u8);
if binary_exponent >= 0 {
left <<= binary_exponent as usize;
} else {
right <<= (-binary_exponent) as usize;
}
if decimal_exponent >= 0 {
right *= pow_ten(decimal_exponent as usize);
} else {
left *= pow_ten((-decimal_exponent) as usize);
}
left.cmp(&right)
}
fn scale_down_and_round(significand: u128, binary_exponent: i32, decimal_places: usize) -> BigUint {
if significand == 0 {
return BigUint::from(0_u8);
}
let mut numerator = BigUint::from(significand);
let mut denominator = pow_five(decimal_places);
let binary_shift = i64::from(binary_exponent) - decimal_places as i64;
if binary_shift >= 0 {
numerator <<= binary_shift as usize;
} else {
denominator <<= (-binary_shift) as usize;
}
let quotient = &numerator / &denominator;
let remainder = numerator - "ient * &denominator;
let twice_remainder = remainder << 1;
if twice_remainder > denominator || (twice_remainder == denominator && quotient.bit(0)) {
quotient + 1_u8
} else {
quotient
}
}
fn fixed_body(
significand: u128,
binary_exponent: i32,
precision: usize,
alternate: bool,
) -> String {
let scaled = scale_and_round(significand, binary_exponent, precision);
let digits = scaled.to_str_radix(10);
if precision == 0 {
if alternate {
return digits + ".";
}
return digits;
}
if digits.len() > precision {
let point = digits.len() - precision;
let mut result = String::with_capacity(digits.len() + 1);
result.push_str(&digits[..point]);
result.push('.');
result.push_str(&digits[point..]);
result
} else {
let leading_zeros = precision - digits.len();
let mut result = String::with_capacity(precision + 2);
result.push_str("0.");
result.extend(std::iter::repeat_n('0', leading_zeros));
result.push_str(&digits);
result
}
}
fn scale_and_round(significand: u128, binary_exponent: i32, precision: usize) -> BigUint {
if significand == 0 {
return BigUint::from(0_u8);
}
let mut numerator = BigUint::from(significand) * pow_five(precision);
if binary_exponent >= 0 {
return numerator << (precision + binary_exponent as usize);
}
let denominator_shift = (-binary_exponent) as usize;
if precision >= denominator_shift {
return numerator << (precision - denominator_shift);
}
let shift = denominator_shift - precision;
let quotient = &numerator >> shift;
numerator -= "ient << shift;
let halfway = BigUint::from(1_u8) << (shift - 1);
if numerator > halfway || (numerator == halfway && quotient.bit(0)) {
quotient + 1_u8
} else {
quotient
}
}
fn pow_five(mut exponent: usize) -> BigUint {
let mut result = BigUint::from(1_u8);
let mut base = BigUint::from(5_u8);
while exponent != 0 {
if exponent & 1 != 0 {
result *= &base;
}
exponent >>= 1;
if exponent != 0 {
base = &base * &base;
}
}
result
}
fn pow_ten(exponent: usize) -> BigUint {
pow_five(exponent) << exponent
}
#[derive(Clone, Copy, Eq, PartialEq)]
enum Base {
Decimal,
Octal,
LowerHex,
UpperHex,
}
impl Base {
fn radix(self) -> u128 {
match self {
Self::Decimal => 10,
Self::Octal => 8,
Self::LowerHex | Self::UpperHex => 16,
}
}
fn digit(self, value: u128) -> u8 {
match value {
0..=9 => b'0' + value as u8,
10..=15 if self == Self::UpperHex => b'A' + (value - 10) as u8,
10..=15 => b'a' + (value - 10) as u8,
_ => unreachable!(),
}
}
}
fn write_integer(
f: &mut Formatter<'_>,
magnitude: u128,
negative: bool,
space_sign: bool,
base: Base,
) -> fmt::Result {
let mut digit_buffer = [0_u8; 128];
let mut digit_start = digit_buffer.len();
let precision = f.precision();
if magnitude != 0 || precision != Some(0) {
let radix = base.radix();
let mut remaining = magnitude;
loop {
digit_start -= 1;
digit_buffer[digit_start] = base.digit(remaining % radix);
remaining /= radix;
if remaining == 0 {
break;
}
}
}
let digits = &digit_buffer[digit_start..];
let mut precision_zeros = precision.unwrap_or_default().saturating_sub(digits.len());
let alternate = f.alternate();
if alternate && base == Base::Octal && precision_zeros == 0 && digits.first() != Some(&b'0') {
precision_zeros = 1;
}
let prefix = if alternate && magnitude != 0 {
match base {
Base::LowerHex => "0x",
Base::UpperHex => "0X",
Base::Decimal | Base::Octal => "",
}
} else {
""
};
let sign = if negative {
"-"
} else if f.sign_plus() {
"+"
} else if space_sign {
" "
} else {
""
};
let content_width = sign.len() + prefix.len() + precision_zeros + digits.len();
let padding = f.width().unwrap_or_default().saturating_sub(content_width);
let alignment = f.align().unwrap_or(Alignment::Right);
let zero_padding =
f.sign_aware_zero_pad() && precision.is_none() && alignment == Alignment::Right;
let (left_spaces, right_spaces) = if zero_padding {
(0, 0)
} else {
match alignment {
Alignment::Left => (0, padding),
Alignment::Right => (padding, 0),
Alignment::Center => (padding / 2, padding - padding / 2),
}
};
write_repeated(f, SPACE_PADDING, left_spaces)?;
f.write_str(sign)?;
f.write_str(prefix)?;
if zero_padding {
write_repeated(f, ZERO_PADDING, padding)?;
}
write_repeated(f, ZERO_PADDING, precision_zeros)?;
f.write_str(unsafe { std::str::from_utf8_unchecked(digits) })?;
write_repeated(f, SPACE_PADDING, right_spaces)
}
fn write_repeated(f: &mut Formatter<'_>, chunk: &str, mut count: usize) -> fmt::Result {
while count >= chunk.len() {
f.write_str(chunk)?;
count -= chunk.len();
}
if count != 0 {
f.write_str(&chunk[..count])?;
}
Ok(())
}