#[repr(C)]pub struct Mat2<T> {
pub rows: CVec2<Vec2<T>>,
}
Expand description
2x2 matrix.
Fields§
§rows: CVec2<Vec2<T>>
Implementations§
source§impl<T> Mat2<T>
impl<T> Mat2<T>
sourcepub fn identity() -> Selfwhere
T: Zero + One,
pub fn identity() -> Selfwhere T: Zero + One,
The identity matrix, which is also the default value for square matrices.
assert_eq!(Mat4::<f32>::default(), Mat4::<f32>::identity());
sourcepub fn apply<F>(&mut self, f: F)where
T: Copy,
F: FnMut(T) -> T,
pub fn apply<F>(&mut self, f: F)where T: Copy, F: FnMut(T) -> T,
Applies the function f to each element of this matrix, in-place.
For an example, see the map()
method.
sourcepub fn apply2<F, S>(&mut self, other: Mat2<S>, f: F)where
T: Copy,
F: FnMut(T, S) -> T,
pub fn apply2<F, S>(&mut self, other: Mat2<S>, f: F)where T: Copy, F: FnMut(T, S) -> T,
Applies the function f to each element of this matrix, in-place.
For an example, see the map2()
method.
sourcepub fn numcast<D>(self) -> Option<Mat2<D>>where
T: NumCast,
D: NumCast,
pub fn numcast<D>(self) -> Option<Mat2<D>>where T: NumCast, D: NumCast,
Returns a memberwise-converted copy of this matrix, using NumCast
.
let m = Mat4::<f32>::identity();
let m: Mat4<i32> = m.numcast().unwrap();
assert_eq!(m, Mat4::identity());
sourcepub fn broadcast_diagonal(val: T) -> Selfwhere
T: Zero + Copy,
pub fn broadcast_diagonal(val: T) -> Selfwhere T: Zero + Copy,
Initializes a new matrix with elements of the diagonal set to val
and the other to zero.
In a way, this is the same as single-argument matrix constructors in GLSL and GLM.
assert_eq!(Mat4::broadcast_diagonal(0), Mat4::zero());
assert_eq!(Mat4::broadcast_diagonal(1), Mat4::identity());
assert_eq!(Mat4::broadcast_diagonal(2), Mat4::new(
2,0,0,0,
0,2,0,0,
0,0,2,0,
0,0,0,2,
));
sourcepub fn with_diagonal(d: Vec2<T>) -> Selfwhere
T: Zero + Copy,
pub fn with_diagonal(d: Vec2<T>) -> Selfwhere T: Zero + Copy,
Initializes a matrix by its diagonal, setting other elements to zero.
sourcepub fn diagonal(self) -> Vec2<T>
pub fn diagonal(self) -> Vec2<T>
Gets the matrix’s diagonal into a vector.
assert_eq!(Mat4::<u32>::zero().diagonal(), Vec4::zero());
assert_eq!(Mat4::<u32>::identity().diagonal(), Vec4::one());
let mut m = Mat4::zero();
m[(0, 0)] = 1;
m[(1, 1)] = 2;
m[(2, 2)] = 3;
m[(3, 3)] = 4;
assert_eq!(m.diagonal(), Vec4::new(1, 2, 3, 4));
assert_eq!(m.diagonal(), Vec4::iota() + 1);
sourcepub fn trace(self) -> Twhere
T: Add<T, Output = T>,
pub fn trace(self) -> Twhere T: Add<T, Output = T>,
The sum of the diagonal’s elements.
assert_eq!(Mat4::<u32>::zero().trace(), 0);
assert_eq!(Mat4::<u32>::identity().trace(), 4);
sourcepub fn mul_memberwise(self, m: Self) -> Selfwhere
T: Mul<Output = T>,
pub fn mul_memberwise(self, m: Self) -> Selfwhere T: Mul<Output = T>,
Multiply elements of this matrix with another’s.
let m = Mat4::new(
0, 1, 2, 3,
1, 2, 3, 4,
2, 3, 4, 5,
3, 4, 5, 6,
);
let r = Mat4::new(
0, 1, 4, 9,
1, 4, 9, 16,
4, 9, 16, 25,
9, 16, 25, 36,
);
assert_eq!(m.mul_memberwise(m), r);
sourcepub const ROW_COUNT: usize = 2usize
pub const ROW_COUNT: usize = 2usize
Convenience constant representing the number of rows for matrices of this type.
source§impl<T> Mat2<T>
impl<T> Mat2<T>
sourcepub fn map_rows<D, F>(self, f: F) -> Mat2<D>where
F: FnMut(Vec2<T>) -> Vec2<D>,
pub fn map_rows<D, F>(self, f: F) -> Mat2<D>where F: FnMut(Vec2<T>) -> Vec2<D>,
Returns a row-wise-converted copy of this matrix, using the given conversion closure.
use vek::mat::repr_c::row_major::Mat4;
let m = Mat4::<f32>::new(
0.25, 1.25, 5.56, 8.66,
8.53, 2.92, 3.86, 9.36,
1.02, 0.28, 5.52, 6.06,
6.20, 7.01, 4.90, 5.26
);
let m = m.map_rows(|row| row.map(|x| x.round() as i32));
assert_eq!(m, Mat4::new(
0, 1, 6, 9,
9, 3, 4, 9,
1, 0, 6, 6,
6, 7, 5, 5
));
sourcepub fn into_row_array(self) -> [T; 4]
pub fn into_row_array(self) -> [T; 4]
Converts this matrix into a fixed-size array of elements.
use vek::mat::repr_c::row_major::Mat4;
let m = Mat4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
);
let array = [
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
];
assert_eq!(m.into_row_array(), array);
sourcepub fn into_row_arrays(self) -> [[T; 2]; 2]
pub fn into_row_arrays(self) -> [[T; 2]; 2]
Converts this matrix into a fixed-size array of fixed-size arrays of elements.
use vek::mat::repr_c::row_major::Mat4;
let m = Mat4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
);
let array = [
[ 0, 1, 2, 3, ],
[ 4, 5, 6, 7, ],
[ 8, 9, 10, 11, ],
[ 12, 13, 14, 15, ],
];
assert_eq!(m.into_row_arrays(), array);
sourcepub fn from_row_array(array: [T; 4]) -> Self
pub fn from_row_array(array: [T; 4]) -> Self
Converts a fixed-size array of elements into a matrix.
use vek::mat::repr_c::row_major::Mat4;
let m = Mat4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
);
let array = [
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
];
assert_eq!(m, Mat4::from_row_array(array));
sourcepub fn from_row_arrays(array: [[T; 2]; 2]) -> Self
pub fn from_row_arrays(array: [[T; 2]; 2]) -> Self
Converts a fixed-size array of fixed-size array of elements into a matrix.
use vek::mat::repr_c::row_major::Mat4;
let m = Mat4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
);
let array = [
[ 0, 1, 2, 3, ],
[ 4, 5, 6, 7, ],
[ 8, 9, 10, 11, ],
[ 12, 13, 14, 15, ],
];
assert_eq!(m, Mat4::from_row_arrays(array));
sourcepub fn into_col_array(self) -> [T; 4]
pub fn into_col_array(self) -> [T; 4]
Converts this matrix into a fixed-size array of elements.
use vek::mat::repr_c::row_major::Mat4;
let m = Mat4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
);
let array = [
0, 4, 8, 12,
1, 5, 9, 13,
2, 6, 10, 14,
3, 7, 11, 15
];
assert_eq!(m.into_col_array(), array);
sourcepub fn into_col_arrays(self) -> [[T; 2]; 2]
pub fn into_col_arrays(self) -> [[T; 2]; 2]
Converts this matrix into a fixed-size array of fixed-size arrays of elements.
use vek::mat::repr_c::row_major::Mat4;
let m = Mat4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
);
let array = [
[ 0, 4, 8, 12, ],
[ 1, 5, 9, 13, ],
[ 2, 6, 10, 14, ],
[ 3, 7, 11, 15, ],
];
assert_eq!(m.into_col_arrays(), array);
sourcepub fn from_col_array(array: [T; 4]) -> Self
pub fn from_col_array(array: [T; 4]) -> Self
Converts a fixed-size array of elements into a matrix.
use vek::mat::repr_c::row_major::Mat4;
let m = Mat4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
);
let array = [
0, 4, 8, 12,
1, 5, 9, 13,
2, 6, 10, 14,
3, 7, 11, 15
];
assert_eq!(m, Mat4::from_col_array(array));
sourcepub fn from_col_arrays(array: [[T; 2]; 2]) -> Self
pub fn from_col_arrays(array: [[T; 2]; 2]) -> Self
Converts a fixed-size array of fixed-size arrays of elements into a matrix.
use vek::mat::repr_c::row_major::Mat4;
let m = Mat4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15
);
let array = [
[ 0, 4, 8, 12, ],
[ 1, 5, 9, 13, ],
[ 2, 6, 10, 14, ],
[ 3, 7, 11, 15, ],
];
assert_eq!(m, Mat4::from_col_arrays(array));
sourcepub fn as_row_ptr(&self) -> *const T
pub fn as_row_ptr(&self) -> *const T
Gets a const pointer to this matrix’s elements.
Panics
Panics if the matrix’s elements are not tightly packed in memory,
which may be the case for matrices in the repr_simd
module.
You may check this with the is_packed()
method.
sourcepub fn as_mut_row_ptr(&mut self) -> *mut T
pub fn as_mut_row_ptr(&mut self) -> *mut T
Gets a mut pointer to this matrix’s elements.
Panics
Panics if the matrix’s elements are not tightly packed in memory,
which may be the case for matrices in the repr_simd
module.
You may check this with the is_packed()
method.
sourcepub fn as_row_slice(&self) -> &[T]
pub fn as_row_slice(&self) -> &[T]
View this matrix as an immutable slice.
Panics
Panics if the matrix’s elements are not tightly packed in memory,
which may be the case for matrices in the repr_simd
module.
You may check this with the is_packed()
method.
sourcepub fn as_mut_row_slice(&mut self) -> &mut [T]
pub fn as_mut_row_slice(&mut self) -> &mut [T]
View this matrix as a mutable slice.
Panics
Panics if the matrix’s elements are not tightly packed in memory,
which may be the case for matrices in the repr_simd
module.
You may check this with the is_packed()
method.
source§impl<T> Mat2<T>
impl<T> Mat2<T>
sourcepub fn gl_should_transpose(&self) -> bool
pub fn gl_should_transpose(&self) -> bool
Gets the transpose
parameter to pass to OpenGL glUniformMatrix*()
functions.
The return value is a plain bool
which you may directly cast
to a GLboolean
.
This takes &self
to prevent surprises when changing the type
of matrix you plan to send.
sourcepub const GL_SHOULD_TRANSPOSE: bool = true
pub const GL_SHOULD_TRANSPOSE: bool = true
The transpose
parameter to pass to OpenGL glUniformMatrix*()
functions.
source§impl<T> Mat2<T>
impl<T> Mat2<T>
sourcepub fn map<D, F>(self, f: F) -> Mat2<D>where
F: FnMut(T) -> D,
pub fn map<D, F>(self, f: F) -> Mat2<D>where F: FnMut(T) -> D,
Returns an element-wise-converted copy of this matrix, using the given conversion closure.
use vek::mat::repr_c::row_major::Mat4;
let m = Mat4::<f32>::new(
0.25, 1.25, 5.56, 8.66,
8.53, 2.92, 3.86, 9.36,
1.02, 0.28, 5.52, 6.06,
6.20, 7.01, 4.90, 5.26
);
let m = m.map(|x| x.round() as i32);
assert_eq!(m, Mat4::new(
0, 1, 6, 9,
9, 3, 4, 9,
1, 0, 6, 6,
6, 7, 5, 5
));
sourcepub fn as_<D>(self) -> Mat2<D>where
T: AsPrimitive<D>,
D: 'static + Copy,
pub fn as_<D>(self) -> Mat2<D>where T: AsPrimitive<D>, D: 'static + Copy,
Returns a memberwise-converted copy of this matrix, using AsPrimitive
.
Examples
let v = Vec4::new(0_f32, 1., 2., 3.);
let i: Vec4<i32> = v.as_();
assert_eq!(i, Vec4::new(0, 1, 2, 3));
Safety
In Rust versions before 1.45.0, some uses of the as
operator were not entirely safe.
In particular, it was undefined behavior if
a truncated floating point value could not fit in the target integer
type (#10184);
let x: u8 = (1.04E+17).as_(); // UB
sourcepub fn map2<D, F, S>(self, other: Mat2<S>, f: F) -> Mat2<D>where
F: FnMut(T, S) -> D,
pub fn map2<D, F, S>(self, other: Mat2<S>, f: F) -> Mat2<D>where F: FnMut(T, S) -> D,
Applies the function f to each element of two matrices, pairwise, and returns the result.
use vek::mat::repr_c::row_major::Mat4;
let a = Mat4::<f32>::new(
0.25, 1.25, 2.52, 2.99,
0.25, 1.25, 2.52, 2.99,
0.25, 1.25, 2.52, 2.99,
0.25, 1.25, 2.52, 2.99
);
let b = Mat4::<i32>::new(
0, 1, 0, 0,
1, 0, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
);
let m = a.map2(b, |a, b| a.round() as i32 + b);
assert_eq!(m, Mat4::new(
0, 2, 3, 3,
1, 1, 3, 3,
0, 1, 4, 3,
0, 1, 3, 4
));
sourcepub fn transposed(self) -> Self
pub fn transposed(self) -> Self
The matrix’s transpose.
let m = Mat2::new(
0, 1,
4, 5
);
let t = Mat2::new(
0, 4,
1, 5
);
assert_eq!(m.transposed(), t);
assert_eq!(m, m.transposed().transposed());
sourcepub fn transpose(&mut self)
pub fn transpose(&mut self)
Transpose this matrix.
let mut m = Mat2::new(
0, 1,
4, 5
);
let t = Mat2::new(
0, 4,
1, 5
);
m.transpose();
assert_eq!(m, t);
sourcepub fn determinant(self) -> Twhere
T: Mul<T, Output = T> + Sub<T, Output = T>,
pub fn determinant(self) -> Twhere T: Mul<T, Output = T> + Sub<T, Output = T>,
Get this matrix’s determinant.
A matrix is invertible if its determinant is non-zero.
let (a,b,c,d) = (0,1,2,3);
let m = Mat2::new(a,b,c,d);
assert_eq!(m.determinant(), a*d - c*b);
sourcepub fn rotate_z(&mut self, angle_radians: T)where
T: Real + MulAdd<T, T, Output = T>,
pub fn rotate_z(&mut self, angle_radians: T)where T: Real + MulAdd<T, T, Output = T>,
Rotates this matrix around the Z axis (counter-clockwise rotation in 2D).
sourcepub fn rotated_z(self, angle_radians: T) -> Selfwhere
T: Real + MulAdd<T, T, Output = T>,
pub fn rotated_z(self, angle_radians: T) -> Selfwhere T: Real + MulAdd<T, T, Output = T>,
Rotates this matrix around the Z axis (counter-clockwise rotation in 2D).
sourcepub fn rotation_z(angle_radians: T) -> Selfwhere
T: Real,
pub fn rotation_z(angle_radians: T) -> Selfwhere T: Real,
Creates a matrix that rotates around the Z axis (counter-clockwise rotation in 2D).
sourcepub fn scale_2d<V: Into<Vec2<T>>>(&mut self, v: V)where
T: Real + MulAdd<T, T, Output = T>,
pub fn scale_2d<V: Into<Vec2<T>>>(&mut self, v: V)where T: Real + MulAdd<T, T, Output = T>,
Scales this matrix in 2D.
sourcepub fn scaled_2d<V: Into<Vec2<T>>>(self, v: V) -> Selfwhere
T: Real + MulAdd<T, T, Output = T>,
pub fn scaled_2d<V: Into<Vec2<T>>>(self, v: V) -> Selfwhere T: Real + MulAdd<T, T, Output = T>,
Returns this matrix scaled in 2D.
sourcepub fn scaling_2d<V: Into<Vec2<T>>>(v: V) -> Selfwhere
T: Zero,
pub fn scaling_2d<V: Into<Vec2<T>>>(v: V) -> Selfwhere T: Zero,
Creates a 2D scaling matrix.
sourcepub fn shear_x(&mut self, k: T)where
T: Real + MulAdd<T, T, Output = T>,
pub fn shear_x(&mut self, k: T)where T: Real + MulAdd<T, T, Output = T>,
Shears this matrix along the X axis.
sourcepub fn sheared_x(self, k: T) -> Selfwhere
T: Real + MulAdd<T, T, Output = T>,
pub fn sheared_x(self, k: T) -> Selfwhere T: Real + MulAdd<T, T, Output = T>,
Returns this matrix sheared along the X axis.
sourcepub fn shearing_x(k: T) -> Selfwhere
T: Zero + One,
pub fn shearing_x(k: T) -> Selfwhere T: Zero + One,
Creates a 2D shearing matrix along the X axis.
sourcepub fn shear_y(&mut self, k: T)where
T: Real + MulAdd<T, T, Output = T>,
pub fn shear_y(&mut self, k: T)where T: Real + MulAdd<T, T, Output = T>,
Shears this matrix along the Y axis.
sourcepub fn sheared_y(self, k: T) -> Selfwhere
T: Real + MulAdd<T, T, Output = T>,
pub fn sheared_y(self, k: T) -> Selfwhere T: Real + MulAdd<T, T, Output = T>,
Returns this matrix sheared along the Y axis.
sourcepub fn shearing_y(k: T) -> Selfwhere
T: Zero + One,
pub fn shearing_y(k: T) -> Selfwhere T: Zero + One,
Creates a 2D shearing matrix along the Y axis.
Trait Implementations§
source§impl<T: AbsDiffEq> AbsDiffEq<Mat2<T>> for Mat2<T>where
T::Epsilon: Copy,
impl<T: AbsDiffEq> AbsDiffEq<Mat2<T>> for Mat2<T>where T::Epsilon: Copy,
source§fn default_epsilon() -> T::Epsilon
fn default_epsilon() -> T::Epsilon
source§fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool
fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool
source§fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
AbsDiffEq::abs_diff_eq
.source§impl<T: Add<Output = T> + Copy> AddAssign<Mat2<T>> for Mat2<T>
impl<T: Add<Output = T> + Copy> AddAssign<Mat2<T>> for Mat2<T>
source§fn add_assign(&mut self, rhs: Self)
fn add_assign(&mut self, rhs: Self)
+=
operation. Read moresource§impl<T: Add<Output = T> + Copy> AddAssign<T> for Mat2<T>
impl<T: Add<Output = T> + Copy> AddAssign<T> for Mat2<T>
source§fn add_assign(&mut self, rhs: T)
fn add_assign(&mut self, rhs: T)
+=
operation. Read moresource§impl<T: Zero + One> Default for Mat2<T>
impl<T: Zero + One> Default for Mat2<T>
The default value for a square matrix is the identity.
assert_eq!(Mat4::<f32>::default(), Mat4::<f32>::identity());
source§impl<'de, T> Deserialize<'de> for Mat2<T>where
T: Deserialize<'de>,
impl<'de, T> Deserialize<'de> for Mat2<T>where T: Deserialize<'de>,
source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,
source§impl<T: Display> Display for Mat2<T>
impl<T: Display> Display for Mat2<T>
Displays this matrix using the following format:
(i
being the number of rows and j
the number of columns)
( m00 ... m0j
... ... ...
mi0 ... mij )
Note that elements are not comma-separated. This format doesn’t depend on the matrix’s storage layout.
source§impl<T: Div<Output = T> + Copy> DivAssign<Mat2<T>> for Mat2<T>
impl<T: Div<Output = T> + Copy> DivAssign<Mat2<T>> for Mat2<T>
source§fn div_assign(&mut self, rhs: Self)
fn div_assign(&mut self, rhs: Self)
/=
operation. Read moresource§impl<T: Div<Output = T> + Copy> DivAssign<T> for Mat2<T>
impl<T: Div<Output = T> + Copy> DivAssign<T> for Mat2<T>
source§fn div_assign(&mut self, rhs: T)
fn div_assign(&mut self, rhs: T)
/=
operation. Read moresource§impl<T> Index<(usize, usize)> for Mat2<T>
impl<T> Index<(usize, usize)> for Mat2<T>
Index this matrix in a layout-agnostic way with an (i, j)
(row index, column index) tuple.
Matrices cannot be indexed by Vec2
s because that would be likely to cause confusion:
should x
be the row index (because it’s the first element) or the column index
(because it’s a horizontal position) ?
source§impl<T> Mul<CubicBezier2<T>> for Rows2<T>where
T: Real + MulAdd<T, T, Output = T>,
impl<T> Mul<CubicBezier2<T>> for Rows2<T>where T: Real + MulAdd<T, T, Output = T>,
§type Output = CubicBezier2<T>
type Output = CubicBezier2<T>
*
operator.source§fn mul(self, rhs: CubicBezier2<T>) -> CubicBezier2<T>
fn mul(self, rhs: CubicBezier2<T>) -> CubicBezier2<T>
*
operation. Read moresource§impl<T: MulAdd<T, T, Output = T> + Mul<Output = T> + Copy> Mul<Mat2<T>> for Mat2<T>
impl<T: MulAdd<T, T, Output = T> + Mul<Output = T> + Copy> Mul<Mat2<T>> for Mat2<T>
Multiplies a row-major matrix with a column-major matrix, producing a column-major matrix.
use vek::mat::row_major::Mat4 as Rows4;
use vek::mat::column_major::Mat4 as Cols4;
let m = Rows4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 0, 1,
2, 3, 4, 5
);
let b = Cols4::from(m);
let r = Cols4::<u32>::new(
26, 32, 18, 24,
82, 104, 66, 88,
38, 56, 74, 92,
54, 68, 42, 56
);
assert_eq!(m * b, r);
assert_eq!(m * Cols4::<u32>::identity(), m.into());
assert_eq!(Rows4::<u32>::identity() * b, m.into());
source§impl<T: MulAdd<T, T, Output = T> + Mul<Output = T> + Copy> Mul<Mat2<T>> for Mat2<T>
impl<T: MulAdd<T, T, Output = T> + Mul<Output = T> + Copy> Mul<Mat2<T>> for Mat2<T>
Multiplies a row-major matrix with another.
use vek::mat::row_major::Mat4;
let m = Mat4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 0, 1,
2, 3, 4, 5
);
let r = Mat4::<u32>::new(
26, 32, 18, 24,
82, 104, 66, 88,
38, 56, 74, 92,
54, 68, 42, 56
);
assert_eq!(m * m, r);
assert_eq!(m, m * Mat4::<u32>::identity());
assert_eq!(m, Mat4::<u32>::identity() * m);
source§impl<T: MulAdd<T, T, Output = T> + Mul<Output = T> + Copy> Mul<Mat2<T>> for Mat2<T>
impl<T: MulAdd<T, T, Output = T> + Mul<Output = T> + Copy> Mul<Mat2<T>> for Mat2<T>
Multiplies a column-major matrix with a row-major matrix.
use vek::mat::row_major::Mat4 as Rows4;
use vek::mat::column_major::Mat4 as Cols4;
let m = Cols4::<u32>::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 0, 1,
2, 3, 4, 5
);
let b = Rows4::from(m);
let r = Rows4::<u32>::new(
26, 32, 18, 24,
82, 104, 66, 88,
38, 56, 74, 92,
54, 68, 42, 56
);
assert_eq!(m * b, r);
assert_eq!(m * Rows4::<u32>::identity(), m.into());
assert_eq!(Cols4::<u32>::identity() * b, m.into());
source§impl<T: MulAdd<T, T, Output = T> + Mul<Output = T> + Copy> Mul<Mat2<T>> for Vec2<T>
impl<T: MulAdd<T, T, Output = T> + Mul<Output = T> + Copy> Mul<Mat2<T>> for Vec2<T>
Multiplies a row vector with a row-major matrix, giving a row vector.
With SIMD vectors, this is the most efficient way.
use vek::mat::row_major::Mat4;
use vek::vec::Vec4;
let m = Mat4::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 0, 1,
2, 3, 4, 5
);
let v = Vec4::new(0, 1, 2, 3);
let r = Vec4::new(26, 32, 18, 24);
assert_eq!(v * m, r);
source§impl<T> Mul<QuadraticBezier2<T>> for Rows2<T>where
T: Real + MulAdd<T, T, Output = T>,
impl<T> Mul<QuadraticBezier2<T>> for Rows2<T>where T: Real + MulAdd<T, T, Output = T>,
§type Output = QuadraticBezier2<T>
type Output = QuadraticBezier2<T>
*
operator.source§fn mul(self, rhs: QuadraticBezier2<T>) -> QuadraticBezier2<T>
fn mul(self, rhs: QuadraticBezier2<T>) -> QuadraticBezier2<T>
*
operation. Read moresource§impl<T: MulAdd<T, T, Output = T> + Mul<Output = T> + Copy> Mul<Vec2<T>> for Mat2<T>
impl<T: MulAdd<T, T, Output = T> + Mul<Output = T> + Copy> Mul<Vec2<T>> for Mat2<T>
Multiplies a row-major matrix with a column vector, giving a column vector.
use vek::mat::row_major::Mat4;
use vek::vec::Vec4;
let m = Mat4::new(
0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 0, 1,
2, 3, 4, 5
);
let v = Vec4::new(0, 1, 2, 3);
let r = Vec4::new(14, 38, 12, 26);
assert_eq!(m * v, r);
source§impl<T> MulAssign<Mat2<T>> for Mat2<T>where
T: Copy + Zero + Add<Output = T> + Mul<Output = T> + MulAdd<T, T, Output = T>,
impl<T> MulAssign<Mat2<T>> for Mat2<T>where T: Copy + Zero + Add<Output = T> + Mul<Output = T> + MulAdd<T, T, Output = T>,
source§fn mul_assign(&mut self, rhs: Self)
fn mul_assign(&mut self, rhs: Self)
*=
operation. Read moresource§impl<T> MulAssign<T> for Mat2<T>where
T: Copy + Zero + Add<Output = T> + Mul<Output = T>,
impl<T> MulAssign<T> for Mat2<T>where T: Copy + Zero + Add<Output = T> + Mul<Output = T>,
source§fn mul_assign(&mut self, rhs: T)
fn mul_assign(&mut self, rhs: T)
*=
operation. Read moresource§impl<T: PartialEq> PartialEq<Mat2<T>> for Mat2<T>
impl<T: PartialEq> PartialEq<Mat2<T>> for Mat2<T>
source§impl<T: RelativeEq> RelativeEq<Mat2<T>> for Mat2<T>where
T::Epsilon: Copy,
impl<T: RelativeEq> RelativeEq<Mat2<T>> for Mat2<T>where T::Epsilon: Copy,
source§fn default_max_relative() -> T::Epsilon
fn default_max_relative() -> T::Epsilon
source§fn relative_eq(
&self,
other: &Self,
epsilon: T::Epsilon,
max_relative: T::Epsilon
) -> bool
fn relative_eq( &self, other: &Self, epsilon: T::Epsilon, max_relative: T::Epsilon ) -> bool
source§fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon ) -> bool
RelativeEq::relative_eq
.source§impl<T: Rem<Output = T> + Copy> RemAssign<Mat2<T>> for Mat2<T>
impl<T: Rem<Output = T> + Copy> RemAssign<Mat2<T>> for Mat2<T>
source§fn rem_assign(&mut self, rhs: Self)
fn rem_assign(&mut self, rhs: Self)
%=
operation. Read moresource§impl<T: Rem<Output = T> + Copy> RemAssign<T> for Mat2<T>
impl<T: Rem<Output = T> + Copy> RemAssign<T> for Mat2<T>
source§fn rem_assign(&mut self, rhs: T)
fn rem_assign(&mut self, rhs: T)
%=
operation. Read moresource§impl<T: Sub<Output = T> + Copy> SubAssign<Mat2<T>> for Mat2<T>
impl<T: Sub<Output = T> + Copy> SubAssign<Mat2<T>> for Mat2<T>
source§fn sub_assign(&mut self, rhs: Self)
fn sub_assign(&mut self, rhs: Self)
-=
operation. Read moresource§impl<T: Sub<Output = T> + Copy> SubAssign<T> for Mat2<T>
impl<T: Sub<Output = T> + Copy> SubAssign<T> for Mat2<T>
source§fn sub_assign(&mut self, rhs: T)
fn sub_assign(&mut self, rhs: T)
-=
operation. Read more