Expand description
The most generic column-major matrix (and vector) type.
It combines four type parameters:
N
: for the matrix components scalar type.R
: for the matrix number of rows.C
: for the matrix number of columns.S
: for the matrix data storage, i.e., the buffer that actually contains the matrix components.
The matrix dimensions parameters R
and C
can either be:
- type-level unsigned integer constants (e.g.
U1
,U124
) from thenalgebra::
root module. All numbers from 0 to 127 are defined that way. - type-level unsigned integer constants (e.g.
U1024
,U10000
) from thetypenum::
crate. Using those, you will not get error messages as nice as for numbers smaller than 128 defined on thenalgebra::
module. - the special value
Dynamic
from thenalgebra::
root module. This indicates that the specified dimension is not known at compile-time. Note that this will generally imply that the matrix data storageS
performs a dynamic allocation and contains extra metadata for the matrix shape.
Note that mixing Dynamic
with type-level unsigned integers is allowed. Actually, a
dynamically-sized column vector should be represented as a Matrix<N, Dynamic, U1, S>
(given
some concrete types for N
and a compatible data storage type S
).
Fields§
§data: S
The data storage that contains all the matrix components and informations about its number of rows and column (if needed).
Implementations§
source§impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar + PartialOrd<N> + Signed,
D: Dim,
S: Storage<N, D, U1>,
impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar + PartialOrd<N> + Signed,
D: Dim,
S: Storage<N, D, U1>,
sourcepub fn imax(&self) -> usize
pub fn imax(&self) -> usize
Computes the index of the vector component with the largest value.
Examples:
let vec = Vector3::new(11, -15, 13);
assert_eq!(vec.imax(), 2);
sourcepub fn iamax(&self) -> usize
pub fn iamax(&self) -> usize
Computes the index of the vector component with the largest absolute value.
Examples:
let vec = Vector3::new(11, -15, 13);
assert_eq!(vec.iamax(), 1);
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar + PartialOrd<N> + Signed,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar + PartialOrd<N> + Signed,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn iamax_full(&self) -> (usize, usize)
pub fn iamax_full(&self) -> (usize, usize)
Computes the index of the matrix component with the largest absolute value.
Examples:
let mat = Matrix2x3::new(11, -12, 13,
21, 22, -23);
assert_eq!(mat.iamax_full(), (1, 2));
source§impl<N, R, C, S> Matrix<N, R, C, S>where
R: Dim,
C: Dim,
S: Storage<N, R, C>,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
impl<N, R, C, S> Matrix<N, R, C, S>where
R: Dim,
C: Dim,
S: Storage<N, R, C>,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
sourcepub fn dot<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> Nwhere
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
pub fn dot<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> Nwhere
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
The dot product between two vectors or matrices (seen as vectors).
Note that this is not the matrix multiplication as in, e.g., numpy. For matrix
multiplication, use one of: .gemm
, .mul_to
, .mul
, the *
operator.
Examples:
let vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
assert_eq!(vec1.dot(&vec2), 1.4);
let mat1 = Matrix2x3::new(1.0, 2.0, 3.0,
4.0, 5.0, 6.0);
let mat2 = Matrix2x3::new(0.1, 0.2, 0.3,
0.4, 0.5, 0.6);
assert_eq!(mat1.dot(&mat2), 9.1);
sourcepub fn tr_dot<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> Nwhere
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<C, R2> + DimEq<R, C2>,
pub fn tr_dot<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> Nwhere
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<C, R2> + DimEq<R, C2>,
The dot product between the transpose of self
and rhs
.
Examples:
let vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = RowVector3::new(0.1, 0.2, 0.3);
assert_eq!(vec1.tr_dot(&vec2), 1.4);
let mat1 = Matrix2x3::new(1.0, 2.0, 3.0,
4.0, 5.0, 6.0);
let mat2 = Matrix3x2::new(0.1, 0.4,
0.2, 0.5,
0.3, 0.6);
assert_eq!(mat1.tr_dot(&mat2), 9.1);
source§impl<N, D, S> Matrix<N, D, U1, S>where
D: Dim,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
S: StorageMut<N, D, U1>,
impl<N, D, S> Matrix<N, D, U1, S>where
D: Dim,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
S: StorageMut<N, D, U1>,
sourcepub fn axpy<D2, SB>(&mut self, a: N, x: &Matrix<N, D2, U1, SB>, b: N)where
D2: Dim,
SB: Storage<N, D2, U1>,
ShapeConstraint: DimEq<D, D2>,
pub fn axpy<D2, SB>(&mut self, a: N, x: &Matrix<N, D2, U1, SB>, b: N)where
D2: Dim,
SB: Storage<N, D2, U1>,
ShapeConstraint: DimEq<D, D2>,
Computes self = a * x + b * self
.
If be is zero, self
is never read from.
Examples:
let mut vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
vec1.axpy(10.0, &vec2, 5.0);
assert_eq!(vec1, Vector3::new(6.0, 12.0, 18.0));
sourcepub fn gemv<R2, C2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
)where
R2: Dim,
C2: Dim,
D3: Dim,
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, R2> + AreMultipliable<R2, C2, D3, U1>,
pub fn gemv<R2, C2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
)where
R2: Dim,
C2: Dim,
D3: Dim,
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, R2> + AreMultipliable<R2, C2, D3, U1>,
Computes self = alpha * a * x + beta * self
, where a
is a matrix, x
a vector, and
alpha, beta
two scalars.
If beta
is zero, self
is never read.
Examples:
let mut vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(0.1, 0.2);
let mat = Matrix2::new(1.0, 2.0,
3.0, 4.0);
vec1.gemv(10.0, &mat, &vec2, 5.0);
assert_eq!(vec1, Vector2::new(10.0, 21.0));
sourcepub fn gemv_symm<D2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, D2, D2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
)where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, D2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
pub fn gemv_symm<D2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, D2, D2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
)where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, D2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
Computes self = alpha * a * x + beta * self
, where a
is a symmetric matrix, x
a
vector, and alpha, beta
two scalars.
If beta
is zero, self
is never read. If self
is read, only its lower-triangular part
(including the diagonal) is actually read.
Examples:
let mat = Matrix2::new(1.0, 2.0,
2.0, 4.0);
let mut vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(0.1, 0.2);
vec1.gemv_symm(10.0, &mat, &vec2, 5.0);
assert_eq!(vec1, Vector2::new(10.0, 20.0));
// The matrix upper-triangular elements can be garbage because it is never
// read by this method. Therefore, it is not necessary for the caller to
// fill the matrix struct upper-triangle.
let mat = Matrix2::new(1.0, 9999999.9999999,
2.0, 4.0);
let mut vec1 = Vector2::new(1.0, 2.0);
vec1.gemv_symm(10.0, &mat, &vec2, 5.0);
assert_eq!(vec1, Vector2::new(10.0, 20.0));
sourcepub fn gemv_tr<R2, C2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
)where
R2: Dim,
C2: Dim,
D3: Dim,
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
pub fn gemv_tr<R2, C2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
)where
R2: Dim,
C2: Dim,
D3: Dim,
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
Computes self = alpha * a.transpose() * x + beta * self
, where a
is a matrix, x
a vector, and
alpha, beta
two scalars.
If beta
is zero, self
is never read.
Examples:
let mat = Matrix2::new(1.0, 3.0,
2.0, 4.0);
let mut vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(0.1, 0.2);
let expected = mat.transpose() * vec2 * 10.0 + vec1 * 5.0;
vec1.gemv_tr(10.0, &mat, &vec2, 5.0);
assert_eq!(vec1, expected);
source§impl<N, R1, C1, S> Matrix<N, R1, C1, S>where
R1: Dim,
C1: Dim,
S: StorageMut<N, R1, C1>,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
impl<N, R1, C1, S> Matrix<N, R1, C1, S>where
R1: Dim,
C1: Dim,
S: StorageMut<N, R1, C1>,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
sourcepub fn ger<D2, D3, SB, SC>(
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
)where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
pub fn ger<D2, D3, SB, SC>(
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
)where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
Computes self = alpha * x * y.transpose() + beta * self
.
If beta
is zero, self
is never read.
Examples:
let mut mat = Matrix2x3::repeat(4.0);
let vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0;
mat.ger(10.0, &vec1, &vec2, 5.0);
assert_eq!(mat, expected);
sourcepub fn gemm<R2, C2, R3, C3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C3> + AreMultipliable<R2, C2, R3, C3>,
pub fn gemm<R2, C2, R3, C3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C3> + AreMultipliable<R2, C2, R3, C3>,
Computes self = alpha * a * b + beta * self
, where a, b, self
are matrices.
alpha
and beta
are scalar.
If beta
is zero, self
is never read.
Examples:
let mut mat1 = Matrix2x4::identity();
let mat2 = Matrix2x3::new(1.0, 2.0, 3.0,
4.0, 5.0, 6.0);
let mat3 = Matrix3x4::new(0.1, 0.2, 0.3, 0.4,
0.5, 0.6, 0.7, 0.8,
0.9, 1.0, 1.1, 1.2);
let expected = mat2 * mat3 * 10.0 + mat1 * 5.0;
mat1.gemm(10.0, &mat2, &mat3, 5.0);
assert_relative_eq!(mat1, expected);
sourcepub fn gemm_tr<R2, C2, R3, C3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + AreMultipliable<C2, R2, R3, C3>,
pub fn gemm_tr<R2, C2, R3, C3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + AreMultipliable<C2, R2, R3, C3>,
Computes self = alpha * a.transpose() * b + beta * self
, where a, b, self
are matrices.
alpha
and beta
are scalar.
If beta
is zero, self
is never read.
Examples:
let mut mat1 = Matrix2x4::identity();
let mat2 = Matrix3x2::new(1.0, 4.0,
2.0, 5.0,
3.0, 6.0);
let mat3 = Matrix3x4::new(0.1, 0.2, 0.3, 0.4,
0.5, 0.6, 0.7, 0.8,
0.9, 1.0, 1.1, 1.2);
let expected = mat2.transpose() * mat3 * 10.0 + mat1 * 5.0;
mat1.gemm_tr(10.0, &mat2, &mat3, 5.0);
assert_relative_eq!(mat1, expected);
source§impl<N, R1, C1, S> Matrix<N, R1, C1, S>where
R1: Dim,
C1: Dim,
S: StorageMut<N, R1, C1>,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
impl<N, R1, C1, S> Matrix<N, R1, C1, S>where
R1: Dim,
C1: Dim,
S: StorageMut<N, R1, C1>,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
sourcepub fn ger_symm<D2, D3, SB, SC>(
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
)where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
pub fn ger_symm<D2, D3, SB, SC>(
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
)where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
Computes self = alpha * x * y.transpose() + beta * self
, where self
is a symmetric
matrix.
If beta
is zero, self
is never read. The result is symmetric. Only the lower-triangular
(including the diagonal) part of self
is read/written.
Examples:
let mut mat = Matrix2::identity();
let vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(0.1, 0.2);
let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0;
mat.m12 = 99999.99999; // This component is on the upper-triangular part and will not be read/written.
mat.ger_symm(10.0, &vec1, &vec2, 5.0);
assert_eq!(mat.lower_triangle(), expected.lower_triangle());
assert_eq!(mat.m12, 99999.99999); // This was untouched.
source§impl<N, D1, S> Matrix<N, D1, D1, S>where
D1: Dim,
S: StorageMut<N, D1, D1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
impl<N, D1, S> Matrix<N, D1, D1, S>where
D1: Dim,
S: StorageMut<N, D1, D1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
sourcepub fn quadform_tr_with_workspace<D2, S2, R3, C3, S3, D4, S4>(
&mut self,
work: &mut Matrix<N, D2, U1, S2>,
alpha: N,
lhs: &Matrix<N, R3, C3, S3>,
mid: &Matrix<N, D4, D4, S4>,
beta: N
)where
D2: Dim,
R3: Dim,
C3: Dim,
D4: Dim,
S2: StorageMut<N, D2, U1>,
S3: Storage<N, R3, C3>,
S4: Storage<N, D4, D4>,
ShapeConstraint: DimEq<D1, D2> + DimEq<D1, R3> + DimEq<D2, R3> + DimEq<C3, D4>,
pub fn quadform_tr_with_workspace<D2, S2, R3, C3, S3, D4, S4>(
&mut self,
work: &mut Matrix<N, D2, U1, S2>,
alpha: N,
lhs: &Matrix<N, R3, C3, S3>,
mid: &Matrix<N, D4, D4, S4>,
beta: N
)where
D2: Dim,
R3: Dim,
C3: Dim,
D4: Dim,
S2: StorageMut<N, D2, U1>,
S3: Storage<N, R3, C3>,
S4: Storage<N, D4, D4>,
ShapeConstraint: DimEq<D1, D2> + DimEq<D1, R3> + DimEq<D2, R3> + DimEq<C3, D4>,
Computes the quadratic form self = alpha * lhs * mid * lhs.transpose() + beta * self
.
This uses the provided workspace work
to avoid allocations for intermediate results.
Examples:
// Note that all those would also work with statically-sized matrices.
// We use DMatrix/DVector since that's the only case where pre-allocating the
// workspace is actually useful (assuming the same workspace is re-used for
// several computations) because it avoids repeated dynamic allocations.
let mut mat = DMatrix::identity(2, 2);
let lhs = DMatrix::from_row_slice(2, 3, &[1.0, 2.0, 3.0,
4.0, 5.0, 6.0]);
let mid = DMatrix::from_row_slice(3, 3, &[0.1, 0.2, 0.3,
0.5, 0.6, 0.7,
0.9, 1.0, 1.1]);
// The random shows that values on the workspace do not
// matter as they will be overwritten.
let mut workspace = DVector::new_random(2);
let expected = &lhs * &mid * lhs.transpose() * 10.0 + &mat * 5.0;
mat.quadform_tr_with_workspace(&mut workspace, 10.0, &lhs, &mid, 5.0);
assert_relative_eq!(mat, expected);
sourcepub fn quadform_tr<R3, C3, S3, D4, S4>(
&mut self,
alpha: N,
lhs: &Matrix<N, R3, C3, S3>,
mid: &Matrix<N, D4, D4, S4>,
beta: N
)where
R3: Dim,
C3: Dim,
D4: Dim,
S3: Storage<N, R3, C3>,
S4: Storage<N, D4, D4>,
ShapeConstraint: DimEq<D1, D1> + DimEq<D1, R3> + DimEq<C3, D4>,
DefaultAllocator: Allocator<N, D1, U1>,
pub fn quadform_tr<R3, C3, S3, D4, S4>(
&mut self,
alpha: N,
lhs: &Matrix<N, R3, C3, S3>,
mid: &Matrix<N, D4, D4, S4>,
beta: N
)where
R3: Dim,
C3: Dim,
D4: Dim,
S3: Storage<N, R3, C3>,
S4: Storage<N, D4, D4>,
ShapeConstraint: DimEq<D1, D1> + DimEq<D1, R3> + DimEq<C3, D4>,
DefaultAllocator: Allocator<N, D1, U1>,
Computes the quadratic form self = alpha * lhs * mid * lhs.transpose() + beta * self
.
This allocates a workspace vector of dimension D1 for intermediate results.
If D1
is a type-level integer, then the allocation is performed on the stack.
Use .quadform_tr_with_workspace(...)
instead to avoid allocations.
Examples:
let mut mat = Matrix2::identity();
let lhs = Matrix2x3::new(1.0, 2.0, 3.0,
4.0, 5.0, 6.0);
let mid = Matrix3::new(0.1, 0.2, 0.3,
0.5, 0.6, 0.7,
0.9, 1.0, 1.1);
let expected = lhs * mid * lhs.transpose() * 10.0 + mat * 5.0;
mat.quadform_tr(10.0, &lhs, &mid, 5.0);
assert_relative_eq!(mat, expected);
sourcepub fn quadform_with_workspace<D2, S2, D3, S3, R4, C4, S4>(
&mut self,
work: &mut Matrix<N, D2, U1, S2>,
alpha: N,
mid: &Matrix<N, D3, D3, S3>,
rhs: &Matrix<N, R4, C4, S4>,
beta: N
)where
D2: Dim,
D3: Dim,
R4: Dim,
C4: Dim,
S2: StorageMut<N, D2, U1>,
S3: Storage<N, D3, D3>,
S4: Storage<N, R4, C4>,
ShapeConstraint: DimEq<D3, R4> + DimEq<D1, C4> + DimEq<D2, D3> + AreMultipliable<C4, R4, D2, U1>,
pub fn quadform_with_workspace<D2, S2, D3, S3, R4, C4, S4>(
&mut self,
work: &mut Matrix<N, D2, U1, S2>,
alpha: N,
mid: &Matrix<N, D3, D3, S3>,
rhs: &Matrix<N, R4, C4, S4>,
beta: N
)where
D2: Dim,
D3: Dim,
R4: Dim,
C4: Dim,
S2: StorageMut<N, D2, U1>,
S3: Storage<N, D3, D3>,
S4: Storage<N, R4, C4>,
ShapeConstraint: DimEq<D3, R4> + DimEq<D1, C4> + DimEq<D2, D3> + AreMultipliable<C4, R4, D2, U1>,
Computes the quadratic form self = alpha * rhs.transpose() * mid * rhs + beta * self
.
This uses the provided workspace work
to avoid allocations for intermediate results.
// Note that all those would also work with statically-sized matrices.
// We use DMatrix/DVector since that's the only case where pre-allocating the
// workspace is actually useful (assuming the same workspace is re-used for
// several computations) because it avoids repeated dynamic allocations.
let mut mat = DMatrix::identity(2, 2);
let rhs = DMatrix::from_row_slice(3, 2, &[1.0, 2.0,
3.0, 4.0,
5.0, 6.0]);
let mid = DMatrix::from_row_slice(3, 3, &[0.1, 0.2, 0.3,
0.5, 0.6, 0.7,
0.9, 1.0, 1.1]);
// The random shows that values on the workspace do not
// matter as they will be overwritten.
let mut workspace = DVector::new_random(3);
let expected = rhs.transpose() * &mid * &rhs * 10.0 + &mat * 5.0;
mat.quadform_with_workspace(&mut workspace, 10.0, &mid, &rhs, 5.0);
assert_relative_eq!(mat, expected);
sourcepub fn quadform<D2, S2, R3, C3, S3>(
&mut self,
alpha: N,
mid: &Matrix<N, D2, D2, S2>,
rhs: &Matrix<N, R3, C3, S3>,
beta: N
)where
D2: Dim,
R3: Dim,
C3: Dim,
S2: Storage<N, D2, D2>,
S3: Storage<N, R3, C3>,
ShapeConstraint: DimEq<D2, R3> + DimEq<D1, C3> + AreMultipliable<C3, R3, D2, U1>,
DefaultAllocator: Allocator<N, D2, U1>,
pub fn quadform<D2, S2, R3, C3, S3>(
&mut self,
alpha: N,
mid: &Matrix<N, D2, D2, S2>,
rhs: &Matrix<N, R3, C3, S3>,
beta: N
)where
D2: Dim,
R3: Dim,
C3: Dim,
S2: Storage<N, D2, D2>,
S3: Storage<N, R3, C3>,
ShapeConstraint: DimEq<D2, R3> + DimEq<D1, C3> + AreMultipliable<C3, R3, D2, U1>,
DefaultAllocator: Allocator<N, D2, U1>,
Computes the quadratic form self = alpha * rhs.transpose() * mid * rhs + beta * self
.
This allocates a workspace vector of dimension D2 for intermediate results.
If D2
is a type-level integer, then the allocation is performed on the stack.
Use .quadform_with_workspace(...)
instead to avoid allocations.
let mut mat = Matrix2::identity();
let rhs = Matrix3x2::new(1.0, 2.0,
3.0, 4.0,
5.0, 6.0);
let mid = Matrix3::new(0.1, 0.2, 0.3,
0.5, 0.6, 0.7,
0.9, 1.0, 1.1);
let expected = rhs.transpose() * mid * rhs * 10.0 + mat * 5.0;
mat.quadform(10.0, &mid, &rhs, 5.0);
assert_relative_eq!(mat, expected);
source§impl<N, R, C, S> Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedNeg,
S: StorageMut<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedNeg,
S: StorageMut<N, R, C>,
source§impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
SA: Storage<N, R1, C1>,
N: Scalar + ClosedAdd<N>,
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
SA: Storage<N, R1, C1>,
N: Scalar + ClosedAdd<N>,
sourcepub fn add_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
pub fn add_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
source§impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
SA: Storage<N, R1, C1>,
N: Scalar + ClosedSub<N>,
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
SA: Storage<N, R1, C1>,
N: Scalar + ClosedSub<N>,
sourcepub fn sub_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
pub fn sub_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
source§impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SA: Storage<N, R1, C1>,
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SA: Storage<N, R1, C1>,
sourcepub fn tr_mul<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, C1, C2, <DefaultAllocator as Allocator<N, C1, C2>>::Buffer>where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
pub fn tr_mul<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, C1, C2, <DefaultAllocator as Allocator<N, C1, C2>>::Buffer>where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
Equivalent to self.transpose() * rhs
.
sourcepub fn tr_mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
pub fn tr_mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
Equivalent to self.transpose() * rhs
but stores the result into out
to avoid
allocations.
sourcepub fn mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1> + SameNumberOfColumns<C3, C2> + AreMultipliable<R1, C1, R2, C2>,
pub fn mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
)where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1> + SameNumberOfColumns<C3, C2> + AreMultipliable<R1, C1, R2, C2>,
Equivalent to self * rhs
but stores the result into out
to avoid allocations.
sourcepub fn kronecker<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output, <DefaultAllocator as Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>>::Buffer>where
R2: Dim,
C2: Dim,
N: ClosedMul<N>,
R1: DimMul<R2>,
C1: DimMul<C2>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>,
pub fn kronecker<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output, <DefaultAllocator as Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>>::Buffer>where
R2: Dim,
C2: Dim,
N: ClosedMul<N>,
R1: DimMul<R2>,
C1: DimMul<C2>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>,
The kronecker product of two matrices (aka. tensor product of the corresponding linear maps).
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar + ClosedAdd<N>,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar + ClosedAdd<N>,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn add_scalar(
&self,
rhs: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
pub fn add_scalar(
&self,
rhs: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
Adds a scalar to self
.
sourcepub fn add_scalar_mut(&mut self, rhs: N)where
S: StorageMut<N, R, C>,
pub fn add_scalar_mut(&mut self, rhs: N)where
S: StorageMut<N, R, C>,
Adds a scalar to self
in-place.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar + PartialOrd<N> + Signed,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar + PartialOrd<N> + Signed,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
source§impl<N, D> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Ring,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Ring,
DefaultAllocator: Allocator<N, D, D>,
sourcepub fn new_scaling(
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
pub fn new_scaling(
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
Creates a new homogeneous matrix that applies the same scaling factor on each dimension.
sourcepub fn new_nonuniform_scaling<SB>(
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
pub fn new_nonuniform_scaling<SB>(
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
Creates a new homogeneous matrix that applies a distinct scaling factor for each dimension.
sourcepub fn new_translation<SB>(
translation: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
pub fn new_translation<SB>(
translation: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
Creates a new homogeneous matrix that applies a pure translation.
source§impl<N> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Real,
impl<N> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Real,
sourcepub fn new_rotation(
angle: N
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
pub fn new_rotation(
angle: N
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
Builds a 2 dimensional homogeneous rotation matrix from an angle in radian.
source§impl<N> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Real,
impl<N> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Real,
sourcepub fn new_rotation(
axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
pub fn new_rotation(
axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
Returns the identity matrix if the given argument is zero.
sourcepub fn new_rotation_wrt_point(
axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
pt: Point<N, U3>
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
pub fn new_rotation_wrt_point(
axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>,
pt: Point<N, U3>
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
Returns the identity matrix if the given argument is zero.
sourcepub fn from_scaled_axis(
axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
pub fn from_scaled_axis(
axisangle: Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
Returns the identity matrix if the given argument is zero.
This is identical to Self::new_rotation
.
sourcepub fn from_euler_angles(
roll: N,
pitch: N,
yaw: N
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
pub fn from_euler_angles(
roll: N,
pitch: N,
yaw: N
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
Creates a new rotation from Euler angles.
The primitive rotations are applied in order: 1 roll − 2 pitch − 3 yaw.
sourcepub fn from_axis_angle(
axis: &Unit<Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>>,
angle: N
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
pub fn from_axis_angle(
axis: &Unit<Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>>,
angle: N
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
Builds a 3D homogeneous rotation matrix from an axis and a rotation angle.
sourcepub fn new_orthographic(
left: N,
right: N,
bottom: N,
top: N,
znear: N,
zfar: N
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
pub fn new_orthographic(
left: N,
right: N,
bottom: N,
top: N,
znear: N,
zfar: N
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
Creates a new homogeneous matrix for an orthographic projection.
sourcepub fn new_perspective(
aspect: N,
fovy: N,
znear: N,
zfar: N
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
pub fn new_perspective(
aspect: N,
fovy: N,
znear: N,
zfar: N
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
Creates a new homogeneous matrix for a perspective projection.
sourcepub fn new_observer_frame(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
pub fn new_observer_frame(
eye: &Point<N, U3>,
target: &Point<N, U3>,
up: &Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
Creates an isometry that corresponds to the local frame of an observer standing at the
point eye
and looking toward target
.
It maps the view direction target - eye
to the positive z
axis and the origin to the
eye
.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar + Ring,
D: DimName,
S: Storage<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar + Ring,
D: DimName,
S: Storage<N, D, D>,
sourcepub fn append_scaling(
&self,
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
DefaultAllocator: Allocator<N, D, D>,
pub fn append_scaling(
&self,
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
DefaultAllocator: Allocator<N, D, D>,
Computes the transformation equal to self
followed by an uniform scaling factor.
sourcepub fn prepend_scaling(
&self,
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
DefaultAllocator: Allocator<N, D, D>,
pub fn prepend_scaling(
&self,
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
DefaultAllocator: Allocator<N, D, D>,
Computes the transformation equal to an uniform scaling factor followed by self
.
sourcepub fn append_nonuniform_scaling<SB>(
&self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
pub fn append_nonuniform_scaling<SB>(
&self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
Computes the transformation equal to self
followed by a non-uniform scaling factor.
sourcepub fn prepend_nonuniform_scaling<SB>(
&self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
pub fn prepend_nonuniform_scaling<SB>(
&self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
Computes the transformation equal to a non-uniform scaling factor followed by self
.
sourcepub fn append_translation<SB>(
&self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
pub fn append_translation<SB>(
&self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
Computes the transformation equal to self
followed by a translation.
sourcepub fn prepend_translation<SB>(
&self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
pub fn prepend_translation<SB>(
&self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
Computes the transformation equal to a translation followed by self
.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar + Ring,
D: DimName,
S: StorageMut<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar + Ring,
D: DimName,
S: StorageMut<N, D, D>,
sourcepub fn append_scaling_mut(&mut self, scaling: N)where
D: DimNameSub<U1>,
pub fn append_scaling_mut(&mut self, scaling: N)where
D: DimNameSub<U1>,
Computes in-place the transformation equal to self
followed by an uniform scaling factor.
sourcepub fn prepend_scaling_mut(&mut self, scaling: N)where
D: DimNameSub<U1>,
pub fn prepend_scaling_mut(&mut self, scaling: N)where
D: DimNameSub<U1>,
Computes in-place the transformation equal to an uniform scaling factor followed by self
.
sourcepub fn append_nonuniform_scaling_mut<SB>(
&mut self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
)where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
pub fn append_nonuniform_scaling_mut<SB>(
&mut self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
)where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
Computes in-place the transformation equal to self
followed by a non-uniform scaling factor.
sourcepub fn prepend_nonuniform_scaling_mut<SB>(
&mut self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
)where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
pub fn prepend_nonuniform_scaling_mut<SB>(
&mut self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
)where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
Computes in-place the transformation equal to a non-uniform scaling factor followed by self
.
sourcepub fn append_translation_mut<SB>(
&mut self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
)where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
pub fn append_translation_mut<SB>(
&mut self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
)where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
Computes the transformation equal to self
followed by a translation.
sourcepub fn prepend_translation_mut<SB>(
&mut self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
)where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
pub fn prepend_translation_mut<SB>(
&mut self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
)where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
Computes the transformation equal to a translation followed by self
.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimNameSub<U1>,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, <D as DimNameSub<U1>>::Output, U1> + Allocator<N, <D as DimNameSub<U1>>::Output, <D as DimNameSub<U1>>::Output>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimNameSub<U1>,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, <D as DimNameSub<U1>>::Output, U1> + Allocator<N, <D as DimNameSub<U1>>::Output, <D as DimNameSub<U1>>::Output>,
sourcepub fn transform_vector(
&self,
v: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
) -> Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
pub fn transform_vector(
&self,
v: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
) -> Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
Transforms the given vector, assuming the matrix self
uses homogeneous coordinates.
sourcepub fn transform_point(
&self,
pt: &Point<N, <D as DimNameSub<U1>>::Output>
) -> Point<N, <D as DimNameSub<U1>>::Output>
pub fn transform_point(
&self,
pt: &Point<N, <D as DimNameSub<U1>>::Output>
) -> Point<N, <D as DimNameSub<U1>>::Output>
Transforms the given point, assuming the matrix self
uses homogeneous coordinates.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn abs(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Signed,
DefaultAllocator: Allocator<N, R, C>,
pub fn abs(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Signed,
DefaultAllocator: Allocator<N, R, C>,
Computes the component-wise absolute value.
Example
let a = Matrix2::new(0.0, 1.0,
-2.0, -3.0);
assert_eq!(a.abs(), Matrix2::new(0.0, 1.0, 2.0, 3.0))
source§impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
N: Scalar,
R1: Dim,
C1: Dim,
SA: Storage<N, R1, C1>,
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
N: Scalar,
R1: Dim,
C1: Dim,
SA: Storage<N, R1, C1>,
sourcepub fn component_mul<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>where
N: ClosedMul<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
pub fn component_mul<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>where
N: ClosedMul<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Componentwise matrix or vector multiplication.
Example
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);
assert_eq!(a.component_mul(&b), expected);
source§impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
N: Scalar,
R1: Dim,
C1: Dim,
SA: StorageMut<N, R1, C1>,
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
N: Scalar,
R1: Dim,
C1: Dim,
SA: StorageMut<N, R1, C1>,
sourcepub fn cmpy<R2, C2, SB, R3, C3, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
)where
N: ClosedMul<N, Output = N> + Zero<Output = N> + Mul<N> + Add<N>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
pub fn cmpy<R2, C2, SB, R3, C3, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
)where
N: ClosedMul<N, Output = N> + Zero<Output = N> + Mul<N> + Add<N>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Computes componentwise self[i] = alpha * a[i] * b[i] + beta * self[i]
.
Example
let mut m = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = (a.component_mul(&b) * 5.0) + m * 10.0;
m.cmpy(5.0, &a, &b, 10.0);
assert_eq!(m, expected);
sourcepub fn component_mul_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)where
N: ClosedMul<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
pub fn component_mul_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)where
N: ClosedMul<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Inplace componentwise matrix or vector multiplication.
Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);
a.component_mul_assign(&b);
assert_eq!(a, expected);
sourcepub fn component_mul_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)where
N: ClosedMul<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
👎Deprecated: This is renamed using the _assign
suffix instead of the _mut
suffix.
pub fn component_mul_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)where
N: ClosedMul<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
_assign
suffix instead of the _mut
suffix.Inplace componentwise matrix or vector multiplication.
Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);
a.component_mul_assign(&b);
assert_eq!(a, expected);
source§impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
N: Scalar,
R1: Dim,
C1: Dim,
SA: Storage<N, R1, C1>,
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
N: Scalar,
R1: Dim,
C1: Dim,
SA: Storage<N, R1, C1>,
sourcepub fn component_div<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>where
N: ClosedDiv<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
pub fn component_div<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>where
N: ClosedDiv<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Componentwise matrix or vector division.
Example
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);
assert_eq!(a.component_div(&b), expected);
source§impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
N: Scalar,
R1: Dim,
C1: Dim,
SA: StorageMut<N, R1, C1>,
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA>where
N: Scalar,
R1: Dim,
C1: Dim,
SA: StorageMut<N, R1, C1>,
sourcepub fn cdpy<R2, C2, SB, R3, C3, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
)where
N: ClosedDiv<N> + Zero<Output = N> + Mul<N, Output = N> + Add<N>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
pub fn cdpy<R2, C2, SB, R3, C3, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
)where
N: ClosedDiv<N> + Zero<Output = N> + Mul<N, Output = N> + Add<N>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Computes componentwise self[i] = alpha * a[i] / b[i] + beta * self[i]
.
Example
let mut m = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let a = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = (a.component_div(&b) * 5.0) + m * 10.0;
m.cdpy(5.0, &a, &b, 10.0);
assert_eq!(m, expected);
sourcepub fn component_div_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)where
N: ClosedDiv<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
pub fn component_div_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)where
N: ClosedDiv<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Inplace componentwise matrix or vector division.
Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);
a.component_div_assign(&b);
assert_eq!(a, expected);
sourcepub fn component_div_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)where
N: ClosedDiv<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
👎Deprecated: This is renamed using the _assign
suffix instead of the _mut
suffix.
pub fn component_div_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>)where
N: ClosedDiv<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
_assign
suffix instead of the _mut
suffix.Inplace componentwise matrix or vector division.
Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);
a.component_div_assign(&b);
assert_eq!(a, expected);
source§impl<N, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Scalar,
R: Dim,
C: Dim,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Scalar,
R: Dim,
C: Dim,
DefaultAllocator: Allocator<N, R, C>,
sourcepub unsafe fn new_uninitialized_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub unsafe fn new_uninitialized_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a new uninitialized matrix. If the matrix has a compile-time dimension, this panics
if nrows != R::to_usize()
or ncols != C::to_usize()
.
sourcepub fn from_element_generic(
nrows: R,
ncols: C,
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn from_element_generic(
nrows: R,
ncols: C,
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix with all its elements set to elem
.
sourcepub fn repeat_generic(
nrows: R,
ncols: C,
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn repeat_generic(
nrows: R,
ncols: C,
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix with all its elements set to elem
.
Same as from_element_generic
.
sourcepub fn zeros_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero,
pub fn zeros_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero,
Creates a matrix with all its elements set to 0.
sourcepub fn from_iterator_generic<I>(
nrows: R,
ncols: C,
iter: I
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
I: IntoIterator<Item = N>,
pub fn from_iterator_generic<I>(
nrows: R,
ncols: C,
iter: I
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
I: IntoIterator<Item = N>,
Creates a matrix with all its elements filled by an iterator.
sourcepub fn from_row_slice_generic(
nrows: R,
ncols: C,
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn from_row_slice_generic(
nrows: R,
ncols: C,
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
sourcepub fn from_column_slice_generic(
nrows: R,
ncols: C,
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn from_column_slice_generic(
nrows: R,
ncols: C,
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice. The components must have the same layout as the matrix data storage (i.e. column-major).
sourcepub fn from_fn_generic<F>(
nrows: R,
ncols: C,
f: F
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
F: FnMut(usize, usize) -> N,
pub fn from_fn_generic<F>(
nrows: R,
ncols: C,
f: F
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
F: FnMut(usize, usize) -> N,
Creates a matrix filled with the results of a function applied to each of its component coordinates.
sourcepub fn identity_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero + One,
pub fn identity_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero + One,
Creates a new identity matrix.
If the matrix is not square, the largest square submatrix starting at index (0, 0)
is set
to the identity matrix. All other entries are set to zero.
sourcepub fn from_diagonal_element_generic(
nrows: R,
ncols: C,
elt: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero + One,
pub fn from_diagonal_element_generic(
nrows: R,
ncols: C,
elt: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero + One,
Creates a new matrix with its diagonal filled with copies of elt
.
If the matrix is not square, the largest square submatrix starting at index (0, 0)
is set
to the identity matrix. All other entries are set to zero.
sourcepub fn from_partial_diagonal_generic(
nrows: R,
ncols: C,
elts: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero,
pub fn from_partial_diagonal_generic(
nrows: R,
ncols: C,
elts: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero,
Creates a new matrix that may be rectangular. The first elts.len()
diagonal elements are
filled with the content of elts
. Others are set to 0.
Panics if elts.len()
is larger than the minimum among nrows
and ncols
.
sourcepub fn from_rows<SB>(
rows: &[Matrix<N, U1, C, SB>]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
SB: Storage<N, U1, C>,
pub fn from_rows<SB>(
rows: &[Matrix<N, U1, C, SB>]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
SB: Storage<N, U1, C>,
Builds a new matrix from its rows.
Panics if not enough rows are provided (for statically-sized matrices), or if all rows do not have the same dimensions.
Example
let m = Matrix3::from_rows(&[ RowVector3::new(1.0, 2.0, 3.0), RowVector3::new(4.0, 5.0, 6.0), RowVector3::new(7.0, 8.0, 9.0) ]);
assert!(m.m11 == 1.0 && m.m12 == 2.0 && m.m13 == 3.0 &&
m.m21 == 4.0 && m.m22 == 5.0 && m.m23 == 6.0 &&
m.m31 == 7.0 && m.m32 == 8.0 && m.m33 == 9.0);
sourcepub fn from_columns<SB>(
columns: &[Matrix<N, R, U1, SB>]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
SB: Storage<N, R, U1>,
pub fn from_columns<SB>(
columns: &[Matrix<N, R, U1, SB>]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
SB: Storage<N, R, U1>,
Builds a new matrix from its columns.
Panics if not enough columns are provided (for statically-sized matrices), or if all columns do not have the same dimensions.
Example
let m = Matrix3::from_columns(&[ Vector3::new(1.0, 2.0, 3.0), Vector3::new(4.0, 5.0, 6.0), Vector3::new(7.0, 8.0, 9.0) ]);
assert!(m.m11 == 1.0 && m.m12 == 4.0 && m.m13 == 7.0 &&
m.m21 == 2.0 && m.m22 == 5.0 && m.m23 == 8.0 &&
m.m31 == 3.0 && m.m32 == 6.0 && m.m33 == 9.0);
sourcepub fn new_random_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
Standard: Distribution<N>,
pub fn new_random_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
Standard: Distribution<N>,
Creates a matrix filled with random values.
sourcepub fn from_distribution_generic<Distr, G>(
nrows: R,
ncols: C,
distribution: &Distr,
rng: &mut G
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
Distr: Distribution<N> + ?Sized,
G: Rng + ?Sized,
pub fn from_distribution_generic<Distr, G>(
nrows: R,
ncols: C,
distribution: &Distr,
rng: &mut G
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
Distr: Distribution<N> + ?Sized,
G: Rng + ?Sized,
Creates a matrix filled with random values from the given distribution.
sourcepub fn from_vec_generic(
nrows: R,
ncols: C,
data: Vec<N, Global>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn from_vec_generic(
nrows: R,
ncols: C,
data: Vec<N, Global>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
Example
let vec = vec![0, 1, 2, 3, 4, 5];
let vec_ptr = vec.as_ptr();
let matrix = Matrix::from_vec_generic(Dynamic::new(vec.len()), U1, vec);
let matrix_storage_ptr = matrix.data.as_ptr();
// `matrix` is backed by exactly the same `Vec` as it was constructed from.
assert_eq!(matrix_storage_ptr, vec_ptr);
source§impl<N, D> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: Dim,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: Dim,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
sourcepub fn from_diagonal<SB>(
diag: &Matrix<N, D, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
SB: Storage<N, D, U1>,
N: Zero,
pub fn from_diagonal<SB>(
diag: &Matrix<N, D, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
SB: Storage<N, D, U1>,
N: Zero,
Creates a square matrix with its diagonal set to diag
and all other entries set to 0.
Example
let m = Matrix3::from_diagonal(&Vector3::new(1.0, 2.0, 3.0));
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal(&DVector::from_row_slice(3, &[1.0, 2.0, 3.0]));
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 3.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 3.0);
source§impl<N, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Scalar,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Scalar,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<N, R, C>,
sourcepub unsafe fn new_uninitialized(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub unsafe fn new_uninitialized(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a new uninitialized matrix or vector.
sourcepub fn from_element(
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn from_element(
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn repeat(
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn repeat(
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn zeros(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero,
pub fn zeros(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero,
Creates a matrix or vector with all its elements set to 0
.
Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_iterator<I>(
iter: I
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
I: IntoIterator<Item = N>,
pub fn from_iterator<I>(
iter: I
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
I: IntoIterator<Item = N>,
Creates a matrix or vector with all its elements filled by an iterator.
The output matrix is filled column-by-column.
Example
let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
sourcepub fn from_row_slice(
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn from_row_slice(
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
Example
let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn from_column_slice(
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn from_column_slice(
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in column-major order.
Example
let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
sourcepub fn from_fn<F>(
f: F
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
F: FnMut(usize, usize) -> N,
pub fn from_fn<F>(
f: F
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
F: FnMut(usize, usize) -> N,
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn identity(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero + One,
pub fn identity(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero + One,
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_diagonal_element(
elt: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero + One,
pub fn from_diagonal_element(
elt: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero + One,
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_partial_diagonal(
elts: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero,
pub fn from_partial_diagonal(
elts: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Zero,
Creates a new matrix that may be rectangular. The first elts.len()
diagonal
elements are filled with the content of elts
. Others are set to 0.
Panics if elts.len()
is larger than the minimum among nrows
and ncols
.
Example
let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
sourcepub fn from_distribution<Distr, G>(
distribution: &Distr,
rng: &mut G
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
Distr: Distribution<N> + ?Sized,
G: Rng + ?Sized,
pub fn from_distribution<Distr, G>(
distribution: &Distr,
rng: &mut G
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
Distr: Distribution<N> + ?Sized,
G: Rng + ?Sized,
Creates a matrix or vector filled with random values from the given distribution.
sourcepub fn from_vec(
data: Vec<N, Global>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn from_vec(
data: Vec<N, Global>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
source§impl<N, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Scalar,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<N, R, C>,
Standard: Distribution<N>,
impl<N, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Scalar,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<N, R, C>,
Standard: Distribution<N>,
sourcepub fn new_random(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
pub fn new_random(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix filled with random values.
source§impl<N, R> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Scalar,
R: DimName,
DefaultAllocator: Allocator<N, R, Dynamic>,
impl<N, R> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Scalar,
R: DimName,
DefaultAllocator: Allocator<N, R, Dynamic>,
sourcepub unsafe fn new_uninitialized(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
pub unsafe fn new_uninitialized(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
Creates a new uninitialized matrix or vector.
sourcepub fn from_element(
ncols: usize,
elem: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
pub fn from_element(
ncols: usize,
elem: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn repeat(
ncols: usize,
elem: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
pub fn repeat(
ncols: usize,
elem: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn zeros(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Zero,
pub fn zeros(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Zero,
Creates a matrix or vector with all its elements set to 0
.
Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_iterator<I>(
ncols: usize,
iter: I
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
I: IntoIterator<Item = N>,
pub fn from_iterator<I>(
ncols: usize,
iter: I
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
I: IntoIterator<Item = N>,
Creates a matrix or vector with all its elements filled by an iterator.
The output matrix is filled column-by-column.
Example
let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
sourcepub fn from_row_slice(
ncols: usize,
slice: &[N]
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
pub fn from_row_slice(
ncols: usize,
slice: &[N]
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
Example
let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn from_column_slice(
ncols: usize,
slice: &[N]
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
pub fn from_column_slice(
ncols: usize,
slice: &[N]
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in column-major order.
Example
let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
sourcepub fn from_fn<F>(
ncols: usize,
f: F
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
F: FnMut(usize, usize) -> N,
pub fn from_fn<F>(
ncols: usize,
f: F
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
F: FnMut(usize, usize) -> N,
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn identity(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Zero + One,
pub fn identity(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Zero + One,
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_diagonal_element(
ncols: usize,
elt: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Zero + One,
pub fn from_diagonal_element(
ncols: usize,
elt: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Zero + One,
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_partial_diagonal(
ncols: usize,
elts: &[N]
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Zero,
pub fn from_partial_diagonal(
ncols: usize,
elts: &[N]
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Zero,
Creates a new matrix that may be rectangular. The first elts.len()
diagonal
elements are filled with the content of elts
. Others are set to 0.
Panics if elts.len()
is larger than the minimum among nrows
and ncols
.
Example
let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
sourcepub fn from_distribution<Distr, G>(
ncols: usize,
distribution: &Distr,
rng: &mut G
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
Distr: Distribution<N> + ?Sized,
G: Rng + ?Sized,
pub fn from_distribution<Distr, G>(
ncols: usize,
distribution: &Distr,
rng: &mut G
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
Distr: Distribution<N> + ?Sized,
G: Rng + ?Sized,
Creates a matrix or vector filled with random values from the given distribution.
sourcepub fn from_vec(
ncols: usize,
data: Vec<N, Global>
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
pub fn from_vec(
ncols: usize,
data: Vec<N, Global>
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
source§impl<N, R> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Scalar,
R: DimName,
DefaultAllocator: Allocator<N, R, Dynamic>,
Standard: Distribution<N>,
impl<N, R> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
N: Scalar,
R: DimName,
DefaultAllocator: Allocator<N, R, Dynamic>,
Standard: Distribution<N>,
sourcepub fn new_random(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
pub fn new_random(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
Creates a matrix filled with random values.
source§impl<N, C> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Scalar,
C: DimName,
DefaultAllocator: Allocator<N, Dynamic, C>,
impl<N, C> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Scalar,
C: DimName,
DefaultAllocator: Allocator<N, Dynamic, C>,
sourcepub unsafe fn new_uninitialized(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
pub unsafe fn new_uninitialized(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
Creates a new uninitialized matrix or vector.
sourcepub fn from_element(
nrows: usize,
elem: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
pub fn from_element(
nrows: usize,
elem: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn repeat(
nrows: usize,
elem: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
pub fn repeat(
nrows: usize,
elem: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn zeros(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Zero,
pub fn zeros(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Zero,
Creates a matrix or vector with all its elements set to 0
.
Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_iterator<I>(
nrows: usize,
iter: I
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
I: IntoIterator<Item = N>,
pub fn from_iterator<I>(
nrows: usize,
iter: I
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
I: IntoIterator<Item = N>,
Creates a matrix or vector with all its elements filled by an iterator.
The output matrix is filled column-by-column.
Example
let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
sourcepub fn from_row_slice(
nrows: usize,
slice: &[N]
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
pub fn from_row_slice(
nrows: usize,
slice: &[N]
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
Example
let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn from_column_slice(
nrows: usize,
slice: &[N]
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
pub fn from_column_slice(
nrows: usize,
slice: &[N]
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in column-major order.
Example
let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
sourcepub fn from_fn<F>(
nrows: usize,
f: F
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
F: FnMut(usize, usize) -> N,
pub fn from_fn<F>(
nrows: usize,
f: F
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
F: FnMut(usize, usize) -> N,
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn identity(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Zero + One,
pub fn identity(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Zero + One,
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_diagonal_element(
nrows: usize,
elt: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Zero + One,
pub fn from_diagonal_element(
nrows: usize,
elt: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Zero + One,
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_partial_diagonal(
nrows: usize,
elts: &[N]
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Zero,
pub fn from_partial_diagonal(
nrows: usize,
elts: &[N]
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Zero,
Creates a new matrix that may be rectangular. The first elts.len()
diagonal
elements are filled with the content of elts
. Others are set to 0.
Panics if elts.len()
is larger than the minimum among nrows
and ncols
.
Example
let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
sourcepub fn from_distribution<Distr, G>(
nrows: usize,
distribution: &Distr,
rng: &mut G
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
Distr: Distribution<N> + ?Sized,
G: Rng + ?Sized,
pub fn from_distribution<Distr, G>(
nrows: usize,
distribution: &Distr,
rng: &mut G
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
Distr: Distribution<N> + ?Sized,
G: Rng + ?Sized,
Creates a matrix or vector filled with random values from the given distribution.
sourcepub fn from_vec(
nrows: usize,
data: Vec<N, Global>
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
pub fn from_vec(
nrows: usize,
data: Vec<N, Global>
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
source§impl<N, C> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Scalar,
C: DimName,
DefaultAllocator: Allocator<N, Dynamic, C>,
Standard: Distribution<N>,
impl<N, C> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
N: Scalar,
C: DimName,
DefaultAllocator: Allocator<N, Dynamic, C>,
Standard: Distribution<N>,
sourcepub fn new_random(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
pub fn new_random(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
Creates a matrix filled with random values.
source§impl<N> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
impl<N> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
sourcepub unsafe fn new_uninitialized(
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
pub unsafe fn new_uninitialized(
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
Creates a new uninitialized matrix or vector.
sourcepub fn from_element(
nrows: usize,
ncols: usize,
elem: N
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
pub fn from_element(
nrows: usize,
ncols: usize,
elem: N
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn repeat(
nrows: usize,
ncols: usize,
elem: N
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
pub fn repeat(
nrows: usize,
ncols: usize,
elem: N
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn zeros(
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Zero,
pub fn zeros(
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Zero,
Creates a matrix or vector with all its elements set to 0
.
Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_iterator<I>(
nrows: usize,
ncols: usize,
iter: I
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
I: IntoIterator<Item = N>,
pub fn from_iterator<I>(
nrows: usize,
ncols: usize,
iter: I
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
I: IntoIterator<Item = N>,
Creates a matrix or vector with all its elements filled by an iterator.
The output matrix is filled column-by-column.
Example
let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
sourcepub fn from_row_slice(
nrows: usize,
ncols: usize,
slice: &[N]
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
pub fn from_row_slice(
nrows: usize,
ncols: usize,
slice: &[N]
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
Example
let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn from_column_slice(
nrows: usize,
ncols: usize,
slice: &[N]
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
pub fn from_column_slice(
nrows: usize,
ncols: usize,
slice: &[N]
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in column-major order.
Example
let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(3, &[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
sourcepub fn from_fn<F>(
nrows: usize,
ncols: usize,
f: F
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
F: FnMut(usize, usize) -> N,
pub fn from_fn<F>(
nrows: usize,
ncols: usize,
f: F
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
F: FnMut(usize, usize) -> N,
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn identity(
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Zero + One,
pub fn identity(
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Zero + One,
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_diagonal_element(
nrows: usize,
ncols: usize,
elt: N
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Zero + One,
pub fn from_diagonal_element(
nrows: usize,
ncols: usize,
elt: N
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Zero + One,
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_partial_diagonal(
nrows: usize,
ncols: usize,
elts: &[N]
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Zero,
pub fn from_partial_diagonal(
nrows: usize,
ncols: usize,
elts: &[N]
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Zero,
Creates a new matrix that may be rectangular. The first elts.len()
diagonal
elements are filled with the content of elts
. Others are set to 0.
Panics if elts.len()
is larger than the minimum among nrows
and ncols
.
Example
let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
sourcepub fn from_distribution<Distr, G>(
nrows: usize,
ncols: usize,
distribution: &Distr,
rng: &mut G
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
Distr: Distribution<N> + ?Sized,
G: Rng + ?Sized,
pub fn from_distribution<Distr, G>(
nrows: usize,
ncols: usize,
distribution: &Distr,
rng: &mut G
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
Distr: Distribution<N> + ?Sized,
G: Rng + ?Sized,
Creates a matrix or vector filled with random values from the given distribution.
sourcepub fn from_vec(
nrows: usize,
ncols: usize,
data: Vec<N, Global>
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
pub fn from_vec(
nrows: usize,
ncols: usize,
data: Vec<N, Global>
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
source§impl<N> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
Standard: Distribution<N>,
impl<N> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
Standard: Distribution<N>,
source§impl<N> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U2>,
impl<N> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U2>,
source§impl<N> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U3>,
impl<N> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U3>,
source§impl<N> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U4>,
impl<N> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U4>,
source§impl<N> Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U5>,
impl<N> Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U5>,
sourcepub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m31: N,
m32: N,
m33: N,
m34: N,
m35: N,
m41: N,
m42: N,
m43: N,
m44: N,
m45: N,
m51: N,
m52: N,
m53: N,
m54: N,
m55: N
) -> Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer>
pub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m31: N,
m32: N,
m33: N,
m34: N,
m35: N,
m41: N,
m42: N,
m43: N,
m44: N,
m45: N,
m51: N,
m52: N,
m53: N,
m54: N,
m55: N
) -> Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer>
Initializes this matrix from its components.
source§impl<N> Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U6>,
impl<N> Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U6>,
sourcepub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m16: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m26: N,
m31: N,
m32: N,
m33: N,
m34: N,
m35: N,
m36: N,
m41: N,
m42: N,
m43: N,
m44: N,
m45: N,
m46: N,
m51: N,
m52: N,
m53: N,
m54: N,
m55: N,
m56: N,
m61: N,
m62: N,
m63: N,
m64: N,
m65: N,
m66: N
) -> Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer>
pub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m16: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m26: N,
m31: N,
m32: N,
m33: N,
m34: N,
m35: N,
m36: N,
m41: N,
m42: N,
m43: N,
m44: N,
m45: N,
m46: N,
m51: N,
m52: N,
m53: N,
m54: N,
m55: N,
m56: N,
m61: N,
m62: N,
m63: N,
m64: N,
m65: N,
m66: N
) -> Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer>
Initializes this matrix from its components.
source§impl<N> Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U3>,
impl<N> Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U3>,
source§impl<N> Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U4>,
impl<N> Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U4>,
source§impl<N> Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U5>,
impl<N> Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U5>,
source§impl<N> Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U6>,
impl<N> Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U6>,
source§impl<N> Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U2>,
impl<N> Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U2>,
source§impl<N> Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U4>,
impl<N> Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U4>,
source§impl<N> Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U5>,
impl<N> Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U5>,
source§impl<N> Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U6>,
impl<N> Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U6>,
source§impl<N> Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U2>,
impl<N> Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U2>,
source§impl<N> Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U3>,
impl<N> Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U3>,
source§impl<N> Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U5>,
impl<N> Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U5>,
source§impl<N> Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U6>,
impl<N> Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U6>,
sourcepub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m16: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m26: N,
m31: N,
m32: N,
m33: N,
m34: N,
m35: N,
m36: N,
m41: N,
m42: N,
m43: N,
m44: N,
m45: N,
m46: N
) -> Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer>
pub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m16: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m26: N,
m31: N,
m32: N,
m33: N,
m34: N,
m35: N,
m36: N,
m41: N,
m42: N,
m43: N,
m44: N,
m45: N,
m46: N
) -> Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer>
Initializes this matrix from its components.
source§impl<N> Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U2>,
impl<N> Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U2>,
source§impl<N> Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U3>,
impl<N> Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U3>,
source§impl<N> Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U4>,
impl<N> Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U4>,
source§impl<N> Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U6>,
impl<N> Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U6>,
sourcepub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m16: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m26: N,
m31: N,
m32: N,
m33: N,
m34: N,
m35: N,
m36: N,
m41: N,
m42: N,
m43: N,
m44: N,
m45: N,
m46: N,
m51: N,
m52: N,
m53: N,
m54: N,
m55: N,
m56: N
) -> Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer>
pub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m16: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m26: N,
m31: N,
m32: N,
m33: N,
m34: N,
m35: N,
m36: N,
m41: N,
m42: N,
m43: N,
m44: N,
m45: N,
m46: N,
m51: N,
m52: N,
m53: N,
m54: N,
m55: N,
m56: N
) -> Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer>
Initializes this matrix from its components.
source§impl<N> Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U2>,
impl<N> Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U2>,
source§impl<N> Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U3>,
impl<N> Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U3>,
source§impl<N> Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U4>,
impl<N> Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U4>,
sourcepub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m21: N,
m22: N,
m23: N,
m24: N,
m31: N,
m32: N,
m33: N,
m34: N,
m41: N,
m42: N,
m43: N,
m44: N,
m51: N,
m52: N,
m53: N,
m54: N,
m61: N,
m62: N,
m63: N,
m64: N
) -> Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer>
pub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m21: N,
m22: N,
m23: N,
m24: N,
m31: N,
m32: N,
m33: N,
m34: N,
m41: N,
m42: N,
m43: N,
m44: N,
m51: N,
m52: N,
m53: N,
m54: N,
m61: N,
m62: N,
m63: N,
m64: N
) -> Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer>
Initializes this matrix from its components.
source§impl<N> Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U5>,
impl<N> Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U5>,
sourcepub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m31: N,
m32: N,
m33: N,
m34: N,
m35: N,
m41: N,
m42: N,
m43: N,
m44: N,
m45: N,
m51: N,
m52: N,
m53: N,
m54: N,
m55: N,
m61: N,
m62: N,
m63: N,
m64: N,
m65: N
) -> Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer>
pub fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m31: N,
m32: N,
m33: N,
m34: N,
m35: N,
m41: N,
m42: N,
m43: N,
m44: N,
m45: N,
m51: N,
m52: N,
m53: N,
m54: N,
m55: N,
m61: N,
m62: N,
m63: N,
m64: N,
m65: N
) -> Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer>
Initializes this matrix from its components.
source§impl<N> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U1>,
impl<N> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U1>,
source§impl<N> Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U2>,
impl<N> Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U2>,
source§impl<N> Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U3>,
impl<N> Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U3>,
source§impl<N> Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U4>,
impl<N> Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U4>,
source§impl<N> Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U5>,
impl<N> Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U5>,
source§impl<N> Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U6>,
impl<N> Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U6>,
source§impl<N> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U1>,
impl<N> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U1>,
source§impl<N> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U1>,
impl<N> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U1>,
source§impl<N> Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U1>,
impl<N> Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U1>,
source§impl<N> Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U1>,
impl<N> Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U1>,
source§impl<N> Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U1>,
impl<N> Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U1>,
source§impl<N, R> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
R: DimName,
N: Scalar + Zero + One,
DefaultAllocator: Allocator<N, R, U1>,
impl<N, R> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
R: DimName,
N: Scalar + Zero + One,
DefaultAllocator: Allocator<N, R, U1>,
sourcepub fn x(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UTerm, Output = Greater>,
pub fn x(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UTerm, Output = Greater>,
The column vector with a 1 as its first component, and zero elsewhere.
sourcepub fn y(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UInt<UTerm, B1>, Output = Greater>,
pub fn y(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UInt<UTerm, B1>, Output = Greater>,
The column vector with a 1 as its second component, and zero elsewhere.
sourcepub fn z(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,
pub fn z(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,
The column vector with a 1 as its third component, and zero elsewhere.
sourcepub fn w(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B1>, Output = Greater>,
pub fn w(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B1>, Output = Greater>,
The column vector with a 1 as its fourth component, and zero elsewhere.
sourcepub fn a(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, Output = Greater>,
pub fn a(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, Output = Greater>,
The column vector with a 1 as its fifth component, and zero elsewhere.
sourcepub fn b(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, Output = Greater>,
pub fn b(
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>where
<R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, Output = Greater>,
The column vector with a 1 as its sixth component, and zero elsewhere.
sourcepub fn x_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>>where
<R as DimName>::Value: Cmp<UTerm, Output = Greater>,
pub fn x_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>>where
<R as DimName>::Value: Cmp<UTerm, Output = Greater>,
The unit column vector with a 1 as its first component, and zero elsewhere.
sourcepub fn y_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>>where
<R as DimName>::Value: Cmp<UInt<UTerm, B1>, Output = Greater>,
pub fn y_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>>where
<R as DimName>::Value: Cmp<UInt<UTerm, B1>, Output = Greater>,
The unit column vector with a 1 as its second component, and zero elsewhere.
sourcepub fn z_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>>where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,
pub fn z_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>>where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,
The unit column vector with a 1 as its third component, and zero elsewhere.
sourcepub fn w_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>>where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B1>, Output = Greater>,
pub fn w_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>>where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B1>, Output = Greater>,
The unit column vector with a 1 as its fourth component, and zero elsewhere.
source§impl<'a, N, R, C, RStride, CStride> Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>where
N: Scalar,
R: Dim,
C: Dim,
RStride: Dim,
CStride: Dim,
impl<'a, N, R, C, RStride, CStride> Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>where
N: Scalar,
R: Dim,
C: Dim,
RStride: Dim,
CStride: Dim,
sourcepub unsafe fn from_slice_with_strides_generic_unchecked(
data: &'a [N],
start: usize,
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>
pub unsafe fn from_slice_with_strides_generic_unchecked(
data: &'a [N],
start: usize,
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>
Creates, without bound-checking, a matrix slice from an array and with dimensions and strides specified by generic types instances.
This method is unsafe because the input data array is not checked to contain enough elements.
The generic types R
, C
, RStride
, CStride
can either be type-level integers or integers wrapped with Dynamic::new()
.
sourcepub fn from_slice_with_strides_generic(
data: &'a [N],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>
pub fn from_slice_with_strides_generic(
data: &'a [N],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>
Creates a matrix slice from an array and with dimensions and strides specified by generic types instances.
Panics if the input data array dose not contain enough elements.
The generic types R
, C
, RStride
, CStride
can either be type-level integers or integers wrapped with Dynamic::new()
.
source§impl<'a, N, R, C, RStride, CStride> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>where
N: Scalar,
R: Dim,
C: Dim,
RStride: Dim,
CStride: Dim,
impl<'a, N, R, C, RStride, CStride> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>where
N: Scalar,
R: Dim,
C: Dim,
RStride: Dim,
CStride: Dim,
sourcepub unsafe fn from_slice_with_strides_generic_unchecked(
data: &'a mut [N],
start: usize,
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>
pub unsafe fn from_slice_with_strides_generic_unchecked(
data: &'a mut [N],
start: usize,
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>
Creates, without bound-checking, a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.
This method is unsafe because the input data array is not checked to contain enough elements.
The generic types R
, C
, RStride
, CStride
can either be type-level integers or integers wrapped with Dynamic::new()
.
sourcepub fn from_slice_with_strides_generic(
data: &'a mut [N],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>
pub fn from_slice_with_strides_generic(
data: &'a mut [N],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>
Creates a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.
Panics if the input data array dose not contain enough elements.
The generic types R
, C
, RStride
, CStride
can either be type-level integers or integers wrapped with Dynamic::new()
.
source§impl<'a, N, R, C> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>where
N: Scalar,
R: Dim,
C: Dim,
impl<'a, N, R, C> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>where
N: Scalar,
R: Dim,
C: Dim,
sourcepub unsafe fn from_slice_generic_unchecked(
data: &'a [N],
start: usize,
nrows: R,
ncols: C
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>
pub unsafe fn from_slice_generic_unchecked(
data: &'a [N],
start: usize,
nrows: R,
ncols: C
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>
Creates, without bound-checking, a matrix slice from an array and with dimensions specified by generic types instances.
This method is unsafe because the input data array is not checked to contain enough elements.
The generic types R
and C
can either be type-level integers or integers wrapped with Dynamic::new()
.
sourcepub fn from_slice_generic(
data: &'a [N],
nrows: R,
ncols: C
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>
pub fn from_slice_generic(
data: &'a [N],
nrows: R,
ncols: C
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>
Creates a matrix slice from an array and with dimensions and strides specified by generic types instances.
Panics if the input data array dose not contain enough elements.
The generic types R
and C
can either be type-level integers or integers wrapped with Dynamic::new()
.
source§impl<'a, N, R, C> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>where
N: Scalar,
R: Dim,
C: Dim,
impl<'a, N, R, C> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>where
N: Scalar,
R: Dim,
C: Dim,
sourcepub unsafe fn from_slice_generic_unchecked(
data: &'a mut [N],
start: usize,
nrows: R,
ncols: C
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>
pub unsafe fn from_slice_generic_unchecked(
data: &'a mut [N],
start: usize,
nrows: R,
ncols: C
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>
Creates, without bound-checking, a mutable matrix slice from an array and with dimensions specified by generic types instances.
This method is unsafe because the input data array is not checked to contain enough elements.
The generic types R
and C
can either be type-level integers or integers wrapped with Dynamic::new()
.
sourcepub fn from_slice_generic(
data: &'a mut [N],
nrows: R,
ncols: C
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>
pub fn from_slice_generic(
data: &'a mut [N],
nrows: R,
ncols: C
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>
Creates a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.
Panics if the input data array dose not contain enough elements.
The generic types R
and C
can either be type-level integers or integers wrapped with Dynamic::new()
.
source§impl<'a, N, R, C> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>where
N: Scalar,
R: DimName,
C: DimName,
impl<'a, N, R, C> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>where
N: Scalar,
R: DimName,
C: DimName,
sourcepub fn from_slice(
data: &'a [N]
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>
pub fn from_slice(
data: &'a [N]
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>
Creates a new matrix slice from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_unchecked(
data: &'a [N],
start: usize
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>
pub unsafe fn from_slice_unchecked(
data: &'a [N],
start: usize
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, U1, R>>
Creates, without bound checking, a new matrix slice from the given data array.
source§impl<'a, N, R, C> Matrix<N, R, C, SliceStorage<'a, N, R, C, Dynamic, Dynamic>>where
N: Scalar,
R: DimName,
C: DimName,
impl<'a, N, R, C> Matrix<N, R, C, SliceStorage<'a, N, R, C, Dynamic, Dynamic>>where
N: Scalar,
R: DimName,
C: DimName,
sourcepub fn from_slice_with_strides(
data: &'a [N],
rstride: usize,
cstride: usize
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, Dynamic, Dynamic>>
pub fn from_slice_with_strides(
data: &'a [N],
rstride: usize,
cstride: usize
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, Dynamic, Dynamic>>
Creates a new matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a [N],
start: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a [N],
start: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, C, SliceStorage<'a, N, R, C, Dynamic, Dynamic>>
Creates, without bound checking, a new matrix slice with the specified strides from the given data array.
source§impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, U1, R>>where
N: Scalar,
R: DimName,
impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, U1, R>>where
N: Scalar,
R: DimName,
sourcepub fn from_slice(
data: &'a [N],
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, U1, R>>
pub fn from_slice(
data: &'a [N],
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, U1, R>>
Creates a new matrix slice from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_unchecked(
data: &'a [N],
start: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, U1, R>>
pub unsafe fn from_slice_unchecked(
data: &'a [N],
start: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, U1, R>>
Creates, without bound checking, a new matrix slice from the given data array.
source§impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, Dynamic, Dynamic>>where
N: Scalar,
R: DimName,
impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, Dynamic, Dynamic>>where
N: Scalar,
R: DimName,
sourcepub fn from_slice_with_strides(
data: &'a [N],
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, Dynamic, Dynamic>>
pub fn from_slice_with_strides(
data: &'a [N],
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, Dynamic, Dynamic>>
Creates a new matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a [N],
start: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a [N],
start: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, Dynamic, Dynamic>>
Creates, without bound checking, a new matrix slice with the specified strides from the given data array.
source§impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, U1, Dynamic>>where
N: Scalar,
C: DimName,
impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, U1, Dynamic>>where
N: Scalar,
C: DimName,
sourcepub fn from_slice(
data: &'a [N],
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, U1, Dynamic>>
pub fn from_slice(
data: &'a [N],
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, U1, Dynamic>>
Creates a new matrix slice from the given data array.
Panics if data
does not contain enough elements.
source§impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, Dynamic, Dynamic>>where
N: Scalar,
C: DimName,
impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, Dynamic, Dynamic>>where
N: Scalar,
C: DimName,
sourcepub fn from_slice_with_strides(
data: &'a [N],
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, Dynamic, Dynamic>>
pub fn from_slice_with_strides(
data: &'a [N],
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, Dynamic, Dynamic>>
Creates a new matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a [N],
start: usize,
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a [N],
start: usize,
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, Dynamic, Dynamic>>
Creates, without bound checking, a new matrix slice with the specified strides from the given data array.
source§impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, U1, Dynamic>>where
N: Scalar,
impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, U1, Dynamic>>where
N: Scalar,
source§impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>where
N: Scalar,
impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>where
N: Scalar,
sourcepub fn from_slice_with_strides(
data: &'a [N],
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>
pub fn from_slice_with_strides(
data: &'a [N],
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>
Creates a new matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a [N],
start: usize,
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a [N],
start: usize,
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>
Creates, without bound checking, a new matrix slice with the specified strides from the given data array.
source§impl<'a, N, R, C> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>where
N: Scalar,
R: DimName,
C: DimName,
impl<'a, N, R, C> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>where
N: Scalar,
R: DimName,
C: DimName,
sourcepub fn from_slice(
data: &'a mut [N]
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>
pub fn from_slice(
data: &'a mut [N]
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>
Creates a new mutable matrix slice from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_unchecked(
data: &'a mut [N],
start: usize
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>
pub unsafe fn from_slice_unchecked(
data: &'a mut [N],
start: usize
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, U1, R>>
Creates, without bound checking, a new mutable matrix slice from the given data array.
source§impl<'a, N, R, C> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, Dynamic, Dynamic>>where
N: Scalar,
R: DimName,
C: DimName,
impl<'a, N, R, C> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, Dynamic, Dynamic>>where
N: Scalar,
R: DimName,
C: DimName,
sourcepub fn from_slice_with_strides_mut(
data: &'a mut [N],
rstride: usize,
cstride: usize
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, Dynamic, Dynamic>>
pub fn from_slice_with_strides_mut(
data: &'a mut [N],
rstride: usize,
cstride: usize
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, Dynamic, Dynamic>>
Creates a new mutable matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [N],
start: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [N],
start: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, C, SliceStorageMut<'a, N, R, C, Dynamic, Dynamic>>
Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.
source§impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, U1, R>>where
N: Scalar,
R: DimName,
impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, U1, R>>where
N: Scalar,
R: DimName,
sourcepub fn from_slice(
data: &'a mut [N],
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, U1, R>>
pub fn from_slice(
data: &'a mut [N],
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, U1, R>>
Creates a new mutable matrix slice from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_unchecked(
data: &'a mut [N],
start: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, U1, R>>
pub unsafe fn from_slice_unchecked(
data: &'a mut [N],
start: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, U1, R>>
Creates, without bound checking, a new mutable matrix slice from the given data array.
source§impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, Dynamic, Dynamic>>where
N: Scalar,
R: DimName,
impl<'a, N, R> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, Dynamic, Dynamic>>where
N: Scalar,
R: DimName,
sourcepub fn from_slice_with_strides_mut(
data: &'a mut [N],
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, Dynamic, Dynamic>>
pub fn from_slice_with_strides_mut(
data: &'a mut [N],
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, Dynamic, Dynamic>>
Creates a new mutable matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [N],
start: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [N],
start: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, Dynamic, Dynamic>>
Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.
source§impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, U1, Dynamic>>where
N: Scalar,
C: DimName,
impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, U1, Dynamic>>where
N: Scalar,
C: DimName,
sourcepub fn from_slice(
data: &'a mut [N],
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, U1, Dynamic>>
pub fn from_slice(
data: &'a mut [N],
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, U1, Dynamic>>
Creates a new mutable matrix slice from the given data array.
Panics if data
does not contain enough elements.
source§impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, Dynamic, Dynamic>>where
N: Scalar,
C: DimName,
impl<'a, N, C> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, Dynamic, Dynamic>>where
N: Scalar,
C: DimName,
sourcepub fn from_slice_with_strides_mut(
data: &'a mut [N],
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, Dynamic, Dynamic>>
pub fn from_slice_with_strides_mut(
data: &'a mut [N],
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, Dynamic, Dynamic>>
Creates a new mutable matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [N],
start: usize,
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [N],
start: usize,
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, Dynamic, Dynamic>>
Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.
source§impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, U1, Dynamic>>where
N: Scalar,
impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, U1, Dynamic>>where
N: Scalar,
source§impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>where
N: Scalar,
impl<'a, N> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>where
N: Scalar,
sourcepub fn from_slice_with_strides_mut(
data: &'a mut [N],
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>
pub fn from_slice_with_strides_mut(
data: &'a mut [N],
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>
Creates a new mutable matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [N],
start: usize,
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [N],
start: usize,
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'a, N, Dynamic, Dynamic, Dynamic, Dynamic>>
Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar + Zero,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar + Zero,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn upper_triangle(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
pub fn upper_triangle(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
Extracts the upper triangular part of this matrix (including the diagonal).
sourcepub fn lower_triangle(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
pub fn lower_triangle(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
Extracts the upper triangular part of this matrix (including the diagonal).
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
sourcepub fn fill_with_identity(&mut self)where
N: Zero + One,
pub fn fill_with_identity(&mut self)where
N: Zero + One,
Fills self
with the identity matrix.
sourcepub fn fill_diagonal(&mut self, val: N)
pub fn fill_diagonal(&mut self, val: N)
Sets all the diagonal elements of this matrix to val
.
sourcepub fn fill_column(&mut self, j: usize, val: N)
pub fn fill_column(&mut self, j: usize, val: N)
Sets all the elements of the selected column to val
.
sourcepub fn set_diagonal<R2, S2>(&mut self, diag: &Matrix<N, R2, U1, S2>)where
R2: Dim,
R: DimMin<C>,
S2: Storage<N, R2, U1>,
ShapeConstraint: DimEq<<R as DimMin<C>>::Output, R2>,
pub fn set_diagonal<R2, S2>(&mut self, diag: &Matrix<N, R2, U1, S2>)where
R2: Dim,
R: DimMin<C>,
S2: Storage<N, R2, U1>,
ShapeConstraint: DimEq<<R as DimMin<C>>::Output, R2>,
Fills the diagonal of this matrix with the content of the given vector.
sourcepub fn set_row<C2, S2>(&mut self, i: usize, row: &Matrix<N, U1, C2, S2>)where
C2: Dim,
S2: Storage<N, U1, C2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn set_row<C2, S2>(&mut self, i: usize, row: &Matrix<N, U1, C2, S2>)where
C2: Dim,
S2: Storage<N, U1, C2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Fills the selected row of this matrix with the content of the given vector.
sourcepub fn set_column<R2, S2>(&mut self, i: usize, column: &Matrix<N, R2, U1, S2>)where
R2: Dim,
S2: Storage<N, R2, U1>,
ShapeConstraint: SameNumberOfRows<R, R2>,
pub fn set_column<R2, S2>(&mut self, i: usize, column: &Matrix<N, R2, U1, S2>)where
R2: Dim,
S2: Storage<N, R2, U1>,
ShapeConstraint: SameNumberOfRows<R, R2>,
Fills the selected column of this matrix with the content of the given vector.
sourcepub fn fill_lower_triangle(&mut self, val: N, shift: usize)
pub fn fill_lower_triangle(&mut self, val: N, shift: usize)
Sets all the elements of the lower-triangular part of this matrix to val
.
The parameter shift
allows some subdiagonals to be left untouched:
- If
shift = 0
then the diagonal is overwritten as well. - If
shift = 1
then the diagonal is left untouched. - If
shift > 1
, then the diagonal and the firstshift - 1
subdiagonals are left untouched.
sourcepub fn fill_upper_triangle(&mut self, val: N, shift: usize)
pub fn fill_upper_triangle(&mut self, val: N, shift: usize)
Sets all the elements of the lower-triangular part of this matrix to val
.
The parameter shift
allows some superdiagonals to be left untouched:
- If
shift = 0
then the diagonal is overwritten as well. - If
shift = 1
then the diagonal is left untouched. - If
shift > 1
, then the diagonal and the firstshift - 1
superdiagonals are left untouched.
sourcepub fn swap_columns(&mut self, icol1: usize, icol2: usize)
pub fn swap_columns(&mut self, icol1: usize, icol2: usize)
Swaps two columns in-place.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar,
D: Dim,
S: StorageMut<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar,
D: Dim,
S: StorageMut<N, D, D>,
sourcepub fn fill_lower_triangle_with_upper_triangle(&mut self)
pub fn fill_lower_triangle_with_upper_triangle(&mut self)
Copies the upper-triangle of this matrix to its lower-triangular part.
This makes the matrix symmetric. Panics if the matrix is not square.
sourcepub fn fill_upper_triangle_with_lower_triangle(&mut self)
pub fn fill_upper_triangle_with_lower_triangle(&mut self)
Copies the upper-triangle of this matrix to its upper-triangular part.
This makes the matrix symmetric. Panics if the matrix is not square.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn remove_column(
self,
i: usize
) -> Matrix<N, R, <C as DimSub<U1>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimSub<U1>>::Output>>::Buffer>where
C: DimSub<U1>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<U1>>::Output>,
pub fn remove_column(
self,
i: usize
) -> Matrix<N, R, <C as DimSub<U1>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimSub<U1>>::Output>>::Buffer>where
C: DimSub<U1>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<U1>>::Output>,
Removes the i
-th column from this matrix.
sourcepub fn remove_fixed_columns<D>(
self,
i: usize
) -> Matrix<N, R, <C as DimSub<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimSub<D>>::Output>>::Buffer>where
D: DimName,
C: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<D>>::Output>,
pub fn remove_fixed_columns<D>(
self,
i: usize
) -> Matrix<N, R, <C as DimSub<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimSub<D>>::Output>>::Buffer>where
D: DimName,
C: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<D>>::Output>,
Removes D::dim()
consecutive columns from this matrix, starting with the i
-th
(included).
sourcepub fn remove_columns(
self,
i: usize,
n: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
C: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,
pub fn remove_columns(
self,
i: usize,
n: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
C: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,
Removes n
consecutive columns from this matrix, starting with the i
-th (included).
sourcepub fn remove_columns_generic<D>(
self,
i: usize,
nremove: D
) -> Matrix<N, R, <C as DimSub<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimSub<D>>::Output>>::Buffer>where
D: Dim,
C: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<D>>::Output>,
pub fn remove_columns_generic<D>(
self,
i: usize,
nremove: D
) -> Matrix<N, R, <C as DimSub<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimSub<D>>::Output>>::Buffer>where
D: Dim,
C: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<D>>::Output>,
Removes nremove.value()
columns from this matrix, starting with the i
-th (included).
This is the generic implementation of .remove_columns(...)
and
.remove_fixed_columns(...)
which have nicer API interfaces.
sourcepub fn remove_row(
self,
i: usize
) -> Matrix<N, <R as DimSub<U1>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimSub<U1>>::Output, C>>::Buffer>where
R: DimSub<U1>,
DefaultAllocator: Reallocator<N, R, C, <R as DimSub<U1>>::Output, C>,
pub fn remove_row(
self,
i: usize
) -> Matrix<N, <R as DimSub<U1>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimSub<U1>>::Output, C>>::Buffer>where
R: DimSub<U1>,
DefaultAllocator: Reallocator<N, R, C, <R as DimSub<U1>>::Output, C>,
Removes the i
-th row from this matrix.
sourcepub fn remove_fixed_rows<D>(
self,
i: usize
) -> Matrix<N, <R as DimSub<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimSub<D>>::Output, C>>::Buffer>where
D: DimName,
R: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, <R as DimSub<D>>::Output, C>,
pub fn remove_fixed_rows<D>(
self,
i: usize
) -> Matrix<N, <R as DimSub<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimSub<D>>::Output, C>>::Buffer>where
D: DimName,
R: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, <R as DimSub<D>>::Output, C>,
Removes D::dim()
consecutive rows from this matrix, starting with the i
-th (included).
sourcepub fn remove_rows(
self,
i: usize,
n: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
R: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
pub fn remove_rows(
self,
i: usize,
n: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
R: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
Removes n
consecutive rows from this matrix, starting with the i
-th (included).
sourcepub fn remove_rows_generic<D>(
self,
i: usize,
nremove: D
) -> Matrix<N, <R as DimSub<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimSub<D>>::Output, C>>::Buffer>where
D: Dim,
R: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, <R as DimSub<D>>::Output, C>,
pub fn remove_rows_generic<D>(
self,
i: usize,
nremove: D
) -> Matrix<N, <R as DimSub<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimSub<D>>::Output, C>>::Buffer>where
D: Dim,
R: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, <R as DimSub<D>>::Output, C>,
Removes nremove.value()
rows from this matrix, starting with the i
-th (included).
This is the generic implementation of .remove_rows(...)
and .remove_fixed_rows(...)
which have nicer API interfaces.
sourcepub fn insert_column(
self,
i: usize,
val: N
) -> Matrix<N, R, <C as DimAdd<U1>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimAdd<U1>>::Output>>::Buffer>where
C: DimAdd<U1>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<U1>>::Output>,
pub fn insert_column(
self,
i: usize,
val: N
) -> Matrix<N, R, <C as DimAdd<U1>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimAdd<U1>>::Output>>::Buffer>where
C: DimAdd<U1>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<U1>>::Output>,
Inserts a column filled with val
at the i-th
position.
sourcepub fn insert_fixed_columns<D>(
self,
i: usize,
val: N
) -> Matrix<N, R, <C as DimAdd<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimAdd<D>>::Output>>::Buffer>where
D: DimName,
C: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<D>>::Output>,
pub fn insert_fixed_columns<D>(
self,
i: usize,
val: N
) -> Matrix<N, R, <C as DimAdd<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimAdd<D>>::Output>>::Buffer>where
D: DimName,
C: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<D>>::Output>,
Inserts D::dim()
columns filled with val
starting at the i-th
position.
sourcepub fn insert_columns(
self,
i: usize,
n: usize,
val: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
C: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,
pub fn insert_columns(
self,
i: usize,
n: usize,
val: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>where
C: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,
Inserts n
columns filled with val
starting at the i-th
position.
sourcepub unsafe fn insert_columns_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> Matrix<N, R, <C as DimAdd<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimAdd<D>>::Output>>::Buffer>where
D: Dim,
C: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<D>>::Output>,
pub unsafe fn insert_columns_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> Matrix<N, R, <C as DimAdd<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimAdd<D>>::Output>>::Buffer>where
D: Dim,
C: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<D>>::Output>,
Inserts ninsert.value()
columns starting at the i-th
place of this matrix.
The added column values are not initialized.
sourcepub fn insert_row(
self,
i: usize,
val: N
) -> Matrix<N, <R as DimAdd<U1>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimAdd<U1>>::Output, C>>::Buffer>where
R: DimAdd<U1>,
DefaultAllocator: Reallocator<N, R, C, <R as DimAdd<U1>>::Output, C>,
pub fn insert_row(
self,
i: usize,
val: N
) -> Matrix<N, <R as DimAdd<U1>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimAdd<U1>>::Output, C>>::Buffer>where
R: DimAdd<U1>,
DefaultAllocator: Reallocator<N, R, C, <R as DimAdd<U1>>::Output, C>,
Inserts a row filled with val
at the i-th
position.
sourcepub fn insert_fixed_rows<D>(
self,
i: usize,
val: N
) -> Matrix<N, <R as DimAdd<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimAdd<D>>::Output, C>>::Buffer>where
D: DimName,
R: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, <R as DimAdd<D>>::Output, C>,
pub fn insert_fixed_rows<D>(
self,
i: usize,
val: N
) -> Matrix<N, <R as DimAdd<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimAdd<D>>::Output, C>>::Buffer>where
D: DimName,
R: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, <R as DimAdd<D>>::Output, C>,
Inserts D::dim()
rows filled with val
starting at the i-th
position.
sourcepub fn insert_rows(
self,
i: usize,
n: usize,
val: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
R: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
pub fn insert_rows(
self,
i: usize,
n: usize,
val: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>where
R: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
Inserts n
rows filled with val
starting at the i-th
position.
sourcepub unsafe fn insert_rows_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> Matrix<N, <R as DimAdd<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimAdd<D>>::Output, C>>::Buffer>where
D: Dim,
R: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, <R as DimAdd<D>>::Output, C>,
pub unsafe fn insert_rows_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> Matrix<N, <R as DimAdd<D>>::Output, C, <DefaultAllocator as Allocator<N, <R as DimAdd<D>>::Output, C>>::Buffer>where
D: Dim,
R: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, <R as DimAdd<D>>::Output, C>,
Inserts ninsert.value()
rows at the i-th
place of this matrix.
The added rows values are not initialized.
This is the generic implementation of .insert_rows(...)
and
.insert_fixed_rows(...)
which have nicer API interfaces.
sourcepub fn resize(
self,
new_nrows: usize,
new_ncols: usize,
val: N
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
DefaultAllocator: Reallocator<N, R, C, Dynamic, Dynamic>,
pub fn resize(
self,
new_nrows: usize,
new_ncols: usize,
val: N
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>where
DefaultAllocator: Reallocator<N, R, C, Dynamic, Dynamic>,
Resizes this matrix so that it contains new_nrows
rows and new_ncols
columns.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
rows and/or columns than self
, then the extra rows or columns are filled with val
.
sourcepub fn fixed_resize<R2, C2>(
self,
val: N
) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>where
R2: DimName,
C2: DimName,
DefaultAllocator: Reallocator<N, R, C, R2, C2>,
pub fn fixed_resize<R2, C2>(
self,
val: N
) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>where
R2: DimName,
C2: DimName,
DefaultAllocator: Reallocator<N, R, C, R2, C2>,
Resizes this matrix so that it contains R2::value()
rows and C2::value()
columns.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
rows and/or columns than self
, then the extra rows or columns are filled with val
.
sourcepub fn resize_generic<R2, C2>(
self,
new_nrows: R2,
new_ncols: C2,
val: N
) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>where
R2: Dim,
C2: Dim,
DefaultAllocator: Reallocator<N, R, C, R2, C2>,
pub fn resize_generic<R2, C2>(
self,
new_nrows: R2,
new_ncols: C2,
val: N
) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>where
R2: Dim,
C2: Dim,
DefaultAllocator: Reallocator<N, R, C, R2, C2>,
Resizes self
such that it has dimensions new_nrows × now_ncols
.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
rows and/or columns than self
, then the extra rows or columns are filled with val
.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
sourcepub unsafe fn from_data_statically_unchecked(data: S) -> Matrix<N, R, C, S>
pub unsafe fn from_data_statically_unchecked(data: S) -> Matrix<N, R, C, S>
Creates a new matrix with the given data without statically checking that the matrix dimension matches the storage dimension.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
The total number of elements of this matrix.
Examples:
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.len(), 12);
sourcepub fn shape(&self) -> (usize, usize)
pub fn shape(&self) -> (usize, usize)
The shape of this matrix returned as the tuple (number of rows, number of columns).
Examples:
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.shape(), (3, 4));
sourcepub fn nrows(&self) -> usize
pub fn nrows(&self) -> usize
The number of rows of this matrix.
Examples:
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.nrows(), 3);
sourcepub fn ncols(&self) -> usize
pub fn ncols(&self) -> usize
The number of columns of this matrix.
Examples:
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.ncols(), 4);
sourcepub fn strides(&self) -> (usize, usize)
pub fn strides(&self) -> (usize, usize)
The strides (row stride, column stride) of this matrix.
Examples:
let mat = DMatrix::<f32>::zeros(10, 10);
let slice = mat.slice_with_steps((0, 0), (5, 3), (1, 2));
// The column strides is the number of steps (here 2) multiplied by the corresponding dimension.
assert_eq!(mat.strides(), (1, 10));
sourcepub fn iter(&self) -> MatrixIter<'_, N, R, C, S> ⓘ
pub fn iter(&self) -> MatrixIter<'_, N, R, C, S> ⓘ
Iterates through this matrix coordinates in column-major order.
Examples:
let mat = Matrix2x3::new(11, 12, 13,
21, 22, 23);
let mut it = mat.iter();
assert_eq!(*it.next().unwrap(), 11);
assert_eq!(*it.next().unwrap(), 21);
assert_eq!(*it.next().unwrap(), 12);
assert_eq!(*it.next().unwrap(), 22);
assert_eq!(*it.next().unwrap(), 13);
assert_eq!(*it.next().unwrap(), 23);
assert!(it.next().is_none());
sourcepub fn vector_to_matrix_index(&self, i: usize) -> (usize, usize)
pub fn vector_to_matrix_index(&self, i: usize) -> (usize, usize)
Computes the row and column coordinates of the i-th element of this matrix seen as a vector.
sourcepub unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N
pub unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N
Gets a reference to the element of this matrix at row irow
and column icol
without
bound-checking.
sourcepub fn relative_eq<R2, C2, SB>(
&self,
other: &Matrix<N, R2, C2, SB>,
eps: <N as AbsDiffEq<N>>::Epsilon,
max_relative: <N as AbsDiffEq<N>>::Epsilon
) -> boolwhere
N: RelativeEq<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn relative_eq<R2, C2, SB>(
&self,
other: &Matrix<N, R2, C2, SB>,
eps: <N as AbsDiffEq<N>>::Epsilon,
max_relative: <N as AbsDiffEq<N>>::Epsilon
) -> boolwhere
N: RelativeEq<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are equal up to a given epsilon.
See relative_eq
from the RelativeEq
trait for more details.
sourcepub fn eq<R2, C2, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> boolwhere
N: PartialEq<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn eq<R2, C2, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> boolwhere
N: PartialEq<N>,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are exactly equal.
sourcepub fn into_owned(
self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
pub fn into_owned(
self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
Moves this matrix into one that owns its data.
sourcepub fn into_owned_sum<R2, C2>(
self
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer>where
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn into_owned_sum<R2, C2>(
self
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer>where
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Moves this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.
sourcepub fn clone_owned(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
pub fn clone_owned(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
Clones this matrix to one that owns its data.
sourcepub fn clone_owned_sum<R2, C2>(
&self
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer>where
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn clone_owned_sum<R2, C2>(
&self
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer>where
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Clones this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.
sourcepub fn map<N2, F>(
&self,
f: F
) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer>where
N2: Scalar,
F: FnMut(N) -> N2,
DefaultAllocator: Allocator<N2, R, C>,
pub fn map<N2, F>(
&self,
f: F
) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer>where
N2: Scalar,
F: FnMut(N) -> N2,
DefaultAllocator: Allocator<N2, R, C>,
Returns a matrix containing the result of f
applied to each of its entries.
sourcepub fn map_with_location<N2, F>(
&self,
f: F
) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer>where
N2: Scalar,
F: FnMut(usize, usize, N) -> N2,
DefaultAllocator: Allocator<N2, R, C>,
pub fn map_with_location<N2, F>(
&self,
f: F
) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer>where
N2: Scalar,
F: FnMut(usize, usize, N) -> N2,
DefaultAllocator: Allocator<N2, R, C>,
Returns a matrix containing the result of f
applied to each of its entries. Unlike map
,
f
also gets passed the row and column index, i.e. f(value, row, col)
.
sourcepub fn zip_map<N2, N3, S2, F>(
&self,
rhs: &Matrix<N2, R, C, S2>,
f: F
) -> Matrix<N3, R, C, <DefaultAllocator as Allocator<N3, R, C>>::Buffer>where
N2: Scalar,
N3: Scalar,
S2: Storage<N2, R, C>,
F: FnMut(N, N2) -> N3,
DefaultAllocator: Allocator<N3, R, C>,
pub fn zip_map<N2, N3, S2, F>(
&self,
rhs: &Matrix<N2, R, C, S2>,
f: F
) -> Matrix<N3, R, C, <DefaultAllocator as Allocator<N3, R, C>>::Buffer>where
N2: Scalar,
N3: Scalar,
S2: Storage<N2, R, C>,
F: FnMut(N, N2) -> N3,
DefaultAllocator: Allocator<N3, R, C>,
Returns a matrix containing the result of f
applied to each entries of self
and
rhs
.
sourcepub fn zip_zip_map<N2, N3, N4, S2, S3, F>(
&self,
b: &Matrix<N2, R, C, S2>,
c: &Matrix<N3, R, C, S3>,
f: F
) -> Matrix<N4, R, C, <DefaultAllocator as Allocator<N4, R, C>>::Buffer>where
N2: Scalar,
N3: Scalar,
N4: Scalar,
S2: Storage<N2, R, C>,
S3: Storage<N3, R, C>,
F: FnMut(N, N2, N3) -> N4,
DefaultAllocator: Allocator<N4, R, C>,
pub fn zip_zip_map<N2, N3, N4, S2, S3, F>(
&self,
b: &Matrix<N2, R, C, S2>,
c: &Matrix<N3, R, C, S3>,
f: F
) -> Matrix<N4, R, C, <DefaultAllocator as Allocator<N4, R, C>>::Buffer>where
N2: Scalar,
N3: Scalar,
N4: Scalar,
S2: Storage<N2, R, C>,
S3: Storage<N3, R, C>,
F: FnMut(N, N2, N3) -> N4,
DefaultAllocator: Allocator<N4, R, C>,
Returns a matrix containing the result of f
applied to each entries of self
and
b
, and c
.
sourcepub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>)where
R2: Dim,
C2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
pub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>)where
R2: Dim,
C2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
Transposes self
and store the result into out
.
sourcepub fn transpose(
&self
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer>where
DefaultAllocator: Allocator<N, C, R>,
pub fn transpose(
&self
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer>where
DefaultAllocator: Allocator<N, C, R>,
Transposes self
.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
sourcepub fn iter_mut(&mut self) -> MatrixIterMut<'_, N, R, C, S> ⓘ
pub fn iter_mut(&mut self) -> MatrixIterMut<'_, N, R, C, S> ⓘ
Mutably iterates through this matrix coordinates.
sourcepub unsafe fn get_unchecked_mut(&mut self, irow: usize, icol: usize) -> &mut N
pub unsafe fn get_unchecked_mut(&mut self, irow: usize, icol: usize) -> &mut N
Gets a mutable reference to the i-th element of this matrix.
sourcepub unsafe fn swap_unchecked(
&mut self,
row_cols1: (usize, usize),
row_cols2: (usize, usize)
)
pub unsafe fn swap_unchecked(
&mut self,
row_cols1: (usize, usize),
row_cols2: (usize, usize)
)
Swaps two entries without bound-checking.
sourcepub fn swap(&mut self, row_cols1: (usize, usize), row_cols2: (usize, usize))
pub fn swap(&mut self, row_cols1: (usize, usize), row_cols2: (usize, usize))
Swaps two entries.
sourcepub fn copy_from_slice(&mut self, slice: &[N])
pub fn copy_from_slice(&mut self, slice: &[N])
Fills this matrix with the content of a slice. Both must hold the same number of elements.
The components of the slice are assumed to be ordered in column-major order.
sourcepub fn copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>)where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>)where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Fills this matrix with the content of another one. Both must have the same shape.
sourcepub fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>)where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, C2> + SameNumberOfColumns<C, R2>,
pub fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>)where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, C2> + SameNumberOfColumns<C, R2>,
Fills this matrix with the content of the transpose another one.
sourcepub fn apply<F>(&mut self, f: F)where
F: FnMut(N) -> N,
DefaultAllocator: Allocator<N, R, C>,
pub fn apply<F>(&mut self, f: F)where
F: FnMut(N) -> N,
DefaultAllocator: Allocator<N, R, C>,
Replaces each component of self
by the result of a closure f
applied on it.
source§impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar,
D: Dim,
S: Storage<N, D, U1>,
impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar,
D: Dim,
S: Storage<N, D, U1>,
sourcepub unsafe fn vget_unchecked(&self, i: usize) -> &N
pub unsafe fn vget_unchecked(&self, i: usize) -> &N
Gets a reference to the i-th element of this column vector without bound checking.
source§impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar,
D: Dim,
S: StorageMut<N, D, U1>,
impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar,
D: Dim,
S: StorageMut<N, D, U1>,
sourcepub unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut N
pub unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut N
Gets a mutable reference to the i-th element of this column vector without bound checking.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: ContiguousStorage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: ContiguousStorage<N, R, C>,
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: ContiguousStorageMut<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: ContiguousStorageMut<N, R, C>,
sourcepub fn as_mut_slice(&mut self) -> &mut [N] ⓘ
pub fn as_mut_slice(&mut self) -> &mut [N] ⓘ
Extracts a mutable slice containing the entire matrix entries ordered column-by-columns.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar,
D: Dim,
S: StorageMut<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar,
D: Dim,
S: StorageMut<N, D, D>,
sourcepub fn transpose_mut(&mut self)
pub fn transpose_mut(&mut self)
Transposes the square matrix self
in-place.
source§impl<N, R, C, S> Matrix<Complex<N>, R, C, S>where
N: Real,
R: Dim,
C: Dim,
S: Storage<Complex<N>, R, C>,
impl<N, R, C, S> Matrix<Complex<N>, R, C, S>where
N: Real,
R: Dim,
C: Dim,
S: Storage<Complex<N>, R, C>,
sourcepub fn conjugate_transpose_to<R2, C2, SB>(
&self,
out: &mut Matrix<Complex<N>, R2, C2, SB>
)where
R2: Dim,
C2: Dim,
SB: StorageMut<Complex<N>, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
pub fn conjugate_transpose_to<R2, C2, SB>(
&self,
out: &mut Matrix<Complex<N>, R2, C2, SB>
)where
R2: Dim,
C2: Dim,
SB: StorageMut<Complex<N>, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
Takes the conjugate and transposes self
and store the result into out
.
sourcepub fn conjugate_transpose(
&self
) -> Matrix<Complex<N>, C, R, <DefaultAllocator as Allocator<Complex<N>, C, R>>::Buffer>where
DefaultAllocator: Allocator<Complex<N>, C, R>,
pub fn conjugate_transpose(
&self
) -> Matrix<Complex<N>, C, R, <DefaultAllocator as Allocator<Complex<N>, C, R>>::Buffer>where
DefaultAllocator: Allocator<Complex<N>, C, R>,
The conjugate transposition of self
.
source§impl<N, D, S> Matrix<Complex<N>, D, D, S>where
N: Real,
D: Dim,
S: StorageMut<Complex<N>, D, D>,
impl<N, D, S> Matrix<Complex<N>, D, D, S>where
N: Real,
D: Dim,
S: StorageMut<Complex<N>, D, D>,
sourcepub fn conjugate_transpose_mut(&mut self)
pub fn conjugate_transpose_mut(&mut self)
Sets self
to its conjugate transpose.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar,
D: Dim,
S: Storage<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar,
D: Dim,
S: Storage<N, D, D>,
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar + One + Zero,
D: DimAdd<U1> + IsNotStaticOne,
S: Storage<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Scalar + One + Zero,
D: DimAdd<U1> + IsNotStaticOne,
S: Storage<N, D, D>,
sourcepub fn to_homogeneous(
&self
) -> Matrix<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>>::Buffer>where
DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>,
pub fn to_homogeneous(
&self
) -> Matrix<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>>::Buffer>where
DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>,
Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and
and setting the diagonal element to 1
.
source§impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar + Zero,
D: DimAdd<U1>,
S: Storage<N, D, U1>,
impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar + Zero,
D: DimAdd<U1>,
S: Storage<N, D, U1>,
sourcepub fn to_homogeneous(
&self
) -> Matrix<N, <D as DimAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, U1>>::Buffer>where
DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, U1>,
pub fn to_homogeneous(
&self
) -> Matrix<N, <D as DimAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, U1>>::Buffer>where
DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, U1>,
Computes the coordinates in projective space of this vector, i.e., appends a 0
to its
coordinates.
sourcepub fn from_homogeneous<SB>(
v: Matrix<N, <D as DimAdd<U1>>::Output, U1, SB>
) -> Option<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>where
SB: Storage<N, <D as DimAdd<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, U1>,
pub fn from_homogeneous<SB>(
v: Matrix<N, <D as DimAdd<U1>>::Output, U1, SB>
) -> Option<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>where
SB: Storage<N, <D as DimAdd<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, U1>,
Constructs a vector from coordinates in projective space, i.e., removes a 0
at the end of
self
. Returns None
if this last component is not zero.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar + Ring,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar + Ring,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn perp<R2, C2, SB>(&self, b: &Matrix<N, R2, C2, SB>) -> Nwhere
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, U2> + SameNumberOfColumns<C, U1> + SameNumberOfRows<R2, U2> + SameNumberOfColumns<C2, U1>,
pub fn perp<R2, C2, SB>(&self, b: &Matrix<N, R2, C2, SB>) -> Nwhere
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, U2> + SameNumberOfColumns<C, U1> + SameNumberOfRows<R2, U2> + SameNumberOfColumns<C2, U1>,
The perpendicular product between two 2D column vectors, i.e. a.x * b.y - a.y * b.x
.
sourcepub fn cross<R2, C2, SB>(
&self,
b: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer>where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn cross<R2, C2, SB>(
&self,
b: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer>where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
The 3D cross product between two vectors.
Panics if the shape is not 3D vector. In the future, this will be implemented only for dynamically-sized matrices and statically-sized 3D matrices.
source§impl<N, S> Matrix<N, U3, U1, S>where
N: Real,
S: Storage<N, U3, U1>,
DefaultAllocator: Allocator<N, U3, U1>,
impl<N, S> Matrix<N, U3, U1, S>where
N: Real,
S: Storage<N, U3, U1>,
DefaultAllocator: Allocator<N, U3, U1>,
sourcepub fn cross_matrix(
&self
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
pub fn cross_matrix(
&self
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
Computes the matrix M
such that for all vector v
we have M * v == self.cross(&v)
.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn norm_squared(&self) -> N
pub fn norm_squared(&self) -> N
The squared L2 norm of this vector.
sourcepub fn magnitude(&self) -> N
pub fn magnitude(&self) -> N
A synonym for the norm of this matrix.
Aka the length.
This function is simply implemented as a call to norm()
sourcepub fn magnitude_squared(&self) -> N
pub fn magnitude_squared(&self) -> N
A synonym for the squared norm of this matrix.
Aka the squared length.
This function is simply implemented as a call to norm_squared()
sourcepub fn normalize(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
pub fn normalize(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
DefaultAllocator: Allocator<N, R, C>,
Returns a normalized version of this matrix.
sourcepub fn try_normalize(
&self,
min_norm: N
) -> Option<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>>where
DefaultAllocator: Allocator<N, R, C>,
pub fn try_normalize(
&self,
min_norm: N
) -> Option<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>>where
DefaultAllocator: Allocator<N, R, C>,
Returns a normalized version of this matrix unless its norm as smaller or equal to eps
.
source§impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar + Zero + One + ClosedAdd<N> + ClosedSub<N> + ClosedMul<N>,
D: Dim,
S: Storage<N, D, U1>,
impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar + Zero + One + ClosedAdd<N> + ClosedSub<N> + ClosedMul<N>,
D: Dim,
S: Storage<N, D, U1>,
sourcepub fn lerp<S2>(
&self,
rhs: &Matrix<N, D, U1, S2>,
t: N
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>where
S2: Storage<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
pub fn lerp<S2>(
&self,
rhs: &Matrix<N, D, U1, S2>,
t: N
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>where
S2: Storage<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
Returns self * (1.0 - t) + rhs * t
, i.e., the linear blend of the vectors x and y using the scalar value a.
The value for a is not restricted to the range [0, 1]
.
Examples:
let x = Vector3::new(1.0, 2.0, 3.0);
let y = Vector3::new(10.0, 20.0, 30.0);
assert_eq!(x.lerp(&y, 0.1), Vector3::new(1.9, 3.8, 5.7));
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
sourcepub fn normalize_mut(&mut self) -> N
pub fn normalize_mut(&mut self) -> N
Normalizes this matrix in-place and returns its norm.
sourcepub fn try_normalize_mut(&mut self, min_norm: N) -> Option<N>
pub fn try_normalize_mut(&mut self, min_norm: N) -> Option<N>
Normalizes this matrix in-place or does nothing if its norm is smaller or equal to eps
.
If the normalization succeeded, returns the old normal of this matrix.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn row(
&self,
i: usize
) -> Matrix<N, U1, C, SliceStorage<'_, N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn row(
&self,
i: usize
) -> Matrix<N, U1, C, SliceStorage<'_, N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the i-th row of this matrix.
sourcepub fn row_part(
&self,
i: usize,
n: usize
) -> Matrix<N, U1, Dynamic, SliceStorage<'_, N, U1, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn row_part(
&self,
i: usize,
n: usize
) -> Matrix<N, U1, Dynamic, SliceStorage<'_, N, U1, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the n
first elements of the i-th row of this matrix.
sourcepub fn rows(
&self,
first_row: usize,
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorage<'_, N, Dynamic, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn rows(
&self,
first_row: usize,
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorage<'_, N, Dynamic, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive rows.
sourcepub fn rows_with_step(
&self,
first_row: usize,
nrows: usize,
step: usize
) -> Matrix<N, Dynamic, C, SliceStorage<'_, N, Dynamic, C, Dynamic, <S as Storage<N, R, C>>::CStride>>
pub fn rows_with_step(
&self,
first_row: usize,
nrows: usize,
step: usize
) -> Matrix<N, Dynamic, C, SliceStorage<'_, N, Dynamic, C, Dynamic, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive rows regularly skipping step
rows.
sourcepub fn fixed_rows<RSlice>(
&self,
first_row: usize
) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
pub fn fixed_rows<RSlice>(
&self,
first_row: usize
) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
Extracts a compile-time number of consecutive rows from this matrix.
sourcepub fn fixed_rows_with_step<RSlice>(
&self,
first_row: usize,
step: usize
) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
pub fn fixed_rows_with_step<RSlice>(
&self,
first_row: usize,
step: usize
) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
Extracts from this matrix a compile-time number of rows regularly skipping step
rows.
sourcepub fn rows_generic<RSlice>(
&self,
row_start: usize,
nrows: RSlice
) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
pub fn rows_generic<RSlice>(
&self,
row_start: usize,
nrows: RSlice
) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
sourcepub fn rows_generic_with_step<RSlice>(
&self,
row_start: usize,
nrows: RSlice,
step: usize
) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
pub fn rows_generic_with_step<RSlice>(
&self,
row_start: usize,
nrows: RSlice,
step: usize
) -> Matrix<N, RSlice, C, SliceStorage<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
sourcepub fn column(
&self,
i: usize
) -> Matrix<N, R, U1, SliceStorage<'_, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn column(
&self,
i: usize
) -> Matrix<N, R, U1, SliceStorage<'_, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the i-th column of this matrix.
sourcepub fn column_part(
&self,
i: usize,
n: usize
) -> Matrix<N, Dynamic, U1, SliceStorage<'_, N, Dynamic, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn column_part(
&self,
i: usize,
n: usize
) -> Matrix<N, Dynamic, U1, SliceStorage<'_, N, Dynamic, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the n
first elements of the i-th column of this matrix.
sourcepub fn columns(
&self,
first_col: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn columns(
&self,
first_col: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive columns.
sourcepub fn columns_with_step(
&self,
first_col: usize,
ncols: usize,
step: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, Dynamic>>
pub fn columns_with_step(
&self,
first_col: usize,
ncols: usize,
step: usize
) -> Matrix<N, R, Dynamic, SliceStorage<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, Dynamic>>
Extracts from this matrix a set of consecutive columns regularly skipping step
columns.
sourcepub fn fixed_columns<CSlice>(
&self,
first_col: usize
) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
CSlice: DimName,
pub fn fixed_columns<CSlice>(
&self,
first_col: usize
) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
CSlice: DimName,
Extracts a compile-time number of consecutive columns from this matrix.
sourcepub fn fixed_columns_with_step<CSlice>(
&self,
first_col: usize,
step: usize
) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>>where
CSlice: DimName,
pub fn fixed_columns_with_step<CSlice>(
&self,
first_col: usize,
step: usize
) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>>where
CSlice: DimName,
Extracts from this matrix a compile-time number of columns regularly skipping
step
columns.
sourcepub fn columns_generic<CSlice>(
&self,
first_col: usize,
ncols: CSlice
) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
CSlice: Dim,
pub fn columns_generic<CSlice>(
&self,
first_col: usize,
ncols: CSlice
) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
CSlice: Dim,
Extracts from this matrix ncols
columns. The number of columns may or may not be
known at compile-time.
sourcepub fn columns_generic_with_step<CSlice>(
&self,
first_col: usize,
ncols: CSlice,
step: usize
) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>>where
CSlice: Dim,
pub fn columns_generic_with_step<CSlice>(
&self,
first_col: usize,
ncols: CSlice,
step: usize
) -> Matrix<N, R, CSlice, SliceStorage<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>>where
CSlice: Dim,
Extracts from this matrix ncols
columns skipping step
columns. Both argument may
or may not be values known at compile-time.
sourcepub fn slice(
&self,
start: (usize, usize),
shape: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'_, N, Dynamic, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn slice(
&self,
start: (usize, usize),
shape: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'_, N, Dynamic, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Slices this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
sourcepub fn slice_with_steps(
&self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'_, N, Dynamic, Dynamic, Dynamic, Dynamic>>
pub fn slice_with_steps(
&self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<'_, N, Dynamic, Dynamic, Dynamic, Dynamic>>
Slices this matrix starting at its component (start.0, start.1)
and with
(shape.0, shape.1)
components. Each row (resp. column) of the sliced matrix is
separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of the
original matrix.
sourcepub fn fixed_slice<RSlice, CSlice>(
&self,
irow: usize,
icol: usize
) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
CSlice: DimName,
pub fn fixed_slice<RSlice, CSlice>(
&self,
irow: usize,
icol: usize
) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
CSlice: DimName,
Slices this matrix starting at its component (irow, icol)
and with (R::dim(), CSlice::dim())
consecutive components.
sourcepub fn fixed_slice_with_steps<RSlice, CSlice>(
&self,
start: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, Dynamic, Dynamic>>where
RSlice: DimName,
CSlice: DimName,
pub fn fixed_slice_with_steps<RSlice, CSlice>(
&self,
start: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, Dynamic, Dynamic>>where
RSlice: DimName,
CSlice: DimName,
Slices this matrix starting at its component (start.0, start.1)
and with
(R::dim(), CSlice::dim())
components. Each row (resp. column) of the sliced
matrix is separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of
the original matrix.
sourcepub fn generic_slice<RSlice, CSlice>(
&self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
CSlice: Dim,
pub fn generic_slice<RSlice, CSlice>(
&self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
CSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
sourcepub fn generic_slice_with_steps<RSlice, CSlice>(
&self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, Dynamic, Dynamic>>where
RSlice: Dim,
CSlice: Dim,
pub fn generic_slice_with_steps<RSlice, CSlice>(
&self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorage<'_, N, RSlice, CSlice, Dynamic, Dynamic>>where
RSlice: Dim,
CSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
sourcepub fn rows_range_pair<Range1, Range2>(
&self,
r1: Range1,
r2: Range2
) -> (Matrix<N, <Range1 as SliceRange<R>>::Size, C, SliceStorage<'_, N, <Range1 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, <Range2 as SliceRange<R>>::Size, C, SliceStorage<'_, N, <Range2 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>)where
Range1: SliceRange<R>,
Range2: SliceRange<R>,
pub fn rows_range_pair<Range1, Range2>(
&self,
r1: Range1,
r2: Range2
) -> (Matrix<N, <Range1 as SliceRange<R>>::Size, C, SliceStorage<'_, N, <Range1 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, <Range2 as SliceRange<R>>::Size, C, SliceStorage<'_, N, <Range2 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>)where
Range1: SliceRange<R>,
Range2: SliceRange<R>,
Splits this NxM matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
sourcepub fn columns_range_pair<Range1, Range2>(
&self,
r1: Range1,
r2: Range2
) -> (Matrix<N, R, <Range1 as SliceRange<C>>::Size, SliceStorage<'_, N, R, <Range1 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, R, <Range2 as SliceRange<C>>::Size, SliceStorage<'_, N, R, <Range2 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>)where
Range1: SliceRange<C>,
Range2: SliceRange<C>,
pub fn columns_range_pair<Range1, Range2>(
&self,
r1: Range1,
r2: Range2
) -> (Matrix<N, R, <Range1 as SliceRange<C>>::Size, SliceStorage<'_, N, R, <Range1 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, R, <Range2 as SliceRange<C>>::Size, SliceStorage<'_, N, R, <Range2 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>)where
Range1: SliceRange<C>,
Range2: SliceRange<C>,
Splits this NxM matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
sourcepub fn row_mut(
&mut self,
i: usize
) -> Matrix<N, U1, C, SliceStorageMut<'_, N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn row_mut(
&mut self,
i: usize
) -> Matrix<N, U1, C, SliceStorageMut<'_, N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the i-th row of this matrix.
sourcepub fn row_part_mut(
&mut self,
i: usize,
n: usize
) -> Matrix<N, U1, Dynamic, SliceStorageMut<'_, N, U1, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn row_part_mut(
&mut self,
i: usize,
n: usize
) -> Matrix<N, U1, Dynamic, SliceStorageMut<'_, N, U1, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the n
first elements of the i-th row of this matrix.
sourcepub fn rows_mut(
&mut self,
first_row: usize,
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<'_, N, Dynamic, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn rows_mut(
&mut self,
first_row: usize,
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<'_, N, Dynamic, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive rows.
sourcepub fn rows_with_step_mut(
&mut self,
first_row: usize,
nrows: usize,
step: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<'_, N, Dynamic, C, Dynamic, <S as Storage<N, R, C>>::CStride>>
pub fn rows_with_step_mut(
&mut self,
first_row: usize,
nrows: usize,
step: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<'_, N, Dynamic, C, Dynamic, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive rows regularly skipping step
rows.
sourcepub fn fixed_rows_mut<RSlice>(
&mut self,
first_row: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
pub fn fixed_rows_mut<RSlice>(
&mut self,
first_row: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
Extracts a compile-time number of consecutive rows from this matrix.
sourcepub fn fixed_rows_with_step_mut<RSlice>(
&mut self,
first_row: usize,
step: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
pub fn fixed_rows_with_step_mut<RSlice>(
&mut self,
first_row: usize,
step: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
Extracts from this matrix a compile-time number of rows regularly skipping step
rows.
sourcepub fn rows_generic_mut<RSlice>(
&mut self,
row_start: usize,
nrows: RSlice
) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
pub fn rows_generic_mut<RSlice>(
&mut self,
row_start: usize,
nrows: RSlice
) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
sourcepub fn rows_generic_with_step_mut<RSlice>(
&mut self,
row_start: usize,
nrows: RSlice,
step: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
pub fn rows_generic_with_step_mut<RSlice>(
&mut self,
row_start: usize,
nrows: RSlice,
step: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<'_, N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
sourcepub fn column_mut(
&mut self,
i: usize
) -> Matrix<N, R, U1, SliceStorageMut<'_, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn column_mut(
&mut self,
i: usize
) -> Matrix<N, R, U1, SliceStorageMut<'_, N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the i-th column of this matrix.
sourcepub fn column_part_mut(
&mut self,
i: usize,
n: usize
) -> Matrix<N, Dynamic, U1, SliceStorageMut<'_, N, Dynamic, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn column_part_mut(
&mut self,
i: usize,
n: usize
) -> Matrix<N, Dynamic, U1, SliceStorageMut<'_, N, Dynamic, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the n
first elements of the i-th column of this matrix.
sourcepub fn columns_mut(
&mut self,
first_col: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn columns_mut(
&mut self,
first_col: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive columns.
sourcepub fn columns_with_step_mut(
&mut self,
first_col: usize,
ncols: usize,
step: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, Dynamic>>
pub fn columns_with_step_mut(
&mut self,
first_col: usize,
ncols: usize,
step: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<'_, N, R, Dynamic, <S as Storage<N, R, C>>::RStride, Dynamic>>
Extracts from this matrix a set of consecutive columns regularly skipping step
columns.
sourcepub fn fixed_columns_mut<CSlice>(
&mut self,
first_col: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
CSlice: DimName,
pub fn fixed_columns_mut<CSlice>(
&mut self,
first_col: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
CSlice: DimName,
Extracts a compile-time number of consecutive columns from this matrix.
sourcepub fn fixed_columns_with_step_mut<CSlice>(
&mut self,
first_col: usize,
step: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>>where
CSlice: DimName,
pub fn fixed_columns_with_step_mut<CSlice>(
&mut self,
first_col: usize,
step: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>>where
CSlice: DimName,
Extracts from this matrix a compile-time number of columns regularly skipping
step
columns.
sourcepub fn columns_generic_mut<CSlice>(
&mut self,
first_col: usize,
ncols: CSlice
) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
CSlice: Dim,
pub fn columns_generic_mut<CSlice>(
&mut self,
first_col: usize,
ncols: CSlice
) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
CSlice: Dim,
Extracts from this matrix ncols
columns. The number of columns may or may not be
known at compile-time.
sourcepub fn columns_generic_with_step_mut<CSlice>(
&mut self,
first_col: usize,
ncols: CSlice,
step: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>>where
CSlice: Dim,
pub fn columns_generic_with_step_mut<CSlice>(
&mut self,
first_col: usize,
ncols: CSlice,
step: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<'_, N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>>where
CSlice: Dim,
Extracts from this matrix ncols
columns skipping step
columns. Both argument may
or may not be values known at compile-time.
sourcepub fn slice_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'_, N, Dynamic, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
pub fn slice_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'_, N, Dynamic, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Slices this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
sourcepub fn slice_with_steps_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'_, N, Dynamic, Dynamic, Dynamic, Dynamic>>
pub fn slice_with_steps_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<'_, N, Dynamic, Dynamic, Dynamic, Dynamic>>
Slices this matrix starting at its component (start.0, start.1)
and with
(shape.0, shape.1)
components. Each row (resp. column) of the sliced matrix is
separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of the
original matrix.
sourcepub fn fixed_slice_mut<RSlice, CSlice>(
&mut self,
irow: usize,
icol: usize
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
CSlice: DimName,
pub fn fixed_slice_mut<RSlice, CSlice>(
&mut self,
irow: usize,
icol: usize
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: DimName,
CSlice: DimName,
Slices this matrix starting at its component (irow, icol)
and with (R::dim(), CSlice::dim())
consecutive components.
sourcepub fn fixed_slice_with_steps_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, Dynamic, Dynamic>>where
RSlice: DimName,
CSlice: DimName,
pub fn fixed_slice_with_steps_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, Dynamic, Dynamic>>where
RSlice: DimName,
CSlice: DimName,
Slices this matrix starting at its component (start.0, start.1)
and with
(R::dim(), CSlice::dim())
components. Each row (resp. column) of the sliced
matrix is separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of
the original matrix.
sourcepub fn generic_slice_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
CSlice: Dim,
pub fn generic_slice_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RSlice: Dim,
CSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
sourcepub fn generic_slice_with_steps_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, Dynamic, Dynamic>>where
RSlice: Dim,
CSlice: Dim,
pub fn generic_slice_with_steps_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<'_, N, RSlice, CSlice, Dynamic, Dynamic>>where
RSlice: Dim,
CSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
sourcepub fn rows_range_pair_mut<Range1, Range2>(
&mut self,
r1: Range1,
r2: Range2
) -> (Matrix<N, <Range1 as SliceRange<R>>::Size, C, SliceStorageMut<'_, N, <Range1 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, <Range2 as SliceRange<R>>::Size, C, SliceStorageMut<'_, N, <Range2 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>)where
Range1: SliceRange<R>,
Range2: SliceRange<R>,
pub fn rows_range_pair_mut<Range1, Range2>(
&mut self,
r1: Range1,
r2: Range2
) -> (Matrix<N, <Range1 as SliceRange<R>>::Size, C, SliceStorageMut<'_, N, <Range1 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, <Range2 as SliceRange<R>>::Size, C, SliceStorageMut<'_, N, <Range2 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>)where
Range1: SliceRange<R>,
Range2: SliceRange<R>,
Splits this NxM matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
sourcepub fn columns_range_pair_mut<Range1, Range2>(
&mut self,
r1: Range1,
r2: Range2
) -> (Matrix<N, R, <Range1 as SliceRange<C>>::Size, SliceStorageMut<'_, N, R, <Range1 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, R, <Range2 as SliceRange<C>>::Size, SliceStorageMut<'_, N, R, <Range2 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>)where
Range1: SliceRange<C>,
Range2: SliceRange<C>,
pub fn columns_range_pair_mut<Range1, Range2>(
&mut self,
r1: Range1,
r2: Range2
) -> (Matrix<N, R, <Range1 as SliceRange<C>>::Size, SliceStorageMut<'_, N, R, <Range1 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, R, <Range2 as SliceRange<C>>::Size, SliceStorageMut<'_, N, R, <Range2 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>)where
Range1: SliceRange<C>,
Range2: SliceRange<C>,
Splits this NxM matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn slice_range<RowRange, ColRange>(
&self,
rows: RowRange,
cols: ColRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorage<'_, N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
pub fn slice_range<RowRange, ColRange>(
&self,
rows: RowRange,
cols: ColRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorage<'_, N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
Slices a sub-matrix containing the rows indexed by the range rows
and the columns indexed
by the range cols
.
sourcepub fn rows_range<RowRange>(
&self,
rows: RowRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, C, SliceStorage<'_, N, <RowRange as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RowRange: SliceRange<R>,
pub fn rows_range<RowRange>(
&self,
rows: RowRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, C, SliceStorage<'_, N, <RowRange as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RowRange: SliceRange<R>,
Slice containing all the rows indexed by the range rows
.
sourcepub fn columns_range<ColRange>(
&self,
cols: ColRange
) -> Matrix<N, R, <ColRange as SliceRange<C>>::Size, SliceStorage<'_, N, R, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
ColRange: SliceRange<C>,
pub fn columns_range<ColRange>(
&self,
cols: ColRange
) -> Matrix<N, R, <ColRange as SliceRange<C>>::Size, SliceStorage<'_, N, R, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
ColRange: SliceRange<C>,
Slice containing all the columns indexed by the range rows
.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
sourcepub fn slice_range_mut<RowRange, ColRange>(
&mut self,
rows: RowRange,
cols: ColRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorageMut<'_, N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
pub fn slice_range_mut<RowRange, ColRange>(
&mut self,
rows: RowRange,
cols: ColRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorageMut<'_, N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
Slices a mutable sub-matrix containing the rows indexed by the range rows
and the columns
indexed by the range cols
.
sourcepub fn rows_range_mut<RowRange>(
&mut self,
rows: RowRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, C, SliceStorageMut<'_, N, <RowRange as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RowRange: SliceRange<R>,
pub fn rows_range_mut<RowRange>(
&mut self,
rows: RowRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, C, SliceStorageMut<'_, N, <RowRange as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
RowRange: SliceRange<R>,
Slice containing all the rows indexed by the range rows
.
sourcepub fn columns_range_mut<ColRange>(
&mut self,
cols: ColRange
) -> Matrix<N, R, <ColRange as SliceRange<C>>::Size, SliceStorageMut<'_, N, R, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
ColRange: SliceRange<C>,
pub fn columns_range_mut<ColRange>(
&mut self,
cols: ColRange
) -> Matrix<N, R, <ColRange as SliceRange<C>>::Size, SliceStorageMut<'_, N, R, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>where
ColRange: SliceRange<C>,
Slice containing all the columns indexed by the range cols
.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
sourcepub fn is_identity(&self, eps: <N as AbsDiffEq<N>>::Epsilon) -> boolwhere
N: Zero + One + RelativeEq<N>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
pub fn is_identity(&self, eps: <N as AbsDiffEq<N>>::Epsilon) -> boolwhere
N: Zero + One + RelativeEq<N>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
Indicated if this is the identity matrix within a relative error of eps
.
If the matrix is diagonal, this checks that diagonal elements (i.e. at coordinates (i, i)
for i from 0
to min(R, C)
) are equal one; and that all other elements are zero.
sourcepub fn is_orthogonal(&self, eps: <N as AbsDiffEq<N>>::Epsilon) -> boolwhere
N: Zero + One + ClosedAdd<N> + ClosedMul<N> + RelativeEq<N>,
S: Storage<N, R, C>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
DefaultAllocator: Allocator<N, C, C>,
pub fn is_orthogonal(&self, eps: <N as AbsDiffEq<N>>::Epsilon) -> boolwhere
N: Zero + One + ClosedAdd<N> + ClosedMul<N> + RelativeEq<N>,
S: Storage<N, R, C>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
DefaultAllocator: Allocator<N, C, C>,
Checks that Mᵀ × M = Id
.
In this definition Id
is approximately equal to the identity matrix with a relative error
equal to eps
.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: Dim,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: Dim,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
sourcepub fn is_special_orthogonal(&self, eps: N) -> boolwhere
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
pub fn is_special_orthogonal(&self, eps: N) -> boolwhere
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
Checks that this matrix is orthogonal and has a determinant equal to 1.
sourcepub fn is_invertible(&self) -> bool
pub fn is_invertible(&self) -> bool
Returns true
if this matrix is invertible.
source§impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar,
D: DimName,
S: Storage<N, D, U1>,
<D as DimName>::Value: Cmp<UTerm, Output = Greater>,
impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar,
D: DimName,
S: Storage<N, D, U1>,
<D as DimName>::Value: Cmp<UTerm, Output = Greater>,
source§impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar,
D: DimName,
S: Storage<N, D, U1>,
<D as DimName>::Value: Cmp<UInt<UTerm, B1>, Output = Greater>,
impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar,
D: DimName,
S: Storage<N, D, U1>,
<D as DimName>::Value: Cmp<UInt<UTerm, B1>, Output = Greater>,
sourcepub fn xy(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
pub fn xy(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn yx(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
pub fn yx(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn yy(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
pub fn yy(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn xxy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn xxy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn xyx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn xyx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn xyy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn xyy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn yxx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn yxx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn yxy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn yxy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
source§impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar,
D: DimName,
S: Storage<N, D, U1>,
<D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,
impl<N, D, S> Matrix<N, D, U1, S>where
N: Scalar,
D: DimName,
S: Storage<N, D, U1>,
<D as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>, Output = Greater>,
sourcepub fn xz(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
pub fn xz(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn yz(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
pub fn yz(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn zx(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
pub fn zx(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn zy(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
pub fn zy(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn zz(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
pub fn zz(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn xxz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn xxz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn xyz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn xyz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn xzx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn xzx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn xzy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn xzy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn xzz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn xzz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn yxz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn yxz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn yyz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn yyz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn yzx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn yzx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn yzy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn yzy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn yzz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn yzz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn zxx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn zxx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn zxy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn zxy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn zxz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn zxz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn zyx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn zyx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn zyy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn zyy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn zyz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn zyz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
sourcepub fn zzx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
pub fn zzx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: DimMin<C>,
C: Dim,
S: Storage<N, R, C>,
<R as DimMin<C>>::Output: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C> + Allocator<N, C, U1> + Allocator<N, R, U1> + Allocator<N, <R as DimMin<C>>::Output, U1> + Allocator<N, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: DimMin<C>,
C: Dim,
S: Storage<N, R, C>,
<R as DimMin<C>>::Output: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C> + Allocator<N, C, U1> + Allocator<N, R, U1> + Allocator<N, <R as DimMin<C>>::Output, U1> + Allocator<N, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>,
sourcepub fn bidiagonalize(self) -> Bidiagonal<N, R, C>
pub fn bidiagonalize(self) -> Bidiagonal<N, R, C>
Computes the bidiagonalization using householder reflections.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimSub<Dynamic>,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimSub<Dynamic>,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimMin<D, Output = D>,
S: Storage<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimMin<D, Output = D>,
S: Storage<N, D, D>,
sourcepub fn determinant(&self) -> Nwhere
DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), D, U1>,
pub fn determinant(&self) -> Nwhere
DefaultAllocator: Allocator<N, D, D> + Allocator<(usize, usize), D, U1>,
Computes the matrix determinant.
If the matrix has a dimension larger than 3, an LU decomposition is used.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: DimMin<C>,
C: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: DimMin<C>,
C: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>,
sourcepub fn full_piv_lu(self) -> FullPivLU<N, R, C>
pub fn full_piv_lu(self) -> FullPivLU<N, R, C>
Computes the LU decomposition with full pivoting of matrix
.
This effectively computes P, L, U, Q
such that P * matrix * Q = LU
.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimSub<U1>,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1> + Allocator<N, <D as DimSub<U1>>::Output, U1>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimSub<U1>,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1> + Allocator<N, <D as DimSub<U1>>::Output, U1>,
sourcepub fn hessenberg(self) -> Hessenberg<N, D>
pub fn hessenberg(self) -> Hessenberg<N, D>
Computes the Hessenberg decomposition of this matrix using householder reflections.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: Dim,
S: Storage<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: Dim,
S: Storage<N, D, D>,
sourcepub fn try_inverse(
self
) -> Option<Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>>where
DefaultAllocator: Allocator<N, D, D>,
pub fn try_inverse(
self
) -> Option<Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>>where
DefaultAllocator: Allocator<N, D, D>,
Attempts to invert this matrix.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: Dim,
S: StorageMut<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: Dim,
S: StorageMut<N, D, D>,
sourcepub fn try_inverse_mut(&mut self) -> boolwhere
DefaultAllocator: Allocator<N, D, D>,
pub fn try_inverse_mut(&mut self) -> boolwhere
DefaultAllocator: Allocator<N, D, D>,
Attempts to invert this matrix in-place. Returns false
and leaves self
untouched if
inversion fails.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: DimMin<C>,
C: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: DimMin<C>,
C: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>,
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: DimMin<C>,
C: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C> + Allocator<N, R, U1> + Allocator<N, <R as DimMin<C>>::Output, U1>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: DimMin<C>,
C: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C> + Allocator<N, R, U1> + Allocator<N, <R as DimMin<C>>::Output, U1>,
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: Dim + DimSub<U1>,
S: Storage<N, D, D>,
ShapeConstraint: DimEq<Dynamic, <D as DimSub<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimSub<U1>>::Output> + Allocator<N, <D as DimSub<U1>>::Output, U1> + Allocator<N, D, D> + Allocator<N, D, U1>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: Dim + DimSub<U1>,
S: Storage<N, D, D>,
ShapeConstraint: DimEq<Dynamic, <D as DimSub<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimSub<U1>>::Output> + Allocator<N, <D as DimSub<U1>>::Output, U1> + Allocator<N, D, D> + Allocator<N, D, U1>,
sourcepub fn real_schur(self) -> RealSchur<N, D>
pub fn real_schur(self) -> RealSchur<N, D>
Computes the Schur decomposition of a square matrix.
sourcepub fn try_real_schur(self, eps: N, max_niter: usize) -> Option<RealSchur<N, D>>
pub fn try_real_schur(self, eps: N, max_niter: usize) -> Option<RealSchur<N, D>>
Attempts to compute the Schur decomposition of a square matrix.
If only eigenvalues are needed, it is more efficient to call the matrix method
.eigenvalues()
instead.
Arguments
eps
− tolerance used to determine when a value converged to 0.max_niter
− maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded,None
is returned. Ifniter == 0
, then the algorithm continues indefinitely until convergence.
sourcepub fn eigenvalues(
&self
) -> Option<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>
pub fn eigenvalues(
&self
) -> Option<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>
Computes the eigenvalues of this matrix.
sourcepub fn complex_eigenvalues(
&self
) -> Matrix<Complex<N>, D, U1, <DefaultAllocator as Allocator<Complex<N>, D, U1>>::Buffer>where
DefaultAllocator: Allocator<Complex<N>, D, U1>,
pub fn complex_eigenvalues(
&self
) -> Matrix<Complex<N>, D, U1, <DefaultAllocator as Allocator<Complex<N>, D, U1>>::Buffer>where
DefaultAllocator: Allocator<Complex<N>, D, U1>,
Computes the eigenvalues of this matrix.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: Dim,
S: Storage<N, D, D>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: Dim,
S: Storage<N, D, D>,
sourcepub fn solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>>where
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>>where
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self . x = b
where x
is the unknown and only
the lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn solve_upper_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>>where
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_upper_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>>where
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self . x = b
where x
is the unknown and only
the upper-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> boolwhere
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> boolwhere
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self . x = b
where x
is the unknown and only the
lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn solve_lower_triangular_with_diag_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>,
diag: N
) -> boolwhere
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular_with_diag_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>,
diag: N
) -> boolwhere
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self . x = b
where x
is the unknown and only the
lower-triangular part of self
is considered not-zero. The diagonal is never read as it is
assumed to be equal to diag
. Returns false
and does not modify its inputs if diag
is zero.
sourcepub fn solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> boolwhere
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> boolwhere
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self . x = b
where x
is the unknown and only the
upper-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>>where
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>>where
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self.transpose() . x = b
where x
is the unknown and only
the lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_upper_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>>where
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_upper_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>>where
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self.transpose() . x = b
where x
is the unknown and only
the upper-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> boolwhere
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> boolwhere
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self.transpose() . x = b
where x
is the unknown and only the
lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> boolwhere
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> boolwhere
R2: Dim,
C2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self.transpose() . x = b
where x
is the unknown and only the
upper-triangular part of self
(including the diagonal) is considered not-zero.
source§impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: DimMin<C>,
C: Dim,
S: Storage<N, R, C>,
<R as DimMin<C>>::Output: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C> + Allocator<N, C, U1> + Allocator<N, R, U1> + Allocator<N, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1> + Allocator<N, <R as DimMin<C>>::Output, C> + Allocator<N, R, <R as DimMin<C>>::Output> + Allocator<N, <R as DimMin<C>>::Output, U1>,
impl<N, R, C, S> Matrix<N, R, C, S>where
N: Real,
R: DimMin<C>,
C: Dim,
S: Storage<N, R, C>,
<R as DimMin<C>>::Output: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C> + Allocator<N, C, U1> + Allocator<N, R, U1> + Allocator<N, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1> + Allocator<N, <R as DimMin<C>>::Output, C> + Allocator<N, R, <R as DimMin<C>>::Output> + Allocator<N, <R as DimMin<C>>::Output, U1>,
sourcepub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<N, R, C>
pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<N, R, C>
Computes the Singular Value Decomposition using implicit shift.
sourcepub fn try_svd(
self,
compute_u: bool,
compute_v: bool,
eps: N,
max_niter: usize
) -> Option<SVD<N, R, C>>
pub fn try_svd(
self,
compute_u: bool,
compute_v: bool,
eps: N,
max_niter: usize
) -> Option<SVD<N, R, C>>
Attempts to compute the Singular Value Decomposition of matrix
using implicit shift.
Arguments
compute_u
− set this totrue
to enable the computation of left-singular vectors.compute_v
− set this totrue
to enable the computation of left-singular vectors.eps
− tolerance used to determine when a value converged to 0.max_niter
− maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded,None
is returned. Ifniter == 0
, then the algorithm continues indefinitely until convergence.
sourcepub fn singular_values(
&self
) -> Matrix<N, <R as DimMin<C>>::Output, U1, <DefaultAllocator as Allocator<N, <R as DimMin<C>>::Output, U1>>::Buffer>
pub fn singular_values(
&self
) -> Matrix<N, <R as DimMin<C>>::Output, U1, <DefaultAllocator as Allocator<N, <R as DimMin<C>>::Output, U1>>::Buffer>
Computes the singular values of this matrix.
sourcepub fn rank(&self, eps: N) -> usize
pub fn rank(&self, eps: N) -> usize
Computes the rank of this matrix.
All singular values below eps
are considered equal to 0.
sourcepub fn pseudo_inverse(
self,
eps: N
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer>where
DefaultAllocator: Allocator<N, C, R>,
pub fn pseudo_inverse(
self,
eps: N
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer>where
DefaultAllocator: Allocator<N, C, R>,
Computes the pseudo-inverse of this matrix.
All singular values below eps
are considered equal to 0.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimSub<U1>,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1> + Allocator<N, <D as DimSub<U1>>::Output, U1>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimSub<U1>,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, U1> + Allocator<N, <D as DimSub<U1>>::Output, U1>,
sourcepub fn symmetric_eigen(self) -> SymmetricEigen<N, D>
pub fn symmetric_eigen(self) -> SymmetricEigen<N, D>
Computes the eigendecomposition of this symmetric matrix.
Only the lower-triangular part (including the diagonal) of m
is read.
sourcepub fn try_symmetric_eigen(
self,
eps: N,
max_niter: usize
) -> Option<SymmetricEigen<N, D>>
pub fn try_symmetric_eigen(
self,
eps: N,
max_niter: usize
) -> Option<SymmetricEigen<N, D>>
Computes the eigendecomposition of the given symmetric matrix with user-specified convergence parameters.
Only the lower-triangular part (including the diagonal) of m
is read.
Arguments
eps
− tolerance used to determine when a value converged to 0.max_niter
− maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded,None
is returned. Ifniter == 0
, then the algorithm continues indefinitely until convergence.
sourcepub fn symmetric_eigenvalues(
&self
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
pub fn symmetric_eigenvalues(
&self
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
Computes the eigenvalues of this symmetric matrix.
Only the lower-triangular part of the matrix is read.
source§impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimSub<U1>,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, <D as DimSub<U1>>::Output, U1>,
impl<N, D, S> Matrix<N, D, D, S>where
N: Real,
D: DimSub<U1>,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, <D as DimSub<U1>>::Output, U1>,
sourcepub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<N, D>
pub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<N, D>
Computes the tridiagonalization of this symmetric matrix.
Only the lower-triangular part (including the diagonal) of m
is read.
Trait Implementations§
source§impl<N, R, C, S> AbsDiffEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + AbsDiffEq<N>,
S: Storage<N, R, C>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
impl<N, R, C, S> AbsDiffEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + AbsDiffEq<N>,
S: Storage<N, R, C>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
source§fn default_epsilon(
) -> <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon
fn default_epsilon(
) -> <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon
source§fn abs_diff_eq(
&self,
other: &Matrix<N, R, C, S>,
epsilon: <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon
) -> bool
fn abs_diff_eq(
&self,
other: &Matrix<N, R, C, S>,
epsilon: <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon
) -> bool
§fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
ApproxEq::abs_diff_eq
.source§impl<N, R, C> AbstractMagma<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + ClosedAdd<N>,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> AbstractMagma<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + ClosedAdd<N>,
DefaultAllocator: Allocator<N, R, C>,
source§impl<N, D> AbstractMagma<Multiplicative> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> AbstractMagma<Multiplicative> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
source§impl<N, R, C> AbstractModule<Additive, Additive, Multiplicative> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + RingCommutative,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> AbstractModule<Additive, Additive, Multiplicative> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + RingCommutative,
DefaultAllocator: Allocator<N, R, C>,
§type AbstractRing = N
type AbstractRing = N
source§fn multiply_by(
&self,
n: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn multiply_by(
&self,
n: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
source§impl<'a, 'b, N, D1, D2, SB> Add<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
impl<'a, 'b, N, D1, D2, SB> Add<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
source§impl<'b, N, D1, D2, SB> Add<&'b Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
impl<'b, N, D1, D2, SB> Add<&'b Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
source§impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
+
operator.source§impl<'b, N, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<'b, N, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
+
operator.source§impl<'a, N, D1, D2, SB> Add<Matrix<N, D2, U1, SB>> for &'a Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
impl<'a, N, D1, D2, SB> Add<Matrix<N, D2, U1, SB>> for &'a Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
source§impl<N, D1, D2, SB> Add<Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
impl<N, D1, D2, SB> Add<Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
source§impl<'a, N, R1, C1, R2, C2, SA, SB> Add<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,
impl<'a, N, R1, C1, R2, C2, SA, SB> Add<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,
§type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer>
type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer>
+
operator.source§impl<N, R1, C1, R2, C2, SA, SB> Add<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<N, R1, C1, R2, C2, SA, SB> Add<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
+
operator.source§impl<'b, N, D1, D2, SB> AddAssign<&'b Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
N: Scalar + ClosedAdd<N>,
SB: Storage<N, D2, U1>,
DefaultAllocator: Allocator<N, D1, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
impl<'b, N, D1, D2, SB> AddAssign<&'b Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
N: Scalar + ClosedAdd<N>,
SB: Storage<N, D2, U1>,
DefaultAllocator: Allocator<N, D1, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
source§impl<'b, N, R1, C1, R2, C2, SA, SB> AddAssign<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<'b, N, R1, C1, R2, C2, SA, SB> AddAssign<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
source§fn add_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>)
fn add_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>)
+=
operation. Read moresource§impl<N, D1, D2, SB> AddAssign<Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
N: Scalar + ClosedAdd<N>,
SB: Storage<N, D2, U1>,
DefaultAllocator: Allocator<N, D1, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
impl<N, D1, D2, SB> AddAssign<Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
N: Scalar + ClosedAdd<N>,
SB: Storage<N, D2, U1>,
DefaultAllocator: Allocator<N, D1, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
source§impl<N, R1, C1, R2, C2, SA, SB> AddAssign<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<N, R1, C1, R2, C2, SA, SB> AddAssign<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
source§fn add_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)
fn add_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)
+=
operation. Read moresource§impl<T: Real> AsMat<Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>> for Orthographic3<T>
impl<T: Real> AsMat<Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>> for Orthographic3<T>
source§impl<N, S> AsMut<[[N; 2]; 2]> for Matrix<N, U2, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U2>,
impl<N, S> AsMut<[[N; 2]; 2]> for Matrix<N, U2, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U2>,
source§impl<N, S> AsMut<[[N; 2]; 3]> for Matrix<N, U2, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U3>,
impl<N, S> AsMut<[[N; 2]; 3]> for Matrix<N, U2, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U3>,
source§impl<N, S> AsMut<[[N; 2]; 4]> for Matrix<N, U2, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U4>,
impl<N, S> AsMut<[[N; 2]; 4]> for Matrix<N, U2, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U4>,
source§impl<N, S> AsMut<[[N; 2]; 5]> for Matrix<N, U2, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U5>,
impl<N, S> AsMut<[[N; 2]; 5]> for Matrix<N, U2, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U5>,
source§impl<N, S> AsMut<[[N; 2]; 6]> for Matrix<N, U2, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U6>,
impl<N, S> AsMut<[[N; 2]; 6]> for Matrix<N, U2, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U6>,
source§impl<N, S> AsMut<[[N; 3]; 2]> for Matrix<N, U3, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U2>,
impl<N, S> AsMut<[[N; 3]; 2]> for Matrix<N, U3, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U2>,
source§impl<N, S> AsMut<[[N; 3]; 3]> for Matrix<N, U3, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U3>,
impl<N, S> AsMut<[[N; 3]; 3]> for Matrix<N, U3, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U3>,
source§impl<N, S> AsMut<[[N; 3]; 4]> for Matrix<N, U3, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U4>,
impl<N, S> AsMut<[[N; 3]; 4]> for Matrix<N, U3, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U4>,
source§impl<N, S> AsMut<[[N; 3]; 5]> for Matrix<N, U3, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U5>,
impl<N, S> AsMut<[[N; 3]; 5]> for Matrix<N, U3, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U5>,
source§impl<N, S> AsMut<[[N; 3]; 6]> for Matrix<N, U3, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U6>,
impl<N, S> AsMut<[[N; 3]; 6]> for Matrix<N, U3, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U6>,
source§impl<N, S> AsMut<[[N; 4]; 2]> for Matrix<N, U4, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U2>,
impl<N, S> AsMut<[[N; 4]; 2]> for Matrix<N, U4, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U2>,
source§impl<N, S> AsMut<[[N; 4]; 3]> for Matrix<N, U4, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U3>,
impl<N, S> AsMut<[[N; 4]; 3]> for Matrix<N, U4, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U3>,
source§impl<N, S> AsMut<[[N; 4]; 4]> for Matrix<N, U4, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U4>,
impl<N, S> AsMut<[[N; 4]; 4]> for Matrix<N, U4, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U4>,
source§impl<N, S> AsMut<[[N; 4]; 5]> for Matrix<N, U4, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U5>,
impl<N, S> AsMut<[[N; 4]; 5]> for Matrix<N, U4, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U5>,
source§impl<N, S> AsMut<[[N; 4]; 6]> for Matrix<N, U4, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U6>,
impl<N, S> AsMut<[[N; 4]; 6]> for Matrix<N, U4, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U6>,
source§impl<N, S> AsMut<[[N; 5]; 2]> for Matrix<N, U5, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U2>,
impl<N, S> AsMut<[[N; 5]; 2]> for Matrix<N, U5, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U2>,
source§impl<N, S> AsMut<[[N; 5]; 3]> for Matrix<N, U5, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U3>,
impl<N, S> AsMut<[[N; 5]; 3]> for Matrix<N, U5, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U3>,
source§impl<N, S> AsMut<[[N; 5]; 4]> for Matrix<N, U5, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U4>,
impl<N, S> AsMut<[[N; 5]; 4]> for Matrix<N, U5, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U4>,
source§impl<N, S> AsMut<[[N; 5]; 5]> for Matrix<N, U5, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U5>,
impl<N, S> AsMut<[[N; 5]; 5]> for Matrix<N, U5, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U5>,
source§impl<N, S> AsMut<[[N; 5]; 6]> for Matrix<N, U5, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U6>,
impl<N, S> AsMut<[[N; 5]; 6]> for Matrix<N, U5, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U6>,
source§impl<N, S> AsMut<[[N; 6]; 2]> for Matrix<N, U6, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U2>,
impl<N, S> AsMut<[[N; 6]; 2]> for Matrix<N, U6, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U2>,
source§impl<N, S> AsMut<[[N; 6]; 3]> for Matrix<N, U6, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U3>,
impl<N, S> AsMut<[[N; 6]; 3]> for Matrix<N, U6, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U3>,
source§impl<N, S> AsMut<[[N; 6]; 4]> for Matrix<N, U6, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U4>,
impl<N, S> AsMut<[[N; 6]; 4]> for Matrix<N, U6, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U4>,
source§impl<N, S> AsMut<[[N; 6]; 5]> for Matrix<N, U6, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U5>,
impl<N, S> AsMut<[[N; 6]; 5]> for Matrix<N, U6, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U5>,
source§impl<N, S> AsMut<[[N; 6]; 6]> for Matrix<N, U6, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U6>,
impl<N, S> AsMut<[[N; 6]; 6]> for Matrix<N, U6, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U6>,
source§impl<N, S> AsMut<[N; 1]> for Matrix<N, U1, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U1>,
impl<N, S> AsMut<[N; 1]> for Matrix<N, U1, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U1>,
source§impl<N, S> AsMut<[N; 10]> for Matrix<N, U1, U10, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U10>,
impl<N, S> AsMut<[N; 10]> for Matrix<N, U1, U10, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U10>,
source§impl<N, S> AsMut<[N; 10]> for Matrix<N, U10, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U10, U1>,
impl<N, S> AsMut<[N; 10]> for Matrix<N, U10, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U10, U1>,
source§impl<N, S> AsMut<[N; 11]> for Matrix<N, U1, U11, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U11>,
impl<N, S> AsMut<[N; 11]> for Matrix<N, U1, U11, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U11>,
source§impl<N, S> AsMut<[N; 11]> for Matrix<N, U11, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U11, U1>,
impl<N, S> AsMut<[N; 11]> for Matrix<N, U11, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U11, U1>,
source§impl<N, S> AsMut<[N; 12]> for Matrix<N, U1, U12, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U12>,
impl<N, S> AsMut<[N; 12]> for Matrix<N, U1, U12, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U12>,
source§impl<N, S> AsMut<[N; 12]> for Matrix<N, U12, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U12, U1>,
impl<N, S> AsMut<[N; 12]> for Matrix<N, U12, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U12, U1>,
source§impl<N, S> AsMut<[N; 13]> for Matrix<N, U1, U13, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U13>,
impl<N, S> AsMut<[N; 13]> for Matrix<N, U1, U13, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U13>,
source§impl<N, S> AsMut<[N; 13]> for Matrix<N, U13, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U13, U1>,
impl<N, S> AsMut<[N; 13]> for Matrix<N, U13, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U13, U1>,
source§impl<N, S> AsMut<[N; 14]> for Matrix<N, U1, U14, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U14>,
impl<N, S> AsMut<[N; 14]> for Matrix<N, U1, U14, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U14>,
source§impl<N, S> AsMut<[N; 14]> for Matrix<N, U14, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U14, U1>,
impl<N, S> AsMut<[N; 14]> for Matrix<N, U14, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U14, U1>,
source§impl<N, S> AsMut<[N; 15]> for Matrix<N, U1, U15, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U15>,
impl<N, S> AsMut<[N; 15]> for Matrix<N, U1, U15, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U15>,
source§impl<N, S> AsMut<[N; 15]> for Matrix<N, U15, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U15, U1>,
impl<N, S> AsMut<[N; 15]> for Matrix<N, U15, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U15, U1>,
source§impl<N, S> AsMut<[N; 16]> for Matrix<N, U1, U16, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U16>,
impl<N, S> AsMut<[N; 16]> for Matrix<N, U1, U16, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U16>,
source§impl<N, S> AsMut<[N; 16]> for Matrix<N, U16, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U16, U1>,
impl<N, S> AsMut<[N; 16]> for Matrix<N, U16, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U16, U1>,
source§impl<N, S> AsMut<[N; 2]> for Matrix<N, U1, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U2>,
impl<N, S> AsMut<[N; 2]> for Matrix<N, U1, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U2>,
source§impl<N, S> AsMut<[N; 2]> for Matrix<N, U2, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U1>,
impl<N, S> AsMut<[N; 2]> for Matrix<N, U2, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U1>,
source§impl<N, S> AsMut<[N; 3]> for Matrix<N, U1, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U3>,
impl<N, S> AsMut<[N; 3]> for Matrix<N, U1, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U3>,
source§impl<N, S> AsMut<[N; 3]> for Matrix<N, U3, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U1>,
impl<N, S> AsMut<[N; 3]> for Matrix<N, U3, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U1>,
source§impl<N, S> AsMut<[N; 4]> for Matrix<N, U1, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U4>,
impl<N, S> AsMut<[N; 4]> for Matrix<N, U1, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U4>,
source§impl<N, S> AsMut<[N; 4]> for Matrix<N, U4, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U1>,
impl<N, S> AsMut<[N; 4]> for Matrix<N, U4, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U1>,
source§impl<N, S> AsMut<[N; 5]> for Matrix<N, U1, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U5>,
impl<N, S> AsMut<[N; 5]> for Matrix<N, U1, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U5>,
source§impl<N, S> AsMut<[N; 5]> for Matrix<N, U5, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U1>,
impl<N, S> AsMut<[N; 5]> for Matrix<N, U5, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U1>,
source§impl<N, S> AsMut<[N; 6]> for Matrix<N, U1, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U6>,
impl<N, S> AsMut<[N; 6]> for Matrix<N, U1, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U6>,
source§impl<N, S> AsMut<[N; 6]> for Matrix<N, U6, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U1>,
impl<N, S> AsMut<[N; 6]> for Matrix<N, U6, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U1>,
source§impl<N, S> AsMut<[N; 7]> for Matrix<N, U1, U7, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U7>,
impl<N, S> AsMut<[N; 7]> for Matrix<N, U1, U7, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U7>,
source§impl<N, S> AsMut<[N; 7]> for Matrix<N, U7, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U7, U1>,
impl<N, S> AsMut<[N; 7]> for Matrix<N, U7, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U7, U1>,
source§impl<N, S> AsMut<[N; 8]> for Matrix<N, U1, U8, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U8>,
impl<N, S> AsMut<[N; 8]> for Matrix<N, U1, U8, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U8>,
source§impl<N, S> AsMut<[N; 8]> for Matrix<N, U8, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U8, U1>,
impl<N, S> AsMut<[N; 8]> for Matrix<N, U8, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U8, U1>,
source§impl<N, S> AsMut<[N; 9]> for Matrix<N, U1, U9, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U9>,
impl<N, S> AsMut<[N; 9]> for Matrix<N, U1, U9, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U9>,
source§impl<N, S> AsMut<[N; 9]> for Matrix<N, U9, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U9, U1>,
impl<N, S> AsMut<[N; 9]> for Matrix<N, U9, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U9, U1>,
source§impl<N, S> AsRef<[[N; 2]; 2]> for Matrix<N, U2, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U2>,
impl<N, S> AsRef<[[N; 2]; 2]> for Matrix<N, U2, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U2>,
source§impl<N, S> AsRef<[[N; 2]; 3]> for Matrix<N, U2, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U3>,
impl<N, S> AsRef<[[N; 2]; 3]> for Matrix<N, U2, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U3>,
source§impl<N, S> AsRef<[[N; 2]; 4]> for Matrix<N, U2, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U4>,
impl<N, S> AsRef<[[N; 2]; 4]> for Matrix<N, U2, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U4>,
source§impl<N, S> AsRef<[[N; 2]; 5]> for Matrix<N, U2, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U5>,
impl<N, S> AsRef<[[N; 2]; 5]> for Matrix<N, U2, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U5>,
source§impl<N, S> AsRef<[[N; 2]; 6]> for Matrix<N, U2, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U6>,
impl<N, S> AsRef<[[N; 2]; 6]> for Matrix<N, U2, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U6>,
source§impl<N, S> AsRef<[[N; 3]; 2]> for Matrix<N, U3, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U2>,
impl<N, S> AsRef<[[N; 3]; 2]> for Matrix<N, U3, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U2>,
source§impl<N, S> AsRef<[[N; 3]; 3]> for Matrix<N, U3, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U3>,
impl<N, S> AsRef<[[N; 3]; 3]> for Matrix<N, U3, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U3>,
source§impl<N, S> AsRef<[[N; 3]; 4]> for Matrix<N, U3, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U4>,
impl<N, S> AsRef<[[N; 3]; 4]> for Matrix<N, U3, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U4>,
source§impl<N, S> AsRef<[[N; 3]; 5]> for Matrix<N, U3, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U5>,
impl<N, S> AsRef<[[N; 3]; 5]> for Matrix<N, U3, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U5>,
source§impl<N, S> AsRef<[[N; 3]; 6]> for Matrix<N, U3, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U6>,
impl<N, S> AsRef<[[N; 3]; 6]> for Matrix<N, U3, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U6>,
source§impl<N, S> AsRef<[[N; 4]; 2]> for Matrix<N, U4, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U2>,
impl<N, S> AsRef<[[N; 4]; 2]> for Matrix<N, U4, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U2>,
source§impl<N, S> AsRef<[[N; 4]; 3]> for Matrix<N, U4, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U3>,
impl<N, S> AsRef<[[N; 4]; 3]> for Matrix<N, U4, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U3>,
source§impl<N, S> AsRef<[[N; 4]; 4]> for Matrix<N, U4, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U4>,
impl<N, S> AsRef<[[N; 4]; 4]> for Matrix<N, U4, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U4>,
source§impl<N, S> AsRef<[[N; 4]; 5]> for Matrix<N, U4, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U5>,
impl<N, S> AsRef<[[N; 4]; 5]> for Matrix<N, U4, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U5>,
source§impl<N, S> AsRef<[[N; 4]; 6]> for Matrix<N, U4, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U6>,
impl<N, S> AsRef<[[N; 4]; 6]> for Matrix<N, U4, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U6>,
source§impl<N, S> AsRef<[[N; 5]; 2]> for Matrix<N, U5, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U2>,
impl<N, S> AsRef<[[N; 5]; 2]> for Matrix<N, U5, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U2>,
source§impl<N, S> AsRef<[[N; 5]; 3]> for Matrix<N, U5, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U3>,
impl<N, S> AsRef<[[N; 5]; 3]> for Matrix<N, U5, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U3>,
source§impl<N, S> AsRef<[[N; 5]; 4]> for Matrix<N, U5, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U4>,
impl<N, S> AsRef<[[N; 5]; 4]> for Matrix<N, U5, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U4>,
source§impl<N, S> AsRef<[[N; 5]; 5]> for Matrix<N, U5, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U5>,
impl<N, S> AsRef<[[N; 5]; 5]> for Matrix<N, U5, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U5>,
source§impl<N, S> AsRef<[[N; 5]; 6]> for Matrix<N, U5, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U6>,
impl<N, S> AsRef<[[N; 5]; 6]> for Matrix<N, U5, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U6>,
source§impl<N, S> AsRef<[[N; 6]; 2]> for Matrix<N, U6, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U2>,
impl<N, S> AsRef<[[N; 6]; 2]> for Matrix<N, U6, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U2>,
source§impl<N, S> AsRef<[[N; 6]; 3]> for Matrix<N, U6, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U3>,
impl<N, S> AsRef<[[N; 6]; 3]> for Matrix<N, U6, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U3>,
source§impl<N, S> AsRef<[[N; 6]; 4]> for Matrix<N, U6, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U4>,
impl<N, S> AsRef<[[N; 6]; 4]> for Matrix<N, U6, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U4>,
source§impl<N, S> AsRef<[[N; 6]; 5]> for Matrix<N, U6, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U5>,
impl<N, S> AsRef<[[N; 6]; 5]> for Matrix<N, U6, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U5>,
source§impl<N, S> AsRef<[[N; 6]; 6]> for Matrix<N, U6, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U6>,
impl<N, S> AsRef<[[N; 6]; 6]> for Matrix<N, U6, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U6>,
source§impl<N, S> AsRef<[N; 1]> for Matrix<N, U1, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U1>,
impl<N, S> AsRef<[N; 1]> for Matrix<N, U1, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U1>,
source§impl<N, S> AsRef<[N; 10]> for Matrix<N, U1, U10, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U10>,
impl<N, S> AsRef<[N; 10]> for Matrix<N, U1, U10, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U10>,
source§impl<N, S> AsRef<[N; 10]> for Matrix<N, U10, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U10, U1>,
impl<N, S> AsRef<[N; 10]> for Matrix<N, U10, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U10, U1>,
source§impl<N, S> AsRef<[N; 11]> for Matrix<N, U1, U11, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U11>,
impl<N, S> AsRef<[N; 11]> for Matrix<N, U1, U11, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U11>,
source§impl<N, S> AsRef<[N; 11]> for Matrix<N, U11, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U11, U1>,
impl<N, S> AsRef<[N; 11]> for Matrix<N, U11, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U11, U1>,
source§impl<N, S> AsRef<[N; 12]> for Matrix<N, U1, U12, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U12>,
impl<N, S> AsRef<[N; 12]> for Matrix<N, U1, U12, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U12>,
source§impl<N, S> AsRef<[N; 12]> for Matrix<N, U12, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U12, U1>,
impl<N, S> AsRef<[N; 12]> for Matrix<N, U12, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U12, U1>,
source§impl<N, S> AsRef<[N; 13]> for Matrix<N, U1, U13, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U13>,
impl<N, S> AsRef<[N; 13]> for Matrix<N, U1, U13, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U13>,
source§impl<N, S> AsRef<[N; 13]> for Matrix<N, U13, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U13, U1>,
impl<N, S> AsRef<[N; 13]> for Matrix<N, U13, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U13, U1>,
source§impl<N, S> AsRef<[N; 14]> for Matrix<N, U1, U14, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U14>,
impl<N, S> AsRef<[N; 14]> for Matrix<N, U1, U14, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U14>,
source§impl<N, S> AsRef<[N; 14]> for Matrix<N, U14, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U14, U1>,
impl<N, S> AsRef<[N; 14]> for Matrix<N, U14, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U14, U1>,
source§impl<N, S> AsRef<[N; 15]> for Matrix<N, U1, U15, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U15>,
impl<N, S> AsRef<[N; 15]> for Matrix<N, U1, U15, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U15>,
source§impl<N, S> AsRef<[N; 15]> for Matrix<N, U15, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U15, U1>,
impl<N, S> AsRef<[N; 15]> for Matrix<N, U15, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U15, U1>,
source§impl<N, S> AsRef<[N; 16]> for Matrix<N, U1, U16, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U16>,
impl<N, S> AsRef<[N; 16]> for Matrix<N, U1, U16, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U16>,
source§impl<N, S> AsRef<[N; 16]> for Matrix<N, U16, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U16, U1>,
impl<N, S> AsRef<[N; 16]> for Matrix<N, U16, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U16, U1>,
source§impl<N, S> AsRef<[N; 2]> for Matrix<N, U1, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U2>,
impl<N, S> AsRef<[N; 2]> for Matrix<N, U1, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U2>,
source§impl<N, S> AsRef<[N; 2]> for Matrix<N, U2, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U1>,
impl<N, S> AsRef<[N; 2]> for Matrix<N, U2, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U1>,
source§impl<N, S> AsRef<[N; 3]> for Matrix<N, U1, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U3>,
impl<N, S> AsRef<[N; 3]> for Matrix<N, U1, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U3>,
source§impl<N, S> AsRef<[N; 3]> for Matrix<N, U3, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U1>,
impl<N, S> AsRef<[N; 3]> for Matrix<N, U3, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U1>,
source§impl<N, S> AsRef<[N; 4]> for Matrix<N, U1, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U4>,
impl<N, S> AsRef<[N; 4]> for Matrix<N, U1, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U4>,
source§impl<N, S> AsRef<[N; 4]> for Matrix<N, U4, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U1>,
impl<N, S> AsRef<[N; 4]> for Matrix<N, U4, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U1>,
source§impl<N, S> AsRef<[N; 5]> for Matrix<N, U1, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U5>,
impl<N, S> AsRef<[N; 5]> for Matrix<N, U1, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U5>,
source§impl<N, S> AsRef<[N; 5]> for Matrix<N, U5, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U1>,
impl<N, S> AsRef<[N; 5]> for Matrix<N, U5, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U1>,
source§impl<N, S> AsRef<[N; 6]> for Matrix<N, U1, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U6>,
impl<N, S> AsRef<[N; 6]> for Matrix<N, U1, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U6>,
source§impl<N, S> AsRef<[N; 6]> for Matrix<N, U6, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U1>,
impl<N, S> AsRef<[N; 6]> for Matrix<N, U6, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U1>,
source§impl<N, S> AsRef<[N; 7]> for Matrix<N, U1, U7, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U7>,
impl<N, S> AsRef<[N; 7]> for Matrix<N, U1, U7, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U7>,
source§impl<N, S> AsRef<[N; 7]> for Matrix<N, U7, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U7, U1>,
impl<N, S> AsRef<[N; 7]> for Matrix<N, U7, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U7, U1>,
source§impl<N, S> AsRef<[N; 8]> for Matrix<N, U1, U8, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U8>,
impl<N, S> AsRef<[N; 8]> for Matrix<N, U1, U8, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U8>,
source§impl<N, S> AsRef<[N; 8]> for Matrix<N, U8, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U8, U1>,
impl<N, S> AsRef<[N; 8]> for Matrix<N, U8, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U8, U1>,
source§impl<N, S> AsRef<[N; 9]> for Matrix<N, U1, U9, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U9>,
impl<N, S> AsRef<[N; 9]> for Matrix<N, U1, U9, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U9>,
source§impl<N, S> AsRef<[N; 9]> for Matrix<N, U9, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U9, U1>,
impl<N, S> AsRef<[N; 9]> for Matrix<N, U9, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U9, U1>,
source§impl<T: Real> AsVec<Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>> for Point1<T>
impl<T: Real> AsVec<Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>> for Point1<T>
source§impl<T: Real> AsVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Point2<T>
impl<T: Real> AsVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Point2<T>
source§impl<T: Real> AsVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Point3<T>
impl<T: Real> AsVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Point3<T>
source§impl<T: Real> AsVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Point4<T>
impl<T: Real> AsVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Point4<T>
source§impl<T: Real> AsVec<Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>> for Point5<T>
impl<T: Real> AsVec<Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>> for Point5<T>
source§impl<T: Real> AsVec<Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>> for Point6<T>
impl<T: Real> AsVec<Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>> for Point6<T>
source§impl<N, R, C> Bounded for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + Bounded,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> Bounded for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + Bounded,
DefaultAllocator: Allocator<N, R, C>,
source§impl<N, R, C, S> Clone for Matrix<N, R, C, S>where
N: Clone + Scalar,
R: Clone + Dim,
C: Clone + Dim,
S: Clone,
impl<N, R, C, S> Clone for Matrix<N, R, C, S>where
N: Clone + Scalar,
R: Clone + Dim,
C: Clone + Dim,
S: Clone,
source§impl<N, S> DerefMut for Matrix<N, U1, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U1>,
impl<N, S> DerefMut for Matrix<N, U1, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U1>,
source§impl<N, S> DerefMut for Matrix<N, U1, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U2>,
impl<N, S> DerefMut for Matrix<N, U1, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U2>,
source§impl<N, S> DerefMut for Matrix<N, U1, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U3>,
impl<N, S> DerefMut for Matrix<N, U1, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U3>,
source§impl<N, S> DerefMut for Matrix<N, U1, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U4>,
impl<N, S> DerefMut for Matrix<N, U1, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U4>,
source§impl<N, S> DerefMut for Matrix<N, U1, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U5>,
impl<N, S> DerefMut for Matrix<N, U1, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U5>,
source§impl<N, S> DerefMut for Matrix<N, U1, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U6>,
impl<N, S> DerefMut for Matrix<N, U1, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U1, U6>,
source§impl<N, S> DerefMut for Matrix<N, U2, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U1>,
impl<N, S> DerefMut for Matrix<N, U2, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U1>,
source§impl<N, S> DerefMut for Matrix<N, U2, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U2>,
impl<N, S> DerefMut for Matrix<N, U2, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U2>,
source§impl<N, S> DerefMut for Matrix<N, U2, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U3>,
impl<N, S> DerefMut for Matrix<N, U2, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U3>,
source§impl<N, S> DerefMut for Matrix<N, U2, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U4>,
impl<N, S> DerefMut for Matrix<N, U2, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U4>,
source§impl<N, S> DerefMut for Matrix<N, U2, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U5>,
impl<N, S> DerefMut for Matrix<N, U2, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U5>,
source§impl<N, S> DerefMut for Matrix<N, U2, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U6>,
impl<N, S> DerefMut for Matrix<N, U2, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U2, U6>,
source§impl<N, S> DerefMut for Matrix<N, U3, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U1>,
impl<N, S> DerefMut for Matrix<N, U3, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U1>,
source§impl<N, S> DerefMut for Matrix<N, U3, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U2>,
impl<N, S> DerefMut for Matrix<N, U3, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U2>,
source§impl<N, S> DerefMut for Matrix<N, U3, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U3>,
impl<N, S> DerefMut for Matrix<N, U3, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U3>,
source§impl<N, S> DerefMut for Matrix<N, U3, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U4>,
impl<N, S> DerefMut for Matrix<N, U3, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U4>,
source§impl<N, S> DerefMut for Matrix<N, U3, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U5>,
impl<N, S> DerefMut for Matrix<N, U3, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U5>,
source§impl<N, S> DerefMut for Matrix<N, U3, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U6>,
impl<N, S> DerefMut for Matrix<N, U3, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U3, U6>,
source§impl<N, S> DerefMut for Matrix<N, U4, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U1>,
impl<N, S> DerefMut for Matrix<N, U4, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U1>,
source§impl<N, S> DerefMut for Matrix<N, U4, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U2>,
impl<N, S> DerefMut for Matrix<N, U4, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U2>,
source§impl<N, S> DerefMut for Matrix<N, U4, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U3>,
impl<N, S> DerefMut for Matrix<N, U4, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U3>,
source§impl<N, S> DerefMut for Matrix<N, U4, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U4>,
impl<N, S> DerefMut for Matrix<N, U4, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U4>,
source§impl<N, S> DerefMut for Matrix<N, U4, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U5>,
impl<N, S> DerefMut for Matrix<N, U4, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U5>,
source§impl<N, S> DerefMut for Matrix<N, U4, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U6>,
impl<N, S> DerefMut for Matrix<N, U4, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U4, U6>,
source§impl<N, S> DerefMut for Matrix<N, U5, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U1>,
impl<N, S> DerefMut for Matrix<N, U5, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U1>,
source§impl<N, S> DerefMut for Matrix<N, U5, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U2>,
impl<N, S> DerefMut for Matrix<N, U5, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U2>,
source§impl<N, S> DerefMut for Matrix<N, U5, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U3>,
impl<N, S> DerefMut for Matrix<N, U5, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U3>,
source§impl<N, S> DerefMut for Matrix<N, U5, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U4>,
impl<N, S> DerefMut for Matrix<N, U5, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U4>,
source§impl<N, S> DerefMut for Matrix<N, U5, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U5>,
impl<N, S> DerefMut for Matrix<N, U5, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U5>,
source§impl<N, S> DerefMut for Matrix<N, U5, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U6>,
impl<N, S> DerefMut for Matrix<N, U5, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U5, U6>,
source§impl<N, S> DerefMut for Matrix<N, U6, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U1>,
impl<N, S> DerefMut for Matrix<N, U6, U1, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U1>,
source§impl<N, S> DerefMut for Matrix<N, U6, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U2>,
impl<N, S> DerefMut for Matrix<N, U6, U2, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U2>,
source§impl<N, S> DerefMut for Matrix<N, U6, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U3>,
impl<N, S> DerefMut for Matrix<N, U6, U3, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U3>,
source§impl<N, S> DerefMut for Matrix<N, U6, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U4>,
impl<N, S> DerefMut for Matrix<N, U6, U4, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U4>,
source§impl<N, S> DerefMut for Matrix<N, U6, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U5>,
impl<N, S> DerefMut for Matrix<N, U6, U5, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U5>,
source§impl<N, S> DerefMut for Matrix<N, U6, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U6>,
impl<N, S> DerefMut for Matrix<N, U6, U6, S>where
N: Scalar,
S: ContiguousStorageMut<N, U6, U6>,
source§impl<N, R, C, S> Display for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + Display,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<usize, R, C>,
impl<N, R, C, S> Display for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + Display,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<usize, R, C>,
source§impl<'a, 'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
impl<'a, 'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
source§impl<'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
impl<'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
source§impl<'a, N, R, C, S> Div<N> for &'a Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedDiv<N>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
impl<'a, N, R, C, S> Div<N> for &'a Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedDiv<N>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
source§impl<N, R, C, S> Div<N> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedDiv<N>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C, S> Div<N> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedDiv<N>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
source§impl<'a, N, R1, C1, D2, SA> Div<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
impl<'a, N, R1, C1, D2, SA> Div<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
source§impl<N, R1, C1, D2, SA> Div<Rotation<N, D2>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
impl<N, R1, C1, D2, SA> Div<Rotation<N, D2>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
source§impl<'b, N, R1, C1> DivAssign<&'b Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer>where
R1: DimName,
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,
impl<'b, N, R1, C1> DivAssign<&'b Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer>where
R1: DimName,
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,
source§fn div_assign(&mut self, right: &'b Rotation<N, C1>)
fn div_assign(&mut self, right: &'b Rotation<N, C1>)
/=
operation. Read moresource§impl<N, R, C, S> DivAssign<N> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedDiv<N>,
S: StorageMut<N, R, C>,
impl<N, R, C, S> DivAssign<N> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedDiv<N>,
S: StorageMut<N, R, C>,
source§fn div_assign(&mut self, rhs: N)
fn div_assign(&mut self, rhs: N)
/=
operation. Read moresource§impl<N, R1, C1> DivAssign<Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer>where
R1: DimName,
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,
impl<N, R1, C1> DivAssign<Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer>where
R1: DimName,
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,
source§fn div_assign(&mut self, right: Rotation<N, C1>)
fn div_assign(&mut self, right: Rotation<N, C1>)
/=
operation. Read moresource§impl<N, R, S, RV, SV> Extend<Matrix<N, RV, U1, SV>> for Matrix<N, R, Dynamic, S>where
N: Scalar,
R: Dim,
S: Extend<Matrix<N, RV, U1, SV>>,
RV: Dim,
SV: Storage<N, RV, U1>,
ShapeConstraint: SameNumberOfRows<R, RV>,
impl<N, R, S, RV, SV> Extend<Matrix<N, RV, U1, SV>> for Matrix<N, R, Dynamic, S>where
N: Scalar,
R: Dim,
S: Extend<Matrix<N, RV, U1, SV>>,
RV: Dim,
SV: Storage<N, RV, U1>,
ShapeConstraint: SameNumberOfRows<R, RV>,
source§fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = Matrix<N, RV, U1, SV>>,
fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = Matrix<N, RV, U1, SV>>,
Extends the number of columns of a Matrix
with Vector
s
from a given iterator.
Example
let data = vec![0, 1, 2, // column 1
3, 4, 5]; // column 2
let mut matrix = DMatrix::from_vec(3, 2, data);
matrix.extend(
vec![Vector3::new(6, 7, 8), // column 3
Vector3::new(9, 10, 11)]); // column 4
assert!(matrix.eq(&Matrix3x4::new(0, 3, 6, 9,
1, 4, 7, 10,
2, 5, 8, 11)));
Panics
This function panics if the dimension of each Vector
yielded
by the given iterator is not equal to the number of rows of
this Matrix
.
let mut matrix =
DMatrix::from_vec(3, 2,
vec![0, 1, 2, // column 1
3, 4, 5]); // column 2
// The following panics because this matrix can only be extended with 3-dimensional vectors.
matrix.extend(
vec![Vector2::new(6, 7)]); // too few dimensions!
let mut matrix =
DMatrix::from_vec(3, 2,
vec![0, 1, 2, // column 1
3, 4, 5]); // column 2
// The following panics because this matrix can only be extended with 3-dimensional vectors.
matrix.extend(
vec![Vector4::new(6, 7, 8, 9)]); // too few dimensions!
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<N, R, RV, SV> Extend<Matrix<N, RV, U1, SV>> for VecStorage<N, R, Dynamic>where
N: Scalar,
R: Dim,
RV: Dim,
SV: Storage<N, RV, U1>,
ShapeConstraint: SameNumberOfRows<R, RV>,
impl<N, R, RV, SV> Extend<Matrix<N, RV, U1, SV>> for VecStorage<N, R, Dynamic>where
N: Scalar,
R: Dim,
RV: Dim,
SV: Storage<N, RV, U1>,
ShapeConstraint: SameNumberOfRows<R, RV>,
source§fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = Matrix<N, RV, U1, SV>>,
fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = Matrix<N, RV, U1, SV>>,
Extends the number of columns of the VecStorage
with vectors
from the given iterator.
Panics
This function panics if the number of rows of each Vector
yielded by the iterator is not equal to the number of rows
of this VecStorage
.
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<N, S> Extend<N> for Matrix<N, Dynamic, U1, S>where
N: Scalar,
S: Extend<N>,
impl<N, S> Extend<N> for Matrix<N, Dynamic, U1, S>where
N: Scalar,
S: Extend<N>,
Extend the number of rows of the Vector
with elements from
a given iterator.
source§fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = N>,
fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = N>,
Extend the number of rows of a Vector
with elements
from the given iterator.
Example
let mut vector = DVector::from_vec(3, vec![0, 1, 2]);
vector.extend(vec![3, 4, 5]);
assert!(vector.eq(&DVector::from_vec(6, vec![0, 1, 2, 3, 4, 5])));
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<N, R, S> Extend<N> for Matrix<N, R, Dynamic, S>where
N: Scalar,
R: Dim,
S: Extend<N>,
impl<N, R, S> Extend<N> for Matrix<N, R, Dynamic, S>where
N: Scalar,
R: Dim,
S: Extend<N>,
Extend the number of columns of the Matrix
with elements from
a given iterator.
source§fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = N>,
fn extend<I>(&mut self, iter: I)where
I: IntoIterator<Item = N>,
Extend the number of columns of the Matrix
with elements
from the given iterator.
Example
let data = vec![0, 1, 2, // column 1
3, 4, 5]; // column 2
let mut matrix = DMatrix::from_vec(3, 2, data);
matrix.extend(vec![6, 7, 8]); // column 3
assert!(matrix.eq(&Matrix3::new(0, 3, 6,
1, 4, 7,
2, 5, 8)));
Panics
This function panics if the number of elements yielded by the
given iterator is not a multiple of the number of rows of the
Matrix
.
let data = vec![0, 1, 2, // column 1
3, 4, 5]; // column 2
let mut matrix = DMatrix::from_vec(3, 2, data);
// The following panics because the vec length is not a multiple of 3.
matrix.extend(vec![6, 7, 8, 9]);
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<T: Real> FastMul<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Matrix2<T>
impl<T: Real> FastMul<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Matrix2<T>
source§impl<T: Real> FastMul<Matrix<T, U2, U2, <DefaultAllocator as Allocator<T, U2, U2>>::Buffer>> for Matrix2<T>
impl<T: Real> FastMul<Matrix<T, U2, U2, <DefaultAllocator as Allocator<T, U2, U2>>::Buffer>> for Matrix2<T>
source§impl<T: Real> FastMul<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Matrix3<T>
impl<T: Real> FastMul<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Matrix3<T>
source§impl<T: Real> FastMul<Matrix<T, U3, U3, <DefaultAllocator as Allocator<T, U3, U3>>::Buffer>> for Matrix3<T>
impl<T: Real> FastMul<Matrix<T, U3, U3, <DefaultAllocator as Allocator<T, U3, U3>>::Buffer>> for Matrix3<T>
source§impl<T: Real> FastMul<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Matrix4<T>
impl<T: Real> FastMul<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Matrix4<T>
source§impl<T: Real> FastMul<Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>> for Matrix4<T>
impl<T: Real> FastMul<Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>> for Matrix4<T>
source§impl<N, R, C> FiniteDimInnerSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Real,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> FiniteDimInnerSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Real,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<N, R, C>,
source§fn orthonormalize(
vs: &mut [Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>]
) -> usize
fn orthonormalize(
vs: &mut [Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>]
) -> usize
source§fn orthonormal_subspace_basis<F>(
vs: &[Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>],
f: F
)where
F: FnMut(&Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>) -> bool,
fn orthonormal_subspace_basis<F>(
vs: &[Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>],
f: F
)where
F: FnMut(&Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>) -> bool,
vs
. If vs
is not a free family, the result is
unspecified. Read moresource§impl<N, R, C> FiniteDimVectorSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + Field,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> FiniteDimVectorSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + Field,
DefaultAllocator: Allocator<N, R, C>,
source§fn canonical_basis_element(
i: usize
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn canonical_basis_element(
i: usize
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
source§fn dot(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> N
fn dot(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> N
source§unsafe fn component_unchecked(&self, i: usize) -> &N
unsafe fn component_unchecked(&self, i: usize) -> &N
&self[i]
but without bound-checking.source§unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut N
unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut N
&mut self[i]
but without bound-checking.source§impl<N> From<[[N; 2]; 2]> for Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U2>,
impl<N> From<[[N; 2]; 2]> for Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U2>,
source§impl<N> From<[[N; 2]; 3]> for Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U3>,
impl<N> From<[[N; 2]; 3]> for Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U3>,
source§impl<N> From<[[N; 2]; 4]> for Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U4>,
impl<N> From<[[N; 2]; 4]> for Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U4>,
source§impl<N> From<[[N; 2]; 5]> for Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U5>,
impl<N> From<[[N; 2]; 5]> for Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U5>,
source§impl<N> From<[[N; 2]; 6]> for Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U6>,
impl<N> From<[[N; 2]; 6]> for Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U6>,
source§impl<N> From<[[N; 3]; 2]> for Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U2>,
impl<N> From<[[N; 3]; 2]> for Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U2>,
source§impl<N> From<[[N; 3]; 3]> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U3>,
impl<N> From<[[N; 3]; 3]> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U3>,
source§impl<N> From<[[N; 3]; 4]> for Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U4>,
impl<N> From<[[N; 3]; 4]> for Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U4>,
source§impl<N> From<[[N; 3]; 5]> for Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U5>,
impl<N> From<[[N; 3]; 5]> for Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U5>,
source§impl<N> From<[[N; 3]; 6]> for Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U6>,
impl<N> From<[[N; 3]; 6]> for Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U6>,
source§impl<N> From<[[N; 4]; 2]> for Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U2>,
impl<N> From<[[N; 4]; 2]> for Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U2>,
source§impl<N> From<[[N; 4]; 3]> for Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U3>,
impl<N> From<[[N; 4]; 3]> for Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U3>,
source§impl<N> From<[[N; 4]; 4]> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U4>,
impl<N> From<[[N; 4]; 4]> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U4>,
source§impl<N> From<[[N; 4]; 5]> for Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U5>,
impl<N> From<[[N; 4]; 5]> for Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U5>,
source§impl<N> From<[[N; 4]; 6]> for Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U6>,
impl<N> From<[[N; 4]; 6]> for Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U6>,
source§impl<N> From<[[N; 5]; 2]> for Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U2>,
impl<N> From<[[N; 5]; 2]> for Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U2>,
source§impl<N> From<[[N; 5]; 3]> for Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U3>,
impl<N> From<[[N; 5]; 3]> for Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U3>,
source§impl<N> From<[[N; 5]; 4]> for Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U4>,
impl<N> From<[[N; 5]; 4]> for Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U4>,
source§impl<N> From<[[N; 5]; 5]> for Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U5>,
impl<N> From<[[N; 5]; 5]> for Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U5>,
source§impl<N> From<[[N; 5]; 6]> for Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U6>,
impl<N> From<[[N; 5]; 6]> for Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U6>,
source§impl<N> From<[[N; 6]; 2]> for Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U2>,
impl<N> From<[[N; 6]; 2]> for Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U2>,
source§impl<N> From<[[N; 6]; 3]> for Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U3>,
impl<N> From<[[N; 6]; 3]> for Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U3>,
source§impl<N> From<[[N; 6]; 4]> for Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U4>,
impl<N> From<[[N; 6]; 4]> for Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U4>,
source§impl<N> From<[[N; 6]; 5]> for Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U5>,
impl<N> From<[[N; 6]; 5]> for Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U5>,
source§impl<N> From<[[N; 6]; 6]> for Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U6>,
impl<N> From<[[N; 6]; 6]> for Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U6>,
source§impl<N> From<[N; 1]> for Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U1>,
impl<N> From<[N; 1]> for Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U1>,
source§impl<N> From<[N; 10]> for Matrix<N, U1, U10, <DefaultAllocator as Allocator<N, U1, U10>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U10>,
impl<N> From<[N; 10]> for Matrix<N, U1, U10, <DefaultAllocator as Allocator<N, U1, U10>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U10>,
source§impl<N> From<[N; 10]> for Matrix<N, U10, U1, <DefaultAllocator as Allocator<N, U10, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U10, U1>,
impl<N> From<[N; 10]> for Matrix<N, U10, U1, <DefaultAllocator as Allocator<N, U10, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U10, U1>,
source§impl<N> From<[N; 11]> for Matrix<N, U1, U11, <DefaultAllocator as Allocator<N, U1, U11>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U11>,
impl<N> From<[N; 11]> for Matrix<N, U1, U11, <DefaultAllocator as Allocator<N, U1, U11>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U11>,
source§impl<N> From<[N; 11]> for Matrix<N, U11, U1, <DefaultAllocator as Allocator<N, U11, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U11, U1>,
impl<N> From<[N; 11]> for Matrix<N, U11, U1, <DefaultAllocator as Allocator<N, U11, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U11, U1>,
source§impl<N> From<[N; 12]> for Matrix<N, U1, U12, <DefaultAllocator as Allocator<N, U1, U12>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U12>,
impl<N> From<[N; 12]> for Matrix<N, U1, U12, <DefaultAllocator as Allocator<N, U1, U12>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U12>,
source§impl<N> From<[N; 12]> for Matrix<N, U12, U1, <DefaultAllocator as Allocator<N, U12, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U12, U1>,
impl<N> From<[N; 12]> for Matrix<N, U12, U1, <DefaultAllocator as Allocator<N, U12, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U12, U1>,
source§impl<N> From<[N; 13]> for Matrix<N, U1, U13, <DefaultAllocator as Allocator<N, U1, U13>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U13>,
impl<N> From<[N; 13]> for Matrix<N, U1, U13, <DefaultAllocator as Allocator<N, U1, U13>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U13>,
source§impl<N> From<[N; 13]> for Matrix<N, U13, U1, <DefaultAllocator as Allocator<N, U13, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U13, U1>,
impl<N> From<[N; 13]> for Matrix<N, U13, U1, <DefaultAllocator as Allocator<N, U13, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U13, U1>,
source§impl<N> From<[N; 14]> for Matrix<N, U1, U14, <DefaultAllocator as Allocator<N, U1, U14>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U14>,
impl<N> From<[N; 14]> for Matrix<N, U1, U14, <DefaultAllocator as Allocator<N, U1, U14>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U14>,
source§impl<N> From<[N; 14]> for Matrix<N, U14, U1, <DefaultAllocator as Allocator<N, U14, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U14, U1>,
impl<N> From<[N; 14]> for Matrix<N, U14, U1, <DefaultAllocator as Allocator<N, U14, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U14, U1>,
source§impl<N> From<[N; 15]> for Matrix<N, U1, U15, <DefaultAllocator as Allocator<N, U1, U15>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U15>,
impl<N> From<[N; 15]> for Matrix<N, U1, U15, <DefaultAllocator as Allocator<N, U1, U15>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U15>,
source§impl<N> From<[N; 15]> for Matrix<N, U15, U1, <DefaultAllocator as Allocator<N, U15, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U15, U1>,
impl<N> From<[N; 15]> for Matrix<N, U15, U1, <DefaultAllocator as Allocator<N, U15, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U15, U1>,
source§impl<N> From<[N; 16]> for Matrix<N, U1, U16, <DefaultAllocator as Allocator<N, U1, U16>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U16>,
impl<N> From<[N; 16]> for Matrix<N, U1, U16, <DefaultAllocator as Allocator<N, U1, U16>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U16>,
source§impl<N> From<[N; 16]> for Matrix<N, U16, U1, <DefaultAllocator as Allocator<N, U16, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U16, U1>,
impl<N> From<[N; 16]> for Matrix<N, U16, U1, <DefaultAllocator as Allocator<N, U16, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U16, U1>,
source§impl<N> From<[N; 2]> for Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U2>,
impl<N> From<[N; 2]> for Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U2>,
source§impl<N> From<[N; 2]> for Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U1>,
impl<N> From<[N; 2]> for Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U1>,
source§impl<N> From<[N; 3]> for Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U3>,
impl<N> From<[N; 3]> for Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U3>,
source§impl<N> From<[N; 3]> for Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U1>,
impl<N> From<[N; 3]> for Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U1>,
source§impl<N> From<[N; 4]> for Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U4>,
impl<N> From<[N; 4]> for Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U4>,
source§impl<N> From<[N; 4]> for Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U1>,
impl<N> From<[N; 4]> for Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U1>,
source§impl<N> From<[N; 5]> for Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U5>,
impl<N> From<[N; 5]> for Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U5>,
source§impl<N> From<[N; 5]> for Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U1>,
impl<N> From<[N; 5]> for Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U1>,
source§impl<N> From<[N; 6]> for Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U6>,
impl<N> From<[N; 6]> for Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U6>,
source§impl<N> From<[N; 6]> for Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U1>,
impl<N> From<[N; 6]> for Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U1>,
source§impl<N> From<[N; 7]> for Matrix<N, U1, U7, <DefaultAllocator as Allocator<N, U1, U7>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U7>,
impl<N> From<[N; 7]> for Matrix<N, U1, U7, <DefaultAllocator as Allocator<N, U1, U7>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U7>,
source§impl<N> From<[N; 7]> for Matrix<N, U7, U1, <DefaultAllocator as Allocator<N, U7, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U7, U1>,
impl<N> From<[N; 7]> for Matrix<N, U7, U1, <DefaultAllocator as Allocator<N, U7, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U7, U1>,
source§impl<N> From<[N; 8]> for Matrix<N, U1, U8, <DefaultAllocator as Allocator<N, U1, U8>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U8>,
impl<N> From<[N; 8]> for Matrix<N, U1, U8, <DefaultAllocator as Allocator<N, U1, U8>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U8>,
source§impl<N> From<[N; 8]> for Matrix<N, U8, U1, <DefaultAllocator as Allocator<N, U8, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U8, U1>,
impl<N> From<[N; 8]> for Matrix<N, U8, U1, <DefaultAllocator as Allocator<N, U8, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U8, U1>,
source§impl<N> From<[N; 9]> for Matrix<N, U1, U9, <DefaultAllocator as Allocator<N, U1, U9>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U9>,
impl<N> From<[N; 9]> for Matrix<N, U1, U9, <DefaultAllocator as Allocator<N, U1, U9>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U9>,
source§impl<N> From<[N; 9]> for Matrix<N, U9, U1, <DefaultAllocator as Allocator<N, U9, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U9, U1>,
impl<N> From<[N; 9]> for Matrix<N, U9, U1, <DefaultAllocator as Allocator<N, U9, U1>>::Buffer>where
N: Scalar,
DefaultAllocator: Allocator<N, U9, U1>,
source§impl<N, D, R> From<Isometry<N, D, R>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
N: Real,
D: DimName + DimNameAdd<U1>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1>,
impl<N, D, R> From<Isometry<N, D, R>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
N: Real,
D: DimName + DimNameAdd<U1>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1>,
source§fn from(
iso: Isometry<N, D, R>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>
fn from(
iso: Isometry<N, D, R>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>
source§impl<N, D> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Point<N, D>where
N: Scalar,
D: DimName,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Point<N, D>where
N: Scalar,
D: DimName,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<N, D> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Translation<N, D>where
N: Scalar,
D: DimName,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Translation<N, D>where
N: Scalar,
D: DimName,
DefaultAllocator: Allocator<N, D, U1>,
source§fn from(
vector: Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Translation<N, D>
fn from(
vector: Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
) -> Translation<N, D>
source§impl<'a, N, C, RStride, CStride> From<Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, RStride, CStride>>> for Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>>where
N: Scalar,
C: Dim,
RStride: Dim,
CStride: Dim,
impl<'a, N, C, RStride, CStride> From<Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, RStride, CStride>>> for Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>>where
N: Scalar,
C: Dim,
RStride: Dim,
CStride: Dim,
source§impl<'a, N, C, RStride, CStride> From<Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, RStride, CStride>>> for Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>>where
N: Scalar,
C: Dim,
RStride: Dim,
CStride: Dim,
impl<'a, N, C, RStride, CStride> From<Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, RStride, CStride>>> for Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>>where
N: Scalar,
C: Dim,
RStride: Dim,
CStride: Dim,
source§impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>> for Matrix<N, R, C, ArrayStorage<N, R, C>>where
N: Scalar,
R: DimName,
C: DimName,
RStride: Dim,
CStride: Dim,
<R as DimName>::Value: Mul<<C as DimName>::Value>,
<<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>,
impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>> for Matrix<N, R, C, ArrayStorage<N, R, C>>where
N: Scalar,
R: DimName,
C: DimName,
RStride: Dim,
CStride: Dim,
<R as DimName>::Value: Mul<<C as DimName>::Value>,
<<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>,
source§fn from(
matrix_slice: Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>
) -> Matrix<N, R, C, ArrayStorage<N, R, C>>
fn from(
matrix_slice: Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>
) -> Matrix<N, R, C, ArrayStorage<N, R, C>>
source§impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>> for Matrix<N, R, C, ArrayStorage<N, R, C>>where
N: Scalar,
R: DimName,
C: DimName,
RStride: Dim,
CStride: Dim,
<R as DimName>::Value: Mul<<C as DimName>::Value>,
<<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>,
impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>> for Matrix<N, R, C, ArrayStorage<N, R, C>>where
N: Scalar,
R: DimName,
C: DimName,
RStride: Dim,
CStride: Dim,
<R as DimName>::Value: Mul<<C as DimName>::Value>,
<<R as DimName>::Value as Mul<<C as DimName>::Value>>::Output: ArrayLength<N>,
source§fn from(
matrix_slice: Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>
) -> Matrix<N, R, C, ArrayStorage<N, R, C>>
fn from(
matrix_slice: Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>
) -> Matrix<N, R, C, ArrayStorage<N, R, C>>
source§impl<'a, N, R, RStride, CStride> From<Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, RStride, CStride>>> for Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>>where
N: Scalar,
R: DimName,
RStride: Dim,
CStride: Dim,
impl<'a, N, R, RStride, CStride> From<Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, RStride, CStride>>> for Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>>where
N: Scalar,
R: DimName,
RStride: Dim,
CStride: Dim,
source§impl<'a, N, R, RStride, CStride> From<Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, RStride, CStride>>> for Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>>where
N: Scalar,
R: DimName,
RStride: Dim,
CStride: Dim,
impl<'a, N, R, RStride, CStride> From<Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, RStride, CStride>>> for Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>>where
N: Scalar,
R: DimName,
RStride: Dim,
CStride: Dim,
source§impl<N> From<Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>> for Quaternion<N>where
N: Real,
impl<N> From<Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>> for Quaternion<N>where
N: Real,
source§impl<N> From<Orthographic3<N>> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Real,
impl<N> From<Orthographic3<N>> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Real,
source§impl<N> From<Perspective3<N>> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Real,
impl<N> From<Perspective3<N>> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Real,
source§impl<N, D> From<Point<N, D>> for Matrix<N, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>where
N: Scalar + Zero + One,
D: DimName + DimNameAdd<U1>,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
impl<N, D> From<Point<N, D>> for Matrix<N, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>where
N: Scalar + Zero + One,
D: DimName + DimNameAdd<U1>,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
source§impl<N> From<Rotation<N, U2>> for Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>where
N: Real,
impl<N> From<Rotation<N, U2>> for Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>where
N: Real,
source§impl<N> From<Rotation<N, U2>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Real,
impl<N> From<Rotation<N, U2>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Real,
source§impl<N> From<Rotation<N, U3>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Real,
impl<N> From<Rotation<N, U3>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Real,
source§impl<N> From<Rotation<N, U3>> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Real,
impl<N> From<Rotation<N, U3>> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Real,
source§impl<N, D, R> From<Similarity<N, D, R>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
N: Real,
D: DimName + DimNameAdd<U1>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
impl<N, D, R> From<Similarity<N, D, R>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
N: Real,
D: DimName + DimNameAdd<U1>,
R: SubsetOf<Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>>,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
source§fn from(
sim: Similarity<N, D, R>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>
fn from(
sim: Similarity<N, D, R>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>
source§impl<N, D, C> From<Transform<N, D, C>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
N: Real,
D: DimName + DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
impl<N, D, C> From<Transform<N, D, C>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
N: Real,
D: DimName + DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
source§fn from(
t: Transform<N, D, C>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>
fn from(
t: Transform<N, D, C>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>
source§impl<N, D> From<Translation<N, D>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
N: Scalar + Zero + One,
D: DimName + DimNameAdd<U1>,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
impl<N, D> From<Translation<N, D>> for Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>where
N: Scalar + Zero + One,
D: DimName + DimNameAdd<U1>,
DefaultAllocator: Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
source§fn from(
t: Translation<N, D>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>
fn from(
t: Translation<N, D>
) -> Matrix<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>
source§impl<N> From<Unit<Complex<N>>> for Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>where
N: Real,
impl<N> From<Unit<Complex<N>>> for Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>where
N: Real,
source§impl<N> From<Unit<Complex<N>>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Real,
impl<N> From<Unit<Complex<N>>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Real,
source§impl<N> From<Unit<Quaternion<N>>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Real,
impl<N> From<Unit<Quaternion<N>>> for Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>where
N: Real,
source§impl<N> From<Unit<Quaternion<N>>> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Real,
impl<N> From<Unit<Quaternion<N>>> for Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>where
N: Real,
source§impl<N, R, C, S> Hash for Matrix<N, R, C, S>where
N: Scalar + Hash,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Hash for Matrix<N, R, C, S>where
N: Scalar + Hash,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
source§impl<N, R, C> Identity<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + Zero,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> Identity<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + Zero,
DefaultAllocator: Allocator<N, R, C>,
source§impl<N, D> Identity<Multiplicative> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> Identity<Multiplicative> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One,
DefaultAllocator: Allocator<N, D, D>,
source§impl<N, R, C, S> Index<(usize, usize)> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar,
S: Storage<N, R, C>,
impl<N, R, C, S> Index<(usize, usize)> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar,
S: Storage<N, R, C>,
source§impl<N, R, C, S> Index<usize> for Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Index<usize> for Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
source§impl<N, R, C, S> IndexMut<(usize, usize)> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar,
S: StorageMut<N, R, C>,
impl<N, R, C, S> IndexMut<(usize, usize)> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar,
S: StorageMut<N, R, C>,
source§impl<N, R, C, S> IndexMut<usize> for Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
impl<N, R, C, S> IndexMut<usize> for Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
source§impl<N, R, C> InnerSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Real,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> InnerSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Real,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<N, R, C>,
source§fn angle(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> N
fn angle(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> N
source§fn inner_product(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> N
fn inner_product(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> N
self
with other
.source§impl<N, S> Into<[[N; 2]; 2]> for Matrix<N, U2, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U2>,
impl<N, S> Into<[[N; 2]; 2]> for Matrix<N, U2, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U2>,
source§impl<N, S> Into<[[N; 2]; 3]> for Matrix<N, U2, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U3>,
impl<N, S> Into<[[N; 2]; 3]> for Matrix<N, U2, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U3>,
source§impl<N, S> Into<[[N; 2]; 4]> for Matrix<N, U2, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U4>,
impl<N, S> Into<[[N; 2]; 4]> for Matrix<N, U2, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U4>,
source§impl<N, S> Into<[[N; 2]; 5]> for Matrix<N, U2, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U5>,
impl<N, S> Into<[[N; 2]; 5]> for Matrix<N, U2, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U5>,
source§impl<N, S> Into<[[N; 2]; 6]> for Matrix<N, U2, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U6>,
impl<N, S> Into<[[N; 2]; 6]> for Matrix<N, U2, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U6>,
source§impl<N, S> Into<[[N; 3]; 2]> for Matrix<N, U3, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U2>,
impl<N, S> Into<[[N; 3]; 2]> for Matrix<N, U3, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U2>,
source§impl<N, S> Into<[[N; 3]; 3]> for Matrix<N, U3, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U3>,
impl<N, S> Into<[[N; 3]; 3]> for Matrix<N, U3, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U3>,
source§impl<N, S> Into<[[N; 3]; 4]> for Matrix<N, U3, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U4>,
impl<N, S> Into<[[N; 3]; 4]> for Matrix<N, U3, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U4>,
source§impl<N, S> Into<[[N; 3]; 5]> for Matrix<N, U3, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U5>,
impl<N, S> Into<[[N; 3]; 5]> for Matrix<N, U3, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U5>,
source§impl<N, S> Into<[[N; 3]; 6]> for Matrix<N, U3, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U6>,
impl<N, S> Into<[[N; 3]; 6]> for Matrix<N, U3, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U6>,
source§impl<N, S> Into<[[N; 4]; 2]> for Matrix<N, U4, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U2>,
impl<N, S> Into<[[N; 4]; 2]> for Matrix<N, U4, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U2>,
source§impl<N, S> Into<[[N; 4]; 3]> for Matrix<N, U4, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U3>,
impl<N, S> Into<[[N; 4]; 3]> for Matrix<N, U4, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U3>,
source§impl<N, S> Into<[[N; 4]; 4]> for Matrix<N, U4, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U4>,
impl<N, S> Into<[[N; 4]; 4]> for Matrix<N, U4, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U4>,
source§impl<N, S> Into<[[N; 4]; 5]> for Matrix<N, U4, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U5>,
impl<N, S> Into<[[N; 4]; 5]> for Matrix<N, U4, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U5>,
source§impl<N, S> Into<[[N; 4]; 6]> for Matrix<N, U4, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U6>,
impl<N, S> Into<[[N; 4]; 6]> for Matrix<N, U4, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U6>,
source§impl<N, S> Into<[[N; 5]; 2]> for Matrix<N, U5, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U2>,
impl<N, S> Into<[[N; 5]; 2]> for Matrix<N, U5, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U2>,
source§impl<N, S> Into<[[N; 5]; 3]> for Matrix<N, U5, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U3>,
impl<N, S> Into<[[N; 5]; 3]> for Matrix<N, U5, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U3>,
source§impl<N, S> Into<[[N; 5]; 4]> for Matrix<N, U5, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U4>,
impl<N, S> Into<[[N; 5]; 4]> for Matrix<N, U5, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U4>,
source§impl<N, S> Into<[[N; 5]; 5]> for Matrix<N, U5, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U5>,
impl<N, S> Into<[[N; 5]; 5]> for Matrix<N, U5, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U5>,
source§impl<N, S> Into<[[N; 5]; 6]> for Matrix<N, U5, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U6>,
impl<N, S> Into<[[N; 5]; 6]> for Matrix<N, U5, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U6>,
source§impl<N, S> Into<[[N; 6]; 2]> for Matrix<N, U6, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U2>,
impl<N, S> Into<[[N; 6]; 2]> for Matrix<N, U6, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U2>,
source§impl<N, S> Into<[[N; 6]; 3]> for Matrix<N, U6, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U3>,
impl<N, S> Into<[[N; 6]; 3]> for Matrix<N, U6, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U3>,
source§impl<N, S> Into<[[N; 6]; 4]> for Matrix<N, U6, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U4>,
impl<N, S> Into<[[N; 6]; 4]> for Matrix<N, U6, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U4>,
source§impl<N, S> Into<[[N; 6]; 5]> for Matrix<N, U6, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U5>,
impl<N, S> Into<[[N; 6]; 5]> for Matrix<N, U6, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U5>,
source§impl<N, S> Into<[[N; 6]; 6]> for Matrix<N, U6, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U6>,
impl<N, S> Into<[[N; 6]; 6]> for Matrix<N, U6, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U6>,
source§impl<N, S> Into<[N; 1]> for Matrix<N, U1, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U1>,
impl<N, S> Into<[N; 1]> for Matrix<N, U1, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U1>,
source§impl<N, S> Into<[N; 10]> for Matrix<N, U1, U10, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U10>,
impl<N, S> Into<[N; 10]> for Matrix<N, U1, U10, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U10>,
source§impl<N, S> Into<[N; 10]> for Matrix<N, U10, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U10, U1>,
impl<N, S> Into<[N; 10]> for Matrix<N, U10, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U10, U1>,
source§impl<N, S> Into<[N; 11]> for Matrix<N, U1, U11, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U11>,
impl<N, S> Into<[N; 11]> for Matrix<N, U1, U11, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U11>,
source§impl<N, S> Into<[N; 11]> for Matrix<N, U11, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U11, U1>,
impl<N, S> Into<[N; 11]> for Matrix<N, U11, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U11, U1>,
source§impl<N, S> Into<[N; 12]> for Matrix<N, U1, U12, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U12>,
impl<N, S> Into<[N; 12]> for Matrix<N, U1, U12, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U12>,
source§impl<N, S> Into<[N; 12]> for Matrix<N, U12, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U12, U1>,
impl<N, S> Into<[N; 12]> for Matrix<N, U12, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U12, U1>,
source§impl<N, S> Into<[N; 13]> for Matrix<N, U1, U13, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U13>,
impl<N, S> Into<[N; 13]> for Matrix<N, U1, U13, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U13>,
source§impl<N, S> Into<[N; 13]> for Matrix<N, U13, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U13, U1>,
impl<N, S> Into<[N; 13]> for Matrix<N, U13, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U13, U1>,
source§impl<N, S> Into<[N; 14]> for Matrix<N, U1, U14, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U14>,
impl<N, S> Into<[N; 14]> for Matrix<N, U1, U14, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U14>,
source§impl<N, S> Into<[N; 14]> for Matrix<N, U14, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U14, U1>,
impl<N, S> Into<[N; 14]> for Matrix<N, U14, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U14, U1>,
source§impl<N, S> Into<[N; 15]> for Matrix<N, U1, U15, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U15>,
impl<N, S> Into<[N; 15]> for Matrix<N, U1, U15, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U15>,
source§impl<N, S> Into<[N; 15]> for Matrix<N, U15, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U15, U1>,
impl<N, S> Into<[N; 15]> for Matrix<N, U15, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U15, U1>,
source§impl<N, S> Into<[N; 16]> for Matrix<N, U1, U16, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U16>,
impl<N, S> Into<[N; 16]> for Matrix<N, U1, U16, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U16>,
source§impl<N, S> Into<[N; 16]> for Matrix<N, U16, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U16, U1>,
impl<N, S> Into<[N; 16]> for Matrix<N, U16, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U16, U1>,
source§impl<N, S> Into<[N; 2]> for Matrix<N, U1, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U2>,
impl<N, S> Into<[N; 2]> for Matrix<N, U1, U2, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U2>,
source§impl<N, S> Into<[N; 2]> for Matrix<N, U2, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U1>,
impl<N, S> Into<[N; 2]> for Matrix<N, U2, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U2, U1>,
source§impl<N, S> Into<[N; 3]> for Matrix<N, U1, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U3>,
impl<N, S> Into<[N; 3]> for Matrix<N, U1, U3, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U3>,
source§impl<N, S> Into<[N; 3]> for Matrix<N, U3, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U1>,
impl<N, S> Into<[N; 3]> for Matrix<N, U3, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U3, U1>,
source§impl<N, S> Into<[N; 4]> for Matrix<N, U1, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U4>,
impl<N, S> Into<[N; 4]> for Matrix<N, U1, U4, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U4>,
source§impl<N, S> Into<[N; 4]> for Matrix<N, U4, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U1>,
impl<N, S> Into<[N; 4]> for Matrix<N, U4, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U4, U1>,
source§impl<N, S> Into<[N; 5]> for Matrix<N, U1, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U5>,
impl<N, S> Into<[N; 5]> for Matrix<N, U1, U5, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U5>,
source§impl<N, S> Into<[N; 5]> for Matrix<N, U5, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U1>,
impl<N, S> Into<[N; 5]> for Matrix<N, U5, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U5, U1>,
source§impl<N, S> Into<[N; 6]> for Matrix<N, U1, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U6>,
impl<N, S> Into<[N; 6]> for Matrix<N, U1, U6, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U6>,
source§impl<N, S> Into<[N; 6]> for Matrix<N, U6, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U1>,
impl<N, S> Into<[N; 6]> for Matrix<N, U6, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U6, U1>,
source§impl<N, S> Into<[N; 7]> for Matrix<N, U1, U7, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U7>,
impl<N, S> Into<[N; 7]> for Matrix<N, U1, U7, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U7>,
source§impl<N, S> Into<[N; 7]> for Matrix<N, U7, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U7, U1>,
impl<N, S> Into<[N; 7]> for Matrix<N, U7, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U7, U1>,
source§impl<N, S> Into<[N; 8]> for Matrix<N, U1, U8, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U8>,
impl<N, S> Into<[N; 8]> for Matrix<N, U1, U8, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U8>,
source§impl<N, S> Into<[N; 8]> for Matrix<N, U8, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U8, U1>,
impl<N, S> Into<[N; 8]> for Matrix<N, U8, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U8, U1>,
source§impl<N, S> Into<[N; 9]> for Matrix<N, U1, U9, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U9>,
impl<N, S> Into<[N; 9]> for Matrix<N, U1, U9, S>where
N: Scalar,
S: ContiguousStorage<N, U1, U9>,
source§impl<N, S> Into<[N; 9]> for Matrix<N, U9, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U9, U1>,
impl<N, S> Into<[N; 9]> for Matrix<N, U9, U1, S>where
N: Scalar,
S: ContiguousStorage<N, U9, U1>,
source§impl<'a, N, R, C, S> IntoIterator for &'a Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
impl<'a, N, R, C, S> IntoIterator for &'a Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
source§impl<'a, N, R, C, S> IntoIterator for &'a mut Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
impl<'a, N, R, C, S> IntoIterator for &'a mut Matrix<N, R, C, S>where
N: Scalar,
R: Dim,
C: Dim,
S: StorageMut<N, R, C>,
source§impl<'a, T: Scalar> IntoVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for &'a [T]
impl<'a, T: Scalar> IntoVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for &'a [T]
source§impl<T: Scalar> IntoVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for [T; 2]
impl<T: Scalar> IntoVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for [T; 2]
source§impl<T: Scalar> IntoVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for T
impl<T: Scalar> IntoVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for T
source§impl<'a, T: Scalar> IntoVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for &'a [T]
impl<'a, T: Scalar> IntoVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for &'a [T]
source§impl<T: Scalar> IntoVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for [T; 3]
impl<T: Scalar> IntoVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for [T; 3]
source§impl<T: Scalar> IntoVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for T
impl<T: Scalar> IntoVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for T
source§impl<'a, T: Scalar> IntoVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for &'a [T]
impl<'a, T: Scalar> IntoVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for &'a [T]
source§impl<T: Scalar> IntoVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for [T; 4]
impl<T: Scalar> IntoVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for [T; 4]
source§impl<T: Scalar> IntoVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for T
impl<T: Scalar> IntoVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for T
source§impl<N, R, C> Inverse<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + ClosedNeg,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> Inverse<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + ClosedNeg,
DefaultAllocator: Allocator<N, R, C>,
source§fn inverse(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn inverse(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
self
, relative to the operator O
.source§fn inverse_mut(&mut self)
fn inverse_mut(&mut self)
self
.source§impl<N, R, C> JoinSemilattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: Dim,
C: Dim,
N: Scalar + JoinSemilattice,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> JoinSemilattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: Dim,
C: Dim,
N: Scalar + JoinSemilattice,
DefaultAllocator: Allocator<N, R, C>,
source§impl<'a, T, S> JoinVec<T, Matrix<T, U2, U1, S>> for Vector<T, U2, S>where
T: BaseNum,
S: Storage<T, U2, U1>,
impl<'a, T, S> JoinVec<T, Matrix<T, U2, U1, S>> for Vector<T, U2, S>where
T: BaseNum,
S: Storage<T, U2, U1>,
source§impl<'a, T, S1, S2> JoinVec<T, Matrix<T, U2, U1, S2>> for Vector<T, U1, S1>where
T: BaseNum,
S1: Storage<T, U1, U1>,
S2: Storage<T, U2, U1>,
impl<'a, T, S1, S2> JoinVec<T, Matrix<T, U2, U1, S2>> for Vector<T, U1, S1>where
T: BaseNum,
S1: Storage<T, U1, U1>,
S2: Storage<T, U2, U1>,
source§impl<'a, T, S1, S3> JoinVec<T, Matrix<T, U3, U1, S3>> for Matrix<T, U1, U1, S1>where
T: BaseNum,
S1: Storage<T, U1, U1>,
S3: Storage<T, U3, U1>,
impl<'a, T, S1, S3> JoinVec<T, Matrix<T, U3, U1, S3>> for Matrix<T, U1, U1, S1>where
T: BaseNum,
S1: Storage<T, U1, U1>,
S3: Storage<T, U3, U1>,
source§impl<'a, T, S> JoinVec<T, T> for Matrix<T, U1, U1, S>where
T: BaseNum,
S: Storage<T, U1, U1>,
impl<'a, T, S> JoinVec<T, T> for Matrix<T, U1, U1, S>where
T: BaseNum,
S: Storage<T, U1, U1>,
source§impl<'a, T, S> JoinVec<T, T> for Matrix<T, U2, U1, S>where
T: BaseNum,
S: Storage<T, U2, U1>,
impl<'a, T, S> JoinVec<T, T> for Matrix<T, U2, U1, S>where
T: BaseNum,
S: Storage<T, U2, U1>,
source§impl<N, R, C> Lattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: Dim,
C: Dim,
N: Scalar + Lattice,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> Lattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: Dim,
C: Dim,
N: Scalar + Lattice,
DefaultAllocator: Allocator<N, R, C>,
source§fn meet_join(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> (Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>, Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>)
fn meet_join(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> (Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>, Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>)
source§fn partial_min<'a>(&'a self, other: &'a Self) -> Option<&'a Self>
fn partial_min<'a>(&'a self, other: &'a Self) -> Option<&'a Self>
self
and other
if they are comparable.source§fn partial_max<'a>(&'a self, other: &'a Self) -> Option<&'a Self>
fn partial_max<'a>(&'a self, other: &'a Self) -> Option<&'a Self>
self
and other
if they are comparable.source§impl<N, R, C> MeetSemilattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: Dim,
C: Dim,
N: Scalar + MeetSemilattice,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> MeetSemilattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: Dim,
C: Dim,
N: Scalar + MeetSemilattice,
DefaultAllocator: Allocator<N, R, C>,
source§impl<N, R, C> Module for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + RingCommutative,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> Module for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + RingCommutative,
DefaultAllocator: Allocator<N, R, C>,
source§impl<'a, 'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, 'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, 'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, 'b, N, D, C> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
impl<'a, 'b, N, D, C> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
source§impl<'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'b, N, D, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'b, N, D, C> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
impl<'b, N, D, C> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
source§impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
source§impl<'a, 'b, N, D1, R2, C2, SB> Mul<&'b Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1>where
D1: DimName,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
impl<'a, 'b, N, D1, R2, C2, SB> Mul<&'b Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1>where
D1: DimName,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
source§impl<'b, N, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'b, N, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
source§impl<'b, N, D1, R2, C2, SB> Mul<&'b Matrix<N, R2, C2, SB>> for Rotation<N, D1>where
D1: DimName,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
impl<'b, N, D1, R2, C2, SB> Mul<&'b Matrix<N, R2, C2, SB>> for Rotation<N, D1>where
D1: DimName,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
source§impl<'a, 'b, N, S> Mul<&'b Matrix<N, U2, U1, S>> for &'a Unit<Complex<N>>where
N: Real,
S: Storage<N, U2, U1>,
DefaultAllocator: Allocator<N, U2, U1>,
impl<'a, 'b, N, S> Mul<&'b Matrix<N, U2, U1, S>> for &'a Unit<Complex<N>>where
N: Real,
S: Storage<N, U2, U1>,
DefaultAllocator: Allocator<N, U2, U1>,
source§impl<'b, N, S> Mul<&'b Matrix<N, U2, U1, S>> for Unit<Complex<N>>where
N: Real,
S: Storage<N, U2, U1>,
DefaultAllocator: Allocator<N, U2, U1>,
impl<'b, N, S> Mul<&'b Matrix<N, U2, U1, S>> for Unit<Complex<N>>where
N: Real,
S: Storage<N, U2, U1>,
DefaultAllocator: Allocator<N, U2, U1>,
source§impl<'a, 'b, N, SB> Mul<&'b Matrix<N, U3, U1, SB>> for &'a Unit<Quaternion<N>>where
N: Real,
SB: Storage<N, U3, U1>,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'a, 'b, N, SB> Mul<&'b Matrix<N, U3, U1, SB>> for &'a Unit<Quaternion<N>>where
N: Real,
SB: Storage<N, U3, U1>,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<'b, N, SB> Mul<&'b Matrix<N, U3, U1, SB>> for Unit<Quaternion<N>>where
N: Real,
SB: Storage<N, U3, U1>,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'b, N, SB> Mul<&'b Matrix<N, U3, U1, SB>> for Unit<Quaternion<N>>where
N: Real,
SB: Storage<N, U3, U1>,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<'a, 'b, N, R1, C1, D2, SA> Mul<&'b Point<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: DimName,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
impl<'a, 'b, N, R1, C1, D2, SA> Mul<&'b Point<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: DimName,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
source§impl<'b, N, R1, C1, D2, SA> Mul<&'b Point<N, D2>> for Matrix<N, R1, C1, SA>where
R1: DimName,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
impl<'b, N, R1, C1, D2, SA> Mul<&'b Point<N, D2>> for Matrix<N, R1, C1, SA>where
R1: DimName,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
source§impl<'a, 'b, N, R1, C1, D2, SA> Mul<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
impl<'a, 'b, N, R1, C1, D2, SA> Mul<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
source§impl<'b, N, R1, C1, D2, SA> Mul<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
impl<'b, N, R1, C1, D2, SA> Mul<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
source§impl<'a, N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<'a, N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<'a, N, D, C> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
impl<'a, N, D, C> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
source§impl<N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Isometry<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
impl<N, D, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R>where
N: Real,
D: DimName,
R: Rotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D, U1>,
source§impl<N, D, C> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
impl<N, D, C> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Transform<N, D, C>where
D: DimNameAdd<U1>,
C: TCategory,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + Real,
DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N, D, U1> + Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,
source§impl<'a, N, R1, C1, R2, C2, SA, SB> Mul<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'a, N, R1, C1, R2, C2, SA, SB> Mul<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
source§impl<'a, N, D1, R2, C2, SB> Mul<Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1>where
D1: DimName,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
impl<'a, N, D1, R2, C2, SB> Mul<Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1>where
D1: DimName,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
source§impl<N, R1, C1, R2, C2, SA, SB> Mul<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<N, R1, C1, R2, C2, SA, SB> Mul<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
source§impl<N, D1, R2, C2, SB> Mul<Matrix<N, R2, C2, SB>> for Rotation<N, D1>where
D1: DimName,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
impl<N, D1, R2, C2, SB> Mul<Matrix<N, R2, C2, SB>> for Rotation<N, D1>where
D1: DimName,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
source§impl<'a, N, S> Mul<Matrix<N, U2, U1, S>> for &'a Unit<Complex<N>>where
N: Real,
S: Storage<N, U2, U1>,
DefaultAllocator: Allocator<N, U2, U1>,
impl<'a, N, S> Mul<Matrix<N, U2, U1, S>> for &'a Unit<Complex<N>>where
N: Real,
S: Storage<N, U2, U1>,
DefaultAllocator: Allocator<N, U2, U1>,
source§impl<N, S> Mul<Matrix<N, U2, U1, S>> for Unit<Complex<N>>where
N: Real,
S: Storage<N, U2, U1>,
DefaultAllocator: Allocator<N, U2, U1>,
impl<N, S> Mul<Matrix<N, U2, U1, S>> for Unit<Complex<N>>where
N: Real,
S: Storage<N, U2, U1>,
DefaultAllocator: Allocator<N, U2, U1>,
source§impl<'a, N, SB> Mul<Matrix<N, U3, U1, SB>> for &'a Unit<Quaternion<N>>where
N: Real,
SB: Storage<N, U3, U1>,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<'a, N, SB> Mul<Matrix<N, U3, U1, SB>> for &'a Unit<Quaternion<N>>where
N: Real,
SB: Storage<N, U3, U1>,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<N, SB> Mul<Matrix<N, U3, U1, SB>> for Unit<Quaternion<N>>where
N: Real,
SB: Storage<N, U3, U1>,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
impl<N, SB> Mul<Matrix<N, U3, U1, SB>> for Unit<Quaternion<N>>where
N: Real,
SB: Storage<N, U3, U1>,
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
source§impl<'a, N, R, C, S> Mul<N> for &'a Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedMul<N>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
impl<'a, N, R, C, S> Mul<N> for &'a Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedMul<N>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
source§impl<N, R, C, S> Mul<N> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedMul<N>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C, S> Mul<N> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedMul<N>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
source§impl<'a, N, R1, C1, D2, SA> Mul<Point<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: DimName,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
impl<'a, N, R1, C1, D2, SA> Mul<Point<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: DimName,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
source§impl<N, R1, C1, D2, SA> Mul<Point<N, D2>> for Matrix<N, R1, C1, SA>where
R1: DimName,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
impl<N, R1, C1, D2, SA> Mul<Point<N, D2>> for Matrix<N, R1, C1, SA>where
R1: DimName,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
source§impl<'a, N, R1, C1, D2, SA> Mul<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
impl<'a, N, R1, C1, D2, SA> Mul<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
source§impl<N, R1, C1, D2, SA> Mul<Rotation<N, D2>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
impl<N, R1, C1, D2, SA> Mul<Rotation<N, D2>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
D2: DimName,
SA: Storage<N, R1, C1>,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
source§impl<'b, N, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SB: Storage<N, R2, C1>,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,
impl<'b, N, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SB: Storage<N, R2, C1>,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,
source§fn mul_assign(&mut self, rhs: &'b Matrix<N, R2, C1, SB>)
fn mul_assign(&mut self, rhs: &'b Matrix<N, R2, C1, SB>)
*=
operation. Read moresource§impl<'b, N, R1, C1> MulAssign<&'b Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer>where
R1: DimName,
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,
impl<'b, N, R1, C1> MulAssign<&'b Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer>where
R1: DimName,
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,
source§fn mul_assign(&mut self, right: &'b Rotation<N, C1>)
fn mul_assign(&mut self, right: &'b Rotation<N, C1>)
*=
operation. Read moresource§impl<N, R1, C1, R2, SA, SB> MulAssign<Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SB: Storage<N, R2, C1>,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,
impl<N, R1, C1, R2, SA, SB> MulAssign<Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
SB: Storage<N, R2, C1>,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,
source§fn mul_assign(&mut self, rhs: Matrix<N, R2, C1, SB>)
fn mul_assign(&mut self, rhs: Matrix<N, R2, C1, SB>)
*=
operation. Read moresource§impl<N, R, C, S> MulAssign<N> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedMul<N>,
S: StorageMut<N, R, C>,
impl<N, R, C, S> MulAssign<N> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedMul<N>,
S: StorageMut<N, R, C>,
source§fn mul_assign(&mut self, rhs: N)
fn mul_assign(&mut self, rhs: N)
*=
operation. Read moresource§impl<N, R1, C1> MulAssign<Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer>where
R1: DimName,
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,
impl<N, R1, C1> MulAssign<Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer>where
R1: DimName,
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>,
source§fn mul_assign(&mut self, right: Rotation<N, C1>)
fn mul_assign(&mut self, right: Rotation<N, C1>)
*=
operation. Read moresource§impl<'a, N, R, C, S> Neg for &'a Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedNeg,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
impl<'a, N, R, C, S> Neg for &'a Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedNeg,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
source§impl<N, R, C, S> Neg for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedNeg,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C, S> Neg for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + ClosedNeg,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
source§impl<N, R, C> NormedSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Real,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> NormedSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
N: Real,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<N, R, C>,
source§fn norm_squared(&self) -> N
fn norm_squared(&self) -> N
source§fn normalize(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn normalize(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
source§fn normalize_mut(&mut self) -> N
fn normalize_mut(&mut self) -> N
source§fn try_normalize(
&self,
min_norm: N
) -> Option<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>>
fn try_normalize(
&self,
min_norm: N
) -> Option<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>>
eps
.source§fn try_normalize_mut(&mut self, min_norm: N) -> Option<N>
fn try_normalize_mut(&mut self, min_norm: N) -> Option<N>
eps
. Read moresource§impl<N, D> One for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> One for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D, D>,
source§impl<N, R, C, S> PartialEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar,
S: Storage<N, R, C>,
impl<N, R, C, S> PartialEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar,
S: Storage<N, R, C>,
source§impl<N, R, C, S> PartialOrd<Matrix<N, R, C, S>> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + PartialOrd<N>,
S: Storage<N, R, C>,
impl<N, R, C, S> PartialOrd<Matrix<N, R, C, S>> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + PartialOrd<N>,
S: Storage<N, R, C>,
source§fn le(&self, right: &Matrix<N, R, C, S>) -> bool
fn le(&self, right: &Matrix<N, R, C, S>) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, N, D> Product<&'a Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D, D>,
impl<'a, N, D> Product<&'a Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D, D>,
source§impl<N, D> Product<Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D, D>,
impl<N, D> Product<Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D, D>,
source§impl<N, R, C, S> RelativeEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + RelativeEq<N>,
S: Storage<N, R, C>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
impl<N, R, C, S> RelativeEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + RelativeEq<N>,
S: Storage<N, R, C>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
source§fn default_max_relative(
) -> <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon
fn default_max_relative(
) -> <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon
source§fn relative_eq(
&self,
other: &Matrix<N, R, C, S>,
epsilon: <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon,
max_relative: <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon
) -> bool
fn relative_eq(
&self,
other: &Matrix<N, R, C, S>,
epsilon: <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon,
max_relative: <Matrix<N, R, C, S> as AbsDiffEq<Matrix<N, R, C, S>>>::Epsilon
) -> bool
§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
ApproxEq::relative_eq
.source§impl<'a, 'b, N, D1, D2, SB> Sub<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedSub<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
impl<'a, 'b, N, D1, D2, SB> Sub<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedSub<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
source§impl<'b, N, D1, D2, SB> Sub<&'b Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedSub<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
impl<'b, N, D1, D2, SB> Sub<&'b Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedSub<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
source§impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
-
operator.source§impl<'b, N, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<'b, N, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
-
operator.source§impl<'a, N, D1, D2, SB> Sub<Matrix<N, D2, U1, SB>> for &'a Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedSub<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
impl<'a, N, D1, D2, SB> Sub<Matrix<N, D2, U1, SB>> for &'a Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedSub<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
source§impl<N, D1, D2, SB> Sub<Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedSub<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
impl<N, D1, D2, SB> Sub<Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
SB: Storage<N, D2, U1>,
N: Scalar + ClosedSub<N>,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
source§impl<'a, N, R1, C1, R2, C2, SA, SB> Sub<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,
impl<'a, N, R1, C1, R2, C2, SA, SB> Sub<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,
§type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer>
type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer>
-
operator.source§impl<N, R1, C1, R2, C2, SA, SB> Sub<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<N, R1, C1, R2, C2, SA, SB> Sub<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
-
operator.source§impl<'b, N, D1, D2, SB> SubAssign<&'b Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
N: Scalar + ClosedSub<N>,
SB: Storage<N, D2, U1>,
DefaultAllocator: Allocator<N, D1, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
impl<'b, N, D1, D2, SB> SubAssign<&'b Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
N: Scalar + ClosedSub<N>,
SB: Storage<N, D2, U1>,
DefaultAllocator: Allocator<N, D1, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
source§impl<'b, N, R1, C1, R2, C2, SA, SB> SubAssign<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<'b, N, R1, C1, R2, C2, SA, SB> SubAssign<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
source§fn sub_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>)
fn sub_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>)
-=
operation. Read moresource§impl<N, D1, D2, SB> SubAssign<Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
N: Scalar + ClosedSub<N>,
SB: Storage<N, D2, U1>,
DefaultAllocator: Allocator<N, D1, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
impl<N, D1, D2, SB> SubAssign<Matrix<N, D2, U1, SB>> for Point<N, D1>where
D1: DimName,
D2: Dim,
N: Scalar + ClosedSub<N>,
SB: Storage<N, D2, U1>,
DefaultAllocator: Allocator<N, D1, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
source§impl<N, R1, C1, R2, C2, SA, SB> SubAssign<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<N, R1, C1, R2, C2, SA, SB> SubAssign<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
source§fn sub_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)
fn sub_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)
-=
operation. Read moresource§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
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<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>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N1, D, D> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<(usize, usize), D, U1> + Allocator<N2, D, D> + Allocator<N2, D, U1>,
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
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<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>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N1, D, D> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<(usize, usize), D, U1> + Allocator<N2, D, D> + Allocator<N2, D, U1>,
source§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>
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>
self
to the equivalent element of its superset.source§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
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
element
is actually part of the subset Self
(and can be converted to it).source§unsafe 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>
unsafe 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>
self.to_superset
but without any property checks. Always succeeds.source§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
N1: Real,
N2: Real + SupersetOf<N1>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D, D> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<(usize, usize), D, U1>,
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
N1: Real,
N2: Real + SupersetOf<N1>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D, D> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<(usize, usize), D, U1>,
source§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>
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>
self
to the equivalent element of its superset.source§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
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
element
is actually part of the subset Self
(and can be converted to it).source§unsafe 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>
unsafe 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>
self.to_superset
but without any property checks. Always succeeds.source§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
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<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>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N1, D, D> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<(usize, usize), D, U1> + Allocator<N2, D, D> + Allocator<N2, D, U1>,
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
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<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>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N1, D, D> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<(usize, usize), D, U1> + Allocator<N2, D, D> + Allocator<N2, D, U1>,
source§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>
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>
self
to the equivalent element of its superset.source§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
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
element
is actually part of the subset Self
(and can be converted to it).source§unsafe 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>
unsafe 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>
self.to_superset
but without any property checks. Always succeeds.source§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
D: DimName + DimNameAdd<U1>,
N1: Real + SubsetOf<N2>,
N2: Real,
C: TCategory,
DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
<N1 as AbsDiffEq<N1>>::Epsilon: Copy,
<N2 as AbsDiffEq<N2>>::Epsilon: Copy,
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
D: DimName + DimNameAdd<U1>,
N1: Real + SubsetOf<N2>,
N2: Real,
C: TCategory,
DefaultAllocator: Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
<N1 as AbsDiffEq<N1>>::Epsilon: Copy,
<N2 as AbsDiffEq<N2>>::Epsilon: Copy,
source§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>
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>
self
to the equivalent element of its superset.source§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
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
element
is actually part of the subset Self
(and can be converted to it).source§unsafe 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>
unsafe 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>
self.to_superset
but without any property checks. Always succeeds.source§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
N1: Real,
N2: Real + SupersetOf<N1>,
D: DimNameAdd<U1>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N2, D, U1> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
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
N1: Real,
N2: Real + SupersetOf<N1>,
D: DimNameAdd<U1>,
DefaultAllocator: Allocator<N1, D, U1> + Allocator<N2, D, U1> + Allocator<N1, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output> + Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>,
source§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>
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>
self
to the equivalent element of its superset.source§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
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
element
is actually part of the subset Self
(and can be converted to it).source§unsafe 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>
unsafe 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>
self.to_superset
but without any property checks. Always succeeds.source§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> + Allocator<N1, <D as DimNameAdd<U1>>::Output, U1> + Allocator<N2, <D as DimNameAdd<U1>>::Output, U1> + Allocator<N2, D, U1>,
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> + Allocator<N1, <D as DimNameAdd<U1>>::Output, U1> + Allocator<N2, <D as DimNameAdd<U1>>::Output, U1> + Allocator<N2, D, U1>,
source§fn to_superset(
&self
) -> Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>
fn to_superset(
&self
) -> Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>
self
to the equivalent element of its superset.source§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
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
element
is actually part of the subset Self
(and can be converted to it).source§unsafe 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>
unsafe 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>
self.to_superset
but without any property checks. Always succeeds.source§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
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N1: Scalar,
N2: Scalar + SupersetOf<N1>,
DefaultAllocator: Allocator<N2, R2, C2> + Allocator<N1, R1, C1> + SameShapeAllocator<N1, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
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
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N1: Scalar,
N2: Scalar + SupersetOf<N1>,
DefaultAllocator: Allocator<N2, R2, C2> + Allocator<N1, R1, C1> + SameShapeAllocator<N1, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
source§fn to_superset(
&self
) -> Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>
fn to_superset(
&self
) -> Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>
self
to the equivalent element of its superset.source§fn is_in_subset(
m: &Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>
) -> bool
fn is_in_subset(
m: &Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>
) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe 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>
unsafe 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>
self.to_superset
but without any property checks. Always succeeds.source§impl<N1, N2> SubsetOf<Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer>> for Unit<Complex<N1>>where
N1: Real,
N2: Real + SupersetOf<N1>,
impl<N1, N2> SubsetOf<Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer>> for Unit<Complex<N1>>where
N1: Real,
N2: Real + SupersetOf<N1>,
source§fn to_superset(
&self
) -> Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer>
fn to_superset(
&self
) -> Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer>
self
to the equivalent element of its superset.source§fn is_in_subset(
m: &Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer>
) -> bool
fn is_in_subset(
m: &Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer>
) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§impl<N1, N2> SubsetOf<Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>> for Unit<Quaternion<N1>>where
N1: Real,
N2: Real + SupersetOf<N1>,
impl<N1, N2> SubsetOf<Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>> for Unit<Quaternion<N1>>where
N1: Real,
N2: Real + SupersetOf<N1>,
source§fn to_superset(
&self
) -> Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>
fn to_superset(
&self
) -> Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>
self
to the equivalent element of its superset.source§fn is_in_subset(
m: &Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>
) -> bool
fn is_in_subset(
m: &Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>
) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§unsafe fn from_superset_unchecked(
m: &Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>
) -> Unit<Quaternion<N1>>
unsafe fn from_superset_unchecked(
m: &Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>
) -> Unit<Quaternion<N1>>
self.to_superset
but without any property checks. Always succeeds.source§impl<'a, N, R, C> Sum<&'a Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + ClosedAdd<N> + Zero,
DefaultAllocator: Allocator<N, R, C>,
impl<'a, N, R, C> Sum<&'a Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + ClosedAdd<N> + Zero,
DefaultAllocator: Allocator<N, R, C>,
source§impl<N, R, C> Sum<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + ClosedAdd<N> + Zero,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> Sum<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + ClosedAdd<N> + Zero,
DefaultAllocator: Allocator<N, R, C>,
source§impl<T: Real> ToMat<Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>> for Orthographic3<T>
impl<T: Real> ToMat<Matrix<T, U4, U4, <DefaultAllocator as Allocator<T, U4, U4>>::Buffer>> for Orthographic3<T>
source§impl<T: Real> ToVec<Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>> for Point1<T>
impl<T: Real> ToVec<Matrix<T, U1, U1, <DefaultAllocator as Allocator<T, U1, U1>>::Buffer>> for Point1<T>
source§impl<T: Real> ToVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Point2<T>
impl<T: Real> ToVec<Matrix<T, U2, U1, <DefaultAllocator as Allocator<T, U2, U1>>::Buffer>> for Point2<T>
source§impl<T: Real> ToVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Point3<T>
impl<T: Real> ToVec<Matrix<T, U3, U1, <DefaultAllocator as Allocator<T, U3, U1>>::Buffer>> for Point3<T>
source§impl<T: Real> ToVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Point4<T>
impl<T: Real> ToVec<Matrix<T, U4, U1, <DefaultAllocator as Allocator<T, U4, U1>>::Buffer>> for Point4<T>
source§impl<T: Real> ToVec<Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>> for Point5<T>
impl<T: Real> ToVec<Matrix<T, U5, U1, <DefaultAllocator as Allocator<T, U5, U1>>::Buffer>> for Point5<T>
source§impl<T: Real> ToVec<Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>> for Point6<T>
impl<T: Real> ToVec<Matrix<T, U6, U1, <DefaultAllocator as Allocator<T, U6, U1>>::Buffer>> for Point6<T>
source§impl<N, D> Transformation<Point<N, <D as DimNameSub<U1>>::Output>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
N: Real,
D: DimNameSub<U1>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, <D as DimNameSub<U1>>::Output, U1> + Allocator<N, <D as DimNameSub<U1>>::Output, <D as DimNameSub<U1>>::Output>,
impl<N, D> Transformation<Point<N, <D as DimNameSub<U1>>::Output>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
N: Real,
D: DimNameSub<U1>,
DefaultAllocator: Allocator<N, D, D> + Allocator<N, <D as DimNameSub<U1>>::Output, U1> + Allocator<N, <D as DimNameSub<U1>>::Output, <D as DimNameSub<U1>>::Output>,
source§fn transform_vector(
&self,
v: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
) -> Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
fn transform_vector(
&self,
v: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
) -> Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
source§fn transform_point(
&self,
pt: &Point<N, <D as DimNameSub<U1>>::Output>
) -> Point<N, <D as DimNameSub<U1>>::Output>
fn transform_point(
&self,
pt: &Point<N, <D as DimNameSub<U1>>::Output>
) -> Point<N, <D as DimNameSub<U1>>::Output>
source§impl<N, R, C, S> UlpsEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + UlpsEq<N>,
S: Storage<N, R, C>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
impl<N, R, C, S> UlpsEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + UlpsEq<N>,
S: Storage<N, R, C>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
source§fn default_max_ulps() -> u32
fn default_max_ulps() -> u32
source§impl<N, R, C> VectorSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + Field,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> VectorSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + Field,
DefaultAllocator: Allocator<N, R, C>,
source§impl<N, R, C> Zero for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + Zero + ClosedAdd<N>,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> Zero for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + Zero + ClosedAdd<N>,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> AbstractGroup<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + AbstractGroup<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> AbstractGroupAbelian<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + AbstractGroupAbelian<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> AbstractLoop<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + AbstractLoop<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> AbstractMonoid<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + AbstractMonoid<Additive> + Zero + ClosedAdd<N>,
DefaultAllocator: Allocator<N, R, C>,
impl<N, D> AbstractMonoid<Multiplicative> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + AbstractMonoid<Multiplicative>,
DefaultAllocator: Allocator<N, D, D>,
impl<N, R, C> AbstractQuasigroup<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + AbstractQuasigroup<Additive> + ClosedAdd<N> + ClosedNeg,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C> AbstractSemigroup<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>where
R: DimName,
C: DimName,
N: Scalar + AbstractSemigroup<Additive> + ClosedAdd<N>,
DefaultAllocator: Allocator<N, R, C>,
impl<N, D> AbstractSemigroup<Multiplicative> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>where
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + AbstractSemigroup<Multiplicative>,
DefaultAllocator: Allocator<N, D, D>,
impl<N, R, C, S> Copy for Matrix<N, R, C, S>where
N: Copy + Scalar,
R: Copy + Dim,
C: Copy + Dim,
S: Copy,
impl<N, R, C, S> Eq for Matrix<N, R, C, S>where
R: Dim,
C: Dim,
N: Scalar + Eq,
S: Storage<N, R, C>,
Auto Trait Implementations§
impl<N, R, C, S> RefUnwindSafe for Matrix<N, R, C, S>where
C: RefUnwindSafe,
N: RefUnwindSafe,
R: RefUnwindSafe,
S: RefUnwindSafe,
impl<N, R, C, S> Send for Matrix<N, R, C, S>where
N: Send,
S: Send,
impl<N, R, C, S> Sync for Matrix<N, R, C, S>where
N: Sync,
S: Sync,
impl<N, R, C, S> Unpin for Matrix<N, R, C, S>where
C: Unpin,
N: Unpin,
R: Unpin,
S: Unpin,
impl<N, R, C, S> UnwindSafe for Matrix<N, R, C, S>where
C: UnwindSafe,
N: UnwindSafe,
R: UnwindSafe,
S: UnwindSafe,
Blanket Implementations§
source§impl<T> LowerBounded for Twhere
T: Bounded,
impl<T> LowerBounded for Twhere
T: Bounded,
source§impl<T> Rand for Twhere
Standard: Distribution<T>,
impl<T> Rand for Twhere
Standard: Distribution<T>,
source§impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
source§fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read moresource§fn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).source§unsafe fn to_subset_unchecked(&self) -> SS
unsafe fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.source§fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.