use crate::options::{Options, RoundMode};
use lexical_util::digit::{char_to_valid_digit_const, digit_to_char_const};
use lexical_util::format::NumberFormat;
use lexical_write_integer::write::WriteInteger;
#[inline(always)]
pub fn min_exact_digits(digit_count: usize, options: &Options) -> usize {
let mut exact_count: usize = digit_count;
if let Some(min_digits) = options.min_significant_digits() {
exact_count = min_digits.get().max(exact_count);
}
exact_count
}
#[cfg_attr(not(feature = "compact"), inline)]
pub unsafe fn round_up(digits: &mut [u8], count: usize, radix: u32) -> (usize, bool) {
debug_assert!(count <= digits.len());
let mut index = count;
let max_char = digit_to_char_const(radix - 1, radix);
while index != 0 {
let c = unsafe { index_unchecked!(digits[index - 1]) };
if c < max_char {
let digit = char_to_valid_digit_const(c, radix);
let rounded = digit_to_char_const(digit + 1, radix);
unsafe { index_unchecked_mut!(digits[index - 1]) = rounded };
return (index, false);
}
index -= 1;
}
unsafe { index_unchecked_mut!(digits[0]) = b'1' };
(1, true)
}
#[allow(clippy::comparison_chain)]
#[cfg_attr(not(feature = "compact"), inline)]
pub unsafe fn truncate_and_round_decimal(
digits: &mut [u8],
digit_count: usize,
options: &Options,
) -> (usize, bool) {
debug_assert!(digit_count <= digits.len());
let max_digits = if let Some(digits) = options.max_significant_digits() {
digits.get()
} else {
return (digit_count, false);
};
if max_digits >= digit_count {
return (digit_count, false);
}
if options.round_mode() == RoundMode::Truncate {
return (max_digits, false);
}
let truncated = unsafe { index_unchecked!(digits[max_digits]) };
let (digits, carried) = if truncated < b'5' {
(max_digits, false)
} else if truncated > b'5' {
unsafe { round_up(digits, max_digits, 10) }
} else {
let (is_odd, is_above) = unsafe {
let to_round = &index_unchecked!(digits[max_digits - 1..digit_count]);
let is_odd = index_unchecked!(to_round[0]) % 2 == 1;
let is_above = index_unchecked!(to_round[2..]).iter().any(|&x| x != b'0');
(is_odd, is_above)
};
if is_odd || is_above {
unsafe { round_up(digits, max_digits, 10) }
} else {
(max_digits, false)
}
};
(digits, carried)
}
#[cfg_attr(not(feature = "compact"), inline)]
pub unsafe fn write_exponent_sign<const FORMAT: u128>(
bytes: &mut [u8],
cursor: &mut usize,
exp: i32,
) -> u32 {
let format = NumberFormat::<{ FORMAT }> {};
if exp < 0 {
unsafe { index_unchecked_mut!(bytes[*cursor]) = b'-' };
*cursor += 1;
exp.wrapping_neg() as u32
} else if cfg!(feature = "format") && format.required_exponent_sign() {
unsafe { index_unchecked_mut!(bytes[*cursor]) = b'+' };
*cursor += 1;
exp as u32
} else {
exp as u32
}
}
#[cfg_attr(not(feature = "compact"), inline)]
pub unsafe fn write_exponent<const FORMAT: u128>(
bytes: &mut [u8],
cursor: &mut usize,
exp: i32,
exponent_character: u8,
) {
*cursor += unsafe {
index_unchecked_mut!(bytes[*cursor]) = exponent_character;
*cursor += 1;
let positive_exp = write_exponent_sign::<FORMAT>(bytes, cursor, exp);
positive_exp.write_exponent::<u32, FORMAT>(&mut index_unchecked_mut!(bytes[*cursor..]))
};
}
macro_rules! write_float {
(
$format:ident,
$sci_exp:ident,
$options:ident,
$write_scientific:ident,
$write_positive:ident,
$write_negative:ident,
$(generic => $generic:tt,)?
args => $($args:expr,)*
) => {{
use lexical_util::format::NumberFormat;
let format = NumberFormat::<{ $format }> {};
let min_exp = $options.negative_exponent_break().map_or(-5, |x| x.get());
let max_exp = $options.positive_exponent_break().map_or(9, |x| x.get());
let outside_break = $sci_exp < min_exp || $sci_exp > max_exp;
let require_exponent = format.required_exponent_notation() || outside_break;
if !format.no_exponent_notation() && require_exponent {
unsafe { $write_scientific::<$($generic,)? FORMAT>($($args,)*) }
} else if $sci_exp >= 0 {
unsafe { $write_positive::<$($generic,)? FORMAT>($($args,)*) }
} else {
unsafe { $write_negative::<$($generic,)? FORMAT>($($args,)*) }
}
}};
}