Struct malachite_base::num::conversion::string::to_string::BaseFmtWrapper

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

A struct that allows for formatting a numeric type 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_base::num::conversion::string::to_string::BaseFmtWrapper;

let x = BaseFmtWrapper::new(1000000000u32, 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_base::num::conversion::string::to_string::BaseFmtWrapper;

assert_eq!(BaseFmtWrapper::new(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 Debug for BaseFmtWrapper<i128>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<i16>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<i32>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<i64>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<i8>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<isize>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<u128>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<u16>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<u32>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<u64>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<u8>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Debug for BaseFmtWrapper<usize>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<i128>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<i16>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<i32>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<i64>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<i8>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<isize>

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

Writes a wrapped signed number 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.

Unlike with the default implementations of Binary, Octal, LowerHex, and UpperHex, negative numbers are represented using a negative sign, not two’s complement.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<u128>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<u16>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<u32>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<u64>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<u8>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

impl Display for BaseFmtWrapper<usize>

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

Writes a wrapped unsigned number 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)$

$M(n) = O(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

See here.

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

Tests for self and other values to be equal, and is used by ==.

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

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>