Lines
100 %
Functions
Branches
use crate::{Denominator, NotOne, Numerator, Q};
use core::fmt;
use core::ops::{Div, Rem};
use typenum::{Bit, Mod, NInt, PInt, Quot, UInt, UTerm, Unsigned, B0, B1, Z0};
macro_rules! impl_fmt {
($fmt:ident, $Fmt:path, $fmt_type:literal, $prefix:literal, $Ux:ty, $WIDTH:literal) => {
mod $fmt {
use super::*;
pub trait PrivateFmtHelperUInt {
type IsZero: Bit;
fn fmt(f: &mut fmt::Formatter) -> fmt::Result;
}
impl PrivateFmtHelperUInt for UTerm {
type IsZero = B1;
fn fmt(f: &mut fmt::Formatter) -> fmt::Result {
let _ = f;
Ok(())
impl<U, B> PrivateFmtHelperUInt for UInt<U, B>
where
Self: Div<$Ux> + Rem<$Ux>,
Quot<Self, $Ux>: PrivateFmtHelperUInt,
Mod<Self, $Ux>: Unsigned,
{
type IsZero = B0;
Quot::<Self, $Ux>::fmt(f)?;
if <Quot<Self, $Ux> as PrivateFmtHelperUInt>::IsZero::BOOL {
write!(f, concat!("{:", $fmt_type, "}"), Mod::<Self, $Ux>::U64)
} else {
write!(
f,
concat!("{:0", $WIDTH, $fmt_type, "}"),
Mod::<Self, $Ux>::U64
)
pub trait PrivateFmtHelperInt {
type IsNegative: Bit;
fn fmt_abs(f: &mut fmt::Formatter) -> fmt::Result;
impl PrivateFmtHelperInt for Z0 {
type IsNegative = B0;
fn fmt_abs(f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("0")
impl<U> PrivateFmtHelperInt for PInt<U>
U: Unsigned + typenum::NonZero + PrivateFmtHelperUInt,
U::fmt(f)
impl<U> PrivateFmtHelperInt for NInt<U>
type IsNegative = B1;
pub trait PrivateFmtHelper {
impl<N> PrivateFmtHelper for Q<N>
N: Numerator + PrivateFmtHelperInt,
if N::IsNegative::BOOL {
f.write_str("-")?;
} else if f.sign_plus() {
f.write_str("+")?;
if f.alternate() {
f.write_str($prefix)?;
N::fmt_abs(f)
impl<N, D> PrivateFmtHelper for Q<N, D>
N: Numerator<D> + PrivateFmtHelperInt,
D: Denominator + NotOne + PrivateFmtHelperInt,
N::fmt_abs(f)?;
f.write_str("/")?;
D::fmt_abs(f)
impl<N, D> $Fmt for Q<N, D>
Self: PrivateFmtHelper,
N: Numerator<D>,
D: Denominator,
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
<Self as PrivateFmtHelper>::fmt(f)
};
impl_fmt!(
display,
fmt::Display,
"",
// The largest power of 10 smaller than u64::MAX
typenum::consts::U10000000000000000000,
19
);
binary,
fmt::Binary,
"b",
"0b",
// 2 ** 64
UInt<typenum::consts::U9223372036854775808, B0>,
64
octal,
fmt::Octal,
"o",
"0o",
// 2 ** 63
typenum::consts::U9223372036854775808,
21
lower_hex,
fmt::LowerHex,
"x",
"0x",
16
upper_hex,
fmt::UpperHex,
"X",
#[cfg(test)]
mod tests {
use crate::*;
use char_buf::CharBuf;
use core::fmt::Write;
use typenum::{PInt, UInt};
macro_rules! format {
($($arg:tt)*) => {
let mut w = CharBuf::<1024>::new();
write!(w, $($arg)*).unwrap();
w
#[test]
fn test_display() {
assert_eq!(format!("{:+#}", Q::<Z0>::new()), "+0");
assert_eq!(format!("{:}", Q::<P1>::new()), "1");
assert_eq!(format!("{:}", Q::<N1>::new()), "-1");
assert_eq!(format!("{:+}", Q::<P2>::new()), "+2");
assert_eq!(format!("{:}", Q::<N2>::new()), "-2");
assert_eq!(format!("{:}", Q::<P1, P2>::new()), "1/2");
assert_eq!(format!("{:+}", Q::<P1, P2>::new()), "+1/2");
assert_eq!(format!("{:}", Q::<N1, P2>::new()), "-1/2");
assert_eq!(format!("{:#}", Q::<P1, P2>::new()), "1/2");
assert_eq!(
format!("{:#}", Q::<PInt<UInt<U10000000000000000000, B1>>>::new()),
"20000000000000000001"
fn test_binary() {
assert_eq!(format!("{:+#b}", Q::<Z0>::new()), "+0b0");
assert_eq!(format!("{:b}", Q::<P1>::new()), "1");
assert_eq!(format!("{:b}", Q::<N1>::new()), "-1");
assert_eq!(format!("{:+b}", Q::<P2>::new()), "+10");
assert_eq!(format!("{:b}", Q::<N2>::new()), "-10");
assert_eq!(format!("{:b}", Q::<P1, P2>::new()), "1/10");
assert_eq!(format!("{:+b}", Q::<P1, P2>::new()), "+1/10");
assert_eq!(format!("{:b}", Q::<N1, P2>::new()), "-1/10");
assert_eq!(format!("{:#b}", Q::<P1, P2>::new()), "0b1/0b10");
format!("{:+#b}", Q::<PInt<UInt<U9223372036854775808, B1>>>::new()),
"+0b10000000000000000000000000000000000000000000000000000000000000001"
fn test_octal() {
assert_eq!(format!("{:+#o}", Q::<Z0>::new()), "+0o0");
assert_eq!(format!("{:o}", Q::<P1>::new()), "1");
assert_eq!(format!("{:o}", Q::<N1>::new()), "-1");
assert_eq!(format!("{:+o}", Q::<P2>::new()), "+2");
assert_eq!(format!("{:o}", Q::<N2>::new()), "-2");
assert_eq!(format!("{:o}", Q::<P1, P2>::new()), "1/2");
assert_eq!(format!("{:+o}", Q::<P1, P2>::new()), "+1/2");
assert_eq!(format!("{:o}", Q::<N1, P2>::new()), "-1/2");
assert_eq!(format!("{:#o}", Q::<P1, P2>::new()), "0o1/0o2");
format!("{:+#o}", Q::<PInt<UInt<U9223372036854775808, B1>>>::new()),
"+0o2000000000000000000001"
fn test_lower_hex() {
assert_eq!(format!("{:+#x}", Q::<Z0>::new()), "+0x0");
assert_eq!(format!("{:x}", Q::<P1>::new()), "1");
assert_eq!(format!("{:x}", Q::<N1>::new()), "-1");
assert_eq!(format!("{:+x}", Q::<P2>::new()), "+2");
assert_eq!(format!("{:x}", Q::<N2>::new()), "-2");
assert_eq!(format!("{:x}", Q::<P1, P10>::new()), "1/a");
assert_eq!(format!("{:+x}", Q::<P1, P10>::new()), "+1/a");
assert_eq!(format!("{:x}", Q::<N1, P10>::new()), "-1/a");
assert_eq!(format!("{:#x}", Q::<P1, P10>::new()), "0x1/0xa");
format!("{:+#x}", Q::<PInt<UInt<U9223372036854775808, B1>>>::new()),
"+0x10000000000000001"
fn test_upper_hex() {
assert_eq!(format!("{:+#X}", Q::<Z0>::new()), "+0x0");
assert_eq!(format!("{:X}", Q::<P1>::new()), "1");
assert_eq!(format!("{:X}", Q::<N1>::new()), "-1");
assert_eq!(format!("{:+X}", Q::<P2>::new()), "+2");
assert_eq!(format!("{:X}", Q::<N2>::new()), "-2");
assert_eq!(format!("{:X}", Q::<P1, P10>::new()), "1/A");
assert_eq!(format!("{:+X}", Q::<P1, P10>::new()), "+1/A");
assert_eq!(format!("{:X}", Q::<N1, P10>::new()), "-1/A");
assert_eq!(format!("{:#X}", Q::<P1, P10>::new()), "0x1/0xA");
format!("{:+#X}", Q::<PInt<UInt<U9223372036854775808, B1>>>::new()),