Struct Expand 

pub struct Expand<T, const D: usize>(/* private fields */)
where
    T: DilatableType;

A DilationMethod implementation which provides expanding dilation meta information

This trait implementation describes the types involved with an expanding dilation as well as some useful constants and wrapper methods which actually perform the dilations.

Although this trait implementation provides the functions for performing dilations, users should generally prefer to dilate via the DilateExpand trait and its dilate_expand() method, which is generally less verbose and therefore more user friendly.

Examples

use dilate::*;

assert_eq!(Expand::<u8, 2>::UNDILATED_MAX, 255);
assert_eq!(Expand::<u8, 2>::UNDILATED_BITS, 8);

assert_eq!(Expand::<u8, 2>::DILATED_MAX, 0b0101010101010101);
assert_eq!(Expand::<u8, 2>::DILATED_BITS, 16);

let original: u8 = 0b1101;
let dilated = Expand::<u8, 2>::dilate(original);

assert_eq!(dilated.value(), 0b01010001);
assert_eq!(dilated, DilatedInt::<Expand<u8, 2>>::new(0b01010001));

assert_eq!(Expand::<u8, 2>::undilate(dilated), original);

For more detailed information, see dilate_expand()

Trait Implementations

impl<T, const D: usize> Clone for Expand<T, D>

where T: DilatableType + Clone,

fn clone(&self) -> Expand<T, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, const D: usize> Debug for Expand<T, D>

where T: DilatableType + Debug,

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

Formats the value using the given formatter.

impl<T, const D: usize> Default for Expand<T, D>

where T: DilatableType + Default,

fn default() -> Expand<T, D>

Returns the “default value” for a type.

impl DilationMethod for Expand<u16, 2>

const D: usize = 2usize

The dilation amount

const UNDILATED_BITS: usize = 16usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffff): <expand::Expand<u16, 2> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 32usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x55555555): <expand::Expand<u16, 2> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffffffff): <expand::Expand<u16, 2> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u16

The external undilated integer type

type Dilated = u32

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u16, 3>

const D: usize = 3usize

The dilation amount

const UNDILATED_BITS: usize = 16usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffff): <expand::Expand<u16, 3> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 48usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x0000249249249249): <expand::Expand<u16, 3> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x0000ffffffffffff): <expand::Expand<u16, 3> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u16

The external undilated integer type

type Dilated = u64

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u16, 4>

const D: usize = 4usize

The dilation amount

const UNDILATED_BITS: usize = 16usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffff): <expand::Expand<u16, 4> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 64usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x1111111111111111): <expand::Expand<u16, 4> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffffffffffffffff): <expand::Expand<u16, 4> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u16

The external undilated integer type

type Dilated = u64

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u16, 5>

const D: usize = 5usize

The dilation amount

const UNDILATED_BITS: usize = 16usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffff): <expand::Expand<u16, 5> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 80usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000000000008421084210842108421): <expand::Expand<u16, 5> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x000000000000ffffffffffffffffffff): <expand::Expand<u16, 5> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u16

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u16, 6>

const D: usize = 6usize

The dilation amount

const UNDILATED_BITS: usize = 16usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffff): <expand::Expand<u16, 6> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 96usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000000041041041041041041041041): <expand::Expand<u16, 6> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x00000000ffffffffffffffffffffffff): <expand::Expand<u16, 6> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u16

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u16, 7>

const D: usize = 7usize

The dilation amount

const UNDILATED_BITS: usize = 16usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffff): <expand::Expand<u16, 7> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 112usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000204081020408102040810204081): <expand::Expand<u16, 7> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x0000ffffffffffffffffffffffffffff): <expand::Expand<u16, 7> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u16

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u16, 8>

const D: usize = 8usize

The dilation amount

const UNDILATED_BITS: usize = 16usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffff): <expand::Expand<u16, 8> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 128usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x01010101010101010101010101010101): <expand::Expand<u16, 8> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffffffffffffffffffffffffffffffff): <expand::Expand<u16, 8> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u16

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u32, 2>

const D: usize = 2usize

The dilation amount

const UNDILATED_BITS: usize = 32usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffffffff): <expand::Expand<u32, 2> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 64usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x5555555555555555): <expand::Expand<u32, 2> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffffffffffffffff): <expand::Expand<u32, 2> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u32

The external undilated integer type

type Dilated = u64

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u32, 3>

const D: usize = 3usize

The dilation amount

const UNDILATED_BITS: usize = 32usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffffffff): <expand::Expand<u32, 3> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 96usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000000249249249249249249249249): <expand::Expand<u32, 3> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x00000000ffffffffffffffffffffffff): <expand::Expand<u32, 3> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u32

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u32, 4>

const D: usize = 4usize

The dilation amount

const UNDILATED_BITS: usize = 32usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffffffff): <expand::Expand<u32, 4> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 128usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x11111111111111111111111111111111): <expand::Expand<u32, 4> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffffffffffffffffffffffffffffffff): <expand::Expand<u32, 4> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u32

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u64, 2>

const D: usize = 2usize

The dilation amount

const UNDILATED_BITS: usize = 64usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffffffffffffffff): <expand::Expand<u64, 2> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 128usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x55555555555555555555555555555555): <expand::Expand<u64, 2> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffffffffffffffffffffffffffffffff): <expand::Expand<u64, 2> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u64

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 10>

const D: usize = 10usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 10> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 80usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000000000000401004010040100401): <expand::Expand<u8, 10> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x000000000000ffffffffffffffffffff): <expand::Expand<u8, 10> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 11>

const D: usize = 11usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 11> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 88usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000000000020040080100200400801): <expand::Expand<u8, 11> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x0000000000ffffffffffffffffffffff): <expand::Expand<u8, 11> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 12>

const D: usize = 12usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 12> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 96usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000000001001001001001001001001): <expand::Expand<u8, 12> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x00000000ffffffffffffffffffffffff): <expand::Expand<u8, 12> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 13>

const D: usize = 13usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 13> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 104usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000000080040020010008004002001): <expand::Expand<u8, 13> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x000000ffffffffffffffffffffffffff): <expand::Expand<u8, 13> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 14>

const D: usize = 14usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 14> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 112usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000004001000400100040010004001): <expand::Expand<u8, 14> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x0000ffffffffffffffffffffffffffff): <expand::Expand<u8, 14> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 15>

const D: usize = 15usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 15> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 120usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000200040008001000200040008001): <expand::Expand<u8, 15> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x00ffffffffffffffffffffffffffffff): <expand::Expand<u8, 15> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 16>

const D: usize = 16usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 16> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 128usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00010001000100010001000100010001): <expand::Expand<u8, 16> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffffffffffffffffffffffffffffffff): <expand::Expand<u8, 16> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 2>

const D: usize = 2usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 2> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 16usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x5555): <expand::Expand<u8, 2> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffff): <expand::Expand<u8, 2> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u16

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 3>

const D: usize = 3usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 3> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 24usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00249249): <expand::Expand<u8, 3> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x00ffffff): <expand::Expand<u8, 3> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u32

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 4>

const D: usize = 4usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 4> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 32usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x11111111): <expand::Expand<u8, 4> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffffffff): <expand::Expand<u8, 4> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u32

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 5>

const D: usize = 5usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 5> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 40usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x0000000842108421): <expand::Expand<u8, 5> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x000000ffffffffff): <expand::Expand<u8, 5> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u64

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 6>

const D: usize = 6usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 6> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 48usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x0000041041041041): <expand::Expand<u8, 6> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x0000ffffffffffff): <expand::Expand<u8, 6> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u64

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 7>

const D: usize = 7usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 7> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 56usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x0002040810204081): <expand::Expand<u8, 7> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x00ffffffffffffff): <expand::Expand<u8, 7> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u64

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 8>

const D: usize = 8usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 8> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 64usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x0101010101010101): <expand::Expand<u8, 8> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffffffffffffffff): <expand::Expand<u8, 8> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u64

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<u8, 9>

const D: usize = 9usize

The dilation amount

const UNDILATED_BITS: usize = 8usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xff): <expand::Expand<u8, 9> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 72usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x00000000000000008040201008040201): <expand::Expand<u8, 9> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0x00000000000000ffffffffffffffffff): <expand::Expand<u8, 9> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = u8

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl DilationMethod for Expand<usize, 2>

const D: usize = 2usize

The dilation amount

const UNDILATED_BITS: usize = 64usize

The number of bits in the DilationMethod::Undilated type which may be dilated into DilationMethod::Dilated

const UNDILATED_MAX: Self::Undilated = {transmute(0xffffffffffffffff): <expand::Expand<usize, 2> as DilationMethod>::Undilated}

The maximum undilated value which may be dilated by this dilation method

const DILATED_BITS: usize = 128usize

The number of maximally dilated bits occupied in DilationMethod::Dilated

const DILATED_MAX: Self::Dilated = {transmute(0x55555555555555555555555555555555): <expand::Expand<usize, 2> as DilationMethod>::Dilated}

The maximum dilated value that can be stored in DilationMethod::Dilated

const DILATED_MASK: Self::Dilated = {transmute(0xffffffffffffffffffffffffffffffff): <expand::Expand<usize, 2> as DilationMethod>::Dilated}

A mask of all dilated bits, including 0 bits

type Undilated = usize

The external undilated integer type

type Dilated = u128

The internal dilated integer type

fn to_dilated(undilated: Self::Undilated) -> Self::Dilated

This function casts an undilated integer to a dilated integer

fn to_undilated(dilated: Self::Dilated) -> Self::Undilated

This function converts a dilated integer to an undilated integer

fn dilate(value: Self::Undilated) -> DilatedInt<Self>

This function carries out the dilation process, converting the DilationMethod::Undilated value to a DilatedInt.

fn undilate(value: DilatedInt<Self>) -> Self::Undilated

This function carries out the undilation process, converting a DilatedInt back to an DilationMethod::Undilated value.

impl<T, const D: usize> Hash for Expand<T, D>

where T: DilatableType + Hash,

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, const D: usize> Ord for Expand<T, D>

where T: DilatableType + Ord,

fn cmp(&self, other: &Expand<T, D>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T, const D: usize> PartialEq for Expand<T, D>

where T: DilatableType + PartialEq,

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

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

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

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

impl<T, const D: usize> PartialOrd for Expand<T, D>

where T: DilatableType + PartialOrd,

fn partial_cmp(&self, other: &Expand<T, D>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, const D: usize> Copy for Expand<T, D>

where T: DilatableType + Copy,

impl<T, const D: usize> Eq for Expand<T, D>

where T: DilatableType + Eq,

impl<T, const D: usize> StructuralPartialEq for Expand<T, D>

where T: DilatableType,