Trait oxygengine_physics_2d::prelude::ncollide2d::simba::scalar::SubsetOf[−]

pub trait SubsetOf<T> {
    pub fn to_superset(&self) -> T;
    pub fn from_superset_unchecked(element: &T) -> Self;
    pub fn is_in_subset(element: &T) -> bool;

    pub fn from_superset(element: &T) -> Option<Self> { ... }
}

Nested sets and conversions between them (using an injective mapping). Useful to work with substructures. In generic code, it is preferable to use SupersetOf as trait bound whenever possible instead of SubsetOf (because SupersetOf is automatically implemented whenever SubsetOf is).

The notion of “nested sets” is very broad and applies to what the types are supposed to represent, independently from their actual implementation details and limitations. For example:

f32 and f64 are both supposed to represent reals and are thus considered equal (even if in practice f64 has more elements).
u32 and i8 are respectively supposed to represent natural and relative numbers. Thus, u32 is a subset of i8.
A quaternion and a 3x3 orthogonal matrix with unit determinant are both sets of rotations. They can thus be considered equal.

In other words, implementation details due to machine limitations are ignored (otherwise we could not even, e.g., convert a u64 to an i64). If considering those limitations are important, other crates allowing you to query the limitations of given types should be used.

Required methods

`pub fn to_superset(&self) -> T`

The inclusion map: converts self to the equivalent element of its superset.

`pub fn from_superset_unchecked(element: &T) -> Self`

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

`pub fn is_in_subset(element: &T) -> bool`

Checks if element is actually part of the subset Self (and can be converted to it).

Loading content...

Provided methods

`pub fn from_superset(element: &T) -> Option<Self>`

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

Must return None if element has no equivalent in Self.

Loading content...

Implementations on Foreign Types

`impl<N2> SubsetOf<AutoSimd<N2>> for usize where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<usize>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> usize`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<i128> for isize`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> isize`

`pub fn is_in_subset(&i128) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for u32 where N2: Zero + SupersetOf<u32>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> u32`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<f64> for f32`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> f32`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<i16> for i128`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> i128`

`pub fn is_in_subset(&i16) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for i64 where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<i64>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> i64`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<f32> for u128`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> u128`

`pub fn is_in_subset(&f32) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for i32 where N2: Zero + SupersetOf<i32>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> i32`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<f64> for i32`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> i32`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<u128> for u8`

`pub fn to_superset(&self) -> u128`

`pub fn from_superset_unchecked(element: &u128) -> u8`

`pub fn is_in_subset(&u128) -> bool`

`impl SubsetOf<f64> for isize`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> isize`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<u128> for u64`

`pub fn to_superset(&self) -> u128`

`pub fn from_superset_unchecked(element: &u128) -> u64`

`pub fn is_in_subset(&u128) -> bool`

`impl SubsetOf<u8> for usize`

`pub fn to_superset(&self) -> u8`

`pub fn from_superset_unchecked(element: &u8) -> usize`

`pub fn is_in_subset(&u8) -> bool`

`impl SubsetOf<isize> for u128`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> u128`

`pub fn is_in_subset(&isize) -> bool`

`impl SubsetOf<f64> for i64`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> i64`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<u128> for u32`

`pub fn to_superset(&self) -> u128`

`pub fn from_superset_unchecked(element: &u128) -> u32`

`pub fn is_in_subset(&u128) -> bool`

`impl SubsetOf<i16> for i64`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> i64`

`pub fn is_in_subset(&i16) -> bool`

`impl SubsetOf<u32> for u32`

`pub fn to_superset(&self) -> u32`

`pub fn from_superset_unchecked(element: &u32) -> u32`

`pub fn is_in_subset(&u32) -> bool`

`impl SubsetOf<u16> for u8`

`pub fn to_superset(&self) -> u16`

`pub fn from_superset_unchecked(element: &u16) -> u8`

`pub fn is_in_subset(&u16) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for i8 where N2: Zero + SupersetOf<i8>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> i8`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<u8> for u16`

`pub fn to_superset(&self) -> u8`

`pub fn from_superset_unchecked(element: &u8) -> u16`

`pub fn is_in_subset(&u8) -> bool`

`impl SubsetOf<i16> for i8`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> i8`

`pub fn is_in_subset(&i16) -> bool`

`impl SubsetOf<i64> for usize`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> usize`

`pub fn is_in_subset(&i64) -> bool`

`impl SubsetOf<i128> for i32`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> i32`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<f32> for isize`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> isize`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<u8> for u64`

`pub fn to_superset(&self) -> u8`

`pub fn from_superset_unchecked(element: &u8) -> u64`

`pub fn is_in_subset(&u8) -> bool`

`impl SubsetOf<i16> for u128`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> u128`

`pub fn is_in_subset(&i16) -> bool`

`impl SubsetOf<f32> for i8`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> i8`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<isize> for i32`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> i32`

`pub fn is_in_subset(&isize) -> bool`

`impl SubsetOf<usize> for u32`

`pub fn to_superset(&self) -> usize`

`pub fn from_superset_unchecked(element: &usize) -> u32`

`pub fn is_in_subset(&usize) -> bool`

`impl SubsetOf<i8> for i16`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> i16`

`pub fn is_in_subset(&i8) -> bool`

`impl SubsetOf<isize> for usize`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> usize`

`pub fn is_in_subset(&isize) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for f64 where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<f64>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> f64`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<i32> for u16`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> u16`

`pub fn is_in_subset(&i32) -> bool`

`impl SubsetOf<i32> for i16`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> i16`

`pub fn is_in_subset(&i32) -> bool`

`impl SubsetOf<u8> for u8`

`pub fn to_superset(&self) -> u8`

`pub fn from_superset_unchecked(element: &u8) -> u8`

`pub fn is_in_subset(&u8) -> bool`

`impl SubsetOf<i128> for i8`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> i8`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<i128> for u128`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> u128`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<i64> for i32`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> i32`

`pub fn is_in_subset(&i64) -> bool`

`impl SubsetOf<u128> for usize`

`pub fn to_superset(&self) -> u128`

`pub fn from_superset_unchecked(element: &u128) -> usize`

`pub fn is_in_subset(&u128) -> bool`

`impl SubsetOf<f64> for i128`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> i128`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<u32> for u16`

`pub fn to_superset(&self) -> u32`

`pub fn from_superset_unchecked(element: &u32) -> u16`

`pub fn is_in_subset(&u32) -> bool`

`impl SubsetOf<i16> for usize`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> usize`

`pub fn is_in_subset(&i16) -> bool`

`impl SubsetOf<i8> for i128`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> i128`

`pub fn is_in_subset(&i8) -> bool`

`impl SubsetOf<i32> for u8`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> u8`

`pub fn is_in_subset(&i32) -> bool`

`impl SubsetOf<isize> for u64`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> u64`

`pub fn is_in_subset(&isize) -> bool`

`impl SubsetOf<i16> for i16`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> i16`

`pub fn is_in_subset(&i16) -> bool`

`impl SubsetOf<i16> for isize`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> isize`

`pub fn is_in_subset(&i16) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for u16 where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<u16>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> u16`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<i8> for u16`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> u16`

`pub fn is_in_subset(&i8) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for f32 where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<f32>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> f32`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<u16> for u128`

`pub fn to_superset(&self) -> u16`

`pub fn from_superset_unchecked(element: &u16) -> u128`

`pub fn is_in_subset(&u16) -> bool`

`impl SubsetOf<f32> for i16`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> i16`

`pub fn is_in_subset(&f32) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for usize where N2: Zero + SupersetOf<usize>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> usize`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<u16> for usize`

`pub fn to_superset(&self) -> u16`

`pub fn from_superset_unchecked(element: &u16) -> usize`

`pub fn is_in_subset(&u16) -> bool`

`impl SubsetOf<i8> for u32`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> u32`

`pub fn is_in_subset(&i8) -> bool`

`impl SubsetOf<u64> for u64`

`pub fn to_superset(&self) -> u64`

`pub fn from_superset_unchecked(element: &u64) -> u64`

`pub fn is_in_subset(&u64) -> bool`

`impl SubsetOf<u128> for u128`

`pub fn to_superset(&self) -> u128`

`pub fn from_superset_unchecked(element: &u128) -> u128`

`pub fn is_in_subset(&u128) -> bool`

`impl SubsetOf<i16> for u16`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> u16`

`pub fn is_in_subset(&i16) -> bool`

`impl SubsetOf<u128> for u16`

`pub fn to_superset(&self) -> u128`

`pub fn from_superset_unchecked(element: &u128) -> u16`

`pub fn is_in_subset(&u128) -> bool`

`impl SubsetOf<u32> for u64`

`pub fn to_superset(&self) -> u32`

`pub fn from_superset_unchecked(element: &u32) -> u64`

`pub fn is_in_subset(&u32) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for isize where N2: Zero + SupersetOf<isize>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> isize`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<u64> for u32`

`pub fn to_superset(&self) -> u64`

`pub fn from_superset_unchecked(element: &u64) -> u32`

`pub fn is_in_subset(&u64) -> bool`

`impl SubsetOf<f32> for u64`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> u64`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<isize> for i16`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> i16`

`pub fn is_in_subset(&isize) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for i128 where N2: Zero + SupersetOf<i128>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> i128`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<i64> for i16`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> i16`

`pub fn is_in_subset(&i64) -> bool`

`impl SubsetOf<i128> for u8`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> u8`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<u8> for u128`

`pub fn to_superset(&self) -> u8`

`pub fn from_superset_unchecked(element: &u8) -> u128`

`pub fn is_in_subset(&u8) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for u16 where N2: Zero + SupersetOf<u16>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> u16`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<i16> for u8`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> u8`

`pub fn is_in_subset(&i16) -> bool`

`impl SubsetOf<u64> for u128`

`pub fn to_superset(&self) -> u64`

`pub fn from_superset_unchecked(element: &u64) -> u128`

`pub fn is_in_subset(&u64) -> bool`

`impl SubsetOf<u32> for u8`

`pub fn to_superset(&self) -> u32`

`pub fn from_superset_unchecked(element: &u32) -> u8`

`pub fn is_in_subset(&u32) -> bool`

`impl SubsetOf<u32> for usize`

`pub fn to_superset(&self) -> u32`

`pub fn from_superset_unchecked(element: &u32) -> usize`

`pub fn is_in_subset(&u32) -> bool`

`impl SubsetOf<i8> for i32`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> i32`

`pub fn is_in_subset(&i8) -> bool`

`impl SubsetOf<isize> for isize`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> isize`

`pub fn is_in_subset(&isize) -> bool`

`impl SubsetOf<usize> for usize`

`pub fn to_superset(&self) -> usize`

`pub fn from_superset_unchecked(element: &usize) -> usize`

`pub fn is_in_subset(&usize) -> bool`

`impl SubsetOf<i64> for isize`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> isize`

`pub fn is_in_subset(&i64) -> bool`

`impl SubsetOf<isize> for i8`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> i8`

`pub fn is_in_subset(&isize) -> bool`

`impl SubsetOf<i16> for u32`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> u32`

`pub fn is_in_subset(&i16) -> bool`

`impl SubsetOf<f64> for u64`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> u64`

`pub fn is_in_subset(&f64) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for i8 where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<i8>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> i8`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<i32> for usize`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> usize`

`pub fn is_in_subset(&i32) -> bool`

`impl SubsetOf<isize> for u32`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> u32`

`pub fn is_in_subset(&isize) -> bool`

`impl SubsetOf<f32> for i64`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> i64`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<usize> for u16`

`pub fn to_superset(&self) -> usize`

`pub fn from_superset_unchecked(element: &usize) -> u16`

`pub fn is_in_subset(&usize) -> bool`

`impl SubsetOf<f32> for u32`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> u32`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<f32> for u8`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> u8`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<i128> for i128`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> i128`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<i16> for i32`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> i32`

`pub fn is_in_subset(&i16) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for f64 where N2: Zero + SupersetOf<f64>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> f64`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<u16> for u32`

`pub fn to_superset(&self) -> u16`

`pub fn from_superset_unchecked(element: &u16) -> u32`

`pub fn is_in_subset(&u16) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for u8 where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<u8>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> u8`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<f32> for f32`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> f32`

`pub fn is_in_subset(&f32) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for u128 where N2: Zero + SupersetOf<u128>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> u128`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<i32> for i8`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> i8`

`pub fn is_in_subset(&i32) -> bool`

`impl SubsetOf<i64> for u128`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> u128`

`pub fn is_in_subset(&i64) -> bool`

`impl SubsetOf<i8> for i8`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> i8`

`pub fn is_in_subset(&i8) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for u64 where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<u64>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> u64`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<f64> for f64`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> f64`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<i128> for i64`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> i64`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<f64> for u128`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> u128`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<i32> for i64`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> i64`

`pub fn is_in_subset(&i32) -> bool`

`impl SubsetOf<usize> for u128`

`pub fn to_superset(&self) -> usize`

`pub fn from_superset_unchecked(element: &usize) -> u128`

`pub fn is_in_subset(&usize) -> bool`

`impl SubsetOf<i32> for i32`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> i32`

`pub fn is_in_subset(&i32) -> bool`

`impl SubsetOf<f32> for u16`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> u16`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<i64> for u64`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> u64`

`pub fn is_in_subset(&i64) -> bool`

`impl SubsetOf<i64> for u32`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> u32`

`pub fn is_in_subset(&i64) -> bool`

`impl SubsetOf<i32> for u32`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> u32`

`pub fn is_in_subset(&i32) -> bool`

`impl SubsetOf<i128> for u32`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> u32`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<f64> for i8`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> i8`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<i64> for u8`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> u8`

`pub fn is_in_subset(&i64) -> bool`

`impl SubsetOf<u64> for u16`

`pub fn to_superset(&self) -> u64`

`pub fn from_superset_unchecked(element: &u64) -> u16`

`pub fn is_in_subset(&u64) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for i32 where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<i32>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> i32`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<i64> for i128`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> i128`

`pub fn is_in_subset(&i64) -> bool`

`impl SubsetOf<f32> for i32`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> i32`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<i8> for u128`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> u128`

`pub fn is_in_subset(&i8) -> bool`

`impl SubsetOf<isize> for u16`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> u16`

`pub fn is_in_subset(&isize) -> bool`

`impl SubsetOf<f32> for usize`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> usize`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<i8> for isize`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> isize`

`pub fn is_in_subset(&i8) -> bool`

`impl SubsetOf<i128> for u16`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> u16`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<f64> for usize`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> usize`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<u16> for u16`

`pub fn to_superset(&self) -> u16`

`pub fn from_superset_unchecked(element: &u16) -> u16`

`pub fn is_in_subset(&u16) -> bool`

`impl SubsetOf<isize> for i128`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> i128`

`pub fn is_in_subset(&isize) -> bool`

`impl SubsetOf<f64> for u8`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> u8`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<u32> for u128`

`pub fn to_superset(&self) -> u32`

`pub fn from_superset_unchecked(element: &u32) -> u128`

`pub fn is_in_subset(&u32) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for isize where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<isize>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> isize`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<u64> for usize`

`pub fn to_superset(&self) -> u64`

`pub fn from_superset_unchecked(element: &u64) -> usize`

`pub fn is_in_subset(&u64) -> bool`

`impl SubsetOf<isize> for i64`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> i64`

`pub fn is_in_subset(&isize) -> bool`

`impl SubsetOf<i32> for i128`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> i128`

`pub fn is_in_subset(&i32) -> bool`

`impl SubsetOf<i8> for usize`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> usize`

`pub fn is_in_subset(&i8) -> bool`

`impl SubsetOf<f64> for i16`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> i16`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<f32> for i128`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> i128`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<i32> for u128`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> u128`

`pub fn is_in_subset(&i32) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for f32 where N2: Zero + SupersetOf<f32>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> f32`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for i16 where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<i16>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> i16`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<i32> for isize`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> isize`

`pub fn is_in_subset(&i32) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for u8 where N2: Zero + SupersetOf<u8>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> u8`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<f64> for u16`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> u16`

`pub fn is_in_subset(&f64) -> bool`

`impl SubsetOf<i128> for usize`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> usize`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<i64> for i64`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> i64`

`pub fn is_in_subset(&i64) -> bool`

`impl SubsetOf<i32> for u64`

`pub fn to_superset(&self) -> i32`

`pub fn from_superset_unchecked(element: &i32) -> u64`

`pub fn is_in_subset(&i32) -> bool`

`impl SubsetOf<i128> for u64`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> u64`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<u8> for u32`

`pub fn to_superset(&self) -> u8`

`pub fn from_superset_unchecked(element: &u8) -> u32`

`pub fn is_in_subset(&u8) -> bool`

`impl SubsetOf<i8> for u8`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> u8`

`pub fn is_in_subset(&i8) -> bool`

`impl SubsetOf<i128> for i16`

`pub fn to_superset(&self) -> i128`

`pub fn from_superset_unchecked(element: &i128) -> i16`

`pub fn is_in_subset(&i128) -> bool`

`impl SubsetOf<usize> for u8`

`pub fn to_superset(&self) -> usize`

`pub fn from_superset_unchecked(element: &usize) -> u8`

`pub fn is_in_subset(&usize) -> bool`

`impl SubsetOf<f32> for f64`

`pub fn to_superset(&self) -> f32`

`pub fn from_superset_unchecked(element: &f32) -> f64`

`pub fn is_in_subset(&f32) -> bool`

`impl SubsetOf<i64> for i8`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> i8`

`pub fn is_in_subset(&i64) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for i64 where N2: Zero + SupersetOf<i64>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> i64`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<i8> for i64`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> i64`

`pub fn is_in_subset(&i8) -> bool`

`impl SubsetOf<isize> for u8`

`pub fn to_superset(&self) -> isize`

`pub fn from_superset_unchecked(element: &isize) -> u8`

`pub fn is_in_subset(&isize) -> bool`

`impl SubsetOf<u16> for u64`

`pub fn to_superset(&self) -> u16`

`pub fn from_superset_unchecked(element: &u16) -> u64`

`pub fn is_in_subset(&u16) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for i16 where N2: Zero + SupersetOf<i16>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> i16`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<i8> for u64`

`pub fn to_superset(&self) -> i8`

`pub fn from_superset_unchecked(element: &i8) -> u64`

`pub fn is_in_subset(&i8) -> bool`

`impl SubsetOf<f64> for u32`

`pub fn to_superset(&self) -> f64`

`pub fn from_superset_unchecked(element: &f64) -> u32`

`pub fn is_in_subset(&f64) -> bool`

`impl<N2> SubsetOf<Complex<N2>> for u64 where N2: Zero + SupersetOf<u64>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> u64`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl SubsetOf<i16> for u64`

`pub fn to_superset(&self) -> i16`

`pub fn from_superset_unchecked(element: &i16) -> u64`

`pub fn is_in_subset(&i16) -> bool`

`impl SubsetOf<u64> for u8`

`pub fn to_superset(&self) -> u64`

`pub fn from_superset_unchecked(element: &u64) -> u8`

`pub fn is_in_subset(&u64) -> bool`

`impl SubsetOf<usize> for u64`

`pub fn to_superset(&self) -> usize`

`pub fn from_superset_unchecked(element: &usize) -> u64`

`pub fn is_in_subset(&usize) -> bool`

`impl<N2> SubsetOf<AutoSimd<N2>> for u32 where AutoSimd<N2>: SimdValue, AutoSimd<N2>: Copy, <AutoSimd<N2> as SimdValue>::Element: SupersetOf<u32>, <AutoSimd<N2> as SimdValue>::Element: PartialEq<<AutoSimd<N2> as SimdValue>::Element>,`

`pub fn to_superset(&self) -> AutoSimd<N2>`

`pub fn from_superset_unchecked(element: &AutoSimd<N2>) -> u32`

`pub fn is_in_subset(c: &AutoSimd<N2>) -> bool`

`impl SubsetOf<i64> for u16`

`pub fn to_superset(&self) -> i64`

`pub fn from_superset_unchecked(element: &i64) -> u16`

`pub fn is_in_subset(&i64) -> bool`

Loading content...

Implementors

`impl SubsetOf<AutoSimd<[f32; 2]>> for AutoSimd<[f32; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[f32; 2]>`

`pub fn from_superset(element: &AutoSimd<[f32; 2]>) -> Option<AutoSimd<[f32; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[f32; 2]> ) -> AutoSimd<[f32; 2]>`

`pub fn is_in_subset(&AutoSimd<[f32; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[f32; 4]>> for AutoSimd<[f32; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[f32; 4]>`

`pub fn from_superset(element: &AutoSimd<[f32; 4]>) -> Option<AutoSimd<[f32; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[f32; 4]> ) -> AutoSimd<[f32; 4]>`

`pub fn is_in_subset(&AutoSimd<[f32; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[f32; 8]>> for AutoSimd<[f32; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[f32; 8]>`

`pub fn from_superset(element: &AutoSimd<[f32; 8]>) -> Option<AutoSimd<[f32; 8]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[f32; 8]> ) -> AutoSimd<[f32; 8]>`

`pub fn is_in_subset(&AutoSimd<[f32; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[f32; 16]>> for AutoSimd<[f32; 16]>`

`pub fn to_superset(&self) -> AutoSimd<[f32; 16]>`

`pub fn from_superset( element: &AutoSimd<[f32; 16]> ) -> Option<AutoSimd<[f32; 16]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[f32; 16]> ) -> AutoSimd<[f32; 16]>`

`pub fn is_in_subset(&AutoSimd<[f32; 16]>) -> bool`

`impl SubsetOf<AutoSimd<[f64; 2]>> for AutoSimd<[f64; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[f64; 2]>`

`pub fn from_superset(element: &AutoSimd<[f64; 2]>) -> Option<AutoSimd<[f64; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[f64; 2]> ) -> AutoSimd<[f64; 2]>`

`pub fn is_in_subset(&AutoSimd<[f64; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[f64; 4]>> for AutoSimd<[f64; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[f64; 4]>`

`pub fn from_superset(element: &AutoSimd<[f64; 4]>) -> Option<AutoSimd<[f64; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[f64; 4]> ) -> AutoSimd<[f64; 4]>`

`pub fn is_in_subset(&AutoSimd<[f64; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[f64; 8]>> for AutoSimd<[f64; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[f64; 8]>`

`pub fn from_superset(element: &AutoSimd<[f64; 8]>) -> Option<AutoSimd<[f64; 8]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[f64; 8]> ) -> AutoSimd<[f64; 8]>`

`pub fn is_in_subset(&AutoSimd<[f64; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[i8; 2]>> for AutoSimd<[i8; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[i8; 2]>`

`pub fn from_superset(element: &AutoSimd<[i8; 2]>) -> Option<AutoSimd<[i8; 2]>>`

`pub fn from_superset_unchecked(element: &AutoSimd<[i8; 2]>) -> AutoSimd<[i8; 2]>`

`pub fn is_in_subset(&AutoSimd<[i8; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[i8; 4]>> for AutoSimd<[i8; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[i8; 4]>`

`pub fn from_superset(element: &AutoSimd<[i8; 4]>) -> Option<AutoSimd<[i8; 4]>>`

`pub fn from_superset_unchecked(element: &AutoSimd<[i8; 4]>) -> AutoSimd<[i8; 4]>`

`pub fn is_in_subset(&AutoSimd<[i8; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[i8; 8]>> for AutoSimd<[i8; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[i8; 8]>`

`pub fn from_superset(element: &AutoSimd<[i8; 8]>) -> Option<AutoSimd<[i8; 8]>>`

`pub fn from_superset_unchecked(element: &AutoSimd<[i8; 8]>) -> AutoSimd<[i8; 8]>`

`pub fn is_in_subset(&AutoSimd<[i8; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[i8; 16]>> for AutoSimd<[i8; 16]>`

`pub fn to_superset(&self) -> AutoSimd<[i8; 16]>`

`pub fn from_superset(element: &AutoSimd<[i8; 16]>) -> Option<AutoSimd<[i8; 16]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i8; 16]> ) -> AutoSimd<[i8; 16]>`

`pub fn is_in_subset(&AutoSimd<[i8; 16]>) -> bool`

`impl SubsetOf<AutoSimd<[i8; 32]>> for AutoSimd<[i8; 32]>`

`pub fn to_superset(&self) -> AutoSimd<[i8; 32]>`

`pub fn from_superset(element: &AutoSimd<[i8; 32]>) -> Option<AutoSimd<[i8; 32]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i8; 32]> ) -> AutoSimd<[i8; 32]>`

`pub fn is_in_subset(&AutoSimd<[i8; 32]>) -> bool`

`impl SubsetOf<AutoSimd<[i16; 2]>> for AutoSimd<[i16; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[i16; 2]>`

`pub fn from_superset(element: &AutoSimd<[i16; 2]>) -> Option<AutoSimd<[i16; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i16; 2]> ) -> AutoSimd<[i16; 2]>`

`pub fn is_in_subset(&AutoSimd<[i16; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[i16; 4]>> for AutoSimd<[i16; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[i16; 4]>`

`pub fn from_superset(element: &AutoSimd<[i16; 4]>) -> Option<AutoSimd<[i16; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i16; 4]> ) -> AutoSimd<[i16; 4]>`

`pub fn is_in_subset(&AutoSimd<[i16; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[i16; 8]>> for AutoSimd<[i16; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[i16; 8]>`

`pub fn from_superset(element: &AutoSimd<[i16; 8]>) -> Option<AutoSimd<[i16; 8]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i16; 8]> ) -> AutoSimd<[i16; 8]>`

`pub fn is_in_subset(&AutoSimd<[i16; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[i16; 16]>> for AutoSimd<[i16; 16]>`

`pub fn to_superset(&self) -> AutoSimd<[i16; 16]>`

`pub fn from_superset( element: &AutoSimd<[i16; 16]> ) -> Option<AutoSimd<[i16; 16]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i16; 16]> ) -> AutoSimd<[i16; 16]>`

`pub fn is_in_subset(&AutoSimd<[i16; 16]>) -> bool`

`impl SubsetOf<AutoSimd<[i16; 32]>> for AutoSimd<[i16; 32]>`

`pub fn to_superset(&self) -> AutoSimd<[i16; 32]>`

`pub fn from_superset( element: &AutoSimd<[i16; 32]> ) -> Option<AutoSimd<[i16; 32]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i16; 32]> ) -> AutoSimd<[i16; 32]>`

`pub fn is_in_subset(&AutoSimd<[i16; 32]>) -> bool`

`impl SubsetOf<AutoSimd<[i32; 2]>> for AutoSimd<[i32; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[i32; 2]>`

`pub fn from_superset(element: &AutoSimd<[i32; 2]>) -> Option<AutoSimd<[i32; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i32; 2]> ) -> AutoSimd<[i32; 2]>`

`pub fn is_in_subset(&AutoSimd<[i32; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[i32; 4]>> for AutoSimd<[i32; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[i32; 4]>`

`pub fn from_superset(element: &AutoSimd<[i32; 4]>) -> Option<AutoSimd<[i32; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i32; 4]> ) -> AutoSimd<[i32; 4]>`

`pub fn is_in_subset(&AutoSimd<[i32; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[i32; 8]>> for AutoSimd<[i32; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[i32; 8]>`

`pub fn from_superset(element: &AutoSimd<[i32; 8]>) -> Option<AutoSimd<[i32; 8]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i32; 8]> ) -> AutoSimd<[i32; 8]>`

`pub fn is_in_subset(&AutoSimd<[i32; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[i32; 16]>> for AutoSimd<[i32; 16]>`

`pub fn to_superset(&self) -> AutoSimd<[i32; 16]>`

`pub fn from_superset( element: &AutoSimd<[i32; 16]> ) -> Option<AutoSimd<[i32; 16]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i32; 16]> ) -> AutoSimd<[i32; 16]>`

`pub fn is_in_subset(&AutoSimd<[i32; 16]>) -> bool`

`impl SubsetOf<AutoSimd<[i64; 2]>> for AutoSimd<[i64; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[i64; 2]>`

`pub fn from_superset(element: &AutoSimd<[i64; 2]>) -> Option<AutoSimd<[i64; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i64; 2]> ) -> AutoSimd<[i64; 2]>`

`pub fn is_in_subset(&AutoSimd<[i64; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[i64; 4]>> for AutoSimd<[i64; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[i64; 4]>`

`pub fn from_superset(element: &AutoSimd<[i64; 4]>) -> Option<AutoSimd<[i64; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i64; 4]> ) -> AutoSimd<[i64; 4]>`

`pub fn is_in_subset(&AutoSimd<[i64; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[i64; 8]>> for AutoSimd<[i64; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[i64; 8]>`

`pub fn from_superset(element: &AutoSimd<[i64; 8]>) -> Option<AutoSimd<[i64; 8]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i64; 8]> ) -> AutoSimd<[i64; 8]>`

`pub fn is_in_subset(&AutoSimd<[i64; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[i128; 1]>> for AutoSimd<[i128; 1]>`

`pub fn to_superset(&self) -> AutoSimd<[i128; 1]>`

`pub fn from_superset( element: &AutoSimd<[i128; 1]> ) -> Option<AutoSimd<[i128; 1]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i128; 1]> ) -> AutoSimd<[i128; 1]>`

`pub fn is_in_subset(&AutoSimd<[i128; 1]>) -> bool`

`impl SubsetOf<AutoSimd<[i128; 2]>> for AutoSimd<[i128; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[i128; 2]>`

`pub fn from_superset( element: &AutoSimd<[i128; 2]> ) -> Option<AutoSimd<[i128; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i128; 2]> ) -> AutoSimd<[i128; 2]>`

`pub fn is_in_subset(&AutoSimd<[i128; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[i128; 4]>> for AutoSimd<[i128; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[i128; 4]>`

`pub fn from_superset( element: &AutoSimd<[i128; 4]> ) -> Option<AutoSimd<[i128; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[i128; 4]> ) -> AutoSimd<[i128; 4]>`

`pub fn is_in_subset(&AutoSimd<[i128; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[isize; 2]>> for AutoSimd<[isize; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[isize; 2]>`

`pub fn from_superset( element: &AutoSimd<[isize; 2]> ) -> Option<AutoSimd<[isize; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[isize; 2]> ) -> AutoSimd<[isize; 2]>`

`pub fn is_in_subset(&AutoSimd<[isize; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[isize; 4]>> for AutoSimd<[isize; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[isize; 4]>`

`pub fn from_superset( element: &AutoSimd<[isize; 4]> ) -> Option<AutoSimd<[isize; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[isize; 4]> ) -> AutoSimd<[isize; 4]>`

`pub fn is_in_subset(&AutoSimd<[isize; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[isize; 8]>> for AutoSimd<[isize; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[isize; 8]>`

`pub fn from_superset( element: &AutoSimd<[isize; 8]> ) -> Option<AutoSimd<[isize; 8]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[isize; 8]> ) -> AutoSimd<[isize; 8]>`

`pub fn is_in_subset(&AutoSimd<[isize; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[u8; 2]>> for AutoSimd<[u8; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[u8; 2]>`

`pub fn from_superset(element: &AutoSimd<[u8; 2]>) -> Option<AutoSimd<[u8; 2]>>`

`pub fn from_superset_unchecked(element: &AutoSimd<[u8; 2]>) -> AutoSimd<[u8; 2]>`

`pub fn is_in_subset(&AutoSimd<[u8; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[u8; 4]>> for AutoSimd<[u8; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[u8; 4]>`

`pub fn from_superset(element: &AutoSimd<[u8; 4]>) -> Option<AutoSimd<[u8; 4]>>`

`pub fn from_superset_unchecked(element: &AutoSimd<[u8; 4]>) -> AutoSimd<[u8; 4]>`

`pub fn is_in_subset(&AutoSimd<[u8; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[u8; 8]>> for AutoSimd<[u8; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[u8; 8]>`

`pub fn from_superset(element: &AutoSimd<[u8; 8]>) -> Option<AutoSimd<[u8; 8]>>`

`pub fn from_superset_unchecked(element: &AutoSimd<[u8; 8]>) -> AutoSimd<[u8; 8]>`

`pub fn is_in_subset(&AutoSimd<[u8; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[u8; 16]>> for AutoSimd<[u8; 16]>`

`pub fn to_superset(&self) -> AutoSimd<[u8; 16]>`

`pub fn from_superset(element: &AutoSimd<[u8; 16]>) -> Option<AutoSimd<[u8; 16]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u8; 16]> ) -> AutoSimd<[u8; 16]>`

`pub fn is_in_subset(&AutoSimd<[u8; 16]>) -> bool`

`impl SubsetOf<AutoSimd<[u8; 32]>> for AutoSimd<[u8; 32]>`

`pub fn to_superset(&self) -> AutoSimd<[u8; 32]>`

`pub fn from_superset(element: &AutoSimd<[u8; 32]>) -> Option<AutoSimd<[u8; 32]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u8; 32]> ) -> AutoSimd<[u8; 32]>`

`pub fn is_in_subset(&AutoSimd<[u8; 32]>) -> bool`

`impl SubsetOf<AutoSimd<[u16; 2]>> for AutoSimd<[u16; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[u16; 2]>`

`pub fn from_superset(element: &AutoSimd<[u16; 2]>) -> Option<AutoSimd<[u16; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u16; 2]> ) -> AutoSimd<[u16; 2]>`

`pub fn is_in_subset(&AutoSimd<[u16; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[u16; 4]>> for AutoSimd<[u16; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[u16; 4]>`

`pub fn from_superset(element: &AutoSimd<[u16; 4]>) -> Option<AutoSimd<[u16; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u16; 4]> ) -> AutoSimd<[u16; 4]>`

`pub fn is_in_subset(&AutoSimd<[u16; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[u16; 8]>> for AutoSimd<[u16; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[u16; 8]>`

`pub fn from_superset(element: &AutoSimd<[u16; 8]>) -> Option<AutoSimd<[u16; 8]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u16; 8]> ) -> AutoSimd<[u16; 8]>`

`pub fn is_in_subset(&AutoSimd<[u16; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[u16; 16]>> for AutoSimd<[u16; 16]>`

`pub fn to_superset(&self) -> AutoSimd<[u16; 16]>`

`pub fn from_superset( element: &AutoSimd<[u16; 16]> ) -> Option<AutoSimd<[u16; 16]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u16; 16]> ) -> AutoSimd<[u16; 16]>`

`pub fn is_in_subset(&AutoSimd<[u16; 16]>) -> bool`

`impl SubsetOf<AutoSimd<[u16; 32]>> for AutoSimd<[u16; 32]>`

`pub fn to_superset(&self) -> AutoSimd<[u16; 32]>`

`pub fn from_superset( element: &AutoSimd<[u16; 32]> ) -> Option<AutoSimd<[u16; 32]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u16; 32]> ) -> AutoSimd<[u16; 32]>`

`pub fn is_in_subset(&AutoSimd<[u16; 32]>) -> bool`

`impl SubsetOf<AutoSimd<[u32; 2]>> for AutoSimd<[u32; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[u32; 2]>`

`pub fn from_superset(element: &AutoSimd<[u32; 2]>) -> Option<AutoSimd<[u32; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u32; 2]> ) -> AutoSimd<[u32; 2]>`

`pub fn is_in_subset(&AutoSimd<[u32; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[u32; 4]>> for AutoSimd<[u32; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[u32; 4]>`

`pub fn from_superset(element: &AutoSimd<[u32; 4]>) -> Option<AutoSimd<[u32; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u32; 4]> ) -> AutoSimd<[u32; 4]>`

`pub fn is_in_subset(&AutoSimd<[u32; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[u32; 8]>> for AutoSimd<[u32; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[u32; 8]>`

`pub fn from_superset(element: &AutoSimd<[u32; 8]>) -> Option<AutoSimd<[u32; 8]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u32; 8]> ) -> AutoSimd<[u32; 8]>`

`pub fn is_in_subset(&AutoSimd<[u32; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[u32; 16]>> for AutoSimd<[u32; 16]>`

`pub fn to_superset(&self) -> AutoSimd<[u32; 16]>`

`pub fn from_superset( element: &AutoSimd<[u32; 16]> ) -> Option<AutoSimd<[u32; 16]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u32; 16]> ) -> AutoSimd<[u32; 16]>`

`pub fn is_in_subset(&AutoSimd<[u32; 16]>) -> bool`

`impl SubsetOf<AutoSimd<[u64; 2]>> for AutoSimd<[u64; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[u64; 2]>`

`pub fn from_superset(element: &AutoSimd<[u64; 2]>) -> Option<AutoSimd<[u64; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u64; 2]> ) -> AutoSimd<[u64; 2]>`

`pub fn is_in_subset(&AutoSimd<[u64; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[u64; 4]>> for AutoSimd<[u64; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[u64; 4]>`

`pub fn from_superset(element: &AutoSimd<[u64; 4]>) -> Option<AutoSimd<[u64; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u64; 4]> ) -> AutoSimd<[u64; 4]>`

`pub fn is_in_subset(&AutoSimd<[u64; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[u64; 8]>> for AutoSimd<[u64; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[u64; 8]>`

`pub fn from_superset(element: &AutoSimd<[u64; 8]>) -> Option<AutoSimd<[u64; 8]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u64; 8]> ) -> AutoSimd<[u64; 8]>`

`pub fn is_in_subset(&AutoSimd<[u64; 8]>) -> bool`

`impl SubsetOf<AutoSimd<[u128; 1]>> for AutoSimd<[u128; 1]>`

`pub fn to_superset(&self) -> AutoSimd<[u128; 1]>`

`pub fn from_superset( element: &AutoSimd<[u128; 1]> ) -> Option<AutoSimd<[u128; 1]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u128; 1]> ) -> AutoSimd<[u128; 1]>`

`pub fn is_in_subset(&AutoSimd<[u128; 1]>) -> bool`

`impl SubsetOf<AutoSimd<[u128; 2]>> for AutoSimd<[u128; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[u128; 2]>`

`pub fn from_superset( element: &AutoSimd<[u128; 2]> ) -> Option<AutoSimd<[u128; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u128; 2]> ) -> AutoSimd<[u128; 2]>`

`pub fn is_in_subset(&AutoSimd<[u128; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[u128; 4]>> for AutoSimd<[u128; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[u128; 4]>`

`pub fn from_superset( element: &AutoSimd<[u128; 4]> ) -> Option<AutoSimd<[u128; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[u128; 4]> ) -> AutoSimd<[u128; 4]>`

`pub fn is_in_subset(&AutoSimd<[u128; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[usize; 2]>> for AutoSimd<[usize; 2]>`

`pub fn to_superset(&self) -> AutoSimd<[usize; 2]>`

`pub fn from_superset( element: &AutoSimd<[usize; 2]> ) -> Option<AutoSimd<[usize; 2]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[usize; 2]> ) -> AutoSimd<[usize; 2]>`

`pub fn is_in_subset(&AutoSimd<[usize; 2]>) -> bool`

`impl SubsetOf<AutoSimd<[usize; 4]>> for AutoSimd<[usize; 4]>`

`pub fn to_superset(&self) -> AutoSimd<[usize; 4]>`

`pub fn from_superset( element: &AutoSimd<[usize; 4]> ) -> Option<AutoSimd<[usize; 4]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[usize; 4]> ) -> AutoSimd<[usize; 4]>`

`pub fn is_in_subset(&AutoSimd<[usize; 4]>) -> bool`

`impl SubsetOf<AutoSimd<[usize; 8]>> for AutoSimd<[usize; 8]>`

`pub fn to_superset(&self) -> AutoSimd<[usize; 8]>`

`pub fn from_superset( element: &AutoSimd<[usize; 8]> ) -> Option<AutoSimd<[usize; 8]>>`

`pub fn from_superset_unchecked( element: &AutoSimd<[usize; 8]> ) -> AutoSimd<[usize; 8]>`

`pub fn is_in_subset(&AutoSimd<[usize; 8]>) -> bool`

`impl<N1, N2> SubsetOf<Complex<N2>> for Complex<N1> where N2: SupersetOf<N1>,`

`pub fn to_superset(&self) -> Complex<N2>`

`pub fn from_superset_unchecked(element: &Complex<N2>) -> Complex<N1>`

`pub fn is_in_subset(c: &Complex<N2>) -> bool`

`impl<N1, N2> SubsetOf<Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer>> for Unit<Complex<N1>> where N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset( &self ) -> Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer>`[src]

`pub fn is_in_subset( m: &Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer> ) -> bool`[src]

`pub fn from_superset_unchecked( m: &Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer> ) -> Unit<Complex<N1>>`[src]

`impl<N1, N2> SubsetOf<Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>> for Unit<Quaternion<N1>> where N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset( &self ) -> Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>`[src]

`pub fn is_in_subset( m: &Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer> ) -> bool`[src]

`pub fn from_superset_unchecked( m: &Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer> ) -> Unit<Quaternion<N1>>`[src]

`impl<N1, N2> SubsetOf<Quaternion<N2>> for Quaternion<N1> where N1: SimdRealField, N2: SimdRealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Quaternion<N2>`[src]

`pub fn is_in_subset(q: &Quaternion<N2>) -> bool`[src]

`pub fn from_superset_unchecked(q: &Quaternion<N2>) -> Quaternion<N1>`[src]

`impl<N1, N2> SubsetOf<Rotation<N2, U2>> for Unit<Complex<N1>> where N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Rotation<N2, U2>`[src]

`pub fn is_in_subset(rot: &Rotation<N2, U2>) -> bool`[src]

`pub fn from_superset_unchecked(rot: &Rotation<N2, U2>) -> Unit<Complex<N1>>`[src]

`impl<N1, N2> SubsetOf<Rotation<N2, U3>> for Unit<Quaternion<N1>> where N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Rotation<N2, U3>`[src]

`pub fn is_in_subset(rot: &Rotation<N2, U3>) -> bool`[src]

`pub fn from_superset_unchecked(rot: &Rotation<N2, U3>) -> Unit<Quaternion<N1>>`[src]

`impl<N1, N2> SubsetOf<Unit<Complex<N2>>> for Rotation<N1, U2> where N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Unit<Complex<N2>>`[src]

`pub fn is_in_subset(q: &Unit<Complex<N2>>) -> bool`[src]

`pub fn from_superset_unchecked(q: &Unit<Complex<N2>>) -> Rotation<N1, U2>`[src]

`impl<N1, N2> SubsetOf<Unit<Complex<N2>>> for Unit<Complex<N1>> where N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Unit<Complex<N2>>`[src]

`pub fn is_in_subset(uq: &Unit<Complex<N2>>) -> bool`[src]

`pub fn from_superset_unchecked(uq: &Unit<Complex<N2>>) -> Unit<Complex<N1>>`[src]

`impl<N1, N2> SubsetOf<Unit<Quaternion<N2>>> for Rotation<N1, U3> where N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Unit<Quaternion<N2>>`[src]

`pub fn is_in_subset(q: &Unit<Quaternion<N2>>) -> bool`[src]

`pub fn from_superset_unchecked(q: &Unit<Quaternion<N2>>) -> Rotation<N1, U3>`[src]

`impl<N1, N2> SubsetOf<Unit<Quaternion<N2>>> for Unit<Quaternion<N1>> where N1: SimdRealField, N2: SimdRealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Unit<Quaternion<N2>>`[src]

`pub fn is_in_subset(uq: &Unit<Quaternion<N2>>) -> bool`[src]

`pub fn from_superset_unchecked( uq: &Unit<Quaternion<N2>> ) -> Unit<Quaternion<N1>>`[src]

`impl<N1, N2, C> SubsetOf<Transform<N2, U2, C>> for Unit<Complex<N1>> where C: SuperTCategoryOf<TAffine>, N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Transform<N2, U2, C>`[src]

`pub fn is_in_subset(t: &Transform<N2, U2, C>) -> bool`[src]

`pub fn from_superset_unchecked(t: &Transform<N2, U2, C>) -> Unit<Complex<N1>>`[src]

`impl<N1, N2, C> SubsetOf<Transform<N2, U3, C>> for Unit<Quaternion<N1>> where C: SuperTCategoryOf<TAffine>, N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Transform<N2, U3, C>`[src]

`pub fn is_in_subset(t: &Transform<N2, U3, C>) -> bool`[src]

`pub fn from_superset_unchecked(t: &Transform<N2, U3, C>) -> Unit<Quaternion<N1>>`[src]

impl<N1, N2, D> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Rotation<N1, D> where D: DimNameAdd<U1> + DimMin<D, Output = D>, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, D>, DefaultAllocator: Allocator<N2, D, D>, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<(usize, usize), D, U1>, [src]

`pub fn to_superset( &self ) -> Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>`[src]

`pub fn is_in_subset( m: &Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> ) -> bool`[src]

`pub fn from_superset_unchecked( m: &Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> ) -> Rotation<N1, D>`[src]

impl<N1, N2, D> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Translation<N1, D> where D: DimNameAdd<U1>, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N2, D, U1>, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, [src]

`pub fn to_superset( &self ) -> Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>`[src]

`pub fn is_in_subset( m: &Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> ) -> bool`[src]

`pub fn from_superset_unchecked( m: &Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> ) -> Translation<N1, D>`[src]

impl<N1, N2, D> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>> for Point<N1, D> where D: DimNameAdd<U1>, N1: Scalar, N2: Scalar + Zero + One + ClosedDiv<N2> + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, U1>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>, DefaultAllocator: Allocator<N2, D, U1>, [src]

`pub fn to_superset( &self ) -> Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>`[src]

`pub fn is_in_subset( v: &Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer> ) -> bool`[src]

`pub fn from_superset_unchecked( v: &Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer> ) -> Point<N1, D>`[src]

`impl<N1, N2, D> SubsetOf<Point<N2, D>> for Point<N1, D> where D: DimName, N1: Scalar, N2: Scalar + SupersetOf<N1>, DefaultAllocator: Allocator<N2, D, U1>, DefaultAllocator: Allocator<N1, D, U1>,` [src]

`pub fn to_superset(&self) -> Point<N2, D>`[src]

`pub fn is_in_subset(m: &Point<N2, D>) -> bool`[src]

`pub fn from_superset_unchecked(m: &Point<N2, D>) -> Point<N1, D>`[src]

`impl<N1, N2, D> SubsetOf<Rotation<N2, D>> for Rotation<N1, D> where D: DimName, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, D>, DefaultAllocator: Allocator<N2, D, D>,` [src]

`pub fn to_superset(&self) -> Rotation<N2, D>`[src]

`pub fn is_in_subset(rot: &Rotation<N2, D>) -> bool`[src]

`pub fn from_superset_unchecked(rot: &Rotation<N2, D>) -> Rotation<N1, D>`[src]

`impl<N1, N2, D> SubsetOf<Translation<N2, D>> for Translation<N1, D> where D: DimName, N1: Scalar, N2: Scalar + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N2, D, U1>,` [src]

`pub fn to_superset(&self) -> Translation<N2, D>`[src]

`pub fn is_in_subset(rot: &Translation<N2, D>) -> bool`[src]

`pub fn from_superset_unchecked(rot: &Translation<N2, D>) -> Translation<N1, D>`[src]

impl<N1, N2, D, C1, C2> SubsetOf<Transform<N2, D, C2>> for Transform<N1, D, C1> where D: DimName + DimNameAdd<U1>, C2: SuperTCategoryOf<C1>, N1: RealField + SubsetOf<N2>, N2: RealField, C1: TCategory, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, <N1 as AbsDiffEq<N1>>::Epsilon: Copy, <N2 as AbsDiffEq<N2>>::Epsilon: Copy, [src]

`pub fn to_superset(&self) -> Transform<N2, D, C2>`[src]

`pub fn is_in_subset(t: &Transform<N2, D, C2>) -> bool`[src]

`pub fn from_superset_unchecked(t: &Transform<N2, D, C2>) -> Transform<N1, D, C1>`[src]

impl<N1, N2, D, C> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Transform<N1, D, C> where C: TCategory, D: DimName + DimNameAdd<U1>, N1: RealField + SubsetOf<N2>, N2: RealField, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, <N1 as AbsDiffEq<N1>>::Epsilon: Copy, <N2 as AbsDiffEq<N2>>::Epsilon: Copy, [src]

`pub fn to_superset( &self ) -> Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>`[src]

`pub fn is_in_subset( m: &Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> ) -> bool`[src]

`pub fn from_superset_unchecked( m: &Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> ) -> Transform<N1, D, C>`[src]

impl<N1, N2, D, C> SubsetOf<Transform<N2, D, C>> for Rotation<N1, D> where C: SuperTCategoryOf<TAffine>, D: DimNameAdd<U1> + DimMin<D, Output = D>, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, D>, DefaultAllocator: Allocator<N2, D, D>, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<(usize, usize), D, U1>, [src]

`pub fn to_superset(&self) -> Transform<N2, D, C>`[src]

`pub fn is_in_subset(t: &Transform<N2, D, C>) -> bool`[src]

`pub fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Rotation<N1, D>`[src]

impl<N1, N2, D, C> SubsetOf<Transform<N2, D, C>> for Translation<N1, D> where C: SuperTCategoryOf<TAffine>, D: DimNameAdd<U1>, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N2, D, U1>, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, [src]

`pub fn to_superset(&self) -> Transform<N2, D, C>`[src]

`pub fn is_in_subset(t: &Transform<N2, D, C>) -> bool`[src]

`pub fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Translation<N1, D>`[src]

`impl<N1, N2, D, R1, R2> SubsetOf<Isometry<N2, D, R2>> for Isometry<N1, D, R1> where D: DimName, R2: AbstractRotation<N2, D>, N1: RealField, N2: RealField + SupersetOf<N1>, R1: AbstractRotation<N1, D> + SubsetOf<R2>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N2, D, U1>,` [src]

`pub fn to_superset(&self) -> Isometry<N2, D, R2>`[src]

`pub fn is_in_subset(iso: &Isometry<N2, D, R2>) -> bool`[src]

`pub fn from_superset_unchecked(iso: &Isometry<N2, D, R2>) -> Isometry<N1, D, R1>`[src]

`impl<N1, N2, D, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Isometry<N1, D, R1> where D: DimName, R2: AbstractRotation<N2, D>, N1: RealField, N2: RealField + SupersetOf<N1>, R1: AbstractRotation<N1, D> + SubsetOf<R2>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N2, D, U1>,` [src]

`pub fn to_superset(&self) -> Similarity<N2, D, R2>`[src]

`pub fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool`[src]

`pub fn from_superset_unchecked( sim: &Similarity<N2, D, R2> ) -> Isometry<N1, D, R1>`[src]

`impl<N1, N2, D, R1, R2> SubsetOf<Similarity<N2, D, R2>> for Similarity<N1, D, R1> where D: DimName, R2: AbstractRotation<N2, D>, N1: RealField + SubsetOf<N2>, N2: RealField + SupersetOf<N1>, R1: AbstractRotation<N1, D> + SubsetOf<R2>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N2, D, U1>,` [src]

`pub fn to_superset(&self) -> Similarity<N2, D, R2>`[src]

`pub fn is_in_subset(sim: &Similarity<N2, D, R2>) -> bool`[src]

`pub fn from_superset_unchecked( sim: &Similarity<N2, D, R2> ) -> Similarity<N1, D, R1>`[src]

`impl<N1, N2, D, R> SubsetOf<Isometry<N2, D, R>> for Rotation<N1, D> where R: AbstractRotation<N2, D> + SupersetOf<Rotation<N1, D>>, D: DimName, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, D>, DefaultAllocator: Allocator<N2, D, U1>,` [src]

`pub fn to_superset(&self) -> Isometry<N2, D, R>`[src]

`pub fn is_in_subset(iso: &Isometry<N2, D, R>) -> bool`[src]

`pub fn from_superset_unchecked(iso: &Isometry<N2, D, R>) -> Rotation<N1, D>`[src]

`impl<N1, N2, D, R> SubsetOf<Isometry<N2, D, R>> for Translation<N1, D> where R: AbstractRotation<N2, D>, D: DimName, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N2, D, U1>,` [src]

`pub fn to_superset(&self) -> Isometry<N2, D, R>`[src]

`pub fn is_in_subset(iso: &Isometry<N2, D, R>) -> bool`[src]

`pub fn from_superset_unchecked(iso: &Isometry<N2, D, R>) -> Translation<N1, D>`[src]

impl<N1, N2, D, R> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Isometry<N1, D, R> where R: AbstractRotation<N1, D> + SubsetOf<Matrix<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> + SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>, D: DimNameAdd<U1> + DimMin<D, Output = D>, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N1, D, D>, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<(usize, usize), D, U1>, DefaultAllocator: Allocator<N2, D, D>, DefaultAllocator: Allocator<N2, D, U1>, [src]

`pub fn to_superset( &self ) -> Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>`[src]

`pub fn is_in_subset( m: &Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> ) -> bool`[src]

`pub fn from_superset_unchecked( m: &Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> ) -> Isometry<N1, D, R>`[src]

impl<N1, N2, D, R> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Similarity<N1, D, R> where R: AbstractRotation<N1, D> + SubsetOf<Matrix<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> + SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>, D: DimNameAdd<U1> + DimMin<D, Output = D>, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N1, D, D>, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<(usize, usize), D, U1>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, D, D>, DefaultAllocator: Allocator<N2, D, U1>, [src]

`pub fn to_superset( &self ) -> Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>`[src]

`pub fn is_in_subset( m: &Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> ) -> bool`[src]

`pub fn from_superset_unchecked( m: &Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer> ) -> Similarity<N1, D, R>`[src]

`impl<N1, N2, D, R> SubsetOf<Similarity<N2, D, R>> for Rotation<N1, D> where R: AbstractRotation<N2, D> + SupersetOf<Rotation<N1, D>>, D: DimName, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, D>, DefaultAllocator: Allocator<N2, D, U1>,` [src]

`pub fn to_superset(&self) -> Similarity<N2, D, R>`[src]

`pub fn is_in_subset(sim: &Similarity<N2, D, R>) -> bool`[src]

`pub fn from_superset_unchecked(sim: &Similarity<N2, D, R>) -> Rotation<N1, D>`[src]

`impl<N1, N2, D, R> SubsetOf<Similarity<N2, D, R>> for Translation<N1, D> where R: AbstractRotation<N2, D>, D: DimName, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N2, D, U1>,` [src]

`pub fn to_superset(&self) -> Similarity<N2, D, R>`[src]

`pub fn is_in_subset(sim: &Similarity<N2, D, R>) -> bool`[src]

`pub fn from_superset_unchecked(sim: &Similarity<N2, D, R>) -> Translation<N1, D>`[src]

impl<N1, N2, D, R, C> SubsetOf<Transform<N2, D, C>> for Isometry<N1, D, R> where C: SuperTCategoryOf<TAffine>, R: AbstractRotation<N1, D> + SubsetOf<Matrix<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> + SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>, D: DimNameAdd<U1> + DimMin<D, Output = D>, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N1, D, D>, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<(usize, usize), D, U1>, DefaultAllocator: Allocator<N2, D, D>, DefaultAllocator: Allocator<N2, D, U1>, [src]

`pub fn to_superset(&self) -> Transform<N2, D, C>`[src]

`pub fn is_in_subset(t: &Transform<N2, D, C>) -> bool`[src]

`pub fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Isometry<N1, D, R>`[src]

impl<N1, N2, D, R, C> SubsetOf<Transform<N2, D, C>> for Similarity<N1, D, R> where C: SuperTCategoryOf<TAffine>, R: AbstractRotation<N1, D> + SubsetOf<Matrix<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> + SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>, D: DimNameAdd<U1> + DimMin<D, Output = D>, N1: RealField, N2: RealField + SupersetOf<N1>, DefaultAllocator: Allocator<N1, D, U1>, DefaultAllocator: Allocator<N1, D, D>, DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<(usize, usize), D, U1>, DefaultAllocator: Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>, DefaultAllocator: Allocator<N2, D, D>, DefaultAllocator: Allocator<N2, D, U1>, [src]

`pub fn to_superset(&self) -> Transform<N2, D, C>`[src]

`pub fn is_in_subset(t: &Transform<N2, D, C>) -> bool`[src]

`pub fn from_superset_unchecked(t: &Transform<N2, D, C>) -> Similarity<N1, D, R>`[src]

impl<N1, N2, R1, C1, R2, C2> SubsetOf<Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>> for Matrix<N1, R1, C1, <DefaultAllocator as Allocator<N1, R1, C1>>::Buffer> where R2: Dim, C2: Dim, N1: Scalar, N2: Scalar + SupersetOf<N1>, R1: Dim, C1: Dim, DefaultAllocator: Allocator<N2, R2, C2>, DefaultAllocator: Allocator<N1, R1, C1>, DefaultAllocator: SameShapeAllocator<N1, R1, C1, R2, C2>, ShapeConstraint: SameNumberOfRows<R1, R2>, ShapeConstraint: SameNumberOfColumns<C1, C2>, [src]

`pub fn to_superset( &self ) -> Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>`[src]

`pub fn is_in_subset( m: &Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer> ) -> bool`[src]

`pub fn from_superset_unchecked( m: &Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer> ) -> Matrix<N1, R1, C1, <DefaultAllocator as Allocator<N1, R1, C1>>::Buffer>`[src]

`impl<N1, N2, R> SubsetOf<Isometry<N2, U2, R>> for Unit<Complex<N1>> where R: AbstractRotation<N2, U2> + SupersetOf<Unit<Complex<N1>>>, N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Isometry<N2, U2, R>`[src]

`pub fn is_in_subset(iso: &Isometry<N2, U2, R>) -> bool`[src]

`pub fn from_superset_unchecked(iso: &Isometry<N2, U2, R>) -> Unit<Complex<N1>>`[src]

`impl<N1, N2, R> SubsetOf<Isometry<N2, U3, R>> for Unit<Quaternion<N1>> where R: AbstractRotation<N2, U3> + SupersetOf<Unit<Quaternion<N1>>>, N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Isometry<N2, U3, R>`[src]

`pub fn is_in_subset(iso: &Isometry<N2, U3, R>) -> bool`[src]

`pub fn from_superset_unchecked( iso: &Isometry<N2, U3, R> ) -> Unit<Quaternion<N1>>`[src]

`impl<N1, N2, R> SubsetOf<Similarity<N2, U2, R>> for Unit<Complex<N1>> where R: AbstractRotation<N2, U2> + SupersetOf<Unit<Complex<N1>>>, N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Similarity<N2, U2, R>`[src]

`pub fn is_in_subset(sim: &Similarity<N2, U2, R>) -> bool`[src]

`pub fn from_superset_unchecked(sim: &Similarity<N2, U2, R>) -> Unit<Complex<N1>>`[src]

`impl<N1, N2, R> SubsetOf<Similarity<N2, U3, R>> for Unit<Quaternion<N1>> where R: AbstractRotation<N2, U3> + SupersetOf<Unit<Quaternion<N1>>>, N1: RealField, N2: RealField + SupersetOf<N1>,` [src]

`pub fn to_superset(&self) -> Similarity<N2, U3, R>`[src]

`pub fn is_in_subset(sim: &Similarity<N2, U3, R>) -> bool`[src]

`pub fn from_superset_unchecked( sim: &Similarity<N2, U3, R> ) -> Unit<Quaternion<N1>>`[src]

Loading content...