Struct ggez::graphics::na::Matrix
[−]
[src]
#[repr(C)]pub struct Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim, { pub data: S, // some fields omitted }
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 contants (e.g. U1
, U124
) from the nalgebra::
root module.
All numbers from 0 to 127 are defined that way.
- type-level unsigned integer constants (e.g. U1024
, U10000
) from the typenum::
crate.
Using those, you will not get error messages as nice as for numbers smaller than 128 defined on
the nalgebra::
module.
- the special value Dynamic
from the nalgebra::
root module. This indicates that the
specified dimension is not known at compile-time. Note that this will generally imply that the
matrix data storage S
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).
Methods
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ClosedNeg,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar + ClosedNeg,
R: Dim,
S: StorageMut<N, R, C>,
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA> where
C1: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
[src]
C1: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
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
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, C1, C2, <DefaultAllocator as Allocator<N, C1, C2>>::Buffer> where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
Equivalent to self.transpose() * rhs
.
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
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: DimEq<C1, R3>,
ShapeConstraint: DimEq<C2, C3>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: DimEq<C1, R3>,
ShapeConstraint: DimEq<C2, C3>,
Equivalent to self.transpose() * rhs
but stores the result into out
to avoid
allocations.
fn mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1>,
ShapeConstraint: SameNumberOfColumns<C3, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1>,
ShapeConstraint: SameNumberOfColumns<C3, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
Equivalent to self * rhs
but stores the result into out
to avoid allocations.
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
C1: DimMul<C2>,
C2: Dim,
N: ClosedMul<N>,
R1: DimMul<R2>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>,
[src]
&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
C1: DimMul<C2>,
C2: Dim,
N: ClosedMul<N>,
R1: DimMul<R2>,
R2: Dim,
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).
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ClosedAdd<N>,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar + ClosedAdd<N>,
R: Dim,
S: Storage<N, R, C>,
fn add_scalar(
&self,
rhs: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&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
.
fn add_scalar_mut(&mut self, rhs: N) where
S: StorageMut<N, R, C>,
[src]
S: StorageMut<N, R, C>,
Adds a scalar to self
in-place.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar + PartialOrd<N> + Signed,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar + PartialOrd<N> + Signed,
R: Dim,
S: Storage<N, R, C>,
fn amax(&self) -> N
[src]
Returns the absolute value of the coefficient with the largest absolute value.
fn amin(&self) -> N
[src]
Returns the absolute value of the coefficient with the smallest absolute value.
impl<N, D, S> Matrix<N, D, U1, S> where
D: Dim,
N: Scalar + PartialOrd<N> + Signed,
S: Storage<N, D, U1>,
[src]
D: Dim,
N: Scalar + PartialOrd<N> + Signed,
S: Storage<N, D, U1>,
fn iamax(&self) -> usize
[src]
Computes the index of the vector component with the largest absolute value.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar + PartialOrd<N> + Signed,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar + PartialOrd<N> + Signed,
R: Dim,
S: Storage<N, R, C>,
fn iamax_full(&self) -> (usize, usize)
[src]
Computes the index of the matrix component with the largest absolute value.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
R: Dim,
S: Storage<N, R, C>,
fn dot<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
The dot product between two 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
, *
.
fn tr_dot<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<C, R2>,
ShapeConstraint: DimEq<R, C2>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<C, R2>,
ShapeConstraint: DimEq<R, C2>,
The dot product between the transpose of self
and rhs
.
impl<N, D, S> Matrix<N, D, U1, S> where
D: Dim,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
S: StorageMut<N, D, U1>,
[src]
D: Dim,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
S: StorageMut<N, D, U1>,
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>,
[src]
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.
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
C2: Dim,
D3: Dim,
N: One,
R2: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, R2>,
ShapeConstraint: AreMultipliable<R2, C2, D3, U1>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
C2: Dim,
D3: Dim,
N: One,
R2: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, R2>,
ShapeConstraint: 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.
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>,
ShapeConstraint: AreMultipliable<D2, D2, D3, U1>,
[src]
&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>,
ShapeConstraint: 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.
impl<N, R1, C1, S> Matrix<N, R1, C1, S> where
C1: Dim,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
S: StorageMut<N, R1, C1>,
[src]
C1: Dim,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
S: StorageMut<N, R1, C1>,
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>,
ShapeConstraint: DimEq<C1, D3>,
[src]
&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>,
ShapeConstraint: DimEq<C1, D3>,
Computes self = alpha * x * y.transpose() + beta * self
.
If beta
is zero, self
is never read.
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
C2: Dim,
C3: Dim,
N: One,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: AreMultipliable<R2, C2, R3, C3>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
C2: Dim,
C3: Dim,
N: One,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: 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.
impl<N, R1, C1, S> Matrix<N, R1, C1, S> where
C1: Dim,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
S: StorageMut<N, R1, C1>,
[src]
C1: Dim,
N: Scalar + Zero + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
S: StorageMut<N, R1, C1>,
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>,
ShapeConstraint: DimEq<C1, D3>,
[src]
&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>,
ShapeConstraint: 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.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
[src]
C: Dim,
N: Scalar,
R: Dim,
unsafe fn from_data_statically_unchecked(data: S) -> Matrix<N, R, C, S>
[src]
Creates a new matrix with the given data without statically checking that the matrix dimension matches the storage dimension.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
fn from_data(data: S) -> Matrix<N, R, C, S>
[src]
Creates a new matrix with the given data.
fn len(&self) -> usize
[src]
The total number of elements of this matrix.
fn shape(&self) -> (usize, usize)
[src]
The shape of this matrix returned as the tuple (number of rows, number of columns).
fn nrows(&self) -> usize
[src]
The number of rows of this matrix.
fn ncols(&self) -> usize
[src]
The number of columns of this matrix.
fn strides(&self) -> (usize, usize)
[src]
The strides (row stride, column stride) of this matrix.
fn iter(&self) -> MatrixIter<N, R, C, S>
[src]
Iterates through this matrix coordinates.
fn vector_to_matrix_index(&self, i: usize) -> (usize, usize)
[src]
Computes the row and column coordinates of the i-th element of this matrix seen as a vector.
unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &N
[src]
Gets a reference to the element of this matrix at row irow
and column icol
without
bound-checking.
fn relative_eq<R2, C2, SB>(
&self,
other: &Matrix<N, R2, C2, SB>,
eps: <N as ApproxEq>::Epsilon,
max_relative: <N as ApproxEq>::Epsilon
) -> bool where
C2: Dim,
N: ApproxEq,
R2: Dim,
SB: Storage<N, R2, C2>,
<N as ApproxEq>::Epsilon: Copy,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&self,
other: &Matrix<N, R2, C2, SB>,
eps: <N as ApproxEq>::Epsilon,
max_relative: <N as ApproxEq>::Epsilon
) -> bool where
C2: Dim,
N: ApproxEq,
R2: Dim,
SB: Storage<N, R2, C2>,
<N as ApproxEq>::Epsilon: Copy,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are equal up to a given epsilon.
See relative_eq
from the ApproxEq
trait for more details.
fn eq<R2, C2, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> bool where
C2: Dim,
N: PartialEq<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
C2: Dim,
N: PartialEq<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are exactly equal.
fn into_owned(
self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
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.
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
C2: Dim,
R2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
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
C2: Dim,
R2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: 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.
fn clone_owned(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&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.
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
C2: Dim,
R2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&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
C2: Dim,
R2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: 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.
fn map<N2, F>(
&self,
f: F
) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer> where
F: FnMut(N) -> N2,
N2: Scalar,
DefaultAllocator: Allocator<N2, R, C>,
[src]
&self,
f: F
) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer> where
F: FnMut(N) -> N2,
N2: Scalar,
DefaultAllocator: Allocator<N2, R, C>,
Returns a matrix containing the result of f
applied to each of its entries.
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
F: FnMut(N, N2) -> N3,
N2: Scalar,
N3: Scalar,
S2: Storage<N2, R, C>,
DefaultAllocator: Allocator<N3, R, C>,
[src]
&self,
rhs: &Matrix<N2, R, C, S2>,
f: F
) -> Matrix<N3, R, C, <DefaultAllocator as Allocator<N3, R, C>>::Buffer> where
F: FnMut(N, N2) -> N3,
N2: Scalar,
N3: Scalar,
S2: Storage<N2, R, C>,
DefaultAllocator: Allocator<N3, R, C>,
Returns a matrix containing the result of f
applied to each entries of self
and
rhs
.
fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>) where
C2: Dim,
R2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
[src]
C2: Dim,
R2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
Transposes self
and store the result into out
.
fn transpose(
&self
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where
DefaultAllocator: Allocator<N, C, R>,
[src]
&self
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where
DefaultAllocator: Allocator<N, C, R>,
Transposes self
.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
fn iter_mut(&mut self) -> MatrixIterMut<N, R, C, S>
[src]
Mutably iterates through this matrix coordinates.
unsafe fn get_unchecked_mut(&mut self, irow: usize, icol: usize) -> &mut N
[src]
Gets a mutable reference to the i-th element of this matrix.
unsafe fn swap_unchecked(
&mut self,
row_cols1: (usize, usize),
row_cols2: (usize, usize)
)
[src]
&mut self,
row_cols1: (usize, usize),
row_cols2: (usize, usize)
)
Swaps two entries without bound-checking.
fn swap(&mut self, row_cols1: (usize, usize), row_cols2: (usize, usize))
[src]
Swaps two entries.
fn copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>) where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Fills this matrix with the content of another one. Both must have the same shape.
fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>) where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
Fills this matrix with the content of the transpose another one.
fn apply<F>(&mut self, f: F) where
F: FnMut(N) -> N,
DefaultAllocator: Allocator<N, R, C>,
[src]
F: FnMut(N) -> N,
DefaultAllocator: Allocator<N, R, C>,
Replaces each component of self
by the result of a closure f
applied on it.
impl<N, D, S> Matrix<N, D, U1, S> where
D: Dim,
N: Scalar,
S: Storage<N, D, U1>,
[src]
D: Dim,
N: Scalar,
S: Storage<N, D, U1>,
unsafe fn vget_unchecked(&self, i: usize) -> &N
[src]
Gets a reference to the i-th element of this column vector without bound checking.
impl<N, D, S> Matrix<N, D, U1, S> where
D: Dim,
N: Scalar,
S: StorageMut<N, D, U1>,
[src]
D: Dim,
N: Scalar,
S: StorageMut<N, D, U1>,
unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut N
[src]
Gets a mutable reference to the i-th element of this column vector without bound checking.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: ContiguousStorage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: ContiguousStorage<N, R, C>,
fn as_slice(&self) -> &[N]
[src]
Extracts a slice containing the entire matrix entries ordered column-by-columns.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: ContiguousStorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: ContiguousStorageMut<N, R, C>,
fn as_mut_slice(&mut self) -> &mut [N]
[src]
Extracts a mutable slice containing the entire matrix entries ordered column-by-columns.
impl<N, D, S> Matrix<N, D, D, S> where
D: Dim,
N: Scalar,
S: StorageMut<N, D, D>,
[src]
D: Dim,
N: Scalar,
S: StorageMut<N, D, D>,
fn transpose_mut(&mut self)
[src]
Transposes the square matrix self
in-place.
impl<N, R, C, S> Matrix<Complex<N>, R, C, S> where
C: Dim,
N: Real,
R: Dim,
S: Storage<Complex<N>, R, C>,
[src]
C: Dim,
N: Real,
R: Dim,
S: Storage<Complex<N>, R, C>,
fn conjugate_transpose_to<R2, C2, SB>(
&self,
out: &mut Matrix<Complex<N>, R2, C2, SB>
) where
C2: Dim,
R2: Dim,
SB: StorageMut<Complex<N>, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
[src]
&self,
out: &mut Matrix<Complex<N>, R2, C2, SB>
) where
C2: Dim,
R2: Dim,
SB: StorageMut<Complex<N>, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
Takes the conjugate and transposes self
and store the result into out
.
fn conjugate_transpose(
&self
) -> Matrix<Complex<N>, C, R, <DefaultAllocator as Allocator<Complex<N>, C, R>>::Buffer> where
DefaultAllocator: Allocator<Complex<N>, C, R>,
[src]
&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
.
impl<N, D, S> Matrix<Complex<N>, D, D, S> where
D: Dim,
N: Real,
S: StorageMut<Complex<N>, D, D>,
[src]
D: Dim,
N: Real,
S: StorageMut<Complex<N>, D, D>,
fn conjugate_transpose_mut(&mut self)
[src]
Sets self
to its conjugate transpose.
impl<N, D, S> Matrix<N, D, D, S> where
D: Dim,
N: Scalar,
S: Storage<N, D, D>,
[src]
D: Dim,
N: Scalar,
S: Storage<N, D, D>,
fn diagonal(
&self
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where
DefaultAllocator: Allocator<N, D, U1>,
[src]
&self
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where
DefaultAllocator: Allocator<N, D, U1>,
Creates a square matrix with its diagonal set to diag
and all other entries set to 0.
fn trace(&self) -> N where
N: Ring,
[src]
N: Ring,
Computes a trace of a square matrix, i.e., the sum of its diagonal elements.
impl<N, D, S> Matrix<N, D, U1, S> where
D: DimAdd<U1>,
N: Scalar + Zero,
S: Storage<N, D, U1>,
[src]
D: DimAdd<U1>,
N: Scalar + Zero,
S: Storage<N, D, U1>,
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>,
[src]
&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.
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>,
[src]
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.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar + Ring,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar + Ring,
R: Dim,
S: Storage<N, R, C>,
fn perp<R2, C2, SB>(&self, b: &Matrix<N, R2, C2, SB>) -> N where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, U2>,
ShapeConstraint: SameNumberOfColumns<C, U1>,
ShapeConstraint: SameNumberOfRows<R2, U2>,
ShapeConstraint: SameNumberOfColumns<C2, U1>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, U2>,
ShapeConstraint: SameNumberOfColumns<C, U1>,
ShapeConstraint: SameNumberOfRows<R2, U2>,
ShapeConstraint: SameNumberOfColumns<C2, U1>,
The perpendicular product between two 2D column vectors, i.e. a.x * b.y - a.y * b.x
.
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
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&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
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: 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.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Real,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Real,
R: Dim,
S: Storage<N, R, C>,
fn angle<R2, C2, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> N where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
The smallest angle between two vectors.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Real,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Real,
R: Dim,
S: Storage<N, R, C>,
fn norm_squared(&self) -> N
[src]
The squared L2 norm of this vector.
fn norm(&self) -> N
[src]
The L2 norm of this matrix.
fn normalize(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&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.
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>,
[src]
&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
.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Real,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Real,
R: Dim,
S: StorageMut<N, R, C>,
fn normalize_mut(&mut self) -> N
[src]
Normalizes this matrix in-place and returns its norm.
fn try_normalize_mut(&mut self, min_norm: N) -> Option<N>
[src]
Normalizes this matrix in-place or does nothing if its norm is smaller or equal to eps
.
If the normalization succeded, returns the old normal of this matrix.
impl<N, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: Dim,
N: Scalar,
R: Dim,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
DefaultAllocator: Allocator<N, R, C>,
unsafe fn new_uninitialized_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
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()
.
fn from_element_generic(
nrows: R,
ncols: C,
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
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
.
fn zeros_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Zero,
[src]
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.
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>,
[src]
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.
fn from_row_slice_generic(
nrows: R,
ncols: C,
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
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.
fn from_column_slice_generic(
nrows: R,
ncols: C,
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
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. row-major or column-major).
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,
[src]
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.
fn identity_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Zero + One,
[src]
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Zero + One,
Creates a new indentity 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.
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,
[src]
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.
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,
[src]
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
.
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>,
[src]
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.
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>,
[src]
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.
fn new_random_generic(
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Rand,
[src]
nrows: R,
ncols: C
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Rand,
Creates a matrix filled with random values.
impl<N, D> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: Dim,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: Dim,
N: Scalar,
DefaultAllocator: Allocator<N, D, D>,
fn from_diagonal<SB>(
diag: &Matrix<N, D, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
N: Zero,
SB: Storage<N, D, U1>,
[src]
diag: &Matrix<N, D, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
N: Zero,
SB: Storage<N, D, U1>,
Creates a square matrix with its diagonal set to diag
and all other entries set to 0.
impl<N, R> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
N: Scalar + Zero + One,
R: DimName,
DefaultAllocator: Allocator<N, R, U1>,
[src]
N: Scalar + Zero + One,
R: DimName,
DefaultAllocator: Allocator<N, R, U1>,
fn x() -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
<R as DimName>::Value: Cmp<UTerm>,
<<R as DimName>::Value as Cmp<UTerm>>::Output == Greater,
[src]
<R as DimName>::Value: Cmp<UTerm>,
<<R as DimName>::Value as Cmp<UTerm>>::Output == Greater,
The column vector with a 1 as its first component, and zero elsewhere.
fn y() -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
<R as DimName>::Value: Cmp<UInt<UTerm, B1>>,
<<R as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,
[src]
<R as DimName>::Value: Cmp<UInt<UTerm, B1>>,
<<R as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,
The column vector with a 1 as its second component, and zero elsewhere.
fn z() -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,
[src]
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,
The column vector with a 1 as its third component, and zero elsewhere.
fn w() -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B1>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B1>>>::Output == Greater,
[src]
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B1>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B1>>>::Output == Greater,
The column vector with a 1 as its fourth component, and zero elsewhere.
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>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output == Greater,
[src]
<R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output == Greater,
The column vector with a 1 as its fifth component, and zero elsewhere.
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>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>>::Output == Greater,
[src]
<R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>>::Output == Greater,
The column vector with a 1 as its sixth component, and zero elsewhere.
fn x_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where
<R as DimName>::Value: Cmp<UTerm>,
<<R as DimName>::Value as Cmp<UTerm>>::Output == Greater,
[src]
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where
<R as DimName>::Value: Cmp<UTerm>,
<<R as DimName>::Value as Cmp<UTerm>>::Output == Greater,
The unit column vector with a 1 as its first component, and zero elsewhere.
fn y_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where
<R as DimName>::Value: Cmp<UInt<UTerm, B1>>,
<<R as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,
[src]
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where
<R as DimName>::Value: Cmp<UInt<UTerm, B1>>,
<<R as DimName>::Value as Cmp<UInt<UTerm, B1>>>::Output == Greater,
The unit column vector with a 1 as its second component, and zero elsewhere.
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>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,
[src]
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B0>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B0>>>::Output == Greater,
The unit column vector with a 1 as its third component, and zero elsewhere.
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>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B1>>>::Output == Greater,
[src]
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where
<R as DimName>::Value: Cmp<UInt<UInt<UTerm, B1>, B1>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UTerm, B1>, B1>>>::Output == Greater,
The unit column vector with a 1 as its fourth component, and zero elsewhere.
fn a_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where
<R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output == Greater,
[src]
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where
<R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>>::Output == Greater,
The unit column vector with a 1 as its fifth component, and zero elsewhere.
fn b_axis(
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where
<R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>>::Output == Greater,
[src]
) -> Unit<Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>> where
<R as DimName>::Value: Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>,
<<R as DimName>::Value as Cmp<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>>::Output == Greater,
The unit column vector with a 1 as its sixth component, and zero elsewhere.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
fn is_empty(&self) -> bool
[src]
Indicates if this is a square matrix.
fn is_square(&self) -> bool
[src]
Indicates if this is a square matrix.
fn is_identity(&self, eps: <N as ApproxEq>::Epsilon) -> bool where
N: Zero + One + ApproxEq,
<N as ApproxEq>::Epsilon: Copy,
[src]
N: Zero + One + ApproxEq,
<N as ApproxEq>::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.
fn is_orthogonal(&self, eps: <N as ApproxEq>::Epsilon) -> bool where
N: Zero + One + ClosedAdd<N> + ClosedMul<N> + ApproxEq,
S: Storage<N, R, C>,
<N as ApproxEq>::Epsilon: Copy,
DefaultAllocator: Allocator<N, C, C>,
[src]
N: Zero + One + ClosedAdd<N> + ClosedMul<N> + ApproxEq,
S: Storage<N, R, C>,
<N as ApproxEq>::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
.
impl<N, D, S> Matrix<N, D, D, S> where
D: Dim,
N: Real,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: Dim,
N: Real,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
fn is_special_orthogonal(&self, eps: N) -> bool where
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
[src]
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
Checks that this matrix is orthogonal and has a determinant equal to 1.
fn is_invertible(&self) -> bool
[src]
Returns true
if this matrix is invertible.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
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
ColRange: SliceRange<C>,
RowRange: SliceRange<R>,
[src]
&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
ColRange: SliceRange<C>,
RowRange: SliceRange<R>,
Slices a sub-matrix containing the rows indexed by the range rows
and the columns indexed
by the range cols
.
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>,
[src]
&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
.
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>,
[src]
&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
.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
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
ColRange: SliceRange<C>,
RowRange: SliceRange<R>,
[src]
&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
ColRange: SliceRange<C>,
RowRange: SliceRange<R>,
Slices a mutable sub-matrix containing the rows indexed by the range rows
and the columns
indexed by the range cols
.
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>,
[src]
&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
.
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>,
[src]
&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
.
impl<N, D> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimName,
N: Scalar + Field,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Field,
DefaultAllocator: Allocator<N, D, D>,
fn new_scaling(
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
[src]
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.
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>,
[src]
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.
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>,
[src]
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.
impl<N> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where
N: Real,
[src]
N: Real,
fn new_rotation(
angle: N
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
[src]
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.
impl<N> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer> where
N: Real,
[src]
N: Real,
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>
[src]
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.
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>
[src]
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.
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>
[src]
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
.
fn from_euler_angles(
roll: N,
pitch: N,
yaw: N
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
[src]
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.
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>
[src]
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.
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>
[src]
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.
fn new_perspective(
aspect: N,
fovy: N,
znear: N,
zfar: N
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
[src]
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.
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>
[src]
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
.
fn look_at_rh(
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>
[src]
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>
Builds a right-handed look-at view matrix.
fn look_at_lh(
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>
[src]
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>
Builds a left-handed look-at view matrix.
impl<N, D, S> Matrix<N, D, D, S> where
D: DimName,
N: Scalar + Field,
S: Storage<N, D, D>,
[src]
D: DimName,
N: Scalar + Field,
S: Storage<N, D, D>,
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>,
[src]
&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.
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>,
[src]
&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
.
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>,
[src]
&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.
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>,
[src]
&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
.
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>,
[src]
&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.
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>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
[src]
&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>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
Computes the transformation equal to a translation followed by self
.
impl<N, D, S> Matrix<N, D, D, S> where
D: DimName,
N: Scalar + Field,
S: StorageMut<N, D, D>,
[src]
D: DimName,
N: Scalar + Field,
S: StorageMut<N, D, D>,
fn append_scaling_mut(&mut self, scaling: N) where
D: DimNameSub<U1>,
[src]
D: DimNameSub<U1>,
Computes in-place the transformation equal to self
followed by an uniform scaling factor.
fn prepend_scaling_mut(&mut self, scaling: N) where
D: DimNameSub<U1>,
[src]
D: DimNameSub<U1>,
Computes in-place the transformation equal to an uniform scaling factor followed by self
.
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>,
[src]
&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.
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>,
[src]
&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
.
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>,
[src]
&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.
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>,
[src]
&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
.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
fn abs(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Signed,
DefaultAllocator: Allocator<N, R, C>,
[src]
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Signed,
DefaultAllocator: Allocator<N, R, C>,
Computes the componentwise absolute value.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar + Zero,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar + Zero,
R: Dim,
S: Storage<N, R, C>,
fn upper_triangle(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&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).
fn lower_triangle(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&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).
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
fn fill(&mut self, val: N)
[src]
Sets all the elements of this matrix to val
.
fn fill_with_identity(&mut self) where
N: Zero + One,
[src]
N: Zero + One,
Fills self
with the identity matrix.
fn fill_diagonal(&mut self, val: N)
[src]
Sets all the diagonal elements of this matrix to val
.
fn fill_row(&mut self, i: usize, val: N)
[src]
Sets all the elements of the selected row to val
.
fn fill_column(&mut self, j: usize, val: N)
[src]
Sets all the elements of the selected column to val
.
fn set_diagonal<R2, S2>(&mut self, diag: &Matrix<N, R2, U1, S2>) where
R: DimMin<C>,
R2: Dim,
S2: Storage<N, R2, U1>,
ShapeConstraint: DimEq<<R as DimMin<C>>::Output, R2>,
[src]
R: DimMin<C>,
R2: Dim,
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.
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>,
[src]
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.
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>,
[src]
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.
fn fill_lower_triangle(&mut self, val: N, shift: usize)
[src]
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 first shift - 1
subdiagonals are left
untouched.
fn fill_upper_triangle(&mut self, val: N, shift: usize)
[src]
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 first shift - 1
superdiagonals are left
untouched.
fn swap_rows(&mut self, irow1: usize, irow2: usize)
[src]
Swaps two rows in-place.
fn swap_columns(&mut self, icol1: usize, icol2: usize)
[src]
Swaps two columns in-place.
impl<N, D, S> Matrix<N, D, D, S> where
D: Dim,
N: Scalar,
S: StorageMut<N, D, D>,
[src]
D: Dim,
N: Scalar,
S: StorageMut<N, D, D>,
fn fill_lower_triangle_with_upper_triangle(&mut self)
[src]
Copies the upper-triangle of this matrix to its lower-triangular part.
This makes the matrix symmetric. Panics if the matrix is not square.
fn fill_upper_triangle_with_lower_triangle(&mut self)
[src]
Copies the upper-triangle of this matrix to its upper-triangular part.
This makes the matrix symmetric. Panics if the matrix is not square.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
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>,
[src]
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.
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
C: DimSub<D>,
D: DimName,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<D>>::Output>,
[src]
self,
i: usize
) -> Matrix<N, R, <C as DimSub<D>>::Output, <DefaultAllocator as Allocator<N, R, <C as DimSub<D>>::Output>>::Buffer> where
C: DimSub<D>,
D: DimName,
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).
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>,
[src]
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).
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
C: DimSub<D>,
D: Dim,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimSub<D>>::Output>,
[src]
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
C: DimSub<D>,
D: Dim,
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.
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>,
[src]
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.
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>,
[src]
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).
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>,
[src]
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).
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>,
[src]
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.
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>,
[src]
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.
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
C: DimAdd<D>,
D: DimName,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<D>>::Output>,
[src]
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
C: DimAdd<D>,
D: DimName,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<D>>::Output>,
Inserts D::dim()
columns filled with val
starting at the i-th
position.
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>,
[src]
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.
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
C: DimAdd<D>,
D: Dim,
DefaultAllocator: Reallocator<N, R, C, R, <C as DimAdd<D>>::Output>,
[src]
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
C: DimAdd<D>,
D: Dim,
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.
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>,
[src]
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.
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>,
[src]
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.
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>,
[src]
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.
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>,
[src]
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.
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>,
[src]
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
.
fn fixed_resize<R2, C2>(
self,
val: N
) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where
C2: DimName,
R2: DimName,
DefaultAllocator: Reallocator<N, R, C, R2, C2>,
[src]
self,
val: N
) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where
C2: DimName,
R2: 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
.
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
C2: Dim,
R2: Dim,
DefaultAllocator: Reallocator<N, R, C, R2, C2>,
[src]
self,
new_nrows: R2,
new_ncols: C2,
val: N
) -> Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer> where
C2: Dim,
R2: 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
.
impl<N, D, S> Matrix<N, D, D, S> where
D: Dim,
N: Real,
S: Storage<N, D, D>,
[src]
D: Dim,
N: Real,
S: Storage<N, D, D>,
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
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: 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 concidered not-zero.
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
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: 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 concidered not-zero.
fn solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: 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 concidered not-zero.
fn solve_lower_triangular_with_diag_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>,
diag: N
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>,
diag: N
) -> bool where
C2: Dim,
R2: 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 concidered 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.
fn solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: 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 concidered not-zero.
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
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: 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 concidered not-zero.
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
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: 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 concidered not-zero.
fn tr_solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: 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 concidered not-zero.
fn tr_solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: 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 concidered not-zero.
impl<N, D, S> Matrix<N, D, D, S> where
D: DimMin<D, Output = D>,
N: Real,
S: Storage<N, D, D>,
[src]
D: DimMin<D, Output = D>,
N: Real,
S: Storage<N, D, D>,
fn determinant(&self) -> N where
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
[src]
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
Computes the matrix determinant.
If the matrix has a dimension larger than 3, an LU decomposition is used.
impl<N, D, S> Matrix<N, D, D, S> where
D: Dim,
N: Real,
S: Storage<N, D, D>,
[src]
D: Dim,
N: Real,
S: Storage<N, D, D>,
fn try_inverse(
self
) -> Option<Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> where
DefaultAllocator: Allocator<N, D, D>,
[src]
self
) -> Option<Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> where
DefaultAllocator: Allocator<N, D, D>,
Attempts to invert this matrix.
impl<N, D, S> Matrix<N, D, D, S> where
D: Dim,
N: Real,
S: StorageMut<N, D, D>,
[src]
D: Dim,
N: Real,
S: StorageMut<N, D, D>,
fn try_inverse_mut(&mut self) -> bool where
DefaultAllocator: Allocator<N, D, D>,
[src]
DefaultAllocator: Allocator<N, D, D>,
Attempts to invert this matrix in-place. Returns false
and leaves self
untouched if
inversion fails.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Real,
R: DimMin<C>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<N, R, U1>,
DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, U1>,
[src]
C: Dim,
N: Real,
R: DimMin<C>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<N, R, U1>,
DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, U1>,
impl<N, D, S> Matrix<N, D, D, S> where
D: DimSub<U1>,
N: Real,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>,
[src]
D: DimSub<U1>,
N: Real,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>,
fn hessenberg(self) -> Hessenberg<N, D>
[src]
Computes the Hessenberg decomposition of this matrix using householder reflections.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Real,
R: DimMin<C>,
S: Storage<N, R, C>,
<R as DimMin<C>>::Output: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<N, C, U1>,
DefaultAllocator: Allocator<N, R, U1>,
DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, U1>,
DefaultAllocator: Allocator<N, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>,
[src]
C: Dim,
N: Real,
R: DimMin<C>,
S: Storage<N, R, C>,
<R as DimMin<C>>::Output: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<N, C, U1>,
DefaultAllocator: Allocator<N, R, U1>,
DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, U1>,
DefaultAllocator: Allocator<N, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>,
fn bidiagonalize(self) -> Bidiagonal<N, R, C>
[src]
Computes the bidiagonalization using householder reflections.
impl<N, D, S> Matrix<N, D, D, S> where
D: DimSub<U1>,
N: Real,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>,
[src]
D: DimSub<U1>,
N: Real,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>,
fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<N, D>
[src]
Computes the tridiagonalization of this symmetric matrix.
Only the lower-triangular part (including the diagonal) of m
is read.
impl<N, D, S> Matrix<N, D, D, S> where
D: DimSub<Dynamic>,
N: Real,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimSub<Dynamic>,
N: Real,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
fn cholesky(self) -> Option<Cholesky<N, D>>
[src]
Attempts to compute the Cholesky decomposition of this matrix.
Returns None
if the input matrix is not definite-positive. The intput matrix is assumed
to be symmetric and only the lower-triangular part is read.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Real,
R: DimMin<C>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>,
[src]
C: Dim,
N: Real,
R: DimMin<C>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>,
fn lu(self) -> LU<N, R, C>
[src]
Computes the LU decomposition with partial (row) pivoting of matrix
.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Real,
R: DimMin<C>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>,
[src]
C: Dim,
N: Real,
R: DimMin<C>,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, U1>,
fn full_piv_lu(self) -> FullPivLU<N, R, C>
[src]
Computes the LU decomposition with full pivoting of matrix
.
This effectively computes P, L, U, Q
such that P * matrix * Q = LU
.
impl<N, D, S> Matrix<N, D, D, S> where
D: Dim + DimSub<U1>,
N: Real,
S: Storage<N, D, D>,
ShapeConstraint: DimEq<Dynamic, <D as DimSub<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimSub<U1>>::Output>,
DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
D: Dim + DimSub<U1>,
N: Real,
S: Storage<N, D, D>,
ShapeConstraint: DimEq<Dynamic, <D as DimSub<U1>>::Output>,
DefaultAllocator: Allocator<N, D, <D as DimSub<U1>>::Output>,
DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
fn real_schur(self) -> RealSchur<N, D>
[src]
Computes the Schur decomposition of a square matrix.
fn try_real_schur(self, eps: N, max_niter: usize) -> Option<RealSchur<N, D>>
[src]
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
− tolerence 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.
fn eigenvalues(
&self
) -> Option<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>
[src]
&self
) -> Option<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>
Computes the eigenvalues of this matrix.
fn complex_eigenvalues(
&self
) -> Matrix<Complex<N>, D, U1, <DefaultAllocator as Allocator<Complex<N>, D, U1>>::Buffer> where
DefaultAllocator: Allocator<Complex<N>, D, U1>,
[src]
&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.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Real,
R: DimMin<C>,
S: Storage<N, R, C>,
<R as DimMin<C>>::Output: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<N, C, U1>,
DefaultAllocator: Allocator<N, R, U1>,
DefaultAllocator: Allocator<N, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, C>,
DefaultAllocator: Allocator<N, R, <R as DimMin<C>>::Output>,
DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, U1>,
[src]
C: Dim,
N: Real,
R: DimMin<C>,
S: Storage<N, R, C>,
<R as DimMin<C>>::Output: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<N, C, U1>,
DefaultAllocator: Allocator<N, R, U1>,
DefaultAllocator: Allocator<N, <<R as DimMin<C>>::Output as DimSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, C>,
DefaultAllocator: Allocator<N, R, <R as DimMin<C>>::Output>,
DefaultAllocator: Allocator<N, <R as DimMin<C>>::Output, U1>,
fn svd(self, compute_u: bool, compute_v: bool) -> SVD<N, R, C>
[src]
Computes the Singular Value Decomposition using implicit shift.
fn try_svd(
self,
compute_u: bool,
compute_v: bool,
eps: N,
max_niter: usize
) -> Option<SVD<N, R, C>>
[src]
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
− tolerence 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.
fn singular_values(
&self
) -> Matrix<N, <R as DimMin<C>>::Output, U1, <DefaultAllocator as Allocator<N, <R as DimMin<C>>::Output, U1>>::Buffer>
[src]
&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.
fn rank(&self, eps: N) -> usize
[src]
Computes the rank of this matrix.
All singular values bellow eps
are considered equal to 0.
fn pseudo_inverse(
self,
eps: N
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where
DefaultAllocator: Allocator<N, C, R>,
[src]
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 bellow eps
are considered equal to 0.
impl<N, D, S> Matrix<N, D, D, S> where
D: DimSub<U1>,
N: Real,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>,
[src]
D: DimSub<U1>,
N: Real,
S: Storage<N, D, D>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, D, U1>,
DefaultAllocator: Allocator<N, <D as DimSub<U1>>::Output, U1>,
fn symmetric_eigen(self) -> SymmetricEigen<N, D>
[src]
Computes the eigendecomposition of this symmetric matrix.
Only the lower-triangular part (including the diagonal) of m
is read.
fn try_symmetric_eigen(
self,
eps: N,
max_niter: usize
) -> Option<SymmetricEigen<N, D>>
[src]
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.
fn symmetric_eigenvalues(
&self
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>
[src]
&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.
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA> where
C1: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
[src]
C1: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
fn add_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA> where
C1: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
[src]
C1: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
fn sub_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
impl<N, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
unsafe fn new_uninitialized(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a new uninitialized matrix.
fn from_element(
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
elem: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix with all its elements set to elem
.
fn zeros() -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Zero,
[src]
N: Zero,
Creates a matrix with all its elements set to 0
.
fn from_iterator<I>(
iter: I
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
I: IntoIterator<Item = N>,
[src]
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.
fn from_row_slice(
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
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.
fn from_column_slice(
slice: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
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.
fn from_fn<F>(
f: F
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
F: FnMut(usize, usize) -> N,
[src]
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.
fn identity(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Zero + One,
[src]
) -> 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.
fn from_diagonal_element(
elt: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Zero + One,
[src]
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.
fn from_partial_diagonal(
elts: &[N]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Zero,
[src]
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
.
impl<N, R, C> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + Rand,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + Rand,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
fn new_random(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Creates a matrix filled with random values.
impl<N, R> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
N: Scalar,
R: DimName,
DefaultAllocator: Allocator<N, R, Dynamic>,
[src]
N: Scalar,
R: DimName,
DefaultAllocator: Allocator<N, R, Dynamic>,
unsafe fn new_uninitialized(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
[src]
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
Creates a new uninitialized matrix.
fn from_element(
ncols: usize,
elem: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
[src]
ncols: usize,
elem: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
Creates a matrix with all its elements set to elem
.
fn zeros(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
N: Zero,
[src]
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
N: Zero,
Creates a matrix with all its elements set to 0
.
fn from_iterator<I>(
ncols: usize,
iter: I
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
I: IntoIterator<Item = N>,
[src]
ncols: usize,
iter: I
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
I: IntoIterator<Item = N>,
Creates a matrix with all its elements filled by an iterator.
fn from_row_slice(
ncols: usize,
slice: &[N]
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
[src]
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.
fn from_column_slice(
ncols: usize,
slice: &[N]
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
[src]
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.
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,
[src]
ncols: usize,
f: F
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
F: FnMut(usize, usize) -> N,
Creates a matrix filled with the results of a function applied to each of its component coordinates.
fn identity(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
N: Zero + One,
[src]
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.
fn from_diagonal_element(
ncols: usize,
elt: N
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
N: Zero + One,
[src]
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.
fn from_partial_diagonal(
ncols: usize,
elts: &[N]
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
N: Zero,
[src]
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
.
impl<N, R> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer> where
N: Scalar + Rand,
R: DimName,
DefaultAllocator: Allocator<N, R, Dynamic>,
[src]
N: Scalar + Rand,
R: DimName,
DefaultAllocator: Allocator<N, R, Dynamic>,
fn new_random(
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
[src]
ncols: usize
) -> Matrix<N, R, Dynamic, <DefaultAllocator as Allocator<N, R, Dynamic>>::Buffer>
Creates a matrix filled with random values.
impl<N, C> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
C: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, Dynamic, C>,
[src]
C: DimName,
N: Scalar,
DefaultAllocator: Allocator<N, Dynamic, C>,
unsafe fn new_uninitialized(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
[src]
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
Creates a new uninitialized matrix.
fn from_element(
nrows: usize,
elem: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
[src]
nrows: usize,
elem: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
Creates a matrix with all its elements set to elem
.
fn zeros(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
N: Zero,
[src]
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
N: Zero,
Creates a matrix with all its elements set to 0
.
fn from_iterator<I>(
nrows: usize,
iter: I
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
I: IntoIterator<Item = N>,
[src]
nrows: usize,
iter: I
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
I: IntoIterator<Item = N>,
Creates a matrix with all its elements filled by an iterator.
fn from_row_slice(
nrows: usize,
slice: &[N]
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
[src]
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.
fn from_column_slice(
nrows: usize,
slice: &[N]
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
[src]
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.
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,
[src]
nrows: usize,
f: F
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, 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.
fn identity(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
N: Zero + One,
[src]
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.
fn from_diagonal_element(
nrows: usize,
elt: N
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
N: Zero + One,
[src]
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.
fn from_partial_diagonal(
nrows: usize,
elts: &[N]
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
N: Zero,
[src]
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
.
impl<N, C> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer> where
C: DimName,
N: Scalar + Rand,
DefaultAllocator: Allocator<N, Dynamic, C>,
[src]
C: DimName,
N: Scalar + Rand,
DefaultAllocator: Allocator<N, Dynamic, C>,
fn new_random(
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
[src]
nrows: usize
) -> Matrix<N, Dynamic, C, <DefaultAllocator as Allocator<N, Dynamic, C>>::Buffer>
Creates a matrix filled with random values.
impl<N> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
unsafe fn new_uninitialized(
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
[src]
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
Creates a new uninitialized matrix.
fn from_element(
nrows: usize,
ncols: usize,
elem: N
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
[src]
nrows: usize,
ncols: usize,
elem: N
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
Creates a matrix with all its elements set to elem
.
fn zeros(
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where
N: Zero,
[src]
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where
N: Zero,
Creates a matrix with all its elements set to 0
.
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>,
[src]
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 with all its elements filled by an iterator.
fn from_row_slice(
nrows: usize,
ncols: usize,
slice: &[N]
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
[src]
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.
fn from_column_slice(
nrows: usize,
ncols: usize,
slice: &[N]
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
[src]
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.
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,
[src]
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 filled with the results of a function applied to each of its component coordinates.
fn identity(
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where
N: Zero + One,
[src]
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.
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,
[src]
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.
fn from_partial_diagonal(
nrows: usize,
ncols: usize,
elts: &[N]
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where
N: Zero,
[src]
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
.
impl<N> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer> where
N: Scalar + Rand,
DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
[src]
N: Scalar + Rand,
DefaultAllocator: Allocator<N, Dynamic, Dynamic>,
fn new_random(
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
[src]
nrows: usize,
ncols: usize
) -> Matrix<N, Dynamic, Dynamic, <DefaultAllocator as Allocator<N, Dynamic, Dynamic>>::Buffer>
Creates a matrix filled with random values.
impl<N> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U2>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U2>,
fn new(
m11: N,
m12: N,
m21: N,
m22: N
) -> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>
[src]
m11: N,
m12: N,
m21: N,
m22: N
) -> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U3>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U3>,
fn new(
m11: N,
m12: N,
m13: N,
m21: N,
m22: N,
m23: N,
m31: N,
m32: N,
m33: N
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
[src]
m11: N,
m12: N,
m13: N,
m21: N,
m22: N,
m23: N,
m31: N,
m32: N,
m33: N
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U4>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U4>,
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
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
[src]
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
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U5>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U5>,
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>
[src]
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.
impl<N> Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U6>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U6>,
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>
[src]
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.
impl<N> Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U3>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U3>,
fn new(
m11: N,
m12: N,
m13: N,
m21: N,
m22: N,
m23: N
) -> Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer>
[src]
m11: N,
m12: N,
m13: N,
m21: N,
m22: N,
m23: N
) -> Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U4>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U4>,
fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m21: N,
m22: N,
m23: N,
m24: N
) -> Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer>
[src]
m11: N,
m12: N,
m13: N,
m14: N,
m21: N,
m22: N,
m23: N,
m24: N
) -> Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U5>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U5>,
fn new(
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N
) -> Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer>
[src]
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N
) -> Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U6>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U6>,
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
) -> Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer>
[src]
m11: N,
m12: N,
m13: N,
m14: N,
m15: N,
m16: N,
m21: N,
m22: N,
m23: N,
m24: N,
m25: N,
m26: N
) -> Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U2>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U2>,
fn new(
m11: N,
m12: N,
m21: N,
m22: N,
m31: N,
m32: N
) -> Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer>
[src]
m11: N,
m12: N,
m21: N,
m22: N,
m31: N,
m32: N
) -> Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U4>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U4>,
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
) -> Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer>
[src]
m11: N,
m12: N,
m13: N,
m14: N,
m21: N,
m22: N,
m23: N,
m24: N,
m31: N,
m32: N,
m33: N,
m34: N
) -> Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U5>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U5>,
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
) -> Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer>
[src]
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
) -> Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U6>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U6>,
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
) -> Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer>
[src]
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
) -> Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U2>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U2>,
fn new(
m11: N,
m12: N,
m21: N,
m22: N,
m31: N,
m32: N,
m41: N,
m42: N
) -> Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer>
[src]
m11: N,
m12: N,
m21: N,
m22: N,
m31: N,
m32: N,
m41: N,
m42: N
) -> Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U3>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U3>,
fn new(
m11: N,
m12: N,
m13: N,
m21: N,
m22: N,
m23: N,
m31: N,
m32: N,
m33: N,
m41: N,
m42: N,
m43: N
) -> Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer>
[src]
m11: N,
m12: N,
m13: N,
m21: N,
m22: N,
m23: N,
m31: N,
m32: N,
m33: N,
m41: N,
m42: N,
m43: N
) -> Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U5>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U5>,
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
) -> Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer>
[src]
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
) -> Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U6>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U6>,
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>
[src]
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.
impl<N> Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U2>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U2>,
fn new(
m11: N,
m12: N,
m21: N,
m22: N,
m31: N,
m32: N,
m41: N,
m42: N,
m51: N,
m52: N
) -> Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer>
[src]
m11: N,
m12: N,
m21: N,
m22: N,
m31: N,
m32: N,
m41: N,
m42: N,
m51: N,
m52: N
) -> Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U3>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U3>,
fn new(
m11: N,
m12: N,
m13: N,
m21: N,
m22: N,
m23: N,
m31: N,
m32: N,
m33: N,
m41: N,
m42: N,
m43: N,
m51: N,
m52: N,
m53: N
) -> Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer>
[src]
m11: N,
m12: N,
m13: N,
m21: N,
m22: N,
m23: N,
m31: N,
m32: N,
m33: N,
m41: N,
m42: N,
m43: N,
m51: N,
m52: N,
m53: N
) -> Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U4>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U4>,
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
) -> Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer>
[src]
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
) -> Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U6>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U6>,
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>
[src]
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.
impl<N> Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U2>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U2>,
fn new(
m11: N,
m12: N,
m21: N,
m22: N,
m31: N,
m32: N,
m41: N,
m42: N,
m51: N,
m52: N,
m61: N,
m62: N
) -> Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer>
[src]
m11: N,
m12: N,
m21: N,
m22: N,
m31: N,
m32: N,
m41: N,
m42: N,
m51: N,
m52: N,
m61: N,
m62: N
) -> Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U3>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U3>,
fn new(
m11: N,
m12: N,
m13: N,
m21: N,
m22: N,
m23: N,
m31: N,
m32: N,
m33: N,
m41: N,
m42: N,
m43: N,
m51: N,
m52: N,
m53: N,
m61: N,
m62: N,
m63: N
) -> Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer>
[src]
m11: N,
m12: N,
m13: N,
m21: N,
m22: N,
m23: N,
m31: N,
m32: N,
m33: N,
m41: N,
m42: N,
m43: N,
m51: N,
m52: N,
m53: N,
m61: N,
m62: N,
m63: N
) -> Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U4>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U4>,
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>
[src]
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.
impl<N> Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U5>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U5>,
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>
[src]
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.
impl<N> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U1>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U1>,
fn new(
x: N
) -> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>
[src]
x: N
) -> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U2>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U2>,
fn new(
x: N,
y: N
) -> Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer>
[src]
x: N,
y: N
) -> Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U3>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U3>,
fn new(
x: N,
y: N,
z: N
) -> Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer>
[src]
x: N,
y: N,
z: N
) -> Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U4>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U4>,
fn new(
x: N,
y: N,
z: N,
w: N
) -> Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer>
[src]
x: N,
y: N,
z: N,
w: N
) -> Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U5>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U5>,
fn new(
x: N,
y: N,
z: N,
w: N,
a: N
) -> Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer>
[src]
x: N,
y: N,
z: N,
w: N,
a: N
) -> Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U1, U6>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U6>,
fn new(
x: N,
y: N,
z: N,
w: N,
a: N,
b: N
) -> Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer>
[src]
x: N,
y: N,
z: N,
w: N,
a: N,
b: N
) -> Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U2, U1>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U1>,
fn new(
x: N,
y: N
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
x: N,
y: N
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U3, U1>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U1>,
fn new(
x: N,
y: N,
z: N
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
x: N,
y: N,
z: N
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U4, U1>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U1>,
fn new(
x: N,
y: N,
z: N,
w: N
) -> Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>
[src]
x: N,
y: N,
z: N,
w: N
) -> Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U5, U1>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U1>,
fn new(
x: N,
y: N,
z: N,
w: N,
a: N
) -> Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer>
[src]
x: N,
y: N,
z: N,
w: N,
a: N
) -> Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer>
Initializes this matrix from its components.
impl<N> Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer> where
N: Scalar,
DefaultAllocator: Allocator<N, U6, U1>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U1>,
fn new(
x: N,
y: N,
z: N,
w: N,
a: N,
b: N
) -> Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer>
[src]
x: N,
y: N,
z: N,
w: N,
a: N,
b: N
) -> Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer>
Initializes this matrix from its components.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
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>>
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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>>
[src]
&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.
fn slice_with_steps(
&self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<N, Dynamic, Dynamic, Dynamic, Dynamic>>
[src]
&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.
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
CSlice: DimName,
RSlice: DimName,
[src]
&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
CSlice: DimName,
RSlice: DimName,
Slices this matrix starting at its component (irow, icol)
and with (R::dim(), CSlice::dim())
consecutive components.
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
CSlice: DimName,
RSlice: DimName,
[src]
&self,
start: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorage<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: DimName,
RSlice: 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.
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
CSlice: Dim,
RSlice: Dim,
[src]
&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
CSlice: Dim,
RSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
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
CSlice: Dim,
RSlice: Dim,
[src]
&self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorage<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: Dim,
RSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
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>,
[src]
&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.
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>,
[src]
&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.
impl<N, R, C, S> Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
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>>
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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,
[src]
&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.
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>>
[src]
&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.
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>>
[src]
&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.
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
CSlice: DimName,
RSlice: DimName,
[src]
&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
CSlice: DimName,
RSlice: DimName,
Slices this matrix starting at its component (irow, icol)
and with (R::dim(), CSlice::dim())
consecutive components.
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
CSlice: DimName,
RSlice: DimName,
[src]
&mut self,
start: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: DimName,
RSlice: 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.
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
CSlice: Dim,
RSlice: Dim,
[src]
&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
CSlice: Dim,
RSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
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
CSlice: Dim,
RSlice: Dim,
[src]
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: Dim,
RSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
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>,
[src]
&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.
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>,
[src]
&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.
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA> where
C1: Dim,
N: Scalar,
R1: Dim,
SA: Storage<N, R1, C1>,
[src]
C1: Dim,
N: Scalar,
R1: Dim,
SA: Storage<N, R1, C1>,
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
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
&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
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA> where
C1: Dim,
N: Scalar,
R1: Dim,
SA: StorageMut<N, R1, C1>,
[src]
C1: Dim,
N: Scalar,
R1: Dim,
SA: StorageMut<N, R1, C1>,
fn component_mul_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
fn component_mul_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
: This is renamed using the _assign
sufix instead of the _mut
suffix.
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA> where
C1: Dim,
N: Scalar,
R1: Dim,
SA: Storage<N, R1, C1>,
[src]
C1: Dim,
N: Scalar,
R1: Dim,
SA: Storage<N, R1, C1>,
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
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
&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
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<N, R1, C1, SA> Matrix<N, R1, C1, SA> where
C1: Dim,
N: Scalar,
R1: Dim,
SA: StorageMut<N, R1, C1>,
[src]
C1: Dim,
N: Scalar,
R1: Dim,
SA: StorageMut<N, R1, C1>,
fn component_div_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
fn component_div_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
: This is renamed using the _assign
sufix instead of the _mut
suffix.
Trait Implementations
impl<'a, N, R, C, S> Neg for &'a Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ClosedNeg,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar + ClosedNeg,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn neg(self) -> <&'a Matrix<N, R, C, S> as Neg>::Output
[src]
impl<N, R, C, S> Neg for Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ClosedNeg,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar + ClosedNeg,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn neg(self) -> <Matrix<N, R, C, S> as Neg>::Output
[src]
impl<N, R, C> InnerSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Real,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Real,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
type Real = N
fn angle(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> N
[src]
&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
[src]
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> N
impl<N, R, C> Rand for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: Dim,
N: Scalar + Rand,
R: Dim,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar + Rand,
R: Dim,
DefaultAllocator: Allocator<N, R, C>,
fn rand<G>(
rng: &mut G
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
G: Rng,
[src]
rng: &mut G
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
G: Rng,
impl<N, R, C, S> Copy for Matrix<N, R, C, S> where
C: Dim + Copy,
N: Scalar + Copy,
R: Dim + Copy,
S: Copy,
[src]
C: Dim + Copy,
N: Scalar + Copy,
R: Dim + Copy,
S: Copy,
impl<N, R, C, S> Clone for Matrix<N, R, C, S> where
C: Dim + Clone,
N: Scalar + Clone,
R: Dim + Clone,
S: Clone,
[src]
C: Dim + Clone,
N: Scalar + Clone,
R: Dim + Clone,
S: Clone,
fn clone(&self) -> Matrix<N, R, C, S>
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<N, R, C> AbstractMonoid<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + AbstractMonoid<Additive> + Zero + ClosedAdd<N>,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + AbstractMonoid<Additive> + Zero + ClosedAdd<N>,
R: DimName,
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> + One,
DefaultAllocator: Allocator<N, D, D>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + AbstractMonoid<Multiplicative> + One,
DefaultAllocator: Allocator<N, D, D>,
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
C1: Dim,
C2: Dim,
N1: Scalar,
N2: Scalar + SupersetOf<N1>,
R1: Dim,
R2: Dim,
DefaultAllocator: Allocator<N2, R2, C2>,
DefaultAllocator: Allocator<N1, R1, C1>,
DefaultAllocator: SameShapeAllocator<N1, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N1: Scalar,
N2: Scalar + SupersetOf<N1>,
R1: Dim,
R2: Dim,
DefaultAllocator: Allocator<N2, R2, C2>,
DefaultAllocator: Allocator<N1, R1, C1>,
DefaultAllocator: SameShapeAllocator<N1, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
fn to_superset(
&self
) -> Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>
[src]
&self
) -> Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>
fn is_in_subset(
m: &Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>
) -> bool
[src]
m: &Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>
) -> bool
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>
[src]
m: &Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>
) -> Matrix<N1, R1, C1, <DefaultAllocator as Allocator<N1, R1, C1>>::Buffer>
impl<N, R, C> Inverse<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + ClosedNeg,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + ClosedNeg,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
fn inverse(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn inverse_mut(&mut self)
[src]
impl<N, R, C> FiniteDimInnerSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Real,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Real,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
fn orthonormalize(
vs: &mut [Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>]
) -> usize
[src]
vs: &mut [Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>]
) -> usize
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,
[src]
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,
impl<N, S> Into<[N; 2]> for Matrix<N, U1, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U2>,
impl<N, S> Into<[N; 6]> for Matrix<N, U6, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U1>,
impl<N, S> Into<[N; 16]> for Matrix<N, U1, U16, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U16>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U16>,
impl<N, S> Into<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U3>,
impl<N, S> Into<[N; 15]> for Matrix<N, U15, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U15, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U15, U1>,
impl<N, S> Into<[N; 3]> for Matrix<N, U3, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U1>,
impl<N, S> Into<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U4>,
impl<N, S> Into<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U6>,
impl<N, S> Into<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U2>,
impl<N, S> Into<[N; 10]> for Matrix<N, U10, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U10, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U10, U1>,
impl<N, S> Into<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U4>,
impl<N, S> Into<[N; 5]> for Matrix<N, U1, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U5>,
impl<N, S> Into<[N; 5]> for Matrix<N, U5, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U1>,
impl<N, S> Into<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U3>,
impl<N, S> Into<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U4>,
impl<N, S> Into<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U5>,
impl<N, S> Into<[N; 12]> for Matrix<N, U12, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U12, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U12, U1>,
impl<N, S> Into<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U5>,
impl<N, S> Into<[N; 16]> for Matrix<N, U16, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U16, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U16, U1>,
impl<N, S> Into<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U6>,
impl<N, S> Into<[N; 7]> for Matrix<N, U7, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U7, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U7, U1>,
impl<N, S> Into<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U2>,
impl<N, S> Into<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U2>,
impl<N, S> Into<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U6>,
impl<N, S> Into<[N; 8]> for Matrix<N, U8, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U8, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U8, U1>,
impl<N, S> Into<[N; 6]> for Matrix<N, U1, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U6>,
impl<N, S> Into<[N; 15]> for Matrix<N, U1, U15, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U15>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U15>,
impl<N, S> Into<[N; 4]> for Matrix<N, U1, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U4>,
impl<N, S> Into<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U2>,
impl<N, S> Into<[N; 11]> for Matrix<N, U11, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U11, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U11, U1>,
impl<N, S> Into<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U5>,
impl<N, S> Into<[N; 2]> for Matrix<N, U2, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U1>,
impl<N, S> Into<[N; 9]> for Matrix<N, U1, U9, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U9>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U9>,
impl<N, S> Into<[N; 4]> for Matrix<N, U4, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U1>,
impl<N, S> Into<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U5>,
impl<N, S> Into<[N; 1]> for Matrix<N, U1, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U1>,
impl<N, S> Into<[N; 13]> for Matrix<N, U1, U13, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U13>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U13>,
impl<N, S> Into<[N; 7]> for Matrix<N, U1, U7, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U7>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U7>,
impl<N, S> Into<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U5>,
impl<N, S> Into<[N; 13]> for Matrix<N, U13, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U13, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U13, U1>,
impl<N, S> Into<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U2>,
impl<N, S> Into<[N; 14]> for Matrix<N, U1, U14, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U14>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U14>,
impl<N, S> Into<[N; 11]> for Matrix<N, U1, U11, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U11>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U11>,
impl<N, S> Into<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U3>,
impl<N, S> Into<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U4>,
impl<N, S> Into<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U6>,
impl<N, S> Into<[N; 3]> for Matrix<N, U1, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U3>,
impl<N, S> Into<[N; 8]> for Matrix<N, U1, U8, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U8>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U8>,
impl<N, S> Into<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U3>,
impl<N, S> Into<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U3>,
impl<N, S> Into<[N; 12]> for Matrix<N, U1, U12, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U12>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U12>,
impl<N, S> Into<[N; 10]> for Matrix<N, U1, U10, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U10>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U10>,
impl<N, S> Into<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U4>,
impl<N, S> Into<[N; 9]> for Matrix<N, U9, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U9, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U9, U1>,
impl<N, S> Into<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U6>,
impl<N, S> Into<[N; 14]> for Matrix<N, U14, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U14, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U14, U1>,
impl<N, D> Transformation<Point<N, <D as DimNameSub<U1>>::Output>> for Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, <D as DimNameSub<U1>>::Output>,
[src]
D: DimNameSub<U1>,
N: Real,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, <D as DimNameSub<U1>>::Output>,
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>
[src]
&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_point(
&self,
pt: &Point<N, <D as DimNameSub<U1>>::Output>
) -> Point<N, <D as DimNameSub<U1>>::Output>
[src]
&self,
pt: &Point<N, <D as DimNameSub<U1>>::Output>
) -> Point<N, <D as DimNameSub<U1>>::Output>
impl<'a, N, R, C, S> Div<N> for &'a Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ClosedDiv<N>,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar + ClosedDiv<N>,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn div(self, rhs: N) -> <&'a Matrix<N, R, C, S> as Div<N>>::Output
[src]
impl<'a, N, R1, C1, D2, SA> Div<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>
fn div(
self,
right: Rotation<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Div<Rotation<N, D2>>>::Output
[src]
self,
right: Rotation<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Div<Rotation<N, D2>>>::Output
impl<N, R1, C1, D2, SA> Div<Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>
fn div(
self,
right: Rotation<N, D2>
) -> <Matrix<N, R1, C1, SA> as Div<Rotation<N, D2>>>::Output
[src]
self,
right: Rotation<N, D2>
) -> <Matrix<N, R1, C1, SA> as Div<Rotation<N, D2>>>::Output
impl<N, R, C, S> Div<N> for Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ClosedDiv<N>,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar + ClosedDiv<N>,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn div(self, rhs: N) -> <Matrix<N, R, C, S> as Div<N>>::Output
[src]
impl<'a, 'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>
fn div(
self,
right: &'b Rotation<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Div<&'b Rotation<N, D2>>>::Output
[src]
self,
right: &'b Rotation<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Div<&'b Rotation<N, D2>>>::Output
impl<'b, N, R1, C1, D2, SA> Div<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>
fn div(
self,
right: &'b Rotation<N, D2>
) -> <Matrix<N, R1, C1, SA> as Div<&'b Rotation<N, D2>>>::Output
[src]
self,
right: &'b Rotation<N, D2>
) -> <Matrix<N, R1, C1, SA> as Div<&'b Rotation<N, D2>>>::Output
impl<N, R, C> Bounded for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + Bounded,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + Bounded,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
fn max_value(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn min_value(
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
impl<'a, N, R, C, S> IntoIterator for &'a mut Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
type Item = &'a mut N
type IntoIter = MatrixIterMut<'a, N, R, C, S>
fn into_iter(self) -> <&'a mut Matrix<N, R, C, S> as IntoIterator>::IntoIter
[src]
impl<'a, N, R, C, S> IntoIterator for &'a Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
type Item = &'a N
type IntoIter = MatrixIter<'a, N, R, C, S>
fn into_iter(self) -> <&'a Matrix<N, R, C, S> as IntoIterator>::IntoIter
[src]
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>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N> + AbstractSemigroup<Multiplicative>,
DefaultAllocator: Allocator<N, D, D>,
impl<N, R, C> AbstractSemigroup<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + AbstractSemigroup<Additive> + ClosedAdd<N>,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + AbstractSemigroup<Additive> + ClosedAdd<N>,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
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>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D, D>,
fn product<I>(
iter: I
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
I: Iterator<Item = &'a Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>>,
[src]
iter: I
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
I: Iterator<Item = &'a Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>>,
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>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D, D>,
fn product<I>(
iter: I
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
I: Iterator<Item = Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>>,
[src]
iter: I
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
I: Iterator<Item = Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>>,
impl<N, R, C> NormedSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Real,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Real,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
fn norm_squared(&self) -> N
[src]
fn norm(&self) -> N
[src]
fn normalize(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn normalize_mut(&mut self) -> N
[src]
fn try_normalize(
&self,
min_norm: N
) -> Option<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>>
[src]
&self,
min_norm: N
) -> Option<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>>
fn try_normalize_mut(&mut self, min_norm: N) -> Option<N>
[src]
impl<N, R, C> AbstractLoop<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + AbstractLoop<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + AbstractLoop<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
impl<'b, N, R1, C1> DivAssign<&'b Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, C1, C1>,
[src]
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, C1, C1>,
fn div_assign(&mut self, right: &'b Rotation<N, C1>)
[src]
impl<N, R, C, S> DivAssign<N> for Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ClosedDiv<N>,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar + ClosedDiv<N>,
R: Dim,
S: StorageMut<N, R, C>,
fn div_assign(&mut self, rhs: N)
[src]
impl<N, R1, C1> DivAssign<Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, C1, C1>,
[src]
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, C1, C1>,
fn div_assign(&mut self, right: Rotation<N, C1>)
[src]
impl<N, R, C> VectorSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + Field,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + Field,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
type Field = N
impl<N, R, C, S> ApproxEq for Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ApproxEq,
R: Dim,
S: Storage<N, R, C>,
<N as ApproxEq>::Epsilon: Copy,
[src]
C: Dim,
N: Scalar + ApproxEq,
R: Dim,
S: Storage<N, R, C>,
<N as ApproxEq>::Epsilon: Copy,
type Epsilon = <N as ApproxEq>::Epsilon
fn default_epsilon() -> <Matrix<N, R, C, S> as ApproxEq>::Epsilon
[src]
fn default_max_relative() -> <Matrix<N, R, C, S> as ApproxEq>::Epsilon
[src]
fn default_max_ulps() -> u32
[src]
fn relative_eq(
&self,
other: &Matrix<N, R, C, S>,
epsilon: <Matrix<N, R, C, S> as ApproxEq>::Epsilon,
max_relative: <Matrix<N, R, C, S> as ApproxEq>::Epsilon
) -> bool
[src]
&self,
other: &Matrix<N, R, C, S>,
epsilon: <Matrix<N, R, C, S> as ApproxEq>::Epsilon,
max_relative: <Matrix<N, R, C, S> as ApproxEq>::Epsilon
) -> bool
fn ulps_eq(
&self,
other: &Matrix<N, R, C, S>,
epsilon: <Matrix<N, R, C, S> as ApproxEq>::Epsilon,
max_ulps: u32
) -> bool
[src]
&self,
other: &Matrix<N, R, C, S>,
epsilon: <Matrix<N, R, C, S> as ApproxEq>::Epsilon,
max_ulps: u32
) -> bool
impl<N, R, C, S> PartialOrd<Matrix<N, R, C, S>> for Matrix<N, R, C, S> where
C: Dim,
N: Scalar + PartialOrd<N>,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar + PartialOrd<N>,
R: Dim,
S: Storage<N, R, C>,
fn partial_cmp(&self, other: &Matrix<N, R, C, S>) -> Option<Ordering>
[src]
fn lt(&self, right: &Matrix<N, R, C, S>) -> bool
[src]
fn le(&self, right: &Matrix<N, R, C, S>) -> bool
[src]
fn gt(&self, right: &Matrix<N, R, C, S>) -> bool
[src]
fn ge(&self, right: &Matrix<N, R, C, S>) -> bool
[src]
impl<N, R, C, S> Hash for Matrix<N, R, C, S> where
C: Dim + Hash,
N: Scalar + Hash,
R: Dim + Hash,
S: Hash,
[src]
C: Dim + Hash,
N: Scalar + Hash,
R: Dim + Hash,
S: Hash,
fn hash<__HNRCS>(&self, __arg_0: &mut __HNRCS) where
__HNRCS: Hasher,
[src]
__HNRCS: Hasher,
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<N, S> DerefMut for Matrix<N, U2, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U4>,
impl<N, S> DerefMut for Matrix<N, U3, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U2>,
impl<N, S> DerefMut for Matrix<N, U5, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U6>,
impl<N, S> DerefMut for Matrix<N, U1, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U1>,
impl<N, S> DerefMut for Matrix<N, U4, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U1>,
impl<N, S> DerefMut for Matrix<N, U1, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U2>,
impl<N, S> DerefMut for Matrix<N, U2, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U2>,
impl<N, S> DerefMut for Matrix<N, U1, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U4>,
impl<N, S> DerefMut for Matrix<N, U6, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U2>,
impl<N, S> DerefMut for Matrix<N, U5, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U4>,
impl<N, S> DerefMut for Matrix<N, U5, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U5>,
impl<N, S> DerefMut for Matrix<N, U1, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U3>,
impl<N, S> DerefMut for Matrix<N, U4, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U2>,
impl<N, S> DerefMut for Matrix<N, U3, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U4>,
impl<N, S> DerefMut for Matrix<N, U6, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U6>,
impl<N, S> DerefMut for Matrix<N, U2, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U5>,
impl<N, S> DerefMut for Matrix<N, U3, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U6>,
impl<N, S> DerefMut for Matrix<N, U5, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U1>,
impl<N, S> DerefMut for Matrix<N, U6, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U1>,
impl<N, S> DerefMut for Matrix<N, U4, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U6>,
impl<N, S> DerefMut for Matrix<N, U1, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U5>,
impl<N, S> DerefMut for Matrix<N, U3, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U3>,
impl<N, S> DerefMut for Matrix<N, U3, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U1>,
impl<N, S> DerefMut for Matrix<N, U1, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U6>,
impl<N, S> DerefMut for Matrix<N, U4, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U5>,
impl<N, S> DerefMut for Matrix<N, U6, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U5>,
impl<N, S> DerefMut for Matrix<N, U6, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U3>,
impl<N, S> DerefMut for Matrix<N, U4, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U3>,
impl<N, S> DerefMut for Matrix<N, U5, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U3>,
impl<N, S> DerefMut for Matrix<N, U3, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U5>,
impl<N, S> DerefMut for Matrix<N, U2, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U1>,
impl<N, S> DerefMut for Matrix<N, U2, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U3>,
impl<N, S> DerefMut for Matrix<N, U2, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U6>,
impl<N, S> DerefMut for Matrix<N, U5, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U2>,
impl<N, S> DerefMut for Matrix<N, U4, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U4>,
impl<N, S> DerefMut for Matrix<N, U6, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U4>,
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U5>,
fn from(
arr: [N; 5]
) -> Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer>
[src]
arr: [N; 5]
) -> Matrix<N, U1, U5, <DefaultAllocator as Allocator<N, U1, U5>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U5>,
fn from(
arr: [[N; 5]; 5]
) -> Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer>
[src]
arr: [[N; 5]; 5]
) -> Matrix<N, U5, U5, <DefaultAllocator as Allocator<N, U5, U5>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U8, U1>,
fn from(
arr: [N; 8]
) -> Matrix<N, U8, U1, <DefaultAllocator as Allocator<N, U8, U1>>::Buffer>
[src]
arr: [N; 8]
) -> Matrix<N, U8, U1, <DefaultAllocator as Allocator<N, U8, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U3>,
fn from(
arr: [N; 3]
) -> Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer>
[src]
arr: [N; 3]
) -> Matrix<N, U1, U3, <DefaultAllocator as Allocator<N, U1, U3>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U13>,
fn from(
arr: [N; 13]
) -> Matrix<N, U1, U13, <DefaultAllocator as Allocator<N, U1, U13>>::Buffer>
[src]
arr: [N; 13]
) -> Matrix<N, U1, U13, <DefaultAllocator as Allocator<N, U1, U13>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U4>,
fn from(
arr: [[N; 6]; 4]
) -> Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer>
[src]
arr: [[N; 6]; 4]
) -> Matrix<N, U6, U4, <DefaultAllocator as Allocator<N, U6, U4>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U12, U1>,
fn from(
arr: [N; 12]
) -> Matrix<N, U12, U1, <DefaultAllocator as Allocator<N, U12, U1>>::Buffer>
[src]
arr: [N; 12]
) -> Matrix<N, U12, U1, <DefaultAllocator as Allocator<N, U12, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U13, U1>,
fn from(
arr: [N; 13]
) -> Matrix<N, U13, U1, <DefaultAllocator as Allocator<N, U13, U1>>::Buffer>
[src]
arr: [N; 13]
) -> Matrix<N, U13, U1, <DefaultAllocator as Allocator<N, U13, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U1>,
fn from(
arr: [N; 2]
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
arr: [N; 2]
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U11, U1>,
fn from(
arr: [N; 11]
) -> Matrix<N, U11, U1, <DefaultAllocator as Allocator<N, U11, U1>>::Buffer>
[src]
arr: [N; 11]
) -> Matrix<N, U11, U1, <DefaultAllocator as Allocator<N, U11, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U3>,
fn from(
arr: [[N; 2]; 3]
) -> Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer>
[src]
arr: [[N; 2]; 3]
) -> Matrix<N, U2, U3, <DefaultAllocator as Allocator<N, U2, U3>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U16, U1>,
fn from(
arr: [N; 16]
) -> Matrix<N, U16, U1, <DefaultAllocator as Allocator<N, U16, U1>>::Buffer>
[src]
arr: [N; 16]
) -> Matrix<N, U16, U1, <DefaultAllocator as Allocator<N, U16, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U15, U1>,
fn from(
arr: [N; 15]
) -> Matrix<N, U15, U1, <DefaultAllocator as Allocator<N, U15, U1>>::Buffer>
[src]
arr: [N; 15]
) -> Matrix<N, U15, U1, <DefaultAllocator as Allocator<N, U15, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U15>,
fn from(
arr: [N; 15]
) -> Matrix<N, U1, U15, <DefaultAllocator as Allocator<N, U1, U15>>::Buffer>
[src]
arr: [N; 15]
) -> Matrix<N, U1, U15, <DefaultAllocator as Allocator<N, U1, U15>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U9>,
fn from(
arr: [N; 9]
) -> Matrix<N, U1, U9, <DefaultAllocator as Allocator<N, U1, U9>>::Buffer>
[src]
arr: [N; 9]
) -> Matrix<N, U1, U9, <DefaultAllocator as Allocator<N, U1, U9>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U1>,
fn from(
arr: [N; 4]
) -> Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>
[src]
arr: [N; 4]
) -> Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U6>,
fn from(
arr: [N; 6]
) -> Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer>
[src]
arr: [N; 6]
) -> Matrix<N, U1, U6, <DefaultAllocator as Allocator<N, U1, U6>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U2>,
fn from(
arr: [[N; 2]; 2]
) -> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>
[src]
arr: [[N; 2]; 2]
) -> Matrix<N, U2, U2, <DefaultAllocator as Allocator<N, U2, U2>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U7>,
fn from(
arr: [N; 7]
) -> Matrix<N, U1, U7, <DefaultAllocator as Allocator<N, U1, U7>>::Buffer>
[src]
arr: [N; 7]
) -> Matrix<N, U1, U7, <DefaultAllocator as Allocator<N, U1, U7>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U2>,
fn from(
arr: [N; 2]
) -> Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer>
[src]
arr: [N; 2]
) -> Matrix<N, U1, U2, <DefaultAllocator as Allocator<N, U1, U2>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U16>,
fn from(
arr: [N; 16]
) -> Matrix<N, U1, U16, <DefaultAllocator as Allocator<N, U1, U16>>::Buffer>
[src]
arr: [N; 16]
) -> Matrix<N, U1, U16, <DefaultAllocator as Allocator<N, U1, U16>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U8>,
fn from(
arr: [N; 8]
) -> Matrix<N, U1, U8, <DefaultAllocator as Allocator<N, U1, U8>>::Buffer>
[src]
arr: [N; 8]
) -> Matrix<N, U1, U8, <DefaultAllocator as Allocator<N, U1, U8>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U5>,
fn from(
arr: [[N; 4]; 5]
) -> Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer>
[src]
arr: [[N; 4]; 5]
) -> Matrix<N, U4, U5, <DefaultAllocator as Allocator<N, U4, U5>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U7, U1>,
fn from(
arr: [N; 7]
) -> Matrix<N, U7, U1, <DefaultAllocator as Allocator<N, U7, U1>>::Buffer>
[src]
arr: [N; 7]
) -> Matrix<N, U7, U1, <DefaultAllocator as Allocator<N, U7, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U14>,
fn from(
arr: [N; 14]
) -> Matrix<N, U1, U14, <DefaultAllocator as Allocator<N, U1, U14>>::Buffer>
[src]
arr: [N; 14]
) -> Matrix<N, U1, U14, <DefaultAllocator as Allocator<N, U1, U14>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U12>,
fn from(
arr: [N; 12]
) -> Matrix<N, U1, U12, <DefaultAllocator as Allocator<N, U1, U12>>::Buffer>
[src]
arr: [N; 12]
) -> Matrix<N, U1, U12, <DefaultAllocator as Allocator<N, U1, U12>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U3>,
fn from(
arr: [[N; 6]; 3]
) -> Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer>
[src]
arr: [[N; 6]; 3]
) -> Matrix<N, U6, U3, <DefaultAllocator as Allocator<N, U6, U3>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U3>,
fn from(
arr: [[N; 5]; 3]
) -> Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer>
[src]
arr: [[N; 5]; 3]
) -> Matrix<N, U5, U3, <DefaultAllocator as Allocator<N, U5, U3>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U3>,
fn from(
arr: [[N; 3]; 3]
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
[src]
arr: [[N; 3]; 3]
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U6>,
fn from(
arr: [[N; 2]; 6]
) -> Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer>
[src]
arr: [[N; 2]; 6]
) -> Matrix<N, U2, U6, <DefaultAllocator as Allocator<N, U2, U6>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U6>,
fn from(
arr: [[N; 5]; 6]
) -> Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer>
[src]
arr: [[N; 5]; 6]
) -> Matrix<N, U5, U6, <DefaultAllocator as Allocator<N, U5, U6>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U1>,
fn from(
arr: [N; 6]
) -> Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer>
[src]
arr: [N; 6]
) -> Matrix<N, U6, U1, <DefaultAllocator as Allocator<N, U6, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U2>,
fn from(
arr: [[N; 6]; 2]
) -> Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer>
[src]
arr: [[N; 6]; 2]
) -> Matrix<N, U6, U2, <DefaultAllocator as Allocator<N, U6, U2>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U6>,
fn from(
arr: [[N; 3]; 6]
) -> Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer>
[src]
arr: [[N; 3]; 6]
) -> Matrix<N, U3, U6, <DefaultAllocator as Allocator<N, U3, U6>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U6>,
fn from(
arr: [[N; 4]; 6]
) -> Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer>
[src]
arr: [[N; 4]; 6]
) -> Matrix<N, U4, U6, <DefaultAllocator as Allocator<N, U4, U6>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U1>,
fn from(
arr: [N; 1]
) -> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>
[src]
arr: [N; 1]
) -> Matrix<N, U1, U1, <DefaultAllocator as Allocator<N, U1, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U9, U1>,
fn from(
arr: [N; 9]
) -> Matrix<N, U9, U1, <DefaultAllocator as Allocator<N, U9, U1>>::Buffer>
[src]
arr: [N; 9]
) -> Matrix<N, U9, U1, <DefaultAllocator as Allocator<N, U9, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U10, U1>,
fn from(
arr: [N; 10]
) -> Matrix<N, U10, U1, <DefaultAllocator as Allocator<N, U10, U1>>::Buffer>
[src]
arr: [N; 10]
) -> Matrix<N, U10, U1, <DefaultAllocator as Allocator<N, U10, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U5>,
fn from(
arr: [[N; 6]; 5]
) -> Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer>
[src]
arr: [[N; 6]; 5]
) -> Matrix<N, U6, U5, <DefaultAllocator as Allocator<N, U6, U5>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U4>,
fn from(
arr: [[N; 4]; 4]
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
[src]
arr: [[N; 4]; 4]
) -> Matrix<N, U4, U4, <DefaultAllocator as Allocator<N, U4, U4>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U1>,
fn from(
arr: [N; 3]
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
arr: [N; 3]
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U4>,
fn from(
arr: [N; 4]
) -> Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer>
[src]
arr: [N; 4]
) -> Matrix<N, U1, U4, <DefaultAllocator as Allocator<N, U1, U4>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U4>,
fn from(
arr: [[N; 3]; 4]
) -> Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer>
[src]
arr: [[N; 3]; 4]
) -> Matrix<N, U3, U4, <DefaultAllocator as Allocator<N, U3, U4>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U4>,
fn from(
arr: [[N; 2]; 4]
) -> Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer>
[src]
arr: [[N; 2]; 4]
) -> Matrix<N, U2, U4, <DefaultAllocator as Allocator<N, U2, U4>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U6, U6>,
fn from(
arr: [[N; 6]; 6]
) -> Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer>
[src]
arr: [[N; 6]; 6]
) -> Matrix<N, U6, U6, <DefaultAllocator as Allocator<N, U6, U6>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U4>,
fn from(
arr: [[N; 5]; 4]
) -> Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer>
[src]
arr: [[N; 5]; 4]
) -> Matrix<N, U5, U4, <DefaultAllocator as Allocator<N, U5, U4>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U3>,
fn from(
arr: [[N; 4]; 3]
) -> Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer>
[src]
arr: [[N; 4]; 3]
) -> Matrix<N, U4, U3, <DefaultAllocator as Allocator<N, U4, U3>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U1>,
fn from(
arr: [N; 5]
) -> Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer>
[src]
arr: [N; 5]
) -> Matrix<N, U5, U1, <DefaultAllocator as Allocator<N, U5, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U2>,
fn from(
arr: [[N; 3]; 2]
) -> Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer>
[src]
arr: [[N; 3]; 2]
) -> Matrix<N, U3, U2, <DefaultAllocator as Allocator<N, U3, U2>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U5, U2>,
fn from(
arr: [[N; 5]; 2]
) -> Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer>
[src]
arr: [[N; 5]; 2]
) -> Matrix<N, U5, U2, <DefaultAllocator as Allocator<N, U5, U2>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U10>,
fn from(
arr: [N; 10]
) -> Matrix<N, U1, U10, <DefaultAllocator as Allocator<N, U1, U10>>::Buffer>
[src]
arr: [N; 10]
) -> Matrix<N, U1, U10, <DefaultAllocator as Allocator<N, U1, U10>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U4, U2>,
fn from(
arr: [[N; 4]; 2]
) -> Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer>
[src]
arr: [[N; 4]; 2]
) -> Matrix<N, U4, U2, <DefaultAllocator as Allocator<N, U4, U2>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U14, U1>,
fn from(
arr: [N; 14]
) -> Matrix<N, U14, U1, <DefaultAllocator as Allocator<N, U14, U1>>::Buffer>
[src]
arr: [N; 14]
) -> Matrix<N, U14, U1, <DefaultAllocator as Allocator<N, U14, U1>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U3, U5>,
fn from(
arr: [[N; 3]; 5]
) -> Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer>
[src]
arr: [[N; 3]; 5]
) -> Matrix<N, U3, U5, <DefaultAllocator as Allocator<N, U3, U5>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U1, U11>,
fn from(
arr: [N; 11]
) -> Matrix<N, U1, U11, <DefaultAllocator as Allocator<N, U1, U11>>::Buffer>
[src]
arr: [N; 11]
) -> Matrix<N, U1, U11, <DefaultAllocator as Allocator<N, U1, U11>>::Buffer>
Performs the conversion.
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>,
[src]
N: Scalar,
DefaultAllocator: Allocator<N, U2, U5>,
fn from(
arr: [[N; 2]; 5]
) -> Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer>
[src]
arr: [[N; 2]; 5]
) -> Matrix<N, U2, U5, <DefaultAllocator as Allocator<N, U2, U5>>::Buffer>
Performs the conversion.
impl<N, R, C> MeetSemilattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: Dim,
N: Scalar + MeetSemilattice,
R: Dim,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar + MeetSemilattice,
R: Dim,
DefaultAllocator: Allocator<N, R, C>,
fn meet(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
impl<N, R, C, S> PartialEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
fn eq(&self, right: &Matrix<N, R, C, S>) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<'a, N, R1, C1, R2, C2, SA, SB> Add<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1>,
ShapeConstraint: SameNumberOfColumns<C2, C1>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1>,
ShapeConstraint: 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>
fn add(
self,
rhs: Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Add<Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Add<Matrix<N, R2, C2, SB>>>::Output
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
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: 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>
fn add(
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Add<&'b Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Add<&'b Matrix<N, R2, C2, SB>>>::Output
impl<'b, N, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: 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>
fn add(
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Add<&'b Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Add<&'b Matrix<N, R2, C2, SB>>>::Output
impl<N, R1, C1, R2, C2, SA, SB> Add<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: 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>
fn add(
self,
rhs: Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Add<Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Add<Matrix<N, R2, C2, SB>>>::Output
impl<N, R, C, S> Debug for Matrix<N, R, C, S> where
C: Dim + Debug,
N: Scalar + Debug,
R: Dim + Debug,
S: Debug,
[src]
C: Dim + Debug,
N: Scalar + Debug,
R: Dim + Debug,
S: Debug,
fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter.
impl<N, R, C> Lattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: Dim,
N: Scalar + Lattice,
R: Dim,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar + Lattice,
R: Dim,
DefaultAllocator: Allocator<N, R, C>,
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>)
[src]
&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>)
impl<N, R, C> FiniteDimVectorSpace for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + Field,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + Field,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
fn dimension() -> usize
[src]
fn canonical_basis_element(
i: usize
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
i: usize
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn dot(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> N
[src]
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> N
unsafe fn component_unchecked(&self, i: usize) -> &N
[src]
unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut N
[src]
impl<'b, N, R1, C1, R2, C2, SA, SB> AddAssign<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
fn add_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>)
[src]
impl<N, R1, C1, R2, C2, SA, SB> AddAssign<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedAdd<N>,
R1: Dim,
R2: Dim,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
fn add_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)
[src]
impl<N, R, C> AbstractQuasigroup<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + AbstractQuasigroup<Additive> + ClosedAdd<N> + ClosedNeg,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + AbstractQuasigroup<Additive> + ClosedAdd<N> + ClosedNeg,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R1, C1, R2, C2, SA, SB> SubAssign<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
fn sub_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)
[src]
impl<'b, N, R1, C1, R2, C2, SA, SB> SubAssign<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
fn sub_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>)
[src]
impl<N, R, C> AbstractGroup<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + AbstractGroup<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + AbstractGroup<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
R: DimName,
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
C: DimName,
N: Scalar + ClosedAdd<N> + Zero,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + ClosedAdd<N> + Zero,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
fn sum<I>(
iter: I
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
I: Iterator<Item = &'a Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>>,
[src]
iter: I
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
I: Iterator<Item = &'a Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>>,
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
C: DimName,
N: Scalar + ClosedAdd<N> + Zero,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + ClosedAdd<N> + Zero,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
fn sum<I>(
iter: I
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
I: Iterator<Item = Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>>,
[src]
iter: I
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
I: Iterator<Item = Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>>,
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>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedMul<N> + ClosedAdd<N>,
DefaultAllocator: Allocator<N, D, D>,
impl<N, R, C> AbstractModule<Additive, Additive, Multiplicative> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + RingCommutative,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + RingCommutative,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
type AbstractRing = N
fn multiply_by(
&self,
n: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
&self,
n: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
impl<N, R, C, S> Index<(usize, usize)> for Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
impl<N, R, C, S> Index<usize> for Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: Storage<N, R, C>,
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>,
[src]
D: DimName,
N: Scalar + Zero + One,
DefaultAllocator: Allocator<N, D, D>,
impl<N, R, C> Identity<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + Zero,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + Zero,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R, C, S> Eq for Matrix<N, R, C, S> where
C: Dim,
N: Scalar + Eq,
R: Dim,
S: Storage<N, R, C>,
[src]
C: Dim,
N: Scalar + Eq,
R: Dim,
S: Storage<N, R, C>,
impl<N, S> Deref for Matrix<N, U3, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U1>,
impl<N, S> Deref for Matrix<N, U5, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U3>,
impl<N, S> Deref for Matrix<N, U6, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U2>,
impl<N, S> Deref for Matrix<N, U1, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U3>,
impl<N, S> Deref for Matrix<N, U3, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U3>,
impl<N, S> Deref for Matrix<N, U6, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U4>,
impl<N, S> Deref for Matrix<N, U3, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U4>,
impl<N, S> Deref for Matrix<N, U1, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U2>,
impl<N, S> Deref for Matrix<N, U1, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U1>,
impl<N, S> Deref for Matrix<N, U1, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U5>,
impl<N, S> Deref for Matrix<N, U4, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U2>,
impl<N, S> Deref for Matrix<N, U1, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U6>,
impl<N, S> Deref for Matrix<N, U2, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U1>,
impl<N, S> Deref for Matrix<N, U4, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U6>,
impl<N, S> Deref for Matrix<N, U4, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U3>,
impl<N, S> Deref for Matrix<N, U5, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U5>,
impl<N, S> Deref for Matrix<N, U6, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U5>,
impl<N, S> Deref for Matrix<N, U4, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U1>,
impl<N, S> Deref for Matrix<N, U2, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U4>,
impl<N, S> Deref for Matrix<N, U6, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U6>,
impl<N, S> Deref for Matrix<N, U5, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U4>,
impl<N, S> Deref for Matrix<N, U6, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U3>,
impl<N, S> Deref for Matrix<N, U2, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U6>,
impl<N, S> Deref for Matrix<N, U6, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U1>,
impl<N, S> Deref for Matrix<N, U3, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U2>,
impl<N, S> Deref for Matrix<N, U3, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U6>,
impl<N, S> Deref for Matrix<N, U2, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U5>,
impl<N, S> Deref for Matrix<N, U5, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U2>,
impl<N, S> Deref for Matrix<N, U5, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U1>,
impl<N, S> Deref for Matrix<N, U1, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U4>,
impl<N, S> Deref for Matrix<N, U5, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U6>,
impl<N, S> Deref for Matrix<N, U2, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U3>,
impl<N, S> Deref for Matrix<N, U4, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U4>,
impl<N, S> Deref for Matrix<N, U4, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U5>,
impl<N, S> Deref for Matrix<N, U2, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U2>,
impl<N, S> Deref for Matrix<N, U3, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U5>,
impl<N, R, C> AbstractGroupAbelian<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + AbstractGroupAbelian<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + AbstractGroupAbelian<Additive> + Zero + ClosedAdd<N> + ClosedNeg,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
impl<N, S> AsRef<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U2>,
impl<N, S> AsRef<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U5>,
impl<N, S> AsRef<[N; 1]> for Matrix<N, U1, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U1>,
impl<N, S> AsRef<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U5>,
impl<N, S> AsRef<[N; 4]> for Matrix<N, U1, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U4>,
impl<N, S> AsRef<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U4>,
impl<N, S> AsRef<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U2>,
impl<N, S> AsRef<[N; 12]> for Matrix<N, U12, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U12, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U12, U1>,
impl<N, S> AsRef<[N; 16]> for Matrix<N, U1, U16, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U16>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U16>,
impl<N, S> AsRef<[N; 7]> for Matrix<N, U1, U7, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U7>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U7>,
impl<N, S> AsRef<[N; 3]> for Matrix<N, U1, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U3>,
impl<N, S> AsRef<[N; 6]> for Matrix<N, U1, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U6>,
impl<N, S> AsRef<[N; 10]> for Matrix<N, U1, U10, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U10>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U10>,
impl<N, S> AsRef<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U6>,
impl<N, S> AsRef<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U5>,
impl<N, S> AsRef<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U5>,
impl<N, S> AsRef<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U6>,
impl<N, S> AsRef<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U4>,
impl<N, S> AsRef<[N; 12]> for Matrix<N, U1, U12, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U12>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U12>,
impl<N, S> AsRef<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U2>,
impl<N, S> AsRef<[N; 14]> for Matrix<N, U14, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U14, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U14, U1>,
impl<N, S> AsRef<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U2>,
impl<N, S> AsRef<[N; 13]> for Matrix<N, U13, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U13, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U13, U1>,
impl<N, S> AsRef<[N; 11]> for Matrix<N, U1, U11, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U11>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U11>,
impl<N, S> AsRef<[N; 2]> for Matrix<N, U2, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U1>,
impl<N, S> AsRef<[N; 8]> for Matrix<N, U1, U8, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U8>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U8>,
impl<N, S> AsRef<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U3>,
impl<N, S> AsRef<[N; 7]> for Matrix<N, U7, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U7, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U7, U1>,
impl<N, S> AsRef<[N; 5]> for Matrix<N, U5, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U1>,
impl<N, S> AsRef<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U2>,
impl<N, S> AsRef<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U5>,
impl<N, S> AsRef<[N; 15]> for Matrix<N, U15, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U15, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U15, U1>,
impl<N, S> AsRef<[N; 10]> for Matrix<N, U10, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U10, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U10, U1>,
impl<N, S> AsRef<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U6>,
impl<N, S> AsRef<[N; 5]> for Matrix<N, U1, U5, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U5>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U5>,
impl<N, S> AsRef<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U4>,
impl<N, S> AsRef<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U4>,
impl<N, S> AsRef<[N; 16]> for Matrix<N, U16, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U16, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U16, U1>,
impl<N, S> AsRef<[N; 13]> for Matrix<N, U1, U13, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U13>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U13>,
impl<N, S> AsRef<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U4>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U4>,
impl<N, S> AsRef<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U2, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U2, U3>,
impl<N, S> AsRef<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U3>,
impl<N, S> AsRef<[N; 9]> for Matrix<N, U9, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U9, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U9, U1>,
impl<N, S> AsRef<[N; 8]> for Matrix<N, U8, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U8, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U8, U1>,
impl<N, S> AsRef<[N; 15]> for Matrix<N, U1, U15, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U15>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U15>,
impl<N, S> AsRef<[N; 2]> for Matrix<N, U1, U2, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U2>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U2>,
impl<N, S> AsRef<[N; 14]> for Matrix<N, U1, U14, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U14>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U14>,
impl<N, S> AsRef<[N; 4]> for Matrix<N, U4, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U1>,
impl<N, S> AsRef<[N; 9]> for Matrix<N, U1, U9, S> where
N: Scalar,
S: ContiguousStorage<N, U1, U9>,
[src]
N: Scalar,
S: ContiguousStorage<N, U1, U9>,
impl<N, S> AsRef<[N; 3]> for Matrix<N, U3, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U1>,
impl<N, S> AsRef<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U5, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U5, U6>,
impl<N, S> AsRef<[N; 11]> for Matrix<N, U11, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U11, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U11, U1>,
impl<N, S> AsRef<[N; 6]> for Matrix<N, U6, U1, S> where
N: Scalar,
S: ContiguousStorage<N, U6, U1>,
[src]
N: Scalar,
S: ContiguousStorage<N, U6, U1>,
impl<N, S> AsRef<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U4, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U4, U3>,
impl<N, S> AsRef<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U6>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U6>,
impl<N, S> AsRef<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where
N: Scalar,
S: ContiguousStorage<N, U3, U3>,
[src]
N: Scalar,
S: ContiguousStorage<N, U3, U3>,
impl<N, S> AsMut<[N; 15]> for Matrix<N, U15, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U15, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U15, U1>,
impl<N, S> AsMut<[N; 11]> for Matrix<N, U1, U11, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U11>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U11>,
impl<N, S> AsMut<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U3>,
impl<N, S> AsMut<[N; 6]> for Matrix<N, U1, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U6>,
impl<N, S> AsMut<[N; 16]> for Matrix<N, U16, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U16, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U16, U1>,
impl<N, S> AsMut<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U2>,
impl<N, S> AsMut<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U5>,
impl<N, S> AsMut<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U4>,
impl<N, S> AsMut<[N; 3]> for Matrix<N, U1, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U3>,
impl<N, S> AsMut<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U2>,
impl<N, S> AsMut<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U4>,
impl<N, S> AsMut<[N; 12]> for Matrix<N, U1, U12, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U12>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U12>,
impl<N, S> AsMut<[N; 10]> for Matrix<N, U1, U10, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U10>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U10>,
impl<N, S> AsMut<[N; 2]> for Matrix<N, U1, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U2>,
impl<N, S> AsMut<[N; 12]> for Matrix<N, U12, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U12, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U12, U1>,
impl<N, S> AsMut<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U6>,
impl<N, S> AsMut<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U3>,
impl<N, S> AsMut<[N; 9]> for Matrix<N, U9, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U9, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U9, U1>,
impl<N, S> AsMut<[N; 4]> for Matrix<N, U4, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U1>,
impl<N, S> AsMut<[N; 4]> for Matrix<N, U1, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U4>,
impl<N, S> AsMut<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U2>,
impl<N, S> AsMut<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U5>,
impl<N, S> AsMut<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U3>,
impl<N, S> AsMut<[N; 2]> for Matrix<N, U2, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U1>,
impl<N, S> AsMut<[N; 8]> for Matrix<N, U8, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U8, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U8, U1>,
impl<N, S> AsMut<[N; 16]> for Matrix<N, U1, U16, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U16>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U16>,
impl<N, S> AsMut<[N; 5]> for Matrix<N, U1, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U5>,
impl<N, S> AsMut<[N; 9]> for Matrix<N, U1, U9, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U9>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U9>,
impl<N, S> AsMut<[N; 7]> for Matrix<N, U7, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U7, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U7, U1>,
impl<N, S> AsMut<[N; 13]> for Matrix<N, U1, U13, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U13>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U13>,
impl<N, S> AsMut<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U2>,
impl<N, S> AsMut<[N; 14]> for Matrix<N, U1, U14, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U14>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U14>,
impl<N, S> AsMut<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U4>,
impl<N, S> AsMut<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U4>,
impl<N, S> AsMut<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U3>,
impl<N, S> AsMut<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U5>,
impl<N, S> AsMut<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U6>,
impl<N, S> AsMut<[N; 15]> for Matrix<N, U1, U15, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U15>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U15>,
impl<N, S> AsMut<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U6>,
impl<N, S> AsMut<[N; 11]> for Matrix<N, U11, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U11, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U11, U1>,
impl<N, S> AsMut<[N; 10]> for Matrix<N, U10, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U10, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U10, U1>,
impl<N, S> AsMut<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U5>,
impl<N, S> AsMut<[N; 1]> for Matrix<N, U1, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U1>,
impl<N, S> AsMut<[N; 7]> for Matrix<N, U1, U7, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U7>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U7>,
impl<N, S> AsMut<[N; 6]> for Matrix<N, U6, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U1>,
impl<N, S> AsMut<[N; 8]> for Matrix<N, U1, U8, S> where
N: Scalar,
S: ContiguousStorageMut<N, U1, U8>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U1, U8>,
impl<N, S> AsMut<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U5>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U5>,
impl<N, S> AsMut<[N; 13]> for Matrix<N, U13, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U13, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U13, U1>,
impl<N, S> AsMut<[N; 3]> for Matrix<N, U3, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U3, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U3, U1>,
impl<N, S> AsMut<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U6>,
impl<N, S> AsMut<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U4>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U4>,
impl<N, S> AsMut<[N; 5]> for Matrix<N, U5, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U5, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U5, U1>,
impl<N, S> AsMut<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where
N: Scalar,
S: ContiguousStorageMut<N, U4, U6>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U4, U6>,
impl<N, S> AsMut<[N; 14]> for Matrix<N, U14, U1, S> where
N: Scalar,
S: ContiguousStorageMut<N, U14, U1>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U14, U1>,
impl<N, S> AsMut<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where
N: Scalar,
S: ContiguousStorageMut<N, U6, U2>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U6, U2>,
impl<N, S> AsMut<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where
N: Scalar,
S: ContiguousStorageMut<N, U2, U3>,
[src]
N: Scalar,
S: ContiguousStorageMut<N, U2, U3>,
impl<N, R, C> Zero for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + Zero + ClosedAdd<N>,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + Zero + ClosedAdd<N>,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
fn zero() -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
fn is_zero(&self) -> bool
[src]
impl<'b, N, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
SB: Storage<N, R2, C1>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
<DefaultAllocator as Allocator<N, R1, C1>>::Buffer == SA,
[src]
C1: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
SB: Storage<N, R2, C1>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
<DefaultAllocator as Allocator<N, R1, C1>>::Buffer == SA,
fn mul_assign(&mut self, rhs: &'b Matrix<N, R2, C1, SB>)
[src]
impl<N, R1, C1, R2, SA, SB> MulAssign<Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
SB: Storage<N, R2, C1>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
<DefaultAllocator as Allocator<N, R1, C1>>::Buffer == SA,
[src]
C1: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
SB: Storage<N, R2, C1>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
<DefaultAllocator as Allocator<N, R1, C1>>::Buffer == SA,
fn mul_assign(&mut self, rhs: Matrix<N, R2, C1, SB>)
[src]
impl<N, R, C, S> MulAssign<N> for Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ClosedMul<N>,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar + ClosedMul<N>,
R: Dim,
S: StorageMut<N, R, C>,
fn mul_assign(&mut self, rhs: N)
[src]
impl<N, R1, C1> MulAssign<Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, C1, C1>,
[src]
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, C1, C1>,
fn mul_assign(&mut self, right: Rotation<N, C1>)
[src]
impl<'b, N, R1, C1> MulAssign<&'b Rotation<N, C1>> for Matrix<N, R1, C1, <DefaultAllocator as Allocator<N, R1, C1>>::Buffer> where
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, C1, C1>,
[src]
C1: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, C1, C1>,
fn mul_assign(&mut self, right: &'b Rotation<N, C1>)
[src]
impl<N, R, C> AbstractMagma<Additive> for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + ClosedAdd<N>,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + ClosedAdd<N>,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
fn operate(
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
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>,
[src]
D: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
DefaultAllocator: Allocator<N, D, D>,
fn operate(
&self,
other: &Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
[src]
&self,
other: &Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>
impl<'a, 'b, N, R1, C1, D2, SA> Mul<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>
fn mul(
self,
right: &'b Rotation<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<&'b Rotation<N, D2>>>::Output
[src]
self,
right: &'b Rotation<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<&'b Rotation<N, D2>>>::Output
impl<N, R1, C1, D2, SA> Mul<Point<N, D2>> for Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, U1>,
DefaultAllocator: Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, U1>,
DefaultAllocator: Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
type Output = Point<N, R1>
fn mul(
self,
right: Point<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<Point<N, D2>>>::Output
[src]
self,
right: Point<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<Point<N, D2>>>::Output
impl<N, R1, C1, D2, SA> Mul<Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>
fn mul(
self,
right: Rotation<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<Rotation<N, D2>>>::Output
[src]
self,
right: Rotation<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<Rotation<N, D2>>>::Output
impl<'a, N, R, C, S> Mul<N> for &'a Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ClosedMul<N>,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar + ClosedMul<N>,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn mul(self, rhs: N) -> <&'a Matrix<N, R, C, S> as Mul<N>>::Output
[src]
impl<N, R, C, S> Mul<N> for Matrix<N, R, C, S> where
C: Dim,
N: Scalar + ClosedMul<N>,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar + ClosedMul<N>,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
fn mul(self, rhs: N) -> <Matrix<N, R, C, S> as Mul<N>>::Output
[src]
impl<'b, N, R1, C1, D2, SA> Mul<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>
fn mul(
self,
right: &'b Rotation<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<&'b Rotation<N, D2>>>::Output
[src]
self,
right: &'b Rotation<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<&'b Rotation<N, D2>>>::Output
impl<'a, N, R1, C1, D2, SA> Mul<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = Matrix<N, R1, D2, <DefaultAllocator as Allocator<N, R1, D2>>::Buffer>
fn mul(
self,
right: Rotation<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<Rotation<N, D2>>>::Output
[src]
self,
right: Rotation<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<Rotation<N, D2>>>::Output
impl<'b, N, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
type Output = Matrix<N, R1, C2, <DefaultAllocator as Allocator<N, R1, C2>>::Buffer>
fn mul(
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Mul<&'b Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Mul<&'b Matrix<N, R2, C2, SB>>>::Output
impl<N, R1, C1, R2, C2, SA, SB> Mul<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
type Output = Matrix<N, R1, C2, <DefaultAllocator as Allocator<N, R1, C2>>::Buffer>
fn mul(
self,
rhs: Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Mul<Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Mul<Matrix<N, R2, C2, SB>>>::Output
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
C1: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
type Output = Matrix<N, R1, C2, <DefaultAllocator as Allocator<N, R1, C2>>::Buffer>
fn mul(
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<&'b Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<&'b Matrix<N, R2, C2, SB>>>::Output
impl<'b, N, R1, C1, D2, SA> Mul<&'b Point<N, D2>> for Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, U1>,
DefaultAllocator: Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, U1>,
DefaultAllocator: Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
type Output = Point<N, R1>
fn mul(
self,
right: &'b Point<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<&'b Point<N, D2>>>::Output
[src]
self,
right: &'b Point<N, D2>
) -> <Matrix<N, R1, C1, SA> as Mul<&'b Point<N, D2>>>::Output
impl<'a, N, R1, C1, R2, C2, SA, SB> Mul<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
type Output = Matrix<N, R1, C2, <DefaultAllocator as Allocator<N, R1, C2>>::Buffer>
fn mul(
self,
rhs: Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<Matrix<N, R2, C2, SB>>>::Output
impl<'a, 'b, N, R1, C1, D2, SA> Mul<&'b Point<N, D2>> for &'a Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, U1>,
DefaultAllocator: Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, U1>,
DefaultAllocator: Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
type Output = Point<N, R1>
fn mul(
self,
right: &'b Point<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<&'b Point<N, D2>>>::Output
[src]
self,
right: &'b Point<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<&'b Point<N, D2>>>::Output
impl<'a, N, R1, C1, D2, SA> Mul<Point<N, D2>> for &'a Matrix<N, R1, C1, SA> where
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, U1>,
DefaultAllocator: Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
[src]
C1: Dim,
D2: DimName,
N: Scalar + Zero + One + ClosedAdd<N> + ClosedMul<N>,
R1: DimName,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C1>,
DefaultAllocator: Allocator<N, D2, U1>,
DefaultAllocator: Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
type Output = Point<N, R1>
fn mul(
self,
right: Point<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<Point<N, D2>>>::Output
[src]
self,
right: Point<N, D2>
) -> <&'a Matrix<N, R1, C1, SA> as Mul<Point<N, D2>>>::Output
impl<N, R, C> Module for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: DimName,
N: Scalar + RingCommutative,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: DimName,
N: Scalar + RingCommutative,
R: DimName,
DefaultAllocator: Allocator<N, R, C>,
type Ring = N
impl<N, R, C, S> IndexMut<(usize, usize)> for Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
impl<N, R, C, S> IndexMut<usize> for Matrix<N, R, C, S> where
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
[src]
C: Dim,
N: Scalar,
R: Dim,
S: StorageMut<N, R, C>,
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
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: 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>
fn sub(
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Sub<&'b Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Sub<&'b Matrix<N, R2, C2, SB>>>::Output
impl<'b, N, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: 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>
fn sub(
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Sub<&'b Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: &'b Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Sub<&'b Matrix<N, R2, C2, SB>>>::Output
impl<'a, N, R1, C1, R2, C2, SA, SB> Sub<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1>,
ShapeConstraint: SameNumberOfColumns<C2, C1>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1>,
ShapeConstraint: 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>
fn sub(
self,
rhs: Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Sub<Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: Matrix<N, R2, C2, SB>
) -> <&'a Matrix<N, R1, C1, SA> as Sub<Matrix<N, R2, C2, SB>>>::Output
impl<N, R1, C1, R2, C2, SA, SB> Sub<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C1: Dim,
C2: Dim,
N: Scalar + ClosedSub<N>,
R1: Dim,
R2: Dim,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: 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>
fn sub(
self,
rhs: Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Sub<Matrix<N, R2, C2, SB>>>::Output
[src]
self,
rhs: Matrix<N, R2, C2, SB>
) -> <Matrix<N, R1, C1, SA> as Sub<Matrix<N, R2, C2, SB>>>::Output
impl<N, R, C> JoinSemilattice for Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
C: Dim,
N: Scalar + JoinSemilattice,
R: Dim,
DefaultAllocator: Allocator<N, R, C>,
[src]
C: Dim,
N: Scalar + JoinSemilattice,
R: Dim,
DefaultAllocator: Allocator<N, R, C>,
fn 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>
[src]
&self,
other: &Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
impl<N, R, C, S> Display for Matrix<N, R, C, S> where
C: Dim,
N: Scalar + Display,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<usize, R, C>,
[src]
C: Dim,
N: Scalar + Display,
R: Dim,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<usize, R, C>,