[−][src]Struct nannou::math::Quaternion
A quaternion in scalar/vector form.
This type is marked as #[repr(C)]
.
Fields
s: S
The scalar part of the quaternion.
v: Vector3<S>
The vector part of the quaternion.
Methods
impl<S> Quaternion<S>
[src]
pub const fn new(w: S, xi: S, yj: S, zk: S) -> Quaternion<S>
[src]
Construct a new quaternion from one scalar component and three imaginary components.
pub const fn from_sv(s: S, v: Vector3<S>) -> Quaternion<S>
[src]
Construct a new quaternion from a scalar and a vector.
impl<S> Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
pub fn from_arc(
src: Vector3<S>,
dst: Vector3<S>,
fallback: Option<Vector3<S>>
) -> Quaternion<S>
[src]
src: Vector3<S>,
dst: Vector3<S>,
fallback: Option<Vector3<S>>
) -> Quaternion<S>
Construct a new quaternion as a closest arc between two vectors
Return the closest rotation that turns src
vector into dst
.
- [Related StackOverflow question] (http://stackoverflow.com/questions/1171849/finding-quaternion-representing-the-rotation-from-one-vector-to-another)
- [Ogre implementation for normalized vectors] (https://bitbucket.org/sinbad/ogre/src/9db75e3ba05c/OgreMain/include/OgreVector3.h?fileviewer=file-view-default#cl-651)
pub fn conjugate(self) -> Quaternion<S>
[src]
The conjugate of the quaternion.
pub fn nlerp(self, other: Quaternion<S>, amount: S) -> Quaternion<S>
[src]
Do a normalized linear interpolation with other
, by amount
.
pub fn slerp(self, other: Quaternion<S>, amount: S) -> Quaternion<S>
[src]
Spherical Linear Interpolation
Return the spherical linear interpolation between the quaternion and
other
. Both quaternions should be normalized first.
Performance notes
The acos
operation used in slerp
is an expensive operation, so
unless your quaternions are far away from each other it's generally
more advisable to use nlerp
when you know your rotations are going
to be small.
- [Understanding Slerp, Then Not Using It] (http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/)
- [Arcsynthesis OpenGL tutorial] (http://www.arcsynthesis.org/gltut/Positioning/Tut08%20Interpolation.html)
pub fn is_finite(&self) -> bool
[src]
impl<S> Quaternion<S> where
S: Copy + NumCast,
[src]
S: Copy + NumCast,
pub fn cast<T>(&self) -> Option<Quaternion<T>> where
T: BaseFloat,
[src]
T: BaseFloat,
Component-wise casting to another type.
Trait Implementations
impl<S> AbsDiffEq<Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Epsilon = <S as AbsDiffEq<S>>::Epsilon
Used for specifying relative comparisons.
fn default_epsilon() -> <S as AbsDiffEq<S>>::Epsilon
[src]
fn abs_diff_eq(
&self,
other: &Quaternion<S>,
epsilon: <S as AbsDiffEq<S>>::Epsilon
) -> bool
[src]
&self,
other: &Quaternion<S>,
epsilon: <S as AbsDiffEq<S>>::Epsilon
) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
impl<'a, S> Add<&'a Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the +
operator.
fn add(self, other: &'a Quaternion<S>) -> Quaternion<S>
[src]
impl<'a, 'b, S> Add<&'a Quaternion<S>> for &'b Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the +
operator.
fn add(self, other: &'a Quaternion<S>) -> Quaternion<S>
[src]
impl<'a, S> Add<Quaternion<S>> for &'a Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the +
operator.
fn add(self, other: Quaternion<S>) -> Quaternion<S>
[src]
impl<S> Add<Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the +
operator.
fn add(self, other: Quaternion<S>) -> Quaternion<S>
[src]
impl<S> AddAssign<Quaternion<S>> for Quaternion<S> where
S: BaseFloat + AddAssign<S>,
[src]
S: BaseFloat + AddAssign<S>,
fn add_assign(&mut self, other: Quaternion<S>)
[src]
impl<S> AsMut<[S; 4]> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
impl<S> AsMut<(S, S, S, S)> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
impl<S> AsRef<[S; 4]> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
impl<S> AsRef<(S, S, S, S)> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
impl<S> Clone for Quaternion<S> where
S: Clone,
[src]
S: Clone,
fn clone(&self) -> Quaternion<S>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<S> Copy for Quaternion<S> where
S: Copy,
[src]
S: Copy,
impl<S> Debug for Quaternion<S> where
S: Debug,
[src]
S: Debug,
impl<'de, S> Deserialize<'de> for Quaternion<S> where
S: Deserialize<'de>,
[src]
S: Deserialize<'de>,
fn deserialize<__D>(
__deserializer: __D
) -> Result<Quaternion<S>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
[src]
__deserializer: __D
) -> Result<Quaternion<S>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
impl<'a, S> Div<S> for &'a Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the /
operator.
fn div(self, other: S) -> Quaternion<S>
[src]
impl<S> Div<S> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the /
operator.
fn div(self, other: S) -> Quaternion<S>
[src]
impl<S> DivAssign<S> for Quaternion<S> where
S: BaseFloat + DivAssign<S>,
[src]
S: BaseFloat + DivAssign<S>,
fn div_assign(&mut self, scalar: S)
[src]
impl<'a, S> From<&'a [S; 4]> for &'a Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(v: &'a [S; 4]) -> &'a Quaternion<S>
[src]
impl<'a, S> From<&'a (S, S, S, S)> for &'a Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(v: &'a (S, S, S, S)) -> &'a Quaternion<S>
[src]
impl<'a, S> From<&'a mut [S; 4]> for &'a mut Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(v: &'a mut [S; 4]) -> &'a mut Quaternion<S>
[src]
impl<'a, S> From<&'a mut (S, S, S, S)> for &'a mut Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(v: &'a mut (S, S, S, S)) -> &'a mut Quaternion<S>
[src]
impl<S> From<[S; 4]> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(v: [S; 4]) -> Quaternion<S>
[src]
impl<S> From<(S, S, S, S)> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(v: (S, S, S, S)) -> Quaternion<S>
[src]
impl<S> From<Basis3<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(b: Basis3<S>) -> Quaternion<S>
[src]
impl<A> From<Euler<A>> for Quaternion<<A as Angle>::Unitless> where
A: Angle + Into<Rad<<A as Angle>::Unitless>>,
[src]
A: Angle + Into<Rad<<A as Angle>::Unitless>>,
impl<S> From<Matrix3<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(mat: Matrix3<S>) -> Quaternion<S>
[src]
Convert the matrix to a quaternion
impl<S> From<Quaternion<S>> for Matrix3<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(quat: Quaternion<S>) -> Matrix3<S>
[src]
Convert the quaternion to a 3 x 3 rotation matrix.
impl<S> From<Quaternion<S>> for Euler<Rad<S>> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(src: Quaternion<S>) -> Euler<Rad<S>>
[src]
impl<S> From<Quaternion<S>> for Matrix4<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(quat: Quaternion<S>) -> Matrix4<S>
[src]
Convert the quaternion to a 4 x 4 rotation matrix.
impl<S> From<Quaternion<S>> for Basis3<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from(quat: Quaternion<S>) -> Basis3<S>
[src]
impl<S> Index<Range<usize>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = [S]
The returned type after indexing.
fn index(&'a self, i: Range<usize>) -> &'a [S]
[src]
impl<S> Index<RangeFrom<usize>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = [S]
The returned type after indexing.
fn index(&'a self, i: RangeFrom<usize>) -> &'a [S]
[src]
impl<S> Index<RangeFull> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
impl<S> Index<RangeTo<usize>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = [S]
The returned type after indexing.
fn index(&'a self, i: RangeTo<usize>) -> &'a [S]
[src]
impl<S> Index<usize> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
impl<S> IndexMut<Range<usize>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn index_mut(&'a mut self, i: Range<usize>) -> &'a mut [S]
[src]
impl<S> IndexMut<RangeFrom<usize>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn index_mut(&'a mut self, i: RangeFrom<usize>) -> &'a mut [S]
[src]
impl<S> IndexMut<RangeFull> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn index_mut(&'a mut self, i: RangeFull) -> &'a mut [S]
[src]
impl<S> IndexMut<RangeTo<usize>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn index_mut(&'a mut self, i: RangeTo<usize>) -> &'a mut [S]
[src]
impl<S> IndexMut<usize> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
impl<S> InnerSpace for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn dot(self, other: Quaternion<S>) -> S
[src]
fn is_perpendicular(self, other: Self) -> bool
[src]
fn magnitude2(self) -> Self::Scalar
[src]
fn magnitude(self) -> Self::Scalar
[src]
fn angle(self, other: Self) -> Rad<Self::Scalar>
[src]
fn normalize(self) -> Self
[src]
fn normalize_to(self, magnitude: Self::Scalar) -> Self
[src]
fn project_on(self, other: Self) -> Self
[src]
impl<S> Into<[S; 4]> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
impl<S> Into<(S, S, S, S)> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
impl<S> MetricSpace for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Metric = S
The metric to be returned by the distance
function.
fn distance2(self, other: Quaternion<S>) -> S
[src]
fn distance(self, other: Self) -> Self::Metric
[src]
impl<'a, 'b, S> Mul<&'a Quaternion<S>> for &'b Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the *
operator.
fn mul(self, other: &'a Quaternion<S>) -> Quaternion<S>
[src]
impl<'a, S> Mul<&'a Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the *
operator.
fn mul(self, other: &'a Quaternion<S>) -> Quaternion<S>
[src]
impl<'a, 'b, S> Mul<&'a Vector3<S>> for &'b Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Vector3<S>
The resulting type after applying the *
operator.
fn mul(self, other: &'a Vector3<S>) -> Vector3<S>
[src]
impl<'a, S> Mul<&'a Vector3<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Vector3<S>
The resulting type after applying the *
operator.
fn mul(self, other: &'a Vector3<S>) -> Vector3<S>
[src]
impl<S> Mul<Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the *
operator.
fn mul(self, other: Quaternion<S>) -> Quaternion<S>
[src]
impl<'a, S> Mul<Quaternion<S>> for &'a Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the *
operator.
fn mul(self, other: Quaternion<S>) -> Quaternion<S>
[src]
impl<S> Mul<S> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the *
operator.
fn mul(self, other: S) -> Quaternion<S>
[src]
impl<'a, S> Mul<S> for &'a Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the *
operator.
fn mul(self, other: S) -> Quaternion<S>
[src]
impl<'a, S> Mul<Vector3<S>> for &'a Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Vector3<S>
The resulting type after applying the *
operator.
fn mul(self, other: Vector3<S>) -> Vector3<S>
[src]
impl<S> Mul<Vector3<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Vector3<S>
The resulting type after applying the *
operator.
fn mul(self, other: Vector3<S>) -> Vector3<S>
[src]
impl<S> MulAssign<S> for Quaternion<S> where
S: BaseFloat + MulAssign<S>,
[src]
S: BaseFloat + MulAssign<S>,
fn mul_assign(&mut self, scalar: S)
[src]
impl<'a, S> Neg for &'a Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the -
operator.
fn neg(self) -> Quaternion<S>
[src]
impl<S> Neg for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the -
operator.
fn neg(self) -> Quaternion<S>
[src]
impl<S> One for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn one() -> Quaternion<S>
[src]
fn set_one(&mut self)
[src]
fn is_one(&self) -> bool where
Self: PartialEq<Self>,
[src]
Self: PartialEq<Self>,
impl<S> PartialEq<Quaternion<S>> for Quaternion<S> where
S: PartialEq<S>,
[src]
S: PartialEq<S>,
fn eq(&self, other: &Quaternion<S>) -> bool
[src]
fn ne(&self, other: &Quaternion<S>) -> bool
[src]
impl<'a, S> Product<&'a Quaternion<S>> for Quaternion<S> where
S: 'a + BaseFloat,
[src]
S: 'a + BaseFloat,
fn product<I>(iter: I) -> Quaternion<S> where
I: Iterator<Item = &'a Quaternion<S>>,
[src]
I: Iterator<Item = &'a Quaternion<S>>,
impl<S> Product<Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn product<I>(iter: I) -> Quaternion<S> where
I: Iterator<Item = Quaternion<S>>,
[src]
I: Iterator<Item = Quaternion<S>>,
impl<S> RelativeEq<Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn default_max_relative() -> <S as AbsDiffEq<S>>::Epsilon
[src]
fn relative_eq(
&self,
other: &Quaternion<S>,
epsilon: <S as AbsDiffEq<S>>::Epsilon,
max_relative: <S as AbsDiffEq<S>>::Epsilon
) -> bool
[src]
&self,
other: &Quaternion<S>,
epsilon: <S as AbsDiffEq<S>>::Epsilon,
max_relative: <S as AbsDiffEq<S>>::Epsilon
) -> bool
fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
impl<S> Rem<S> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the %
operator.
fn rem(self, other: S) -> Quaternion<S>
[src]
impl<'a, S> Rem<S> for &'a Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the %
operator.
fn rem(self, other: S) -> Quaternion<S>
[src]
impl<S> RemAssign<S> for Quaternion<S> where
S: BaseFloat + RemAssign<S>,
[src]
S: BaseFloat + RemAssign<S>,
fn rem_assign(&mut self, scalar: S)
[src]
impl<S> Rotation<Point3<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn look_at(dir: Vector3<S>, up: Vector3<S>) -> Quaternion<S>
[src]
fn between_vectors(a: Vector3<S>, b: Vector3<S>) -> Quaternion<S>
[src]
fn rotate_vector(&self, vec: Vector3<S>) -> Vector3<S>
[src]
fn invert(&self) -> Quaternion<S>
[src]
fn rotate_point(&self, point: P) -> P
[src]
impl<S> Rotation3<S> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn from_axis_angle<A>(axis: Vector3<S>, angle: A) -> Quaternion<S> where
A: Into<Rad<S>>,
[src]
A: Into<Rad<S>>,
fn from_angle_x<A>(theta: A) -> Self where
A: Into<Rad<S>>,
[src]
A: Into<Rad<S>>,
fn from_angle_y<A>(theta: A) -> Self where
A: Into<Rad<S>>,
[src]
A: Into<Rad<S>>,
fn from_angle_z<A>(theta: A) -> Self where
A: Into<Rad<S>>,
[src]
A: Into<Rad<S>>,
impl<S> Serialize for Quaternion<S> where
S: Serialize,
[src]
S: Serialize,
fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
[src]
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
impl<S> StructuralPartialEq for Quaternion<S>
[src]
impl<'a, S> Sub<&'a Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the -
operator.
fn sub(self, other: &'a Quaternion<S>) -> Quaternion<S>
[src]
impl<'a, 'b, S> Sub<&'a Quaternion<S>> for &'b Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the -
operator.
fn sub(self, other: &'a Quaternion<S>) -> Quaternion<S>
[src]
impl<'a, S> Sub<Quaternion<S>> for &'a Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the -
operator.
fn sub(self, other: Quaternion<S>) -> Quaternion<S>
[src]
impl<S> Sub<Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
type Output = Quaternion<S>
The resulting type after applying the -
operator.
fn sub(self, other: Quaternion<S>) -> Quaternion<S>
[src]
impl<S> SubAssign<Quaternion<S>> for Quaternion<S> where
S: BaseFloat + SubAssign<S>,
[src]
S: BaseFloat + SubAssign<S>,
fn sub_assign(&mut self, other: Quaternion<S>)
[src]
impl<'a, S> Sum<&'a Quaternion<S>> for Quaternion<S> where
S: 'a + BaseFloat,
[src]
S: 'a + BaseFloat,
fn sum<I>(iter: I) -> Quaternion<S> where
I: Iterator<Item = &'a Quaternion<S>>,
[src]
I: Iterator<Item = &'a Quaternion<S>>,
impl<S> Sum<Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn sum<I>(iter: I) -> Quaternion<S> where
I: Iterator<Item = Quaternion<S>>,
[src]
I: Iterator<Item = Quaternion<S>>,
impl<S> UlpsEq<Quaternion<S>> for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
fn default_max_ulps() -> u32
[src]
fn ulps_eq(
&self,
other: &Quaternion<S>,
epsilon: <S as AbsDiffEq<S>>::Epsilon,
max_ulps: u32
) -> bool
[src]
&self,
other: &Quaternion<S>,
epsilon: <S as AbsDiffEq<S>>::Epsilon,
max_ulps: u32
) -> bool
fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool
impl<S> VectorSpace for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
impl<S> Zero for Quaternion<S> where
S: BaseFloat,
[src]
S: BaseFloat,
Auto Trait Implementations
impl<S> RefUnwindSafe for Quaternion<S> where
S: RefUnwindSafe,
S: RefUnwindSafe,
impl<S> Send for Quaternion<S> where
S: Send,
S: Send,
impl<S> Sync for Quaternion<S> where
S: Sync,
S: Sync,
impl<S> Unpin for Quaternion<S> where
S: Unpin,
S: Unpin,
impl<S> UnwindSafe for Quaternion<S> where
S: UnwindSafe,
S: UnwindSafe,
Blanket Implementations
impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S where
D: AdaptFrom<S, Swp, Dwp, T>,
Dwp: WhitePoint,
Swp: WhitePoint,
T: Component + Float,
[src]
D: AdaptFrom<S, Swp, Dwp, T>,
Dwp: WhitePoint,
Swp: WhitePoint,
T: Component + Float,
fn adapt_into_using<M>(self, method: M) -> D where
M: TransformMatrix<Swp, Dwp, T>,
[src]
M: TransformMatrix<Swp, Dwp, T>,
fn adapt_into(self) -> D
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> ConvertInto<U> for T where
U: ConvertFrom<T>,
[src]
U: ConvertFrom<T>,
fn convert_into(self) -> U
[src]
fn convert_unclamped_into(self) -> U
[src]
fn try_convert_into(self) -> Result<U, OutOfBounds<U>>
[src]
impl<T> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,
[src]
T: for<'de> Deserialize<'de>,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, Rhs> NumAssignOps<Rhs> for T where
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
[src]
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
[src]
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
impl<T> One for T where
T: One,
T: One,
fn one() -> T
impl<T> SetParameter for T
fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where
T: Parameter<Self>,
T: Parameter<Self>,
impl<T> SetParameter for T
fn set<T>(&mut self, value: T) -> <T as Parameter<Self>>::Result where
T: Parameter<Self>,
T: Parameter<Self>,
impl<T> Style for T where
T: Any + Debug + PartialEq<T>,
[src]
T: Any + Debug + PartialEq<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,
fn vzip(self) -> V
impl<T> Zero for T where
T: Zero,
T: Zero,