[−][src]Struct nalgebra::base::Matrix
The most generic column-major matrix (and vector) type.
It combines four type parameters:
N
: for the matrix components scalar type.R
: for the matrix number of rows.C
: for the matrix number of columns.S
: for the matrix data storage, i.e., the buffer that actually contains the matrix components.
The matrix dimensions parameters R
and C
can either be:
- type-level unsigned integer constants (e.g.
U1
,U124
) from thenalgebra::
root module. All numbers from 0 to 127Â are defined that way. - type-level unsigned integer constants (e.g.
U1024
,U10000
) from thetypenum::
crate. Using those, you will not get error messages as nice as for numbers smaller than 128 defined on thenalgebra::
module. - the special value
Dynamic
from thenalgebra::
root module. This indicates that the specified dimension is not known at compile-time. Note that this will generally imply that the matrix data storageS
performs a dynamic allocation and contains extra metadata for the matrix shape.
Note that mixing Dynamic
with type-level unsigned integers is allowed. Actually, a
dynamically-sized column vector should be represented as a Matrix<N, Dynamic, U1, S>
(given
some concrete types for N
and a compatible data storage type S
).
Fields
data: S
The data storage that contains all the matrix components and informations about its number of rows and column (if needed).
Methods
impl<N: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn iamax_full(&self) -> (usize, usize)
[src]
Computes the index of the matrix component with the largest absolute value.
Examples:
let mat = Matrix2x3::new(11, -12, 13, 21, 22, -23); assert_eq!(mat.iamax_full(), (1, 2));
impl<N, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
pub fn dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N where
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
[src]
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
The dot product between two vectors or matrices (seen as vectors).
Note that this is not the matrix multiplication as in, e.g., numpy. For matrix
multiplication, use one of: .gemm
, .mul_to
, .mul
, the *
operator.
Examples:
let vec1 = Vector3::new(1.0, 2.0, 3.0); let vec2 = Vector3::new(0.1, 0.2, 0.3); assert_eq!(vec1.dot(&vec2), 1.4); let mat1 = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); let mat2 = Matrix2x3::new(0.1, 0.2, 0.3, 0.4, 0.5, 0.6); assert_eq!(mat1.dot(&mat2), 9.1);
pub fn tr_dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N where
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<C, R2> + DimEq<R, C2>,
[src]
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<C, R2> + DimEq<R, C2>,
The dot product between the transpose of self
and rhs
.
Examples:
let vec1 = Vector3::new(1.0, 2.0, 3.0); let vec2 = RowVector3::new(0.1, 0.2, 0.3); assert_eq!(vec1.tr_dot(&vec2), 1.4); let mat1 = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); let mat2 = Matrix3x2::new(0.1, 0.4, 0.2, 0.5, 0.3, 0.6); assert_eq!(mat1.tr_dot(&mat2), 9.1);
impl<N, R1: Dim, C1: Dim, S: StorageMut<N, R1, C1>> Matrix<N, R1, C1, S> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
pub fn ger<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: N,
x: &Vector<N, D2, SB>,
y: &Vector<N, D3, SC>,
beta: N
) where
N: One,
SB: Storage<N, D2>,
SC: Storage<N, D3>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
[src]
&mut self,
alpha: N,
x: &Vector<N, D2, SB>,
y: &Vector<N, D3, SC>,
beta: N
) where
N: One,
SB: Storage<N, D2>,
SC: Storage<N, D3>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
Computes self = alpha * x * y.transpose() + beta * self
.
If beta
is zero, self
is never read.
Examples:
let mut mat = Matrix2x3::repeat(4.0); let vec1 = Vector2::new(1.0, 2.0); let vec2 = Vector3::new(0.1, 0.2, 0.3); let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0; mat.ger(10.0, &vec1, &vec2, 5.0); assert_eq!(mat, expected);
pub fn gemm<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C3> + 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
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C3> + AreMultipliable<R2, C2, R3, C3>,
Computes self = alpha * a * b + beta * self
, where a, b, self
are matrices.
alpha
and beta
are scalar.
If beta
is zero, self
is never read.
Examples:
let mut mat1 = Matrix2x4::identity(); let mat2 = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); let mat3 = Matrix3x4::new(0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2); let expected = mat2 * mat3 * 10.0 + mat1 * 5.0; mat1.gemm(10.0, &mat2, &mat3, 5.0); assert_relative_eq!(mat1, expected);
pub fn gemm_tr<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + AreMultipliable<C2, R2, R3, C3>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
N: One,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + AreMultipliable<C2, R2, R3, C3>,
Computes self = alpha * a.transpose() * b + beta * self
, where a, b, self
are matrices.
alpha
and beta
are scalar.
If beta
is zero, self
is never read.
Examples:
let mut mat1 = Matrix2x4::identity(); let mat2 = Matrix3x2::new(1.0, 4.0, 2.0, 5.0, 3.0, 6.0); let mat3 = Matrix3x4::new(0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2); let expected = mat2.transpose() * mat3 * 10.0 + mat1 * 5.0; mat1.gemm_tr(10.0, &mat2, &mat3, 5.0); assert_relative_eq!(mat1, expected);
impl<N, R1: Dim, C1: Dim, S: StorageMut<N, R1, C1>> Matrix<N, R1, C1, S> where
N: Scalar + Zero + ClosedAdd + ClosedMul,
[src]
N: Scalar + Zero + ClosedAdd + ClosedMul,
pub fn ger_symm<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: N,
x: &Vector<N, D2, SB>,
y: &Vector<N, D3, SC>,
beta: N
) where
N: One,
SB: Storage<N, D2>,
SC: Storage<N, D3>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
[src]
&mut self,
alpha: N,
x: &Vector<N, D2, SB>,
y: &Vector<N, D3, SC>,
beta: N
) where
N: One,
SB: Storage<N, D2>,
SC: Storage<N, D3>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
Computes self = alpha * x * y.transpose() + beta * self
, where self
is a symmetric
matrix.
If beta
is zero, self
is never read. The result is symmetric. Only the lower-triangular
(including the diagonal) part of self
is read/written.
Examples:
let mut mat = Matrix2::identity(); let vec1 = Vector2::new(1.0, 2.0); let vec2 = Vector2::new(0.1, 0.2); let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0; mat.m12 = 99999.99999; // This component is on the upper-triangular part and will not be read/written. mat.ger_symm(10.0, &vec1, &vec2, 5.0); assert_eq!(mat.lower_triangle(), expected.lower_triangle()); assert_eq!(mat.m12, 99999.99999); // This was untouched.
impl<N, R: Dim, C: Dim, S> Matrix<N, R, C, S> where
N: Scalar + ClosedNeg,
S: StorageMut<N, R, C>,
[src]
N: Scalar + ClosedNeg,
S: StorageMut<N, R, C>,
impl<N, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA> where
N: Scalar + ClosedAdd,
[src]
N: Scalar + ClosedAdd,
pub fn add_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
impl<N, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA> where
N: Scalar + ClosedSub,
[src]
N: Scalar + ClosedSub,
pub fn sub_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
impl<N, R1: Dim, C1: Dim, SA> Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SA: Storage<N, R1, C1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SA: Storage<N, R1, C1>,
pub fn tr_mul<R2: Dim, C2: Dim, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> MatrixMN<N, C1, C2> where
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> MatrixMN<N, C1, C2> where
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
Equivalent to self.transpose() * rhs
.
pub fn tr_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
Equivalent to self.transpose() * rhs
but stores the result into out
to avoid
allocations.
pub fn mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1> + SameNumberOfColumns<C3, C2> + AreMultipliable<R1, C1, R2, C2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1> + SameNumberOfColumns<C3, C2> + AreMultipliable<R1, C1, R2, C2>,
Equivalent to self * rhs
but stores the result into out
to avoid allocations.
pub fn kronecker<R2: Dim, C2: Dim, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> MatrixMN<N, DimProd<R1, R2>, DimProd<C1, C2>> where
N: ClosedMul,
R1: DimMul<R2>,
C1: DimMul<C2>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, DimProd<R1, R2>, DimProd<C1, C2>>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> MatrixMN<N, DimProd<R1, R2>, DimProd<C1, C2>> where
N: ClosedMul,
R1: DimMul<R2>,
C1: DimMul<C2>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, DimProd<R1, R2>, DimProd<C1, C2>>,
The kronecker product of two matrices (aka. tensor product of the corresponding linear maps).
impl<N: Scalar + ClosedAdd, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn add_scalar(&self, rhs: N) -> MatrixMN<N, R, C> where
DefaultAllocator: Allocator<N, R, C>,
[src]
DefaultAllocator: Allocator<N, R, C>,
Adds a scalar to self
.
pub 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: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn amax(&self) -> N
[src]
Returns the absolute value of the coefficient with the largest absolute value.
pub fn amin(&self) -> N
[src]
Returns the absolute value of the coefficient with the smallest absolute value.
impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn abs(&self) -> MatrixMN<N, R, C> where
N: Signed,
DefaultAllocator: Allocator<N, R, C>,
[src]
N: Signed,
DefaultAllocator: Allocator<N, R, C>,
Computes the component-wise absolute value.
Example
let a = Matrix2::new(0.0, 1.0, -2.0, -3.0); assert_eq!(a.abs(), Matrix2::new(0.0, 1.0, 2.0, 3.0))
impl<N: Scalar, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA>
[src]
pub fn component_mul<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> MatrixSum<N, R1, C1, R2, C2> where
N: ClosedMul,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> MatrixSum<N, R1, C1, R2, C2> where
N: ClosedMul,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Componentwise matrix or vector multiplication.
Example
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0); let b = Matrix2::new(4.0, 5.0, 6.0, 7.0); let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0); assert_eq!(a.component_mul(&b), expected);
impl<N: Scalar, R1: Dim, C1: Dim, SA: StorageMut<N, R1, C1>> Matrix<N, R1, C1, SA>
[src]
pub fn cmpy<R2, C2, SB, R3, C3, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
N: ClosedMul + Zero + Mul<N, Output = N> + Add<N, Output = N>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
N: ClosedMul + Zero + Mul<N, Output = N> + Add<N, Output = N>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Computes componentwise self[i] = alpha * a[i] * b[i] + beta * self[i]
.
Example
let mut m = Matrix2::new(0.0, 1.0, 2.0, 3.0); let a = Matrix2::new(0.0, 1.0, 2.0, 3.0); let b = Matrix2::new(4.0, 5.0, 6.0, 7.0); let expected = (a.component_mul(&b) * 5.0) + m * 10.0; m.cmpy(5.0, &a, &b, 10.0); assert_eq!(m, expected);
pub fn component_mul_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where
N: ClosedMul,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
N: ClosedMul,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Inplace componentwise matrix or vector multiplication.
Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0); let b = Matrix2::new(4.0, 5.0, 6.0, 7.0); let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0); a.component_mul_assign(&b); assert_eq!(a, expected);
pub fn component_mul_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where
N: ClosedMul,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
N: ClosedMul,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
This is renamed using the _assign
suffix instead of the _mut
suffix.
Inplace componentwise matrix or vector multiplication.
Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0); let b = Matrix2::new(4.0, 5.0, 6.0, 7.0); let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0); a.component_mul_assign(&b); assert_eq!(a, expected);
impl<N: Scalar, R1: Dim, C1: Dim, SA: Storage<N, R1, C1>> Matrix<N, R1, C1, SA>
[src]
pub fn component_div<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> MatrixSum<N, R1, C1, R2, C2> where
N: ClosedDiv,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> MatrixSum<N, R1, C1, R2, C2> where
N: ClosedDiv,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Componentwise matrix or vector division.
Example
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0); let b = Matrix2::new(4.0, 5.0, 6.0, 7.0); let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0); assert_eq!(a.component_div(&b), expected);
impl<N: Scalar, R1: Dim, C1: Dim, SA: StorageMut<N, R1, C1>> Matrix<N, R1, C1, SA>
[src]
pub fn cdpy<R2, C2, SB, R3, C3, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
N: ClosedDiv + Zero + Mul<N, Output = N> + Add<N, Output = N>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
N: ClosedDiv + Zero + Mul<N, Output = N> + Add<N, Output = N>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Computes componentwise self[i] = alpha * a[i] / b[i] + beta * self[i]
.
Example
let mut m = Matrix2::new(0.0, 1.0, 2.0, 3.0); let a = Matrix2::new(4.0, 5.0, 6.0, 7.0); let b = Matrix2::new(4.0, 5.0, 6.0, 7.0); let expected = (a.component_div(&b) * 5.0) + m * 10.0; m.cdpy(5.0, &a, &b, 10.0); assert_eq!(m, expected);
pub fn component_div_assign<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where
N: ClosedDiv,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
N: ClosedDiv,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Inplace componentwise matrix or vector division.
Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0); let b = Matrix2::new(4.0, 5.0, 6.0, 7.0); let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0); a.component_div_assign(&b); assert_eq!(a, expected);
pub fn component_div_mut<R2, C2, SB>(&mut self, rhs: &Matrix<N, R2, C2, SB>) where
N: ClosedDiv,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
N: ClosedDiv,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
This is renamed using the _assign
suffix instead of the _mut
suffix.
Inplace componentwise matrix or vector division.
Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0); let b = Matrix2::new(4.0, 5.0, 6.0, 7.0); let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0); a.component_div_assign(&b); assert_eq!(a, expected);
impl<N: Scalar + Zero, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn upper_triangle(&self) -> MatrixMN<N, R, C> where
DefaultAllocator: Allocator<N, R, C>,
[src]
DefaultAllocator: Allocator<N, R, C>,
Extracts the upper triangular part of this matrix (including the diagonal).
pub fn lower_triangle(&self) -> MatrixMN<N, R, C> where
DefaultAllocator: Allocator<N, R, C>,
[src]
DefaultAllocator: Allocator<N, R, C>,
Extracts the upper triangular part of this matrix (including the diagonal).
impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn fill(&mut self, val: N)
[src]
Sets all the elements of this matrix to val
.
pub fn fill_with_identity(&mut self) where
N: Zero + One,
[src]
N: Zero + One,
Fills self
with the identity matrix.
pub fn fill_diagonal(&mut self, val: N)
[src]
Sets all the diagonal elements of this matrix to val
.
pub fn fill_row(&mut self, i: usize, val: N)
[src]
Sets all the elements of the selected row to val
.
pub fn fill_column(&mut self, j: usize, val: N)
[src]
Sets all the elements of the selected column to val
.
pub fn set_diagonal<R2: Dim, S2>(&mut self, diag: &Vector<N, R2, S2>) where
R: DimMin<C>,
S2: Storage<N, R2>,
ShapeConstraint: DimEq<DimMinimum<R, C>, R2>,
[src]
R: DimMin<C>,
S2: Storage<N, R2>,
ShapeConstraint: DimEq<DimMinimum<R, C>, R2>,
Fills the diagonal of this matrix with the content of the given vector.
pub fn set_row<C2: Dim, S2>(&mut self, i: usize, row: &RowVector<N, C2, S2>) where
S2: Storage<N, U1, C2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
S2: Storage<N, U1, C2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Fills the selected row of this matrix with the content of the given vector.
pub fn set_column<R2: Dim, S2>(&mut self, i: usize, column: &Vector<N, R2, S2>) where
S2: Storage<N, R2, U1>,
ShapeConstraint: SameNumberOfRows<R, R2>,
[src]
S2: Storage<N, R2, U1>,
ShapeConstraint: SameNumberOfRows<R, R2>,
Fills the selected column of this matrix with the content of the given vector.
pub 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 firstshift - 1
subdiagonals are left untouched.
pub 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 firstshift - 1
superdiagonals are left untouched.
pub fn swap_rows(&mut self, irow1: usize, irow2: usize)
[src]
Swaps two rows in-place.
pub fn swap_columns(&mut self, icol1: usize, icol2: usize)
[src]
Swaps two columns in-place.
impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S>
[src]
pub 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.
pub 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: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn remove_column(self, i: usize) -> MatrixMN<N, R, DimDiff<C, U1>> where
C: DimSub<U1>,
DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, U1>>,
[src]
C: DimSub<U1>,
DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, U1>>,
Removes the i
-th column from this matrix.
pub fn remove_fixed_columns<D>(self, i: usize) -> MatrixMN<N, R, DimDiff<C, D>> where
D: DimName,
C: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, D>>,
[src]
D: DimName,
C: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, D>>,
Removes D::dim()
consecutive columns from this matrix, starting with the i
-th
(included).
pub fn remove_columns(self, i: usize, n: usize) -> MatrixMN<N, R, Dynamic> where
C: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,
[src]
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).
pub fn remove_columns_generic<D>(
self,
i: usize,
nremove: D
) -> MatrixMN<N, R, DimDiff<C, D>> where
D: Dim,
C: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, D>>,
[src]
self,
i: usize,
nremove: D
) -> MatrixMN<N, R, DimDiff<C, D>> where
D: Dim,
C: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, R, DimDiff<C, D>>,
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.
pub fn remove_row(self, i: usize) -> MatrixMN<N, DimDiff<R, U1>, C> where
R: DimSub<U1>,
DefaultAllocator: Reallocator<N, R, C, DimDiff<R, U1>, C>,
[src]
R: DimSub<U1>,
DefaultAllocator: Reallocator<N, R, C, DimDiff<R, U1>, C>,
Removes the i
-th row from this matrix.
pub fn remove_fixed_rows<D>(self, i: usize) -> MatrixMN<N, DimDiff<R, D>, C> where
D: DimName,
R: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, DimDiff<R, D>, C>,
[src]
D: DimName,
R: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, DimDiff<R, D>, C>,
Removes D::dim()
consecutive rows from this matrix, starting with the i
-th (included).
pub fn remove_rows(self, i: usize, n: usize) -> MatrixMN<N, Dynamic, C> where
R: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
[src]
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).
pub fn remove_rows_generic<D>(
self,
i: usize,
nremove: D
) -> MatrixMN<N, DimDiff<R, D>, C> where
D: Dim,
R: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, DimDiff<R, D>, C>,
[src]
self,
i: usize,
nremove: D
) -> MatrixMN<N, DimDiff<R, D>, C> where
D: Dim,
R: DimSub<D>,
DefaultAllocator: Reallocator<N, R, C, DimDiff<R, D>, 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.
pub fn insert_column(self, i: usize, val: N) -> MatrixMN<N, R, DimSum<C, U1>> where
C: DimAdd<U1>,
DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, U1>>,
[src]
C: DimAdd<U1>,
DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, U1>>,
Inserts a column filled with val
at the i-th
position.
pub fn insert_fixed_columns<D>(
self,
i: usize,
val: N
) -> MatrixMN<N, R, DimSum<C, D>> where
D: DimName,
C: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, D>>,
[src]
self,
i: usize,
val: N
) -> MatrixMN<N, R, DimSum<C, D>> where
D: DimName,
C: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, D>>,
Inserts D::dim()
columns filled with val
starting at the i-th
position.
pub fn insert_columns(
self,
i: usize,
n: usize,
val: N
) -> MatrixMN<N, R, Dynamic> where
C: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, R, Dynamic>,
[src]
self,
i: usize,
n: usize,
val: N
) -> MatrixMN<N, R, Dynamic> 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.
pub unsafe fn insert_columns_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> MatrixMN<N, R, DimSum<C, D>> where
D: Dim,
C: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, D>>,
[src]
self,
i: usize,
ninsert: D
) -> MatrixMN<N, R, DimSum<C, D>> where
D: Dim,
C: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, R, DimSum<C, D>>,
Inserts ninsert.value()
columns starting at the i-th
place of this matrix.
The added column values are not initialized.
pub fn insert_row(self, i: usize, val: N) -> MatrixMN<N, DimSum<R, U1>, C> where
R: DimAdd<U1>,
DefaultAllocator: Reallocator<N, R, C, DimSum<R, U1>, C>,
[src]
R: DimAdd<U1>,
DefaultAllocator: Reallocator<N, R, C, DimSum<R, U1>, C>,
Inserts a row filled with val
at the i-th
position.
pub fn insert_fixed_rows<D>(
self,
i: usize,
val: N
) -> MatrixMN<N, DimSum<R, D>, C> where
D: DimName,
R: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, DimSum<R, D>, C>,
[src]
self,
i: usize,
val: N
) -> MatrixMN<N, DimSum<R, D>, C> where
D: DimName,
R: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, DimSum<R, D>, C>,
Inserts D::dim()
rows filled with val
starting at the i-th
position.
pub fn insert_rows(self, i: usize, n: usize, val: N) -> MatrixMN<N, Dynamic, C> where
R: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
[src]
R: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<N, R, C, Dynamic, C>,
Inserts n
rows filled with val
starting at the i-th
position.
pub unsafe fn insert_rows_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> MatrixMN<N, DimSum<R, D>, C> where
D: Dim,
R: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, DimSum<R, D>, C>,
[src]
self,
i: usize,
ninsert: D
) -> MatrixMN<N, DimSum<R, D>, C> where
D: Dim,
R: DimAdd<D>,
DefaultAllocator: Reallocator<N, R, C, DimSum<R, D>, 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.
pub fn resize(self, new_nrows: usize, new_ncols: usize, val: N) -> DMatrix<N> where
DefaultAllocator: Reallocator<N, R, C, Dynamic, Dynamic>,
[src]
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
.
pub fn fixed_resize<R2: DimName, C2: DimName>(
self,
val: N
) -> MatrixMN<N, R2, C2> where
DefaultAllocator: Reallocator<N, R, C, R2, C2>,
[src]
self,
val: N
) -> MatrixMN<N, R2, C2> where
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
.
pub fn resize_generic<R2: Dim, C2: Dim>(
self,
new_nrows: R2,
new_ncols: C2,
val: N
) -> MatrixMN<N, R2, C2> where
DefaultAllocator: Reallocator<N, R, C, R2, C2>,
[src]
self,
new_nrows: R2,
new_ncols: C2,
val: N
) -> MatrixMN<N, R2, C2> where
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: Scalar, R: Dim, C: Dim, S> Matrix<N, R, C, S>
[src]
pub 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: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn from_data(data: S) -> Matrix<N, R, C, S>
[src]
Creates a new matrix with the given data.
pub fn len(&self) -> usize
[src]
The total number of elements of this matrix.
Examples:
let mat = Matrix3x4::<f32>::zeros(); assert_eq!(mat.len(), 12);
pub fn shape(&self) -> (usize, usize)
[src]
The shape of this matrix returned as the tuple (number of rows, number of columns).
Examples:
let mat = Matrix3x4::<f32>::zeros(); assert_eq!(mat.shape(), (3, 4));
pub fn nrows(&self) -> usize
[src]
The number of rows of this matrix.
Examples:
let mat = Matrix3x4::<f32>::zeros(); assert_eq!(mat.nrows(), 3);
pub fn ncols(&self) -> usize
[src]
The number of columns of this matrix.
Examples:
let mat = Matrix3x4::<f32>::zeros(); assert_eq!(mat.ncols(), 4);
pub fn strides(&self) -> (usize, usize)
[src]
The strides (row stride, column stride) of this matrix.
Examples:
let mat = DMatrix::<f32>::zeros(10, 10); let slice = mat.slice_with_steps((0, 0), (5, 3), (1, 2)); // The column strides is the number of steps (here 2) multiplied by the corresponding dimension. assert_eq!(mat.strides(), (1, 10));
ⓘImportant traits for MatrixIter<'a, N, R, C, S>pub fn iter(&self) -> MatrixIter<N, R, C, S>
[src]
Iterates through this matrix coordinates in column-major order.
Examples:
let mat = Matrix2x3::new(11, 12, 13, 21, 22, 23); let mut it = mat.iter(); assert_eq!(*it.next().unwrap(), 11); assert_eq!(*it.next().unwrap(), 21); assert_eq!(*it.next().unwrap(), 12); assert_eq!(*it.next().unwrap(), 22); assert_eq!(*it.next().unwrap(), 13); assert_eq!(*it.next().unwrap(), 23); assert!(it.next().is_none());
pub 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.
pub 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.
pub fn relative_eq<R2, C2, SB>(
&self,
other: &Matrix<N, R2, C2, SB>,
eps: N::Epsilon,
max_relative: N::Epsilon
) -> bool where
N: RelativeEq,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
N::Epsilon: Copy,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
[src]
&self,
other: &Matrix<N, R2, C2, SB>,
eps: N::Epsilon,
max_relative: N::Epsilon
) -> bool where
N: RelativeEq,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
N::Epsilon: Copy,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are equal up to a given epsilon.
See relative_eq
from the RelativeEq
trait for more details.
pub fn eq<R2, C2, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> bool where
N: PartialEq,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
[src]
N: PartialEq,
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are exactly equal.
pub fn into_owned(self) -> MatrixMN<N, R, C> where
DefaultAllocator: Allocator<N, R, C>,
[src]
DefaultAllocator: Allocator<N, R, C>,
Moves this matrix into one that owns its data.
pub fn into_owned_sum<R2, C2>(self) -> MatrixSum<N, R, C, R2, C2> where
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
[src]
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Moves this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.
pub fn clone_owned(&self) -> MatrixMN<N, R, C> where
DefaultAllocator: Allocator<N, R, C>,
[src]
DefaultAllocator: Allocator<N, R, C>,
Clones this matrix to one that owns its data.
pub fn clone_owned_sum<R2, C2>(&self) -> MatrixSum<N, R, C, R2, C2> where
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
[src]
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Clones this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.
pub fn map<N2: Scalar, F: FnMut(N) -> N2>(&self, f: F) -> MatrixMN<N2, R, C> where
DefaultAllocator: Allocator<N2, R, C>,
[src]
DefaultAllocator: Allocator<N2, R, C>,
Returns a matrix containing the result of f
applied to each of its entries.
pub fn map_with_location<N2: Scalar, F: FnMut(usize, usize, N) -> N2>(
&self,
f: F
) -> MatrixMN<N2, R, C> where
DefaultAllocator: Allocator<N2, R, C>,
[src]
&self,
f: F
) -> MatrixMN<N2, R, C> where
DefaultAllocator: Allocator<N2, R, C>,
Returns a matrix containing the result of f
applied to each of its entries. Unlike map
,
f
also gets passed the row and column index, i.e. f(value, row, col)
.
pub fn zip_map<N2, N3, S2, F>(
&self,
rhs: &Matrix<N2, R, C, S2>,
f: F
) -> MatrixMN<N3, R, C> where
N2: Scalar,
N3: Scalar,
S2: Storage<N2, R, C>,
F: FnMut(N, N2) -> N3,
DefaultAllocator: Allocator<N3, R, C>,
[src]
&self,
rhs: &Matrix<N2, R, C, S2>,
f: F
) -> MatrixMN<N3, R, C> where
N2: Scalar,
N3: Scalar,
S2: Storage<N2, R, C>,
F: FnMut(N, N2) -> N3,
DefaultAllocator: Allocator<N3, R, C>,
Returns a matrix containing the result of f
applied to each entries of self
and
rhs
.
pub fn zip_zip_map<N2, N3, N4, S2, S3, F>(
&self,
b: &Matrix<N2, R, C, S2>,
c: &Matrix<N3, R, C, S3>,
f: F
) -> MatrixMN<N4, R, C> where
N2: Scalar,
N3: Scalar,
N4: Scalar,
S2: Storage<N2, R, C>,
S3: Storage<N3, R, C>,
F: FnMut(N, N2, N3) -> N4,
DefaultAllocator: Allocator<N4, R, C>,
[src]
&self,
b: &Matrix<N2, R, C, S2>,
c: &Matrix<N3, R, C, S3>,
f: F
) -> MatrixMN<N4, R, C> where
N2: Scalar,
N3: Scalar,
N4: Scalar,
S2: Storage<N2, R, C>,
S3: Storage<N3, R, C>,
F: FnMut(N, N2, N3) -> N4,
DefaultAllocator: Allocator<N4, R, C>,
Returns a matrix containing the result of f
applied to each entries of self
and
b
, and c
.
pub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>) where
R2: Dim,
C2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
[src]
R2: Dim,
C2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
Transposes self
and store the result into out
.
pub fn transpose(&self) -> MatrixMN<N, C, R> where
DefaultAllocator: Allocator<N, C, R>,
[src]
DefaultAllocator: Allocator<N, C, R>,
Transposes self
.
impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>
[src]
ⓘImportant traits for MatrixIterMut<'a, N, R, C, S>pub fn iter_mut(&mut self) -> MatrixIterMut<N, R, C, S>
[src]
Mutably iterates through this matrix coordinates.
pub 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.
pub 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.
pub fn swap(&mut self, row_cols1: (usize, usize), row_cols2: (usize, usize))
[src]
Swaps two entries.
pub fn copy_from_slice(&mut self, slice: &[N])
[src]
Fills this matrix with the content of a slice. Both must hold the same number of elements.
The components of the slice are assumed to be ordered in column-major order.
pub fn copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>) where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
[src]
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Fills this matrix with the content of another one. Both must have the same shape.
pub fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>) where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, C2> + SameNumberOfColumns<C, R2>,
[src]
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, C2> + SameNumberOfColumns<C, R2>,
Fills this matrix with the content of the transpose another one.
pub fn apply<F: FnMut(N) -> N>(&mut self, f: F) where
DefaultAllocator: Allocator<N, R, C>,
[src]
DefaultAllocator: Allocator<N, R, C>,
Replaces each component of self
by the result of a closure f
applied on it.
impl<N: Scalar, R: Dim, C: Dim, S: ContiguousStorage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn as_slice(&self) -> &[N]
[src]
Extracts a slice containing the entire matrix entries ordered column-by-columns.
impl<N: Scalar, R: Dim, C: Dim, S: ContiguousStorageMut<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn as_mut_slice(&mut self) -> &mut [N]
[src]
Extracts a mutable slice containing the entire matrix entries ordered column-by-columns.
impl<N: Scalar, D: Dim, S: StorageMut<N, D, D>> Matrix<N, D, D, S>
[src]
pub fn transpose_mut(&mut self)
[src]
Transposes the square matrix self
in-place.
impl<N: Real, R: Dim, C: Dim, S: Storage<Complex<N>, R, C>> Matrix<Complex<N>, R, C, S>
[src]
pub fn conjugate_transpose_to<R2, C2, SB>(
&self,
out: &mut Matrix<Complex<N>, R2, C2, SB>
) where
R2: Dim,
C2: Dim,
SB: StorageMut<Complex<N>, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
[src]
&self,
out: &mut Matrix<Complex<N>, R2, C2, SB>
) where
R2: Dim,
C2: Dim,
SB: StorageMut<Complex<N>, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2> + SameNumberOfColumns<C, R2>,
Takes the conjugate and transposes self
and store the result into out
.
pub fn conjugate_transpose(&self) -> MatrixMN<Complex<N>, C, R> where
DefaultAllocator: Allocator<Complex<N>, C, R>,
[src]
DefaultAllocator: Allocator<Complex<N>, C, R>,
The conjugate transposition of self
.
impl<N: Real, D: Dim, S: StorageMut<Complex<N>, D, D>> Matrix<Complex<N>, D, D, S>
[src]
pub fn conjugate_transpose_mut(&mut self)
[src]
Sets self
to its conjugate transpose.
impl<N: Scalar + One + Zero, D: DimAdd<U1> + IsNotStaticOne, S: Storage<N, D, D>> Matrix<N, D, D, S>
[src]
pub fn to_homogeneous(&self) -> MatrixN<N, DimSum<D, U1>> where
DefaultAllocator: Allocator<N, DimSum<D, U1>, DimSum<D, U1>>,
[src]
DefaultAllocator: Allocator<N, DimSum<D, U1>, DimSum<D, U1>>,
Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and
and setting the diagonal element to 1
.
impl<N: Scalar + Ring, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn perp<R2, C2, SB>(&self, b: &Matrix<N, R2, C2, SB>) -> N where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, U2> + SameNumberOfColumns<C, U1> + SameNumberOfRows<R2, U2> + SameNumberOfColumns<C2, U1>,
[src]
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, U2> + SameNumberOfColumns<C, U1> + SameNumberOfRows<R2, U2> + SameNumberOfColumns<C2, U1>,
The perpendicular product between two 2D column vectors, i.e. a.x * b.y - a.y * b.x
.
pub fn cross<R2, C2, SB>(
&self,
b: &Matrix<N, R2, C2, SB>
) -> MatrixCross<N, R, C, R2, C2> where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
[src]
&self,
b: &Matrix<N, R2, C2, SB>
) -> MatrixCross<N, R, C, R2, C2> where
R2: Dim,
C2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
The 3D cross product between two vectors.
Panics if the shape is not 3D vector. In the future, this will be implemented only for dynamically-sized matrices and statically-sized 3D matrices.
impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn angle<R2: Dim, C2: Dim, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> N where
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
[src]
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2> + DimEq<C, C2>,
The smallest angle between two vectors.
impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn norm_squared(&self) -> N
[src]
The squared L2 norm of this vector.
pub fn norm(&self) -> N
[src]
The L2 norm of this matrix.
pub fn magnitude(&self) -> N
[src]
A synonym for the norm of this matrix.
Aka the length.
This function is simply implemented as a call to norm()
pub fn magnitude_squared(&self) -> N
[src]
A synonym for the squared norm of this matrix.
Aka the squared length.
This function is simply implemented as a call to norm_squared()
pub fn normalize(&self) -> MatrixMN<N, R, C> where
DefaultAllocator: Allocator<N, R, C>,
[src]
DefaultAllocator: Allocator<N, R, C>,
Returns a normalized version of this matrix.
pub fn try_normalize(&self, min_norm: N) -> Option<MatrixMN<N, R, C>> where
DefaultAllocator: Allocator<N, R, C>,
[src]
DefaultAllocator: Allocator<N, R, C>,
Returns a normalized version of this matrix unless its norm as smaller or equal to eps
.
impl<N: Real, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn normalize_mut(&mut self) -> N
[src]
Normalizes this matrix in-place and returns its norm.
pub 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 succeeded, returns the old normal of this matrix.
impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn row(&self, i: usize) -> MatrixSlice<N, U1, C, S::RStride, S::CStride>
[src]
Returns a slice containing the i-th row of this matrix.
pub fn row_part(
&self,
i: usize,
n: usize
) -> MatrixSlice<N, U1, Dynamic, S::RStride, S::CStride>
[src]
&self,
i: usize,
n: usize
) -> MatrixSlice<N, U1, Dynamic, S::RStride, S::CStride>
Returns a slice containing the n
first elements of the i-th row of this matrix.
pub fn rows(
&self,
first_row: usize,
nrows: usize
) -> MatrixSlice<N, Dynamic, C, S::RStride, S::CStride>
[src]
&self,
first_row: usize,
nrows: usize
) -> MatrixSlice<N, Dynamic, C, S::RStride, S::CStride>
Extracts from this matrix a set of consecutive rows.
pub fn rows_with_step(
&self,
first_row: usize,
nrows: usize,
step: usize
) -> MatrixSlice<N, Dynamic, C, Dynamic, S::CStride>
[src]
&self,
first_row: usize,
nrows: usize,
step: usize
) -> MatrixSlice<N, Dynamic, C, Dynamic, S::CStride>
Extracts from this matrix a set of consecutive rows regularly skipping step
rows.
pub fn fixed_rows<RSlice: DimName>(
&self,
first_row: usize
) -> MatrixSlice<N, RSlice, C, S::RStride, S::CStride>
[src]
&self,
first_row: usize
) -> MatrixSlice<N, RSlice, C, S::RStride, S::CStride>
Extracts a compile-time number of consecutive rows from this matrix.
pub fn fixed_rows_with_step<RSlice: DimName>(
&self,
first_row: usize,
step: usize
) -> MatrixSlice<N, RSlice, C, Dynamic, S::CStride>
[src]
&self,
first_row: usize,
step: usize
) -> MatrixSlice<N, RSlice, C, Dynamic, S::CStride>
Extracts from this matrix a compile-time number of rows regularly skipping step
rows.
pub fn rows_generic<RSlice: Dim>(
&self,
row_start: usize,
nrows: RSlice
) -> MatrixSlice<N, RSlice, C, S::RStride, S::CStride>
[src]
&self,
row_start: usize,
nrows: RSlice
) -> MatrixSlice<N, RSlice, C, S::RStride, S::CStride>
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
pub fn rows_generic_with_step<RSlice>(
&self,
row_start: usize,
nrows: RSlice,
step: usize
) -> MatrixSlice<N, RSlice, C, Dynamic, S::CStride> where
RSlice: Dim,
[src]
&self,
row_start: usize,
nrows: RSlice,
step: usize
) -> MatrixSlice<N, RSlice, C, Dynamic, S::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.
pub fn column(&self, i: usize) -> MatrixSlice<N, R, U1, S::RStride, S::CStride>
[src]
Returns a slice containing the i-th column of this matrix.
pub fn column_part(
&self,
i: usize,
n: usize
) -> MatrixSlice<N, Dynamic, U1, S::RStride, S::CStride>
[src]
&self,
i: usize,
n: usize
) -> MatrixSlice<N, Dynamic, U1, S::RStride, S::CStride>
Returns a slice containing the n
first elements of the i-th column of this matrix.
pub fn columns(
&self,
first_col: usize,
ncols: usize
) -> MatrixSlice<N, R, Dynamic, S::RStride, S::CStride>
[src]
&self,
first_col: usize,
ncols: usize
) -> MatrixSlice<N, R, Dynamic, S::RStride, S::CStride>
Extracts from this matrix a set of consecutive columns.
pub fn columns_with_step(
&self,
first_col: usize,
ncols: usize,
step: usize
) -> MatrixSlice<N, R, Dynamic, S::RStride, Dynamic>
[src]
&self,
first_col: usize,
ncols: usize,
step: usize
) -> MatrixSlice<N, R, Dynamic, S::RStride, Dynamic>
Extracts from this matrix a set of consecutive columns regularly skipping step
columns.
pub fn fixed_columns<CSlice: DimName>(
&self,
first_col: usize
) -> MatrixSlice<N, R, CSlice, S::RStride, S::CStride>
[src]
&self,
first_col: usize
) -> MatrixSlice<N, R, CSlice, S::RStride, S::CStride>
Extracts a compile-time number of consecutive columns from this matrix.
pub fn fixed_columns_with_step<CSlice: DimName>(
&self,
first_col: usize,
step: usize
) -> MatrixSlice<N, R, CSlice, S::RStride, Dynamic>
[src]
&self,
first_col: usize,
step: usize
) -> MatrixSlice<N, R, CSlice, S::RStride, Dynamic>
Extracts from this matrix a compile-time number of columns regularly skipping
step
columns.
pub fn columns_generic<CSlice: Dim>(
&self,
first_col: usize,
ncols: CSlice
) -> MatrixSlice<N, R, CSlice, S::RStride, S::CStride>
[src]
&self,
first_col: usize,
ncols: CSlice
) -> MatrixSlice<N, R, CSlice, S::RStride, S::CStride>
Extracts from this matrix ncols
columns. The number of columns may or may not be
known at compile-time.
pub fn columns_generic_with_step<CSlice: Dim>(
&self,
first_col: usize,
ncols: CSlice,
step: usize
) -> MatrixSlice<N, R, CSlice, S::RStride, Dynamic>
[src]
&self,
first_col: usize,
ncols: CSlice,
step: usize
) -> MatrixSlice<N, R, CSlice, S::RStride, Dynamic>
Extracts from this matrix ncols
columns skipping step
columns. Both argument may
or may not be values known at compile-time.
pub fn slice(
&self,
start: (usize, usize),
shape: (usize, usize)
) -> MatrixSlice<N, Dynamic, Dynamic, S::RStride, S::CStride>
[src]
&self,
start: (usize, usize),
shape: (usize, usize)
) -> MatrixSlice<N, Dynamic, Dynamic, S::RStride, S::CStride>
Slices this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
pub fn slice_with_steps(
&self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> MatrixSlice<N, Dynamic, Dynamic, Dynamic, Dynamic>
[src]
&self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> MatrixSlice<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.
pub fn fixed_slice<RSlice, CSlice>(
&self,
irow: usize,
icol: usize
) -> MatrixSlice<N, RSlice, CSlice, S::RStride, S::CStride> where
RSlice: DimName,
CSlice: DimName,
[src]
&self,
irow: usize,
icol: usize
) -> MatrixSlice<N, RSlice, CSlice, S::RStride, S::CStride> where
RSlice: DimName,
CSlice: DimName,
Slices this matrix starting at its component (irow, icol)
and with (R::dim(), CSlice::dim())
consecutive components.
pub fn fixed_slice_with_steps<RSlice, CSlice>(
&self,
start: (usize, usize),
steps: (usize, usize)
) -> MatrixSlice<N, RSlice, CSlice, Dynamic, Dynamic> where
RSlice: DimName,
CSlice: DimName,
[src]
&self,
start: (usize, usize),
steps: (usize, usize)
) -> MatrixSlice<N, RSlice, CSlice, Dynamic, Dynamic> where
RSlice: DimName,
CSlice: DimName,
Slices this matrix starting at its component (start.0, start.1)
and with
(R::dim(), CSlice::dim())
components. Each row (resp. column) of the sliced
matrix is separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of
the original matrix.
pub fn generic_slice<RSlice, CSlice>(
&self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> MatrixSlice<N, RSlice, CSlice, S::RStride, S::CStride> where
RSlice: Dim,
CSlice: Dim,
[src]
&self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> MatrixSlice<N, RSlice, CSlice, S::RStride, S::CStride> where
RSlice: Dim,
CSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
pub fn generic_slice_with_steps<RSlice, CSlice>(
&self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> MatrixSlice<N, RSlice, CSlice, Dynamic, Dynamic> where
RSlice: Dim,
CSlice: Dim,
[src]
&self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> MatrixSlice<N, RSlice, CSlice, Dynamic, Dynamic> where
RSlice: Dim,
CSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
pub fn rows_range_pair<Range1: SliceRange<R>, Range2: SliceRange<R>>(
&self,
r1: Range1,
r2: Range2
) -> (MatrixSlice<N, Range1::Size, C, S::RStride, S::CStride>, MatrixSlice<N, Range2::Size, C, S::RStride, S::CStride>)
[src]
&self,
r1: Range1,
r2: Range2
) -> (MatrixSlice<N, Range1::Size, C, S::RStride, S::CStride>, MatrixSlice<N, Range2::Size, C, S::RStride, S::CStride>)
Splits this NxM matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
pub fn columns_range_pair<Range1: SliceRange<C>, Range2: SliceRange<C>>(
&self,
r1: Range1,
r2: Range2
) -> (MatrixSlice<N, R, Range1::Size, S::RStride, S::CStride>, MatrixSlice<N, R, Range2::Size, S::RStride, S::CStride>)
[src]
&self,
r1: Range1,
r2: Range2
) -> (MatrixSlice<N, R, Range1::Size, S::RStride, S::CStride>, MatrixSlice<N, R, Range2::Size, S::RStride, S::CStride>)
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: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn row_mut(
&mut self,
i: usize
) -> MatrixSliceMut<N, U1, C, S::RStride, S::CStride>
[src]
&mut self,
i: usize
) -> MatrixSliceMut<N, U1, C, S::RStride, S::CStride>
Returns a slice containing the i-th row of this matrix.
pub fn row_part_mut(
&mut self,
i: usize,
n: usize
) -> MatrixSliceMut<N, U1, Dynamic, S::RStride, S::CStride>
[src]
&mut self,
i: usize,
n: usize
) -> MatrixSliceMut<N, U1, Dynamic, S::RStride, S::CStride>
Returns a slice containing the n
first elements of the i-th row of this matrix.
pub fn rows_mut(
&mut self,
first_row: usize,
nrows: usize
) -> MatrixSliceMut<N, Dynamic, C, S::RStride, S::CStride>
[src]
&mut self,
first_row: usize,
nrows: usize
) -> MatrixSliceMut<N, Dynamic, C, S::RStride, S::CStride>
Extracts from this matrix a set of consecutive rows.
pub fn rows_with_step_mut(
&mut self,
first_row: usize,
nrows: usize,
step: usize
) -> MatrixSliceMut<N, Dynamic, C, Dynamic, S::CStride>
[src]
&mut self,
first_row: usize,
nrows: usize,
step: usize
) -> MatrixSliceMut<N, Dynamic, C, Dynamic, S::CStride>
Extracts from this matrix a set of consecutive rows regularly skipping step
rows.
pub fn fixed_rows_mut<RSlice: DimName>(
&mut self,
first_row: usize
) -> MatrixSliceMut<N, RSlice, C, S::RStride, S::CStride>
[src]
&mut self,
first_row: usize
) -> MatrixSliceMut<N, RSlice, C, S::RStride, S::CStride>
Extracts a compile-time number of consecutive rows from this matrix.
pub fn fixed_rows_with_step_mut<RSlice: DimName>(
&mut self,
first_row: usize,
step: usize
) -> MatrixSliceMut<N, RSlice, C, Dynamic, S::CStride>
[src]
&mut self,
first_row: usize,
step: usize
) -> MatrixSliceMut<N, RSlice, C, Dynamic, S::CStride>
Extracts from this matrix a compile-time number of rows regularly skipping step
rows.
pub fn rows_generic_mut<RSlice: Dim>(
&mut self,
row_start: usize,
nrows: RSlice
) -> MatrixSliceMut<N, RSlice, C, S::RStride, S::CStride>
[src]
&mut self,
row_start: usize,
nrows: RSlice
) -> MatrixSliceMut<N, RSlice, C, S::RStride, S::CStride>
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
pub fn rows_generic_with_step_mut<RSlice>(
&mut self,
row_start: usize,
nrows: RSlice,
step: usize
) -> MatrixSliceMut<N, RSlice, C, Dynamic, S::CStride> where
RSlice: Dim,
[src]
&mut self,
row_start: usize,
nrows: RSlice,
step: usize
) -> MatrixSliceMut<N, RSlice, C, Dynamic, S::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.
pub fn column_mut(
&mut self,
i: usize
) -> MatrixSliceMut<N, R, U1, S::RStride, S::CStride>
[src]
&mut self,
i: usize
) -> MatrixSliceMut<N, R, U1, S::RStride, S::CStride>
Returns a slice containing the i-th column of this matrix.
pub fn column_part_mut(
&mut self,
i: usize,
n: usize
) -> MatrixSliceMut<N, Dynamic, U1, S::RStride, S::CStride>
[src]
&mut self,
i: usize,
n: usize
) -> MatrixSliceMut<N, Dynamic, U1, S::RStride, S::CStride>
Returns a slice containing the n
first elements of the i-th column of this matrix.
pub fn columns_mut(
&mut self,
first_col: usize,
ncols: usize
) -> MatrixSliceMut<N, R, Dynamic, S::RStride, S::CStride>
[src]
&mut self,
first_col: usize,
ncols: usize
) -> MatrixSliceMut<N, R, Dynamic, S::RStride, S::CStride>
Extracts from this matrix a set of consecutive columns.
pub fn columns_with_step_mut(
&mut self,
first_col: usize,
ncols: usize,
step: usize
) -> MatrixSliceMut<N, R, Dynamic, S::RStride, Dynamic>
[src]
&mut self,
first_col: usize,
ncols: usize,
step: usize
) -> MatrixSliceMut<N, R, Dynamic, S::RStride, Dynamic>
Extracts from this matrix a set of consecutive columns regularly skipping step
columns.
pub fn fixed_columns_mut<CSlice: DimName>(
&mut self,
first_col: usize
) -> MatrixSliceMut<N, R, CSlice, S::RStride, S::CStride>
[src]
&mut self,
first_col: usize
) -> MatrixSliceMut<N, R, CSlice, S::RStride, S::CStride>
Extracts a compile-time number of consecutive columns from this matrix.
pub fn fixed_columns_with_step_mut<CSlice: DimName>(
&mut self,
first_col: usize,
step: usize
) -> MatrixSliceMut<N, R, CSlice, S::RStride, Dynamic>
[src]
&mut self,
first_col: usize,
step: usize
) -> MatrixSliceMut<N, R, CSlice, S::RStride, Dynamic>
Extracts from this matrix a compile-time number of columns regularly skipping
step
columns.
pub fn columns_generic_mut<CSlice: Dim>(
&mut self,
first_col: usize,
ncols: CSlice
) -> MatrixSliceMut<N, R, CSlice, S::RStride, S::CStride>
[src]
&mut self,
first_col: usize,
ncols: CSlice
) -> MatrixSliceMut<N, R, CSlice, S::RStride, S::CStride>
Extracts from this matrix ncols
columns. The number of columns may or may not be
known at compile-time.
pub fn columns_generic_with_step_mut<CSlice: Dim>(
&mut self,
first_col: usize,
ncols: CSlice,
step: usize
) -> MatrixSliceMut<N, R, CSlice, S::RStride, Dynamic>
[src]
&mut self,
first_col: usize,
ncols: CSlice,
step: usize
) -> MatrixSliceMut<N, R, CSlice, S::RStride, Dynamic>
Extracts from this matrix ncols
columns skipping step
columns. Both argument may
or may not be values known at compile-time.
pub fn slice_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize)
) -> MatrixSliceMut<N, Dynamic, Dynamic, S::RStride, S::CStride>
[src]
&mut self,
start: (usize, usize),
shape: (usize, usize)
) -> MatrixSliceMut<N, Dynamic, Dynamic, S::RStride, S::CStride>
Slices this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
pub fn slice_with_steps_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> MatrixSliceMut<N, Dynamic, Dynamic, Dynamic, Dynamic>
[src]
&mut self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> MatrixSliceMut<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.
pub fn fixed_slice_mut<RSlice, CSlice>(
&mut self,
irow: usize,
icol: usize
) -> MatrixSliceMut<N, RSlice, CSlice, S::RStride, S::CStride> where
RSlice: DimName,
CSlice: DimName,
[src]
&mut self,
irow: usize,
icol: usize
) -> MatrixSliceMut<N, RSlice, CSlice, S::RStride, S::CStride> where
RSlice: DimName,
CSlice: DimName,
Slices this matrix starting at its component (irow, icol)
and with (R::dim(), CSlice::dim())
consecutive components.
pub fn fixed_slice_with_steps_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
steps: (usize, usize)
) -> MatrixSliceMut<N, RSlice, CSlice, Dynamic, Dynamic> where
RSlice: DimName,
CSlice: DimName,
[src]
&mut self,
start: (usize, usize),
steps: (usize, usize)
) -> MatrixSliceMut<N, RSlice, CSlice, Dynamic, Dynamic> where
RSlice: DimName,
CSlice: DimName,
Slices this matrix starting at its component (start.0, start.1)
and with
(R::dim(), CSlice::dim())
components. Each row (resp. column) of the sliced
matrix is separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of
the original matrix.
pub fn generic_slice_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> MatrixSliceMut<N, RSlice, CSlice, S::RStride, S::CStride> where
RSlice: Dim,
CSlice: Dim,
[src]
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> MatrixSliceMut<N, RSlice, CSlice, S::RStride, S::CStride> where
RSlice: Dim,
CSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
pub fn generic_slice_with_steps_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> MatrixSliceMut<N, RSlice, CSlice, Dynamic, Dynamic> where
RSlice: Dim,
CSlice: Dim,
[src]
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> MatrixSliceMut<N, RSlice, CSlice, Dynamic, Dynamic> where
RSlice: Dim,
CSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
pub fn rows_range_pair_mut<Range1: SliceRange<R>, Range2: SliceRange<R>>(
&mut self,
r1: Range1,
r2: Range2
) -> (MatrixSliceMut<N, Range1::Size, C, S::RStride, S::CStride>, MatrixSliceMut<N, Range2::Size, C, S::RStride, S::CStride>)
[src]
&mut self,
r1: Range1,
r2: Range2
) -> (MatrixSliceMut<N, Range1::Size, C, S::RStride, S::CStride>, MatrixSliceMut<N, Range2::Size, C, S::RStride, S::CStride>)
Splits this NxM matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
pub fn columns_range_pair_mut<Range1: SliceRange<C>, Range2: SliceRange<C>>(
&mut self,
r1: Range1,
r2: Range2
) -> (MatrixSliceMut<N, R, Range1::Size, S::RStride, S::CStride>, MatrixSliceMut<N, R, Range2::Size, S::RStride, S::CStride>)
[src]
&mut self,
r1: Range1,
r2: Range2
) -> (MatrixSliceMut<N, R, Range1::Size, S::RStride, S::CStride>, MatrixSliceMut<N, R, Range2::Size, S::RStride, S::CStride>)
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: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn slice_range<RowRange, ColRange>(
&self,
rows: RowRange,
cols: ColRange
) -> MatrixSlice<N, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
[src]
&self,
rows: RowRange,
cols: ColRange
) -> MatrixSlice<N, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
Slices a sub-matrix containing the rows indexed by the range rows
and the columns indexed
by the range cols
.
pub fn rows_range<RowRange: SliceRange<R>>(
&self,
rows: RowRange
) -> MatrixSlice<N, RowRange::Size, C, S::RStride, S::CStride>
[src]
&self,
rows: RowRange
) -> MatrixSlice<N, RowRange::Size, C, S::RStride, S::CStride>
Slice containing all the rows indexed by the range rows
.
pub fn columns_range<ColRange: SliceRange<C>>(
&self,
cols: ColRange
) -> MatrixSlice<N, R, ColRange::Size, S::RStride, S::CStride>
[src]
&self,
cols: ColRange
) -> MatrixSlice<N, R, ColRange::Size, S::RStride, S::CStride>
Slice containing all the columns indexed by the range rows
.
impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn slice_range_mut<RowRange, ColRange>(
&mut self,
rows: RowRange,
cols: ColRange
) -> MatrixSliceMut<N, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
[src]
&mut self,
rows: RowRange,
cols: ColRange
) -> MatrixSliceMut<N, RowRange::Size, ColRange::Size, S::RStride, S::CStride> where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
Slices a mutable sub-matrix containing the rows indexed by the range rows
and the columns
indexed by the range cols
.
pub fn rows_range_mut<RowRange: SliceRange<R>>(
&mut self,
rows: RowRange
) -> MatrixSliceMut<N, RowRange::Size, C, S::RStride, S::CStride>
[src]
&mut self,
rows: RowRange
) -> MatrixSliceMut<N, RowRange::Size, C, S::RStride, S::CStride>
Slice containing all the rows indexed by the range rows
.
pub fn columns_range_mut<ColRange: SliceRange<C>>(
&mut self,
cols: ColRange
) -> MatrixSliceMut<N, R, ColRange::Size, S::RStride, S::CStride>
[src]
&mut self,
cols: ColRange
) -> MatrixSliceMut<N, R, ColRange::Size, S::RStride, S::CStride>
Slice containing all the columns indexed by the range cols
.
impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S>
[src]
pub fn is_empty(&self) -> bool
[src]
Indicates if this is an empty matrix.
pub fn is_square(&self) -> bool
[src]
Indicates if this is a square matrix.
pub fn is_identity(&self, eps: N::Epsilon) -> bool where
N: Zero + One + RelativeEq,
N::Epsilon: Copy,
[src]
N: Zero + One + RelativeEq,
N::Epsilon: Copy,
Indicated if this is the identity matrix within a relative error of eps
.
If the matrix is diagonal, this checks that diagonal elements (i.e. at coordinates (i, i)
for i from 0
to min(R, C)
) are equal one; and that all other elements are zero.
pub fn is_orthogonal(&self, eps: N::Epsilon) -> bool where
N: Zero + One + ClosedAdd + ClosedMul + RelativeEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
DefaultAllocator: Allocator<N, C, C>,
[src]
N: Zero + One + ClosedAdd + ClosedMul + RelativeEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
DefaultAllocator: Allocator<N, C, C>,
Checks that Mᵀ × M = Id
.
In this definition Id
is approximately equal to the identity matrix with a relative error
equal to eps
.
impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C> + Allocator<N, C> + Allocator<N, R> + Allocator<N, DimMinimum<R, C>> + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>,
[src]
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C> + Allocator<N, C> + Allocator<N, R> + Allocator<N, DimMinimum<R, C>> + Allocator<N, DimDiff<DimMinimum<R, C>, U1>>,
pub fn bidiagonalize(self) -> Bidiagonal<N, R, C>
[src]
Computes the bidiagonalization using householder reflections.
impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where
DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
[src]
DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
pub 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: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where
DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
[src]
DefaultAllocator: Allocator<N, R, C> + Allocator<(usize, usize), DimMinimum<R, C>>,
pub fn lu(self) -> LU<N, R, C>
[src]
Computes the LU decomposition with partial (row) pivoting of matrix
.
impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where
DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimMinimum<R, C>>,
[src]
DefaultAllocator: Allocator<N, R, C> + Allocator<N, R> + Allocator<N, DimMinimum<R, C>>,
impl<N: Real, R: DimMin<C>, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> where
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C> + Allocator<N, C> + Allocator<N, R> + Allocator<N, DimDiff<DimMinimum<R, C>, U1>> + Allocator<N, DimMinimum<R, C>, C> + Allocator<N, R, DimMinimum<R, C>> + Allocator<N, DimMinimum<R, C>>,
[src]
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<N, R, C> + Allocator<N, C> + Allocator<N, R> + Allocator<N, DimDiff<DimMinimum<R, C>, U1>> + Allocator<N, DimMinimum<R, C>, C> + Allocator<N, R, DimMinimum<R, C>> + Allocator<N, DimMinimum<R, C>>,
pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<N, R, C>
[src]
Computes the Singular Value Decomposition using implicit shift.
pub 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
− 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.
pub fn singular_values(&self) -> VectorN<N, DimMinimum<R, C>>
[src]
Computes the singular values of this matrix.
pub fn rank(&self, eps: N) -> usize
[src]
Computes the rank of this matrix.
All singular values below eps
are considered equal to 0.
pub fn pseudo_inverse(self, eps: N) -> MatrixMN<N, C, R> where
DefaultAllocator: Allocator<N, C, R>,
[src]
DefaultAllocator: Allocator<N, C, R>,
Computes the pseudo-inverse of this matrix.
All singular values below eps
are considered equal to 0.
Trait Implementations
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; 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; 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; 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]> 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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: Scalar, S> AsMut<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where
S: ContiguousStorageMut<N, U2, U2>,
[src]
S: ContiguousStorageMut<N, U2, U2>,
impl<N: Scalar, S> AsMut<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where
S: ContiguousStorageMut<N, U2, U3>,
[src]
S: ContiguousStorageMut<N, U2, U3>,
impl<N: Scalar, S> AsMut<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where
S: ContiguousStorageMut<N, U2, U4>,
[src]
S: ContiguousStorageMut<N, U2, U4>,
impl<N: Scalar, S> AsMut<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where
S: ContiguousStorageMut<N, U2, U5>,
[src]
S: ContiguousStorageMut<N, U2, U5>,
impl<N: Scalar, S> AsMut<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where
S: ContiguousStorageMut<N, U2, U6>,
[src]
S: ContiguousStorageMut<N, U2, U6>,
impl<N: Scalar, S> AsMut<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where
S: ContiguousStorageMut<N, U3, U2>,
[src]
S: ContiguousStorageMut<N, U3, U2>,
impl<N: Scalar, S> AsMut<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where
S: ContiguousStorageMut<N, U3, U3>,
[src]
S: ContiguousStorageMut<N, U3, U3>,
impl<N: Scalar, S> AsMut<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where
S: ContiguousStorageMut<N, U3, U4>,
[src]
S: ContiguousStorageMut<N, U3, U4>,
impl<N: Scalar, S> AsMut<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where
S: ContiguousStorageMut<N, U3, U5>,
[src]
S: ContiguousStorageMut<N, U3, U5>,
impl<N: Scalar, S> AsMut<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where
S: ContiguousStorageMut<N, U3, U6>,
[src]
S: ContiguousStorageMut<N, U3, U6>,
impl<N: Scalar, S> AsMut<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where
S: ContiguousStorageMut<N, U4, U2>,
[src]
S: ContiguousStorageMut<N, U4, U2>,
impl<N: Scalar, S> AsMut<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where
S: ContiguousStorageMut<N, U4, U3>,
[src]
S: ContiguousStorageMut<N, U4, U3>,
impl<N: Scalar, S> AsMut<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where
S: ContiguousStorageMut<N, U4, U4>,
[src]
S: ContiguousStorageMut<N, U4, U4>,
impl<N: Scalar, S> AsMut<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where
S: ContiguousStorageMut<N, U4, U5>,
[src]
S: ContiguousStorageMut<N, U4, U5>,
impl<N: Scalar, S> AsMut<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where
S: ContiguousStorageMut<N, U4, U6>,
[src]
S: ContiguousStorageMut<N, U4, U6>,
impl<N: Scalar, S> AsMut<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where
S: ContiguousStorageMut<N, U5, U2>,
[src]
S: ContiguousStorageMut<N, U5, U2>,
impl<N: Scalar, S> AsMut<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where
S: ContiguousStorageMut<N, U5, U3>,
[src]
S: ContiguousStorageMut<N, U5, U3>,
impl<N: Scalar, S> AsMut<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where
S: ContiguousStorageMut<N, U5, U4>,
[src]
S: ContiguousStorageMut<N, U5, U4>,
impl<N: Scalar, S> AsMut<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where
S: ContiguousStorageMut<N, U5, U5>,
[src]
S: ContiguousStorageMut<N, U5, U5>,
impl<N: Scalar, S> AsMut<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where
S: ContiguousStorageMut<N, U5, U6>,
[src]
S: ContiguousStorageMut<N, U5, U6>,
impl<N: Scalar, S> AsMut<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where
S: ContiguousStorageMut<N, U6, U2>,
[src]
S: ContiguousStorageMut<N, U6, U2>,
impl<N: Scalar, S> AsMut<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where
S: ContiguousStorageMut<N, U6, U3>,
[src]
S: ContiguousStorageMut<N, U6, U3>,
impl<N: Scalar, S> AsMut<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where
S: ContiguousStorageMut<N, U6, U4>,
[src]
S: ContiguousStorageMut<N, U6, U4>,
impl<N: Scalar, S> AsMut<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where
S: ContiguousStorageMut<N, U6, U5>,
[src]
S: ContiguousStorageMut<N, U6, U5>,
impl<N: Scalar, S> AsMut<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where
S: ContiguousStorageMut<N, U6, U6>,
[src]
S: ContiguousStorageMut<N, U6, U6>,
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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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: Scalar, S> AsRef<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where
S: ContiguousStorage<N, U2, U2>,
[src]
S: ContiguousStorage<N, U2, U2>,
impl<N: Scalar, S> AsRef<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where
S: ContiguousStorage<N, U2, U3>,
[src]
S: ContiguousStorage<N, U2, U3>,
impl<N: Scalar, S> AsRef<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where
S: ContiguousStorage<N, U2, U4>,
[src]
S: ContiguousStorage<N, U2, U4>,
impl<N: Scalar, S> AsRef<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where
S: ContiguousStorage<N, U2, U5>,
[src]
S: ContiguousStorage<N, U2, U5>,
impl<N: Scalar, S> AsRef<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where
S: ContiguousStorage<N, U2, U6>,
[src]
S: ContiguousStorage<N, U2, U6>,
impl<N: Scalar, S> AsRef<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where
S: ContiguousStorage<N, U3, U2>,
[src]
S: ContiguousStorage<N, U3, U2>,
impl<N: Scalar, S> AsRef<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where
S: ContiguousStorage<N, U3, U3>,
[src]
S: ContiguousStorage<N, U3, U3>,
impl<N: Scalar, S> AsRef<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where
S: ContiguousStorage<N, U3, U4>,
[src]
S: ContiguousStorage<N, U3, U4>,
impl<N: Scalar, S> AsRef<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where
S: ContiguousStorage<N, U3, U5>,
[src]
S: ContiguousStorage<N, U3, U5>,
impl<N: Scalar, S> AsRef<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where
S: ContiguousStorage<N, U3, U6>,
[src]
S: ContiguousStorage<N, U3, U6>,
impl<N: Scalar, S> AsRef<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where
S: ContiguousStorage<N, U4, U2>,
[src]
S: ContiguousStorage<N, U4, U2>,
impl<N: Scalar, S> AsRef<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where
S: ContiguousStorage<N, U4, U3>,
[src]
S: ContiguousStorage<N, U4, U3>,
impl<N: Scalar, S> AsRef<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where
S: ContiguousStorage<N, U4, U4>,
[src]
S: ContiguousStorage<N, U4, U4>,
impl<N: Scalar, S> AsRef<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where
S: ContiguousStorage<N, U4, U5>,
[src]
S: ContiguousStorage<N, U4, U5>,
impl<N: Scalar, S> AsRef<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where
S: ContiguousStorage<N, U4, U6>,
[src]
S: ContiguousStorage<N, U4, U6>,
impl<N: Scalar, S> AsRef<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where
S: ContiguousStorage<N, U5, U2>,
[src]
S: ContiguousStorage<N, U5, U2>,
impl<N: Scalar, S> AsRef<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where
S: ContiguousStorage<N, U5, U3>,
[src]
S: ContiguousStorage<N, U5, U3>,
impl<N: Scalar, S> AsRef<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where
S: ContiguousStorage<N, U5, U4>,
[src]
S: ContiguousStorage<N, U5, U4>,
impl<N: Scalar, S> AsRef<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where
S: ContiguousStorage<N, U5, U5>,
[src]
S: ContiguousStorage<N, U5, U5>,
impl<N: Scalar, S> AsRef<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where
S: ContiguousStorage<N, U5, U6>,
[src]
S: ContiguousStorage<N, U5, U6>,
impl<N: Scalar, S> AsRef<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where
S: ContiguousStorage<N, U6, U2>,
[src]
S: ContiguousStorage<N, U6, U2>,
impl<N: Scalar, S> AsRef<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where
S: ContiguousStorage<N, U6, U3>,
[src]
S: ContiguousStorage<N, U6, U3>,
impl<N: Scalar, S> AsRef<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where
S: ContiguousStorage<N, U6, U4>,
[src]
S: ContiguousStorage<N, U6, U4>,
impl<N: Scalar, S> AsRef<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where
S: ContiguousStorage<N, U6, U5>,
[src]
S: ContiguousStorage<N, U6, U5>,
impl<N: Scalar, S> AsRef<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where
S: ContiguousStorage<N, U6, U6>,
[src]
S: ContiguousStorage<N, U6, U6>,
impl<N, R: Dim, C: Dim, S> Eq for Matrix<N, R, C, S> where
N: Scalar + Eq,
S: Storage<N, R, C>,
[src]
N: Scalar + Eq,
S: Storage<N, R, C>,
impl<N, R, S> Extend<N> for Matrix<N, R, Dynamic, S> where
N: Scalar,
R: Dim,
S: Extend<N>,
[src]
N: Scalar,
R: Dim,
S: Extend<N>,
Extend the number of columns of the Matrix
with elements from
a given iterator.
fn extend<I: IntoIterator<Item = N>>(&mut self, iter: I)
[src]
Extend the number of columns of the Matrix
with elements
from the given iterator.
Example
let data = vec![0, 1, 2, // column 1 3, 4, 5]; // column 2 let mut matrix = DMatrix::from_vec(3, 2, data); matrix.extend(vec![6, 7, 8]); // column 3 assert!(matrix.eq(&Matrix3::new(0, 3, 6, 1, 4, 7, 2, 5, 8)));
Panics
This function panics if the number of elements yielded by the
given iterator is not a multiple of the number of rows of the
Matrix
.
let data = vec![0, 1, 2, // column 1 3, 4, 5]; // column 2 let mut matrix = DMatrix::from_vec(3, 2, data); // The following panics because the vec length is not a multiple of 3. matrix.extend(vec![6, 7, 8, 9]);
impl<N, S> Extend<N> for Matrix<N, Dynamic, U1, S> where
N: Scalar,
S: Extend<N>,
[src]
N: Scalar,
S: Extend<N>,
Extend the number of rows of the Vector
with elements from
a given iterator.
fn extend<I: IntoIterator<Item = N>>(&mut self, iter: I)
[src]
Extend the number of rows of a Vector
with elements
from the given iterator.
Example
let mut vector = DVector::from_vec(3, vec![0, 1, 2]); vector.extend(vec![3, 4, 5]); assert!(vector.eq(&DVector::from_vec(6, vec![0, 1, 2, 3, 4, 5])));
impl<N, R, S, RV, SV> Extend<Matrix<N, RV, U1, SV>> for Matrix<N, R, Dynamic, S> where
N: Scalar,
R: Dim,
S: Extend<Vector<N, RV, SV>>,
RV: Dim,
SV: Storage<N, RV>,
ShapeConstraint: SameNumberOfRows<R, RV>,
[src]
N: Scalar,
R: Dim,
S: Extend<Vector<N, RV, SV>>,
RV: Dim,
SV: Storage<N, RV>,
ShapeConstraint: SameNumberOfRows<R, RV>,
fn extend<I: IntoIterator<Item = Vector<N, RV, SV>>>(&mut self, iter: I)
[src]
Extends the number of columns of a Matrix
with Vector
s
from a given iterator.
Example
let data = vec![0, 1, 2, // column 1 3, 4, 5]; // column 2 let mut matrix = DMatrix::from_vec(3, 2, data); matrix.extend( vec![Vector3::new(6, 7, 8), // column 3 Vector3::new(9, 10, 11)]); // column 4 assert!(matrix.eq(&Matrix3x4::new(0, 3, 6, 9, 1, 4, 7, 10, 2, 5, 8, 11)));
Panics
This function panics if the dimension of each Vector
yielded
by the given iterator is not equal to the number of rows of
this Matrix
.
let mut matrix = DMatrix::from_vec(3, 2, vec![0, 1, 2, // column 1 3, 4, 5]); // column 2 // The following panics because this matrix can only be extended with 3-dimensional vectors. matrix.extend( vec![Vector2::new(6, 7)]); // too few dimensions!
let mut matrix = DMatrix::from_vec(3, 2, vec![0, 1, 2, // column 1 3, 4, 5]); // column 2 // The following panics because this matrix can only be extended with 3-dimensional vectors. matrix.extend( vec![Vector4::new(6, 7, 8, 9)]); // too few dimensions!
impl<N, R, RV, SV> Extend<Matrix<N, RV, U1, SV>> for VecStorage<N, R, Dynamic> where
N: Scalar,
R: Dim,
RV: Dim,
SV: Storage<N, RV>,
ShapeConstraint: SameNumberOfRows<R, RV>,
[src]
N: Scalar,
R: Dim,
RV: Dim,
SV: Storage<N, RV>,
ShapeConstraint: SameNumberOfRows<R, RV>,
fn extend<I: IntoIterator<Item = Vector<N, RV, SV>>>(&mut self, iter: I)
[src]
Extends the number of columns of the VecStorage
with vectors
from the given iterator.
Panics
This function panics if the number of rows of each Vector
yielded by the iterator is not equal to the number of rows
of this VecStorage
.
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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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; 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]> 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; 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]> 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; 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; 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; 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; 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; 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; 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; 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; 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> 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; 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: Scalar, S> Into<[[N; 2]; 2]> for Matrix<N, U2, U2, S> where
S: ContiguousStorage<N, U2, U2>,
[src]
S: ContiguousStorage<N, U2, U2>,
impl<N: Scalar, S> Into<[[N; 2]; 3]> for Matrix<N, U2, U3, S> where
S: ContiguousStorage<N, U2, U3>,
[src]
S: ContiguousStorage<N, U2, U3>,
impl<N: Scalar, S> Into<[[N; 2]; 4]> for Matrix<N, U2, U4, S> where
S: ContiguousStorage<N, U2, U4>,
[src]
S: ContiguousStorage<N, U2, U4>,
impl<N: Scalar, S> Into<[[N; 2]; 5]> for Matrix<N, U2, U5, S> where
S: ContiguousStorage<N, U2, U5>,
[src]
S: ContiguousStorage<N, U2, U5>,
impl<N: Scalar, S> Into<[[N; 2]; 6]> for Matrix<N, U2, U6, S> where
S: ContiguousStorage<N, U2, U6>,
[src]
S: ContiguousStorage<N, U2, U6>,
impl<N: Scalar, S> Into<[[N; 3]; 2]> for Matrix<N, U3, U2, S> where
S: ContiguousStorage<N, U3, U2>,
[src]
S: ContiguousStorage<N, U3, U2>,
impl<N: Scalar, S> Into<[[N; 3]; 3]> for Matrix<N, U3, U3, S> where
S: ContiguousStorage<N, U3, U3>,
[src]
S: ContiguousStorage<N, U3, U3>,
impl<N: Scalar, S> Into<[[N; 3]; 4]> for Matrix<N, U3, U4, S> where
S: ContiguousStorage<N, U3, U4>,
[src]
S: ContiguousStorage<N, U3, U4>,
impl<N: Scalar, S> Into<[[N; 3]; 5]> for Matrix<N, U3, U5, S> where
S: ContiguousStorage<N, U3, U5>,
[src]
S: ContiguousStorage<N, U3, U5>,
impl<N: Scalar, S> Into<[[N; 3]; 6]> for Matrix<N, U3, U6, S> where
S: ContiguousStorage<N, U3, U6>,
[src]
S: ContiguousStorage<N, U3, U6>,
impl<N: Scalar, S> Into<[[N; 4]; 2]> for Matrix<N, U4, U2, S> where
S: ContiguousStorage<N, U4, U2>,
[src]
S: ContiguousStorage<N, U4, U2>,
impl<N: Scalar, S> Into<[[N; 4]; 3]> for Matrix<N, U4, U3, S> where
S: ContiguousStorage<N, U4, U3>,
[src]
S: ContiguousStorage<N, U4, U3>,
impl<N: Scalar, S> Into<[[N; 4]; 4]> for Matrix<N, U4, U4, S> where
S: ContiguousStorage<N, U4, U4>,
[src]
S: ContiguousStorage<N, U4, U4>,
impl<N: Scalar, S> Into<[[N; 4]; 5]> for Matrix<N, U4, U5, S> where
S: ContiguousStorage<N, U4, U5>,
[src]
S: ContiguousStorage<N, U4, U5>,
impl<N: Scalar, S> Into<[[N; 4]; 6]> for Matrix<N, U4, U6, S> where
S: ContiguousStorage<N, U4, U6>,
[src]
S: ContiguousStorage<N, U4, U6>,
impl<N: Scalar, S> Into<[[N; 5]; 2]> for Matrix<N, U5, U2, S> where
S: ContiguousStorage<N, U5, U2>,
[src]
S: ContiguousStorage<N, U5, U2>,
impl<N: Scalar, S> Into<[[N; 5]; 3]> for Matrix<N, U5, U3, S> where
S: ContiguousStorage<N, U5, U3>,
[src]
S: ContiguousStorage<N, U5, U3>,
impl<N: Scalar, S> Into<[[N; 5]; 4]> for Matrix<N, U5, U4, S> where
S: ContiguousStorage<N, U5, U4>,
[src]
S: ContiguousStorage<N, U5, U4>,
impl<N: Scalar, S> Into<[[N; 5]; 5]> for Matrix<N, U5, U5, S> where
S: ContiguousStorage<N, U5, U5>,
[src]
S: ContiguousStorage<N, U5, U5>,
impl<N: Scalar, S> Into<[[N; 5]; 6]> for Matrix<N, U5, U6, S> where
S: ContiguousStorage<N, U5, U6>,
[src]
S: ContiguousStorage<N, U5, U6>,
impl<N: Scalar, S> Into<[[N; 6]; 2]> for Matrix<N, U6, U2, S> where
S: ContiguousStorage<N, U6, U2>,
[src]
S: ContiguousStorage<N, U6, U2>,
impl<N: Scalar, S> Into<[[N; 6]; 3]> for Matrix<N, U6, U3, S> where
S: ContiguousStorage<N, U6, U3>,
[src]
S: ContiguousStorage<N, U6, U3>,
impl<N: Scalar, S> Into<[[N; 6]; 4]> for Matrix<N, U6, U4, S> where
S: ContiguousStorage<N, U6, U4>,
[src]
S: ContiguousStorage<N, U6, U4>,
impl<N: Scalar, S> Into<[[N; 6]; 5]> for Matrix<N, U6, U5, S> where
S: ContiguousStorage<N, U6, U5>,
[src]
S: ContiguousStorage<N, U6, U5>,
impl<N: Scalar, S> Into<[[N; 6]; 6]> for Matrix<N, U6, U6, S> where
S: ContiguousStorage<N, U6, U6>,
[src]
S: ContiguousStorage<N, U6, U6>,
impl<N: Clone + Scalar, R: Clone + Dim, C: Clone + Dim, S: Clone> Clone for Matrix<N, R, C, S>
[src]
impl<N, R: Dim, C: Dim, S> PartialOrd<Matrix<N, R, C, S>> for Matrix<N, R, C, S> where
N: Scalar + PartialOrd,
S: Storage<N, R, C>,
[src]
N: Scalar + PartialOrd,
S: Storage<N, R, C>,
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
[src]
fn lt(&self, right: &Self) -> bool
[src]
fn le(&self, right: &Self) -> bool
[src]
fn gt(&self, right: &Self) -> bool
[src]
fn ge(&self, right: &Self) -> bool
[src]
impl<N, R: Dim, C: Dim, S> PartialEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S> where
N: Scalar,
S: Storage<N, R, C>,
[src]
N: Scalar,
S: Storage<N, R, C>,
fn eq(&self, right: &Matrix<N, R, C, S>) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> IntoIterator for &'a Matrix<N, R, C, S>
[src]
type Item = &'a N
The type of the elements being iterated over.
type IntoIter = MatrixIter<'a, N, R, C, S>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> IntoIterator for &'a mut Matrix<N, R, C, S>
[src]
type Item = &'a mut N
The type of the elements being iterated over.
type IntoIter = MatrixIterMut<'a, N, R, C, S>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorage<'a, N, R, C, RStride, CStride>>> for Matrix<N, R, C, ArrayStorage<N, R, C>> where
N: Scalar,
R: DimName,
C: DimName,
RStride: Dim,
CStride: Dim,
R::Value: Mul<C::Value>,
Prod<R::Value, C::Value>: ArrayLength<N>,
[src]
N: Scalar,
R: DimName,
C: DimName,
RStride: Dim,
CStride: Dim,
R::Value: Mul<C::Value>,
Prod<R::Value, C::Value>: ArrayLength<N>,
fn from(matrix_slice: MatrixSlice<'a, N, R, C, RStride, CStride>) -> Self
[src]
impl<'a, N, C, RStride, CStride> From<Matrix<N, Dynamic, C, SliceStorage<'a, N, Dynamic, C, RStride, CStride>>> for Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>> where
N: Scalar,
C: Dim,
RStride: Dim,
CStride: Dim,
[src]
N: Scalar,
C: Dim,
RStride: Dim,
CStride: Dim,
fn from(matrix_slice: MatrixSlice<'a, N, Dynamic, C, RStride, CStride>) -> Self
[src]
impl<'a, N, R, RStride, CStride> From<Matrix<N, R, Dynamic, SliceStorage<'a, N, R, Dynamic, RStride, CStride>>> for Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>> where
N: Scalar,
R: DimName,
RStride: Dim,
CStride: Dim,
[src]
N: Scalar,
R: DimName,
RStride: Dim,
CStride: Dim,
fn from(matrix_slice: MatrixSlice<'a, N, R, Dynamic, RStride, CStride>) -> Self
[src]
impl<'a, N, R, C, RStride, CStride> From<Matrix<N, R, C, SliceStorageMut<'a, N, R, C, RStride, CStride>>> for Matrix<N, R, C, ArrayStorage<N, R, C>> where
N: Scalar,
R: DimName,
C: DimName,
RStride: Dim,
CStride: Dim,
R::Value: Mul<C::Value>,
Prod<R::Value, C::Value>: ArrayLength<N>,
[src]
N: Scalar,
R: DimName,
C: DimName,
RStride: Dim,
CStride: Dim,
R::Value: Mul<C::Value>,
Prod<R::Value, C::Value>: ArrayLength<N>,
fn from(matrix_slice: MatrixSliceMut<'a, N, R, C, RStride, CStride>) -> Self
[src]
impl<'a, N, C, RStride, CStride> From<Matrix<N, Dynamic, C, SliceStorageMut<'a, N, Dynamic, C, RStride, CStride>>> for Matrix<N, Dynamic, C, VecStorage<N, Dynamic, C>> where
N: Scalar,
C: Dim,
RStride: Dim,
CStride: Dim,
[src]
N: Scalar,
C: Dim,
RStride: Dim,
CStride: Dim,
fn from(
matrix_slice: MatrixSliceMut<'a, N, Dynamic, C, RStride, CStride>
) -> Self
[src]
matrix_slice: MatrixSliceMut<'a, N, Dynamic, C, RStride, CStride>
) -> Self
impl<'a, N, R, RStride, CStride> From<Matrix<N, R, Dynamic, SliceStorageMut<'a, N, R, Dynamic, RStride, CStride>>> for Matrix<N, R, Dynamic, VecStorage<N, R, Dynamic>> where
N: Scalar,
R: DimName,
RStride: Dim,
CStride: Dim,
[src]
N: Scalar,
R: DimName,
RStride: Dim,
CStride: Dim,
fn from(
matrix_slice: MatrixSliceMut<'a, N, R, Dynamic, RStride, CStride>
) -> Self
[src]
matrix_slice: MatrixSliceMut<'a, N, R, Dynamic, RStride, CStride>
) -> Self
impl<N: Scalar, D: DimName> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Point<N, D> where
DefaultAllocator: Allocator<N, D>,
[src]
DefaultAllocator: Allocator<N, D>,
impl<N: Real> From<Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>> for Quaternion<N>
[src]
impl<N: Scalar, D: DimName> From<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Translation<N, D> where
DefaultAllocator: Allocator<N, D>,
[src]
DefaultAllocator: Allocator<N, D>,
impl<N: Copy + Scalar, R: Copy + Dim, C: Copy + Dim, S: Copy> Copy for Matrix<N, R, C, S>
[src]
impl<N: Scalar, S> DerefMut for Matrix<N, U1, U1, S> where
S: ContiguousStorageMut<N, U1, U1>,
[src]
S: ContiguousStorageMut<N, U1, U1>,
impl<N: Scalar, S> DerefMut for Matrix<N, U2, U1, S> where
S: ContiguousStorageMut<N, U2, U1>,
[src]
S: ContiguousStorageMut<N, U2, U1>,
impl<N: Scalar, S> DerefMut for Matrix<N, U3, U1, S> where
S: ContiguousStorageMut<N, U3, U1>,
[src]
S: ContiguousStorageMut<N, U3, U1>,
impl<N: Scalar, S> DerefMut for Matrix<N, U4, U1, S> where
S: ContiguousStorageMut<N, U4, U1>,
[src]
S: ContiguousStorageMut<N, U4, U1>,
impl<N: Scalar, S> DerefMut for Matrix<N, U5, U1, S> where
S: ContiguousStorageMut<N, U5, U1>,
[src]
S: ContiguousStorageMut<N, U5, U1>,
impl<N: Scalar, S> DerefMut for Matrix<N, U6, U1, S> where
S: ContiguousStorageMut<N, U6, U1>,
[src]
S: ContiguousStorageMut<N, U6, U1>,
impl<N: Scalar, S> DerefMut for Matrix<N, U1, U2, S> where
S: ContiguousStorageMut<N, U1, U2>,
[src]
S: ContiguousStorageMut<N, U1, U2>,
impl<N: Scalar, S> DerefMut for Matrix<N, U1, U3, S> where
S: ContiguousStorageMut<N, U1, U3>,
[src]
S: ContiguousStorageMut<N, U1, U3>,
impl<N: Scalar, S> DerefMut for Matrix<N, U1, U4, S> where
S: ContiguousStorageMut<N, U1, U4>,
[src]
S: ContiguousStorageMut<N, U1, U4>,
impl<N: Scalar, S> DerefMut for Matrix<N, U1, U5, S> where
S: ContiguousStorageMut<N, U1, U5>,
[src]
S: ContiguousStorageMut<N, U1, U5>,
impl<N: Scalar, S> DerefMut for Matrix<N, U1, U6, S> where
S: ContiguousStorageMut<N, U1, U6>,
[src]
S: ContiguousStorageMut<N, U1, U6>,
impl<N: Scalar, S> DerefMut for Matrix<N, U2, U2, S> where
S: ContiguousStorageMut<N, U2, U2>,
[src]
S: ContiguousStorageMut<N, U2, U2>,
impl<N: Scalar, S> DerefMut for Matrix<N, U2, U3, S> where
S: ContiguousStorageMut<N, U2, U3>,
[src]
S: ContiguousStorageMut<N, U2, U3>,
impl<N: Scalar, S> DerefMut for Matrix<N, U2, U4, S> where
S: ContiguousStorageMut<N, U2, U4>,
[src]
S: ContiguousStorageMut<N, U2, U4>,
impl<N: Scalar, S> DerefMut for Matrix<N, U2, U5, S> where
S: ContiguousStorageMut<N, U2, U5>,
[src]
S: ContiguousStorageMut<N, U2, U5>,
impl<N: Scalar, S> DerefMut for Matrix<N, U2, U6, S> where
S: ContiguousStorageMut<N, U2, U6>,
[src]
S: ContiguousStorageMut<N, U2, U6>,
impl<N: Scalar, S> DerefMut for Matrix<N, U3, U2, S> where
S: ContiguousStorageMut<N, U3, U2>,
[src]
S: ContiguousStorageMut<N, U3, U2>,
impl<N: Scalar, S> DerefMut for Matrix<N, U3, U3, S> where
S: ContiguousStorageMut<N, U3, U3>,
[src]
S: ContiguousStorageMut<N, U3, U3>,
impl<N: Scalar, S> DerefMut for Matrix<N, U3, U4, S> where
S: ContiguousStorageMut<N, U3, U4>,
[src]
S: ContiguousStorageMut<N, U3, U4>,
impl<N: Scalar, S> DerefMut for Matrix<N, U3, U5, S> where
S: ContiguousStorageMut<N, U3, U5>,
[src]
S: ContiguousStorageMut<N, U3, U5>,
impl<N: Scalar, S> DerefMut for Matrix<N, U3, U6, S> where
S: ContiguousStorageMut<N, U3, U6>,
[src]
S: ContiguousStorageMut<N, U3, U6>,
impl<N: Scalar, S> DerefMut for Matrix<N, U4, U2, S> where
S: ContiguousStorageMut<N, U4, U2>,
[src]
S: ContiguousStorageMut<N, U4, U2>,
impl<N: Scalar, S> DerefMut for Matrix<N, U4, U3, S> where
S: ContiguousStorageMut<N, U4, U3>,
[src]
S: ContiguousStorageMut<N, U4, U3>,
impl<N: Scalar, S> DerefMut for Matrix<N, U4, U4, S> where
S: ContiguousStorageMut<N, U4, U4>,
[src]
S: ContiguousStorageMut<N, U4, U4>,
impl<N: Scalar, S> DerefMut for Matrix<N, U4, U5, S> where
S: ContiguousStorageMut<N, U4, U5>,
[src]
S: ContiguousStorageMut<N, U4, U5>,
impl<N: Scalar, S> DerefMut for Matrix<N, U4, U6, S> where
S: ContiguousStorageMut<N, U4, U6>,
[src]
S: ContiguousStorageMut<N, U4, U6>,
impl<N: Scalar, S> DerefMut for Matrix<N, U5, U2, S> where
S: ContiguousStorageMut<N, U5, U2>,
[src]
S: ContiguousStorageMut<N, U5, U2>,
impl<N: Scalar, S> DerefMut for Matrix<N, U5, U3, S> where
S: ContiguousStorageMut<N, U5, U3>,
[src]
S: ContiguousStorageMut<N, U5, U3>,
impl<N: Scalar, S> DerefMut for Matrix<N, U5, U4, S> where
S: ContiguousStorageMut<N, U5, U4>,
[src]
S: ContiguousStorageMut<N, U5, U4>,
impl<N: Scalar, S> DerefMut for Matrix<N, U5, U5, S> where
S: ContiguousStorageMut<N, U5, U5>,
[src]
S: ContiguousStorageMut<N, U5, U5>,
impl<N: Scalar, S> DerefMut for Matrix<N, U5, U6, S> where
S: ContiguousStorageMut<N, U5, U6>,
[src]
S: ContiguousStorageMut<N, U5, U6>,
impl<N: Scalar, S> DerefMut for Matrix<N, U6, U2, S> where
S: ContiguousStorageMut<N, U6, U2>,
[src]
S: ContiguousStorageMut<N, U6, U2>,
impl<N: Scalar, S> DerefMut for Matrix<N, U6, U3, S> where
S: ContiguousStorageMut<N, U6, U3>,
[src]
S: ContiguousStorageMut<N, U6, U3>,
impl<N: Scalar, S> DerefMut for Matrix<N, U6, U4, S> where
S: ContiguousStorageMut<N, U6, U4>,
[src]
S: ContiguousStorageMut<N, U6, U4>,
impl<N: Scalar, S> DerefMut for Matrix<N, U6, U5, S> where
S: ContiguousStorageMut<N, U6, U5>,
[src]
S: ContiguousStorageMut<N, U6, U5>,
impl<N: Scalar, S> DerefMut for Matrix<N, U6, U6, S> where
S: ContiguousStorageMut<N, U6, U6>,
[src]
S: ContiguousStorageMut<N, U6, U6>,
impl<N, R, C, S> Hash for Matrix<N, R, C, S> where
N: Scalar + Hash,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
[src]
N: Scalar + Hash,
R: Dim,
C: Dim,
S: Storage<N, R, C>,
fn hash<H: Hasher>(&self, state: &mut H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<'b, N, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
type Output = MatrixSum<N, R1, C1, R2, C2>
The resulting type after applying the +
operator.
fn add(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'a, N, R1, C1, R2, C2, SA, SB> Add<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,
type Output = MatrixSum<N, R2, C2, R1, C1>
The resulting type after applying the +
operator.
fn add(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<N, R1, C1, R2, C2, SA, SB> Add<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
type Output = MatrixSum<N, R1, C1, R2, C2>
The resulting type after applying the +
operator.
fn add(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
type Output = MatrixSum<N, R1, C1, R2, C2>
The resulting type after applying the +
operator.
fn add(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'a, 'b, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Add<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
N: Scalar + ClosedAdd,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
[src]
N: Scalar + ClosedAdd,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
type Output = Point<N, D1>
The resulting type after applying the +
operator.
fn add(self, right: &'b Vector<N, D2, SB>) -> Self::Output
[src]
impl<'a, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Add<Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
N: Scalar + ClosedAdd,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
[src]
N: Scalar + ClosedAdd,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
type Output = Point<N, D1>
The resulting type after applying the +
operator.
fn add(self, right: Vector<N, D2, SB>) -> Self::Output
[src]
impl<'b, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Add<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
N: Scalar + ClosedAdd,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
[src]
N: Scalar + ClosedAdd,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
type Output = Point<N, D1>
The resulting type after applying the +
operator.
fn add(self, right: &'b Vector<N, D2, SB>) -> Self::Output
[src]
impl<N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Add<Matrix<N, D2, U1, SB>> for Point<N, D1> where
N: Scalar + ClosedAdd,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
[src]
N: Scalar + ClosedAdd,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
type Output = Point<N, D1>
The resulting type after applying the +
operator.
fn add(self, right: Vector<N, D2, SB>) -> Self::Output
[src]
impl<'b, N, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
type Output = MatrixSum<N, R1, C1, R2, C2>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'a, N, R1, C1, R2, C2, SA, SB> Sub<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,
type Output = MatrixSum<N, R2, C2, R1, C1>
The resulting type after applying the -
operator.
fn sub(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<N, R1, C1, R2, C2, SA, SB> Sub<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
type Output = MatrixSum<N, R1, C1, R2, C2>
The resulting type after applying the -
operator.
fn sub(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'a, 'b, N, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
type Output = MatrixSum<N, R1, C1, R2, C2>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'a, 'b, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Sub<&'b Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
N: Scalar + ClosedSub,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
[src]
N: Scalar + ClosedSub,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
type Output = Point<N, D1>
The resulting type after applying the -
operator.
fn sub(self, right: &'b Vector<N, D2, SB>) -> Self::Output
[src]
impl<'a, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Sub<Matrix<N, D2, U1, SB>> for &'a Point<N, D1> where
N: Scalar + ClosedSub,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
[src]
N: Scalar + ClosedSub,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
type Output = Point<N, D1>
The resulting type after applying the -
operator.
fn sub(self, right: Vector<N, D2, SB>) -> Self::Output
[src]
impl<'b, N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Sub<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
N: Scalar + ClosedSub,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
[src]
N: Scalar + ClosedSub,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
type Output = Point<N, D1>
The resulting type after applying the -
operator.
fn sub(self, right: &'b Vector<N, D2, SB>) -> Self::Output
[src]
impl<N, D1: DimName, D2: Dim, SB: Storage<N, D2>> Sub<Matrix<N, D2, U1, SB>> for Point<N, D1> where
N: Scalar + ClosedSub,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
[src]
N: Scalar + ClosedSub,
DefaultAllocator: Allocator<N, D1, U1> + Allocator<N, D2, U1> + SameShapeAllocator<N, D1, U1, D2, U1>,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1>,
type Output = Point<N, D1>
The resulting type after applying the -
operator.
fn sub(self, right: Vector<N, D2, SB>) -> Self::Output
[src]
impl<N, R: Dim, C: Dim, S> Mul<N> for Matrix<N, R, C, S> where
N: Scalar + ClosedMul,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
N: Scalar + ClosedMul,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = MatrixMN<N, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: N) -> Self::Output
[src]
impl<'a, N, R: Dim, C: Dim, S> Mul<N> for &'a Matrix<N, R, C, S> where
N: Scalar + ClosedMul,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
N: Scalar + ClosedMul,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = MatrixMN<N, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: N) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<u8, R, C>> Mul<Matrix<u8, R, C, S>> for u8 where
DefaultAllocator: Allocator<u8, R, C>,
[src]
DefaultAllocator: Allocator<u8, R, C>,
type Output = MatrixMN<u8, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<u8, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<u8, R, C>> Mul<&'b Matrix<u8, R, C, S>> for u8 where
DefaultAllocator: Allocator<u8, R, C>,
[src]
DefaultAllocator: Allocator<u8, R, C>,
type Output = MatrixMN<u8, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<u8, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<u16, R, C>> Mul<Matrix<u16, R, C, S>> for u16 where
DefaultAllocator: Allocator<u16, R, C>,
[src]
DefaultAllocator: Allocator<u16, R, C>,
type Output = MatrixMN<u16, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<u16, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<u16, R, C>> Mul<&'b Matrix<u16, R, C, S>> for u16 where
DefaultAllocator: Allocator<u16, R, C>,
[src]
DefaultAllocator: Allocator<u16, R, C>,
type Output = MatrixMN<u16, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<u16, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<u32, R, C>> Mul<Matrix<u32, R, C, S>> for u32 where
DefaultAllocator: Allocator<u32, R, C>,
[src]
DefaultAllocator: Allocator<u32, R, C>,
type Output = MatrixMN<u32, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<u32, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<u32, R, C>> Mul<&'b Matrix<u32, R, C, S>> for u32 where
DefaultAllocator: Allocator<u32, R, C>,
[src]
DefaultAllocator: Allocator<u32, R, C>,
type Output = MatrixMN<u32, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<u32, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<u64, R, C>> Mul<Matrix<u64, R, C, S>> for u64 where
DefaultAllocator: Allocator<u64, R, C>,
[src]
DefaultAllocator: Allocator<u64, R, C>,
type Output = MatrixMN<u64, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<u64, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<u64, R, C>> Mul<&'b Matrix<u64, R, C, S>> for u64 where
DefaultAllocator: Allocator<u64, R, C>,
[src]
DefaultAllocator: Allocator<u64, R, C>,
type Output = MatrixMN<u64, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<u64, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<usize, R, C>> Mul<Matrix<usize, R, C, S>> for usize where
DefaultAllocator: Allocator<usize, R, C>,
[src]
DefaultAllocator: Allocator<usize, R, C>,
type Output = MatrixMN<usize, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<usize, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<usize, R, C>> Mul<&'b Matrix<usize, R, C, S>> for usize where
DefaultAllocator: Allocator<usize, R, C>,
[src]
DefaultAllocator: Allocator<usize, R, C>,
type Output = MatrixMN<usize, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<usize, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<i8, R, C>> Mul<Matrix<i8, R, C, S>> for i8 where
DefaultAllocator: Allocator<i8, R, C>,
[src]
DefaultAllocator: Allocator<i8, R, C>,
type Output = MatrixMN<i8, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<i8, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<i8, R, C>> Mul<&'b Matrix<i8, R, C, S>> for i8 where
DefaultAllocator: Allocator<i8, R, C>,
[src]
DefaultAllocator: Allocator<i8, R, C>,
type Output = MatrixMN<i8, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<i8, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<i16, R, C>> Mul<Matrix<i16, R, C, S>> for i16 where
DefaultAllocator: Allocator<i16, R, C>,
[src]
DefaultAllocator: Allocator<i16, R, C>,
type Output = MatrixMN<i16, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<i16, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<i16, R, C>> Mul<&'b Matrix<i16, R, C, S>> for i16 where
DefaultAllocator: Allocator<i16, R, C>,
[src]
DefaultAllocator: Allocator<i16, R, C>,
type Output = MatrixMN<i16, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<i16, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<i32, R, C>> Mul<Matrix<i32, R, C, S>> for i32 where
DefaultAllocator: Allocator<i32, R, C>,
[src]
DefaultAllocator: Allocator<i32, R, C>,
type Output = MatrixMN<i32, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<i32, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<i32, R, C>> Mul<&'b Matrix<i32, R, C, S>> for i32 where
DefaultAllocator: Allocator<i32, R, C>,
[src]
DefaultAllocator: Allocator<i32, R, C>,
type Output = MatrixMN<i32, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<i32, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<i64, R, C>> Mul<Matrix<i64, R, C, S>> for i64 where
DefaultAllocator: Allocator<i64, R, C>,
[src]
DefaultAllocator: Allocator<i64, R, C>,
type Output = MatrixMN<i64, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<i64, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<i64, R, C>> Mul<&'b Matrix<i64, R, C, S>> for i64 where
DefaultAllocator: Allocator<i64, R, C>,
[src]
DefaultAllocator: Allocator<i64, R, C>,
type Output = MatrixMN<i64, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<i64, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<isize, R, C>> Mul<Matrix<isize, R, C, S>> for isize where
DefaultAllocator: Allocator<isize, R, C>,
[src]
DefaultAllocator: Allocator<isize, R, C>,
type Output = MatrixMN<isize, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<isize, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<isize, R, C>> Mul<&'b Matrix<isize, R, C, S>> for isize where
DefaultAllocator: Allocator<isize, R, C>,
[src]
DefaultAllocator: Allocator<isize, R, C>,
type Output = MatrixMN<isize, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<isize, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<f32, R, C>> Mul<Matrix<f32, R, C, S>> for f32 where
DefaultAllocator: Allocator<f32, R, C>,
[src]
DefaultAllocator: Allocator<f32, R, C>,
type Output = MatrixMN<f32, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<f32, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<f32, R, C>> Mul<&'b Matrix<f32, R, C, S>> for f32 where
DefaultAllocator: Allocator<f32, R, C>,
[src]
DefaultAllocator: Allocator<f32, R, C>,
type Output = MatrixMN<f32, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<f32, R, C, S>) -> Self::Output
[src]
impl<R: Dim, C: Dim, S: Storage<f64, R, C>> Mul<Matrix<f64, R, C, S>> for f64 where
DefaultAllocator: Allocator<f64, R, C>,
[src]
DefaultAllocator: Allocator<f64, R, C>,
type Output = MatrixMN<f64, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<f64, R, C, S>) -> Self::Output
[src]
impl<'b, R: Dim, C: Dim, S: Storage<f64, R, C>> Mul<&'b Matrix<f64, R, C, S>> for f64 where
DefaultAllocator: Allocator<f64, R, C>,
[src]
DefaultAllocator: Allocator<f64, R, C>,
type Output = MatrixMN<f64, R, C>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<f64, R, C, S>) -> Self::Output
[src]
impl<'a, 'b, N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SA: Storage<N, R1, C1>,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
type Output = MatrixMN<N, R1, C2>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'a, N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<N, R2, C2, SB>> for &'a Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
type Output = MatrixMN<N, R1, C2>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'b, N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
type Output = MatrixMN<N, R1, C2>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<N, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SB: Storage<N, R2, C2>,
SA: Storage<N, R1, C1>,
DefaultAllocator: Allocator<N, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
type Output = MatrixMN<N, R1, C2>
The resulting type after applying the *
operator.
fn mul(self, rhs: Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<N, R1: DimName, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<Point<N, D2>> for Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
type Output = Point<N, R1>
The resulting type after applying the *
operator.
fn mul(self, right: Point<N, D2>) -> Self::Output
[src]
impl<'a, N, R1: DimName, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<Point<N, D2>> for &'a Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
type Output = Point<N, R1>
The resulting type after applying the *
operator.
fn mul(self, right: Point<N, D2>) -> Self::Output
[src]
impl<'b, N, R1: DimName, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<&'b Point<N, D2>> for Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
type Output = Point<N, R1>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Point<N, D2>) -> Self::Output
[src]
impl<'a, 'b, N, R1: DimName, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<&'b Point<N, D2>> for &'a Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, U1> + Allocator<N, R1, U1>,
ShapeConstraint: AreMultipliable<R1, C1, D2, U1>,
type Output = Point<N, R1>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Point<N, D2>) -> Self::Output
[src]
impl<N, D1: DimName, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>> Mul<Matrix<N, R2, C2, SB>> for Rotation<N, D1> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = MatrixMN<N, D1, C2>
The resulting type after applying the *
operator.
fn mul(self, right: Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'a, N, D1: DimName, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>> Mul<Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = MatrixMN<N, D1, C2>
The resulting type after applying the *
operator.
fn mul(self, right: Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'b, N, D1: DimName, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>> Mul<&'b Matrix<N, R2, C2, SB>> for Rotation<N, D1> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = MatrixMN<N, D1, C2>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<'a, 'b, N, D1: DimName, R2: Dim, C2: Dim, SB: Storage<N, R2, C2>> Mul<&'b Matrix<N, R2, C2, SB>> for &'a Rotation<N, D1> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, D1, D1> + Allocator<N, R2, C2> + Allocator<N, D1, C2>,
DefaultAllocator: Allocator<N, D1, C2>,
ShapeConstraint: AreMultipliable<D1, D1, R2, C2>,
type Output = MatrixMN<N, D1, C2>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Matrix<N, R2, C2, SB>) -> Self::Output
[src]
impl<N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = MatrixMN<N, R1, D2>
The resulting type after applying the *
operator.
fn mul(self, right: Rotation<N, D2>) -> Self::Output
[src]
impl<'a, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = MatrixMN<N, R1, D2>
The resulting type after applying the *
operator.
fn mul(self, right: Rotation<N, D2>) -> Self::Output
[src]
impl<'b, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = MatrixMN<N, R1, D2>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Rotation<N, D2>) -> Self::Output
[src]
impl<'a, 'b, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Mul<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = MatrixMN<N, R1, D2>
The resulting type after applying the *
operator.
fn mul(self, right: &'b Rotation<N, D2>) -> Self::Output
[src]
impl<'a, 'b, N: Real, SB: Storage<N, U3>> Mul<&'b Matrix<N, U3, U1, SB>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
type Output = Vector3<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Vector<N, U3, SB>) -> Self::Output
[src]
impl<'a, N: Real, SB: Storage<N, U3>> Mul<Matrix<N, U3, U1, SB>> for &'a UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
type Output = Vector3<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: Vector<N, U3, SB>) -> Self::Output
[src]
impl<'b, N: Real, SB: Storage<N, U3>> Mul<&'b Matrix<N, U3, U1, SB>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
type Output = Vector3<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Vector<N, U3, SB>) -> Self::Output
[src]
impl<N: Real, SB: Storage<N, U3>> Mul<Matrix<N, U3, U1, SB>> for UnitQuaternion<N> where
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
[src]
DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U1>,
type Output = Vector3<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: Vector<N, U3, SB>) -> Self::Output
[src]
impl<N: Real, S: Storage<N, U2>> Mul<Matrix<N, U2, U1, S>> for UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
DefaultAllocator: Allocator<N, U2, U1>,
type Output = Vector2<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: Vector<N, U2, S>) -> Self::Output
[src]
impl<'a, N: Real, S: Storage<N, U2>> Mul<Matrix<N, U2, U1, S>> for &'a UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
DefaultAllocator: Allocator<N, U2, U1>,
type Output = Vector2<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: Vector<N, U2, S>) -> Self::Output
[src]
impl<'b, N: Real, S: Storage<N, U2>> Mul<&'b Matrix<N, U2, U1, S>> for UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
DefaultAllocator: Allocator<N, U2, U1>,
type Output = Vector2<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Vector<N, U2, S>) -> Self::Output
[src]
impl<'a, 'b, N: Real, S: Storage<N, U2>> Mul<&'b Matrix<N, U2, U1, S>> for &'a UnitComplex<N> where
DefaultAllocator: Allocator<N, U2, U1>,
[src]
DefaultAllocator: Allocator<N, U2, U1>,
type Output = Vector2<N>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b Vector<N, U2, S>) -> Self::Output
[src]
impl<N: Real, D: DimName, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: VectorN<N, D>) -> Self::Output
[src]
impl<'a, N: Real, D: DimName, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: VectorN<N, D>) -> Self::Output
[src]
impl<'b, N: Real, D: DimName, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: &'b VectorN<N, D>) -> Self::Output
[src]
impl<'a, 'b, N: Real, D: DimName, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Isometry<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: &'b VectorN<N, D>) -> Self::Output
[src]
impl<N: Real, D: DimName, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: VectorN<N, D>) -> Self::Output
[src]
impl<'a, N: Real, D: DimName, R> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: VectorN<N, D>) -> Self::Output
[src]
impl<'b, N: Real, D: DimName, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: &'b VectorN<N, D>) -> Self::Output
[src]
impl<'a, 'b, N: Real, D: DimName, R> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Similarity<N, D, R> where
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
[src]
R: AlgaRotation<Point<N, D>>,
DefaultAllocator: Allocator<N, D>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, right: &'b VectorN<N, D>) -> Self::Output
[src]
impl<N, D: DimNameAdd<U1>, C: TCategory> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Transform<N, D, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, rhs: VectorN<N, D>) -> Self::Output
[src]
impl<'a, N, D: DimNameAdd<U1>, C: TCategory> Mul<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Transform<N, D, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, rhs: VectorN<N, D>) -> Self::Output
[src]
impl<'b, N, D: DimNameAdd<U1>, C: TCategory> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for Transform<N, D, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b VectorN<N, D>) -> Self::Output
[src]
impl<'a, 'b, N, D: DimNameAdd<U1>, C: TCategory> Mul<&'b Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>> for &'a Transform<N, D, C> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul + Real,
DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1> + Allocator<N, DimNameSum<D, U1>, U1>,
type Output = VectorN<N, D>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'b VectorN<N, D>) -> Self::Output
[src]
impl<N, R: Dim, C: Dim, S> Div<N> for Matrix<N, R, C, S> where
N: Scalar + ClosedDiv,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
N: Scalar + ClosedDiv,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = MatrixMN<N, R, C>
The resulting type after applying the /
operator.
fn div(self, rhs: N) -> Self::Output
[src]
impl<'a, N, R: Dim, C: Dim, S> Div<N> for &'a Matrix<N, R, C, S> where
N: Scalar + ClosedDiv,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
N: Scalar + ClosedDiv,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = MatrixMN<N, R, C>
The resulting type after applying the /
operator.
fn div(self, rhs: N) -> Self::Output
[src]
impl<N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Div<Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = MatrixMN<N, R1, D2>
The resulting type after applying the /
operator.
fn div(self, right: Rotation<N, D2>) -> Self::Output
[src]
impl<'a, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Div<Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = MatrixMN<N, R1, D2>
The resulting type after applying the /
operator.
fn div(self, right: Rotation<N, D2>) -> Self::Output
[src]
impl<'b, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Div<&'b Rotation<N, D2>> for Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = MatrixMN<N, R1, D2>
The resulting type after applying the /
operator.
fn div(self, right: &'b Rotation<N, D2>) -> Self::Output
[src]
impl<'a, 'b, N, R1: Dim, C1: Dim, D2: DimName, SA: Storage<N, R1, C1>> Div<&'b Rotation<N, D2>> for &'a Matrix<N, R1, C1, SA> where
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
[src]
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, D2, D2> + Allocator<N, R1, D2>,
DefaultAllocator: Allocator<N, R1, D2>,
ShapeConstraint: AreMultipliable<R1, C1, D2, D2>,
type Output = MatrixMN<N, R1, D2>
The resulting type after applying the /
operator.
fn div(self, right: &'b Rotation<N, D2>) -> Self::Output
[src]
impl<N, R: Dim, C: Dim, S> Neg for Matrix<N, R, C, S> where
N: Scalar + ClosedNeg,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
N: Scalar + ClosedNeg,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = MatrixMN<N, R, C>
The resulting type after applying the -
operator.
fn neg(self) -> Self::Output
[src]
impl<'a, N, R: Dim, C: Dim, S> Neg for &'a Matrix<N, R, C, S> where
N: Scalar + ClosedNeg,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
[src]
N: Scalar + ClosedNeg,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<N, R, C>,
type Output = MatrixMN<N, R, C>
The resulting type after applying the -
operator.
fn neg(self) -> Self::Output
[src]
impl<'b, N, R1, C1, R2, C2, SA, SB> AddAssign<&'b Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedAdd,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
fn add_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)
[src]
impl<'b, N, D1: DimName, D2: Dim, SB> AddAssign<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
N: Scalar + ClosedAdd,
SB: Storage<N, D2>,
DefaultAllocator: Allocator<N, D1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
[src]
N: Scalar + ClosedAdd,
SB: Storage<N, D2>,
DefaultAllocator: Allocator<N, D1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
fn add_assign(&mut self, right: &'b Vector<N, D2, SB>)
[src]
impl<N, D1: DimName, D2: Dim, SB> AddAssign<Matrix<N, D2, U1, SB>> for Point<N, D1> where
N: Scalar + ClosedAdd,
SB: Storage<N, D2>,
DefaultAllocator: Allocator<N, D1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
[src]
N: Scalar + ClosedAdd,
SB: Storage<N, D2>,
DefaultAllocator: Allocator<N, D1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
fn add_assign(&mut self, right: Vector<N, D2, 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
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
fn sub_assign(&mut self, rhs: &'b Matrix<N, R2, C2, SB>)
[src]
impl<N, R1, C1, R2, C2, SA, SB> SubAssign<Matrix<N, R2, C2, SB>> for Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N: Scalar + ClosedSub,
SA: StorageMut<N, R1, C1>,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
fn sub_assign(&mut self, rhs: Matrix<N, R2, C2, SB>)
[src]
impl<'b, N, D1: DimName, D2: Dim, SB> SubAssign<&'b Matrix<N, D2, U1, SB>> for Point<N, D1> where
N: Scalar + ClosedSub,
SB: Storage<N, D2>,
DefaultAllocator: Allocator<N, D1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
[src]
N: Scalar + ClosedSub,
SB: Storage<N, D2>,
DefaultAllocator: Allocator<N, D1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
fn sub_assign(&mut self, right: &'b Vector<N, D2, SB>)
[src]
impl<N, D1: DimName, D2: Dim, SB> SubAssign<Matrix<N, D2, U1, SB>> for Point<N, D1> where
N: Scalar + ClosedSub,
SB: Storage<N, D2>,
DefaultAllocator: Allocator<N, D1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
[src]
N: Scalar + ClosedSub,
SB: Storage<N, D2>,
DefaultAllocator: Allocator<N, D1>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
fn sub_assign(&mut self, right: Vector<N, D2, SB>)
[src]
impl<N, R: Dim, C: Dim, S> MulAssign<N> for Matrix<N, R, C, S> where
N: Scalar + ClosedMul,
S: StorageMut<N, R, C>,
[src]
N: Scalar + ClosedMul,
S: StorageMut<N, R, C>,
fn mul_assign(&mut self, rhs: N)
[src]
impl<N, R1, C1, R2, SA, SB> MulAssign<Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SB: Storage<N, R2, C1>,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SB: Storage<N, R2, C1>,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,
fn mul_assign(&mut self, rhs: Matrix<N, R2, C1, SB>)
[src]
impl<'b, N, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SB: Storage<N, R2, C1>,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
N: Scalar + Zero + One + ClosedAdd + ClosedMul,
SB: Storage<N, R2, C1>,
SA: ContiguousStorageMut<N, R1, C1> + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>,
fn mul_assign(&mut self, rhs: &'b Matrix<N, R2, C1, SB>)
[src]
impl<N, R: Dim, C: Dim, S> DivAssign<N> for Matrix<N, R, C, S> where
N: Scalar + ClosedDiv,
S: StorageMut<N, R, C>,
[src]
N: Scalar + ClosedDiv,
S: StorageMut<N, R, C>,
fn div_assign(&mut self, rhs: N)
[src]
impl<N: Scalar, S> Deref for Matrix<N, U1, U1, S> where
S: ContiguousStorage<N, U1, U1>,
[src]
S: ContiguousStorage<N, U1, U1>,
impl<N: Scalar, S> Deref for Matrix<N, U2, U1, S> where
S: ContiguousStorage<N, U2, U1>,
[src]
S: ContiguousStorage<N, U2, U1>,
impl<N: Scalar, S> Deref for Matrix<N, U3, U1, S> where
S: ContiguousStorage<N, U3, U1>,
[src]
S: ContiguousStorage<N, U3, U1>,
impl<N: Scalar, S> Deref for Matrix<N, U4, U1, S> where
S: ContiguousStorage<N, U4, U1>,
[src]
S: ContiguousStorage<N, U4, U1>,
impl<N: Scalar, S> Deref for Matrix<N, U5, U1, S> where
S: ContiguousStorage<N, U5, U1>,
[src]
S: ContiguousStorage<N, U5, U1>,
impl<N: Scalar, S> Deref for Matrix<N, U6, U1, S> where
S: ContiguousStorage<N, U6, U1>,
[src]
S: ContiguousStorage<N, U6, U1>,
type Target = XYZWAB<N>
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
impl<N: Scalar, S> Deref for Matrix<N, U1, U2, S> where
S: ContiguousStorage<N, U1, U2>,
[src]
S: ContiguousStorage<N, U1, U2>,
impl<N: Scalar, S> Deref for Matrix<N, U1, U3, S> where
S: ContiguousStorage<N, U1, U3>,
[src]
S: ContiguousStorage<N, U1, U3>,
impl<N: Scalar, S> Deref for Matrix<N, U1, U4, S> where
S: ContiguousStorage<N, U1, U4>,
[src]
S: ContiguousStorage<N, U1, U4>,
impl<N: Scalar, S> Deref for Matrix<N, U1, U5, S> where
S: ContiguousStorage<N, U1, U5>,
[src]
S: ContiguousStorage<N, U1, U5>,
impl<N: Scalar, S> Deref for Matrix<N, U1, U6, S> where
S: ContiguousStorage<N, U1, U6>,
[src]
S: ContiguousStorage<N, U1, U6>,
type Target = XYZWAB<N>
The resulting type after dereferencing.
fn deref(&self) -> &Self::Target
[src]
impl<N: Scalar, S> Deref for Matrix<N, U2, U2, S> where
S: ContiguousStorage<N, U2, U2>,
[src]
S: ContiguousStorage<N, U2, U2>,
impl<N: Scalar, S> Deref for Matrix<N, U2, U3, S> where
S: ContiguousStorage<N, U2, U3>,
[src]
S: ContiguousStorage<N, U2, U3>,
impl<N: Scalar, S> Deref for Matrix<N, U2, U4, S> where
S: ContiguousStorage<N, U2, U4>,
[src]
S: ContiguousStorage<N, U2, U4>,
impl<N: Scalar, S> Deref for Matrix<N, U2, U5, S> where
S: ContiguousStorage<N, U2, U5>,
[src]
S: ContiguousStorage<N, U2, U5>,
impl<N: Scalar, S> Deref for Matrix<N, U2, U6, S> where
S: ContiguousStorage<N, U2, U6>,
[src]
S: ContiguousStorage<N, U2, U6>,
impl<N: Scalar, S> Deref for Matrix<N, U3, U2, S> where
S: ContiguousStorage<N, U3, U2>,
[src]
S: ContiguousStorage<N, U3, U2>,
impl<N: Scalar, S> Deref for Matrix<N, U3, U3, S> where
S: ContiguousStorage<N, U3, U3>,
[src]
S: ContiguousStorage<N, U3, U3>,
impl<N: Scalar, S> Deref for Matrix<N, U3, U4, S> where
S: ContiguousStorage<N, U3, U4>,
[src]
S: ContiguousStorage<N, U3, U4>,
impl<N: Scalar, S> Deref for Matrix<N, U3, U5, S> where
S: ContiguousStorage<N, U3, U5>,
[src]
S: ContiguousStorage<N, U3, U5>,
impl<N: Scalar, S> Deref for Matrix<N, U3, U6, S> where
S: ContiguousStorage<N, U3, U6>,
[src]
S: ContiguousStorage<N, U3, U6>,
impl<N: Scalar, S> Deref for Matrix<N, U4, U2, S> where
S: ContiguousStorage<N, U4, U2>,
[src]
S: ContiguousStorage<N, U4, U2>,
impl<N: Scalar, S> Deref for Matrix<N, U4, U3, S> where
S: ContiguousStorage<N, U4, U3>,
[src]
S: ContiguousStorage<N, U4, U3>,
impl<N: Scalar, S> Deref for Matrix<N, U4, U4, S> where
S: ContiguousStorage<N, U4, U4>,
[src]
S: ContiguousStorage<N, U4, U4>,
impl<N: Scalar, S> Deref for Matrix<N, U4, U5, S> where
S: ContiguousStorage<N, U4, U5>,
[src]
S: ContiguousStorage<N, U4, U5>,
impl<N: Scalar, S> Deref for Matrix<N, U4, U6, S> where
S: ContiguousStorage<N, U4, U6>,
[src]
S: ContiguousStorage<N, U4, U6>,
impl<N: Scalar, S> Deref for Matrix<N, U5, U2, S> where
S: ContiguousStorage<N, U5, U2>,
[src]
S: ContiguousStorage<N, U5, U2>,
impl<N: Scalar, S> Deref for Matrix<N, U5, U3, S> where
S: ContiguousStorage<N, U5, U3>,
[src]
S: ContiguousStorage<N, U5, U3>,
impl<N: Scalar, S> Deref for Matrix<N, U5, U4, S> where
S: ContiguousStorage<N, U5, U4>,
[src]
S: ContiguousStorage<N, U5, U4>,
impl<N: Scalar, S> Deref for Matrix<N, U5, U5, S> where
S: ContiguousStorage<N, U5, U5>,
[src]
S: ContiguousStorage<N, U5, U5>,
impl<N: Scalar, S> Deref for Matrix<N, U5, U6, S> where
S: ContiguousStorage<N, U5, U6>,
[src]
S: ContiguousStorage<N, U5, U6>,
impl<N: Scalar, S> Deref for Matrix<N, U6, U2, S> where
S: ContiguousStorage<N, U6, U2>,
[src]
S: ContiguousStorage<N, U6, U2>,
impl<N: Scalar, S> Deref for Matrix<N, U6, U3, S> where
S: ContiguousStorage<N, U6, U3>,
[src]
S: ContiguousStorage<N, U6, U3>,
impl<N: Scalar, S> Deref for Matrix<N, U6, U4, S> where
S: ContiguousStorage<N, U6, U4>,
[src]
S: ContiguousStorage<N, U6, U4>,
impl<N: Scalar, S> Deref for Matrix<N, U6, U5, S> where
S: ContiguousStorage<N, U6, U5>,
[src]
S: ContiguousStorage<N, U6, U5>,
impl<N: Scalar, S> Deref for Matrix<N, U6, U6, S> where
S: ContiguousStorage<N, U6, U6>,
[src]
S: ContiguousStorage<N, U6, U6>,
impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Index<usize> for Matrix<N, R, C, S>
[src]
impl<N, R: Dim, C: Dim, S> Index<(usize, usize)> for Matrix<N, R, C, S> where
N: Scalar,
S: Storage<N, R, C>,
[src]
N: Scalar,
S: Storage<N, R, C>,
impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> IndexMut<usize> for Matrix<N, R, C, S>
[src]
impl<N, R: Dim, C: Dim, S> IndexMut<(usize, usize)> for Matrix<N, R, C, S> where
N: Scalar,
S: StorageMut<N, R, C>,
[src]
N: Scalar,
S: StorageMut<N, R, C>,
impl<N, R: Dim, C: Dim, S> Display for Matrix<N, R, C, S> where
N: Scalar + Display,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<usize, R, C>,
[src]
N: Scalar + Display,
S: Storage<N, R, C>,
DefaultAllocator: Allocator<usize, R, C>,
impl<N: Scalar, R: Dim, C: Dim, S: Debug> Debug for Matrix<N, R, C, S>
[src]
impl<N, D: DimName> Product<Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> for MatrixN<N, D> where
N: Scalar + Zero + One + ClosedMul + ClosedAdd,
DefaultAllocator: Allocator<N, D, D>,
[src]
N: Scalar + Zero + One + ClosedMul + ClosedAdd,
DefaultAllocator: Allocator<N, D, D>,
impl<'a, N, D: DimName> Product<&'a Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer>> for MatrixN<N, D> where
N: Scalar + Zero + One + ClosedMul + ClosedAdd,
DefaultAllocator: Allocator<N, D, D>,
[src]
N: Scalar + Zero + One + ClosedMul + ClosedAdd,
DefaultAllocator: Allocator<N, D, D>,
impl<N, R: DimName, C: DimName> Sum<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> for MatrixMN<N, R, C> where
N: Scalar + ClosedAdd + Zero,
DefaultAllocator: Allocator<N, R, C>,
[src]
N: Scalar + ClosedAdd + Zero,
DefaultAllocator: Allocator<N, R, C>,
impl<'a, N, R: DimName, C: DimName> Sum<&'a Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> for MatrixMN<N, R, C> where
N: Scalar + ClosedAdd + Zero,
DefaultAllocator: Allocator<N, R, C>,
[src]
N: Scalar + ClosedAdd + Zero,
DefaultAllocator: Allocator<N, R, C>,
impl<N, R: Dim, C: Dim, S> AbsDiffEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S> where
N: Scalar + AbsDiffEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
[src]
N: Scalar + AbsDiffEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
type Epsilon = N::Epsilon
Used for specifying relative comparisons.
fn default_epsilon() -> Self::Epsilon
[src]
fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool
[src]
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
[src]
impl<N, R: Dim, C: Dim, S> RelativeEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S> where
N: Scalar + RelativeEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
[src]
N: Scalar + RelativeEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
fn default_max_relative() -> Self::Epsilon
[src]
fn relative_eq(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
[src]
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
[src]
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
impl<N, R: Dim, C: Dim, S> UlpsEq<Matrix<N, R, C, S>> for Matrix<N, R, C, S> where
N: Scalar + UlpsEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
[src]
N: Scalar + UlpsEq,
S: Storage<N, R, C>,
N::Epsilon: Copy,
fn default_max_ulps() -> u32
[src]
fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool
[src]
fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool
[src]
impl<N: Scalar, R: Dim, C: Dim> Distribution<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> for Standard where
DefaultAllocator: Allocator<N, R, C>,
Standard: Distribution<N>,
[src]
DefaultAllocator: Allocator<N, R, C>,
Standard: Distribution<N>,
fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> MatrixMN<N, R, C>
[src]
fn sample_iter<R>(&'a self, rng: &'a mut R) -> DistIter<'a, Self, R, T> where
R: Rng,
[src]
R: Rng,
impl<N1, N2, R1, C1, R2, C2> SubsetOf<Matrix<N2, R2, C2, <DefaultAllocator as Allocator<N2, R2, C2>>::Buffer>> for MatrixMN<N1, R1, C1> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N1: Scalar,
N2: Scalar + SupersetOf<N1>,
DefaultAllocator: Allocator<N2, R2, C2> + Allocator<N1, R1, C1> + SameShapeAllocator<N1, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
[src]
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
N1: Scalar,
N2: Scalar + SupersetOf<N1>,
DefaultAllocator: Allocator<N2, R2, C2> + Allocator<N1, R1, C1> + SameShapeAllocator<N1, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
fn to_superset(&self) -> MatrixMN<N2, R2, C2>
[src]
fn is_in_subset(m: &MatrixMN<N2, R2, C2>) -> bool
[src]
unsafe fn from_superset_unchecked(m: &MatrixMN<N2, R2, C2>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
impl<N1, N2, D> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, U1>>::Buffer>> for Point<N1, D> where
D: DimNameAdd<U1>,
N1: Scalar,
N2: Scalar + Zero + One + ClosedDiv + SupersetOf<N1>,
DefaultAllocator: Allocator<N1, D> + Allocator<N1, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>> + Allocator<N2, D>,
[src]
D: DimNameAdd<U1>,
N1: Scalar,
N2: Scalar + Zero + One + ClosedDiv + SupersetOf<N1>,
DefaultAllocator: Allocator<N1, D> + Allocator<N1, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>> + Allocator<N2, D>,
fn to_superset(&self) -> VectorN<N2, DimNameSum<D, U1>>
[src]
fn is_in_subset(v: &VectorN<N2, DimNameSum<D, U1>>) -> bool
[src]
unsafe fn from_superset_unchecked(v: &VectorN<N2, DimNameSum<D, U1>>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
impl<N1, N2, D> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Rotation<N1, D> where
N1: Real,
N2: Real + SupersetOf<N1>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D, D> + Allocator<N2, D, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D>,
fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>>
[src]
fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool
[src]
unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix<N2, U4, U4, <DefaultAllocator as Allocator<N2, U4, U4>>::Buffer>> for UnitQuaternion<N1>
[src]
fn to_superset(&self) -> Matrix4<N2>
[src]
fn is_in_subset(m: &Matrix4<N2>) -> bool
[src]
unsafe fn from_superset_unchecked(m: &Matrix4<N2>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
impl<N1: Real, N2: Real + SupersetOf<N1>> SubsetOf<Matrix<N2, U3, U3, <DefaultAllocator as Allocator<N2, U3, U3>>::Buffer>> for UnitComplex<N1>
[src]
fn to_superset(&self) -> Matrix3<N2>
[src]
fn is_in_subset(m: &Matrix3<N2>) -> bool
[src]
unsafe fn from_superset_unchecked(m: &Matrix3<N2>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
impl<N1, N2, D> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Translation<N1, D> where
N1: Real,
N2: Real + SupersetOf<N1>,
D: DimNameAdd<U1>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
D: DimNameAdd<U1>,
DefaultAllocator: Allocator<N1, D> + Allocator<N2, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>>
[src]
fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool
[src]
unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
impl<N1, N2, D, R> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Isometry<N1, D, R> where
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N1, D>> + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>> + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D> + Allocator<N1, D, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D> + Allocator<N2, D, D> + Allocator<N2, D>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N1, D>> + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>> + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D> + Allocator<N1, D, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D> + Allocator<N2, D, D> + Allocator<N2, D>,
fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>>
[src]
fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool
[src]
unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
impl<N1, N2, D, R> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Similarity<N1, D, R> where
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N1, D>> + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>> + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D> + Allocator<N1, D, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D> + Allocator<N2, D, D> + Allocator<N2, D>,
[src]
N1: Real,
N2: Real + SupersetOf<N1>,
R: Rotation<Point<N1, D>> + SubsetOf<MatrixN<N1, DimNameSum<D, U1>>> + SubsetOf<MatrixN<N2, DimNameSum<D, U1>>>,
D: DimNameAdd<U1> + DimMin<D, Output = D>,
DefaultAllocator: Allocator<N1, D> + Allocator<N1, D, D> + Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<(usize, usize), D> + Allocator<N2, D, D> + Allocator<N2, D>,
fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>>
[src]
fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool
[src]
unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
impl<N1, N2, D: DimName, C> SubsetOf<Matrix<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output, <DefaultAllocator as Allocator<N2, <D as DimNameAdd<U1>>::Output, <D as DimNameAdd<U1>>::Output>>::Buffer>> for Transform<N1, D, C> where
N1: Real + SubsetOf<N2>,
N2: Real,
C: TCategory,
D: DimNameAdd<U1>,
DefaultAllocator: Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
N1::Epsilon: Copy,
N2::Epsilon: Copy,
[src]
N1: Real + SubsetOf<N2>,
N2: Real,
C: TCategory,
D: DimNameAdd<U1>,
DefaultAllocator: Allocator<N1, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N2, DimNameSum<D, U1>, DimNameSum<D, U1>>,
N1::Epsilon: Copy,
N2::Epsilon: Copy,
fn to_superset(&self) -> MatrixN<N2, DimNameSum<D, U1>>
[src]
fn is_in_subset(m: &MatrixN<N2, DimNameSum<D, U1>>) -> bool
[src]
unsafe fn from_superset_unchecked(m: &MatrixN<N2, DimNameSum<D, U1>>) -> Self
[src]
fn from_superset(element: &T) -> Option<Self>
[src]
Auto Trait Implementations
impl<N, R, C, S> Unpin for Matrix<N, R, C, S> where
C: Unpin,
N: Unpin,
R: Unpin,
S: Unpin,
C: Unpin,
N: Unpin,
R: Unpin,
S: Unpin,
impl<N, R, C, S> Sync for Matrix<N, R, C, S> where
N: Sync,
S: Sync,
N: Sync,
S: Sync,
impl<N, R, C, S> Send for Matrix<N, R, C, S> where
N: Send,
S: Send,
N: Send,
S: Send,
impl<N, R, C, S> UnwindSafe for Matrix<N, R, C, S> where
C: UnwindSafe,
N: UnwindSafe,
R: UnwindSafe,
S: UnwindSafe,
C: UnwindSafe,
N: UnwindSafe,
R: UnwindSafe,
S: UnwindSafe,
impl<N, R, C, S> RefUnwindSafe for Matrix<N, R, C, S> where
C: RefUnwindSafe,
N: RefUnwindSafe,
R: RefUnwindSafe,
S: RefUnwindSafe,
C: RefUnwindSafe,
N: RefUnwindSafe,
R: RefUnwindSafe,
S: RefUnwindSafe,
Blanket Implementations
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Same<T> for T
[src]
type Output = T
Should always be Self
impl<T> Rand for T where
Standard: Distribution<T>,
[src]
Standard: Distribution<T>,
impl<T> ClosedNeg for T where
T: Neg<Output = T>,
[src]
T: Neg<Output = T>,
impl<T, Right> ClosedAdd<Right> for T where
T: Add<Right, Output = T> + AddAssign<Right>,
[src]
T: Add<Right, Output = T> + AddAssign<Right>,
impl<T, Right> ClosedSub<Right> for T where
T: Sub<Right, Output = T> + SubAssign<Right>,
[src]
T: Sub<Right, Output = T> + SubAssign<Right>,
impl<T, Right> ClosedMul<Right> for T where
T: Mul<Right, Output = T> + MulAssign<Right>,
[src]
T: Mul<Right, Output = T> + MulAssign<Right>,
impl<T, Right> ClosedDiv<Right> for T where
T: Div<Right, Output = T> + DivAssign<Right>,
[src]
T: Div<Right, Output = T> + DivAssign<Right>,
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
[src]
fn is_in_subset(&self) -> bool
[src]
unsafe fn to_subset_unchecked(&self) -> SS
[src]
fn from_subset(element: &SS) -> SP
[src]
impl<T> AdditiveMagma for T where
T: AbstractMagma<Additive>,
[src]
T: AbstractMagma<Additive>,
impl<T> AdditiveQuasigroup for T where
T: AbstractQuasigroup<Additive> + ClosedSub<T> + AdditiveMagma,
[src]
T: AbstractQuasigroup<Additive> + ClosedSub<T> + AdditiveMagma,
impl<T> AdditiveLoop for T where
T: AbstractLoop<Additive> + ClosedNeg + AdditiveQuasigroup + Zero,
[src]
T: AbstractLoop<Additive> + ClosedNeg + AdditiveQuasigroup + Zero,
impl<T> AdditiveSemigroup for T where
T: AbstractSemigroup<Additive> + ClosedAdd<T> + AdditiveMagma,
[src]
T: AbstractSemigroup<Additive> + ClosedAdd<T> + AdditiveMagma,
impl<T> AdditiveMonoid for T where
T: AbstractMonoid<Additive> + AdditiveSemigroup + Zero,
[src]
T: AbstractMonoid<Additive> + AdditiveSemigroup + Zero,
impl<T> AdditiveGroup for T where
T: AbstractGroup<Additive> + AdditiveLoop + AdditiveMonoid,
[src]
T: AbstractGroup<Additive> + AdditiveLoop + AdditiveMonoid,
impl<T> AdditiveGroupAbelian for T where
T: AbstractGroupAbelian<Additive> + AdditiveGroup,
[src]
T: AbstractGroupAbelian<Additive> + AdditiveGroup,
impl<T> MultiplicativeMagma for T where
T: AbstractMagma<Multiplicative>,
[src]
T: AbstractMagma<Multiplicative>,
impl<T> MultiplicativeSemigroup for T where
T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma,
[src]
T: AbstractSemigroup<Multiplicative> + ClosedMul<T> + MultiplicativeMagma,
impl<T> MultiplicativeMonoid for T where
T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One,
[src]
T: AbstractMonoid<Multiplicative> + MultiplicativeSemigroup + One,
impl<R, E> Transformation<E> for R where
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
[src]
E: EuclideanSpace<Real = R>,
R: Real,
<E as EuclideanSpace>::Coordinates: ClosedMul<R>,
<E as EuclideanSpace>::Coordinates: ClosedDiv<R>,
<E as EuclideanSpace>::Coordinates: ClosedNeg,
fn transform_point(&self, pt: &E) -> E
[src]
fn transform_vector(
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates
[src]
&self,
v: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates