Trait BitConvertible

pub trait BitConvertible {
    // Required methods
    fn to_bits_asc(&self) -> Vec<bool>;
    fn to_bits_desc(&self) -> Vec<bool>;
    fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> Self;
    fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> Self;
}

Defines functions that express a number as a Vec of bits or construct a number from an iterator of bits.

Required Methods

fn to_bits_asc(&self) -> Vec<bool>

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

fn to_bits_desc(&self) -> Vec<bool>

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

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> Self

Converts an iterator of bits into a number. The input bits are in ascending order: least- to most-significant.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> Self

Converts an iterator of bits into a value. The input bits are in descending order: most- to least-significant.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl BitConvertible for i8

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the last bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the first bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> i8

Converts an iterator of bits into a value. The bits should be in ascending order (least- to most-significant).

The bits are interpreted as in twos-complement, and the last bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

Let $k$ be bits.count(). If $k = 0$ or $b_{k-1}$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_{k-1}$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^i [b_i] \right ) - 2^k. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that doesn’t fit in the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> i8

Converts an iterator of bits into a value. The bits should be in descending order (most- to least-significant).

The bits are interpreted as in twos-complement, and the first bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

If bits is empty or $b_0$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_0$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^{k-i-1} [b_i] \right ) - 2^k. $$

Examples

See here.

impl BitConvertible for i16

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the last bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the first bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> i16

Converts an iterator of bits into a value. The bits should be in ascending order (least- to most-significant).

The bits are interpreted as in twos-complement, and the last bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

Let $k$ be bits.count(). If $k = 0$ or $b_{k-1}$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_{k-1}$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^i [b_i] \right ) - 2^k. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that doesn’t fit in the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> i16

Converts an iterator of bits into a value. The bits should be in descending order (most- to least-significant).

The bits are interpreted as in twos-complement, and the first bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

If bits is empty or $b_0$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_0$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^{k-i-1} [b_i] \right ) - 2^k. $$

Examples

See here.

impl BitConvertible for i32

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the last bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the first bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> i32

Converts an iterator of bits into a value. The bits should be in ascending order (least- to most-significant).

The bits are interpreted as in twos-complement, and the last bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

Let $k$ be bits.count(). If $k = 0$ or $b_{k-1}$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_{k-1}$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^i [b_i] \right ) - 2^k. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that doesn’t fit in the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> i32

Converts an iterator of bits into a value. The bits should be in descending order (most- to least-significant).

The bits are interpreted as in twos-complement, and the first bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

If bits is empty or $b_0$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_0$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^{k-i-1} [b_i] \right ) - 2^k. $$

Examples

See here.

impl BitConvertible for i64

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the last bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the first bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> i64

Converts an iterator of bits into a value. The bits should be in ascending order (least- to most-significant).

The bits are interpreted as in twos-complement, and the last bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

Let $k$ be bits.count(). If $k = 0$ or $b_{k-1}$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_{k-1}$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^i [b_i] \right ) - 2^k. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that doesn’t fit in the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> i64

Converts an iterator of bits into a value. The bits should be in descending order (most- to least-significant).

The bits are interpreted as in twos-complement, and the first bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

If bits is empty or $b_0$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_0$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^{k-i-1} [b_i] \right ) - 2^k. $$

Examples

See here.

impl BitConvertible for i128

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the last bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the first bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> i128

Converts an iterator of bits into a value. The bits should be in ascending order (least- to most-significant).

The bits are interpreted as in twos-complement, and the last bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

Let $k$ be bits.count(). If $k = 0$ or $b_{k-1}$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_{k-1}$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^i [b_i] \right ) - 2^k. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that doesn’t fit in the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> i128

Converts an iterator of bits into a value. The bits should be in descending order (most- to least-significant).

The bits are interpreted as in twos-complement, and the first bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

If bits is empty or $b_0$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_0$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^{k-i-1} [b_i] \right ) - 2^k. $$

Examples

See here.

impl BitConvertible for isize

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the last bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, the first bit is the sign bit: false if the number is non-negative and true if it is negative.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> isize

Converts an iterator of bits into a value. The bits should be in ascending order (least- to most-significant).

The bits are interpreted as in twos-complement, and the last bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

Let $k$ be bits.count(). If $k = 0$ or $b_{k-1}$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_{k-1}$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^i [b_i] \right ) - 2^k. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that doesn’t fit in the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> isize

Converts an iterator of bits into a value. The bits should be in descending order (most- to least-significant).

The bits are interpreted as in twos-complement, and the first bit is the sign bit; if it is false, the number is non-negative, and if it is true, the number is negative.

The function panics if the input represents a number that can’t fit in the output type.

If bits is empty or $b_0$ is false, then $$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

If $b_0$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^{k-i-1} [b_i] \right ) - 2^k. $$

Examples

See here.

impl BitConvertible for u8

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it ends with true.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it begins with true.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> u8

Converts an iterator of bits into a number. The bits should be in ascending order (least- to most-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> u8

Converts an iterator of bits into a number. The bits should be in descending order (most- to least-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

impl BitConvertible for u16

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it ends with true.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it begins with true.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> u16

Converts an iterator of bits into a number. The bits should be in ascending order (least- to most-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> u16

Converts an iterator of bits into a number. The bits should be in descending order (most- to least-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

impl BitConvertible for u32

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it ends with true.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it begins with true.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> u32

Converts an iterator of bits into a number. The bits should be in ascending order (least- to most-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> u32

Converts an iterator of bits into a number. The bits should be in descending order (most- to least-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

impl BitConvertible for u64

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it ends with true.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it begins with true.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> u64

Converts an iterator of bits into a number. The bits should be in ascending order (least- to most-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> u64

Converts an iterator of bits into a number. The bits should be in descending order (most- to least-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

impl BitConvertible for u128

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it ends with true.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it begins with true.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> u128

Converts an iterator of bits into a number. The bits should be in ascending order (least- to most-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> u128

Converts an iterator of bits into a number. The bits should be in descending order (most- to least-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

impl BitConvertible for usize

fn to_bits_asc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it ends with true.

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().

Examples

See here.

fn to_bits_desc(&self) -> Vec<bool>

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

If the number is 0, the Vec is empty; otherwise, it begins with true.

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().

Examples

See here.

fn from_bits_asc<I: Iterator<Item = bool>>(bits: I) -> usize

Converts an iterator of bits into a number. The bits should be in ascending order (least- to most-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

fn from_bits_desc<I: Iterator<Item = bool>>(bits: I) -> usize

Converts an iterator of bits into a number. The bits should be in descending order (most- to least-significant).

The function panics if the input represents a number that can’t fit in the output type.

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if the bits represent a value that isn’t representable by the output type.

Examples

See here.

Implementors