Struct malachite_nz::natural::conversion::string::to_string::BaseFmtWrapper

pub struct BaseFmtWrapper<T> { /* private fields */ }

A struct that allows for formatting a Natural or Integer and rendering its digits in a specified base.

Implementations

impl<T> BaseFmtWrapper<T>

pub fn new(x: T, base: u8) -> Self

Creates a new BaseFmtWrapper.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if base is less than 2 or greater than 36.

Examples

use malachite_nz::integer::Integer;
use malachite_nz::natural::conversion::string::to_string::BaseFmtWrapper;
use malachite_nz::natural::Natural;

let n = Natural::from(1000000000u32);
let x = BaseFmtWrapper::new(&n, 36);
assert_eq!(format!("{}", x), "gjdgxs");
assert_eq!(format!("{:#}", x), "GJDGXS");

let n = Integer::from(-1000000000);
let x = BaseFmtWrapper::new(&n, 36);
assert_eq!(format!("{}", x), "-gjdgxs");
assert_eq!(format!("{:#}", x), "-GJDGXS");

pub fn unwrap(self) -> T

Recovers the value from a BaseFmtWrapper.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_nz::natural::conversion::string::to_string::BaseFmtWrapper;
use malachite_nz::natural::Natural;

assert_eq!(
    BaseFmtWrapper::new(Natural::from(1000000000u32), 36).unwrap(),
    1000000000
);

Trait Implementations

impl<T: Clone> Clone for BaseFmtWrapper<T>

fn clone(&self) -> BaseFmtWrapper<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for BaseFmtWrapper<&'a Integer>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Writes a wrapped Integer to a string using a specified base.

If the base is greater than 10, lowercase alphabetic letters are used by default. Using the # flag switches to uppercase letters. Padding with zeros works as usual.

This is the same as the Display::fmt implementation.

Worst-case complexity

$T(n) = O(n (\log n)^2 \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if base is less than 2 or greater than 36.

Examples

use malachite_nz::integer::Integer;
use malachite_nz::natural::conversion::string::to_string::BaseFmtWrapper;

let n = Integer::from(-1000000000);
let x = BaseFmtWrapper::new(&n, 36);
assert_eq!(format!("{:?}", x), "-gjdgxs");
assert_eq!(format!("{:#?}", x), "-GJDGXS");
assert_eq!(format!("{:010?}", x), "-000gjdgxs");
assert_eq!(format!("{:#010?}", x), "-000GJDGXS");

impl<'a> Debug for BaseFmtWrapper<&'a Natural>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Writes a wrapped Natural to a string using a specified base.

If the base is greater than 10, lowercase alphabetic letters are used by default. Using the # flag switches to uppercase letters. Padding with zeros works as usual.

This is the same as the Display::fmt implementation.

Worst-case complexity

$T(n) = O(n (\log n)^2 \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if base is less than 2 or greater than 36.

Examples

use malachite_nz::natural::conversion::string::to_string::BaseFmtWrapper;
use malachite_nz::natural::Natural;

let n = Natural::from(1000000000u32);
let x = BaseFmtWrapper::new(&n, 36);
assert_eq!(format!("{:?}", x), "gjdgxs");
assert_eq!(format!("{:#?}", x), "GJDGXS");
assert_eq!(format!("{:010?}", x), "0000gjdgxs");
assert_eq!(format!("{:#010?}", x), "0000GJDGXS");

impl<'a> Display for BaseFmtWrapper<&'a Integer>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Writes a wrapped Integer to a string using a specified base.

If the base is greater than 10, lowercase alphabetic letters are used by default. Using the # flag switches to uppercase letters. Padding with zeros works as usual.

Worst-case complexity

$T(n) = O(n (\log n)^2 \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if base is less than 2 or greater than 36.

Examples

use malachite_nz::integer::Integer;
use malachite_nz::natural::conversion::string::to_string::BaseFmtWrapper;

let n = Integer::from(-1000000000);
let x = BaseFmtWrapper::new(&n, 36);
assert_eq!(format!("{}", x), "-gjdgxs");
assert_eq!(format!("{:#}", x), "-GJDGXS");
assert_eq!(format!("{:010}", x), "-000gjdgxs");
assert_eq!(format!("{:#010}", x), "-000GJDGXS");

impl<'a> Display for BaseFmtWrapper<&'a Natural>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Writes a wrapped Natural to a string using a specified base.

If the base is greater than 10, lowercase alphabetic letters are used by default. Using the # flag switches to uppercase letters. Padding with zeros works as usual.

Worst-case complexity

$T(n) = O(n (\log n)^2 \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if base is less than 2 or greater than 36.

Examples

use malachite_nz::natural::conversion::string::to_string::BaseFmtWrapper;
use malachite_nz::natural::Natural;

let n = Natural::from(1000000000u32);
let x = BaseFmtWrapper::new(&n, 36);
assert_eq!(format!("{}", x), "gjdgxs");
assert_eq!(format!("{:#}", x), "GJDGXS");
assert_eq!(format!("{:010}", x), "0000gjdgxs");
assert_eq!(format!("{:#010}", x), "0000GJDGXS");

impl<T: Hash> Hash for BaseFmtWrapper<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq for BaseFmtWrapper<T>

fn eq(&self, other: &BaseFmtWrapper<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq> Eq for BaseFmtWrapper<T>

impl<T> StructuralPartialEq for BaseFmtWrapper<T>