Trait malachite_base::num::conversion::traits::VecFromOtherType

pub trait VecFromOtherType<T>: Sized {
    // Required method
    fn vec_from_other_type(value: T) -> Vec<Self>;
}

Converts a slice of one type of value to a Vec of another type.

Required Methods

fn vec_from_other_type(value: T) -> Vec<Self>

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl VecFromOtherType<u8> for u8

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u8> for u16

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u8> for u32

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u8> for u64

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u8> for u128

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u8> for usize

fn vec_from_other_type(x: u8) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for u8

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for u16

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for u32

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for u64

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for u128

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u16> for usize

fn vec_from_other_type(x: u16) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for u8

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for u16

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for u32

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for u64

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for u128

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u32> for usize

fn vec_from_other_type(x: u32) -> Vec<Self>

Converts a u32 to a Vec of usizes.

Worst-case complexity

Constant time and additional memory.

See here.

impl VecFromOtherType<u64> for u8

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u64> for u16

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u64> for u32

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u64> for u64

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u64> for u128

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u64> for usize

fn vec_from_other_type(x: u64) -> Vec<Self>

Converts a u64 to a Vec of usizes.

Worst-case complexity

Constant time and additional memory.

See here.

impl VecFromOtherType<u128> for u8

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u128> for u16

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u128> for u32

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u128> for u64

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u128> for u128

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<u128> for usize

fn vec_from_other_type(x: u128) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<usize> for u8

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<usize> for u16

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a smaller unsigned type.

The input value will be broken up into several values in the output Vec.

$f(x) = (y_k){k=0}^{m-1}$, where $x = \sum{j=0}^{m-1}2^{jW}y_j$ and $m = 2^{V-W}n$.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<usize> for u32

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a usize to a Vec of u32s.

Worst-case complexity

Constant time and additional memory.

See here.

impl VecFromOtherType<usize> for u64

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a usize to a Vec of u64s.

Worst-case complexity

Constant time and additional memory.

See here.

impl VecFromOtherType<usize> for u128

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a value of one type of unsigned integer to a Vec of a larger unsigned type.

The output Vec only contains one value. The least-significant bits of the output value contain the input value, and the most-significant bits are set to 0.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl VecFromOtherType<usize> for usize

fn vec_from_other_type(x: usize) -> Vec<Self>

Converts a value of one type to a Vec of the same type.

In this case, it just creates a one-element Vec.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

Implementors