Trait malachite_base::num::conversion::traits::PowerOf2Digits

pub trait PowerOf2Digits<T>: Sized {
    // Required methods
    fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<T>;
    fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<T>;
    fn from_power_of_2_digits_asc<I: Iterator<Item = T>>(
        log_base: u64,
        digits: I,
    ) -> Option<Self>;
    fn from_power_of_2_digits_desc<I: Iterator<Item = T>>(
        log_base: u64,
        digits: I,
    ) -> Option<Self>;
}

Expresses a value as a Vec of base-$2^k$ digits, or reads a value from an iterator of base-$2^k$ digits.

The trait is parameterized by the digit type.

Required Methods

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<T>

Returns a Vec containing the digits of a value in ascending order: least- to most-significant.

The base is $2^k$, where $k$ is log_base.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<T>

Returns a Vec containing the digits of a value in descending order: most- to least-significant.

The base is $2^k$, where $k$ is log_base.

fn from_power_of_2_digits_asc<I: Iterator<Item = T>>( log_base: u64, digits: I, ) -> Option<Self>

Converts an iterator of digits into a value.

The input digits are in ascending order: least- to most-significant. The base is $2^k$, where $k$ is log_base.

fn from_power_of_2_digits_desc<I: Iterator<Item = T>>( log_base: u64, digits: I, ) -> Option<Self>

Converts an iterator of digits into a value.

The input digits are in descending order: most- to least-significant. The base is $2^k$, where $k$ is log_base.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl PowerOf2Digits<u8> for u8

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u8> for u16

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u8> for u32

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u8> for u64

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u8> for u128

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u8> for usize

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u8>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u16> for u8

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u16> for u16

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u16> for u32

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u16> for u64

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u16> for u128

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u16> for usize

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u16>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u32> for u8

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u32> for u16

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u32> for u32

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u32> for u64

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u32> for u128

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u32> for usize

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u32>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u64> for u8

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u64> for u16

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u64> for u32

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u64> for u64

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u64> for u128

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u64> for usize

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u64>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u128> for u8

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u128> for u16

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u128> for u32

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u128> for u64

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u128> for u128

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<u128> for usize

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u128>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<usize> for u8

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<u8>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<usize> for u16

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<u16>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<usize> for u32

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<u32>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<usize> for u64

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<u64>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<usize> for u128

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<u128>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

impl PowerOf2Digits<usize> for usize

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in ascending order (least- to most-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a number in descending order (most- to least-significant).

The base-2 logarithm of the base is specified. log_base must be no larger than the width of the digit type. If self is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = x. $$

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 log_base is greater than the width of the output type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in ascending order (least- to most-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = usize>>( log_base: u64, digits: I, ) -> Option<usize>

Converts an iterator of base-$2^k$ digits into a value.

The base-2 logarithm of the base is specified. The input digits are in descending order (most- to least-significant). log_base must be no larger than the width of the digit type. The function returns None if the input represents a number that can’t fit in the output type.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

Implementors