[−][src]Struct cv::Skew3
Contains a member of the lie algebra so(3), a representation of the tangent space of 3d rotation. This is also known as the lie algebra of the 3d rotation group SO(3).
Implementations
impl Skew3
[src]
pub fn rotation(self) -> Rotation<f64, U3>
[src]
Converts the Skew3 to a Rotation3 matrix.
pub fn vee(
mat: Matrix<f64, U3, U3, <DefaultAllocator as Allocator<f64, U3, U3>>::Buffer>
) -> Skew3
[src]
mat: Matrix<f64, U3, U3, <DefaultAllocator as Allocator<f64, U3, U3>>::Buffer>
) -> Skew3
This converts a matrix in skew-symmetric form into a Skew3.
Warning: Does no check to ensure matrix is actually skew-symmetric.
pub fn hat(
self
) -> Matrix<f64, U3, U3, <DefaultAllocator as Allocator<f64, U3, U3>>::Buffer>
[src]
self
) -> Matrix<f64, U3, U3, <DefaultAllocator as Allocator<f64, U3, U3>>::Buffer>
This converts the Skew3 into its skew-symmetric matrix form.
pub fn hat2(
self
) -> Matrix<f64, U3, U3, <DefaultAllocator as Allocator<f64, U3, U3>>::Buffer>
[src]
self
) -> Matrix<f64, U3, U3, <DefaultAllocator as Allocator<f64, U3, U3>>::Buffer>
This converts the Skew3 into its squared skew-symmetric matrix form efficiently.
pub fn bracket(self, rhs: Skew3) -> Skew3
[src]
Computes the lie bracket [self, rhs].
pub fn jacobian_input(
self
) -> Matrix<f64, U3, U3, <DefaultAllocator as Allocator<f64, U3, U3>>::Buffer>
[src]
self
) -> Matrix<f64, U3, U3, <DefaultAllocator as Allocator<f64, U3, U3>>::Buffer>
The jacobian of the output of a rotation in respect to the input of a rotation.
y = R * x
dy/dx = R
The formula is pretty simple and is just the rotation matrix created from the exponential map of this so(3) element into SO(3).
pub fn jacobian_self(
y: Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
) -> Matrix<f64, U3, U3, <DefaultAllocator as Allocator<f64, U3, U3>>::Buffer>
[src]
y: Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
) -> Matrix<f64, U3, U3, <DefaultAllocator as Allocator<f64, U3, U3>>::Buffer>
The jacobian of the output of a rotation in respect to the rotation itself.
y = R * x
dy/dR = -hat(y)
The derivative is purely based on the current output vector, and thus doesn't take self
.
Methods from Deref<Target = Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>>
pub fn icamax(&self) -> usize
[src]
Computes the index of the vector component with the largest complex or real absolute value.
Examples:
let vec = Vector3::new(Complex::new(11.0, 3.0), Complex::new(-15.0, 0.0), Complex::new(13.0, 5.0)); assert_eq!(vec.icamax(), 2);
pub fn argmax(&self) -> (usize, N)
[src]
Computes the index and value of the vector component with the largest value.
Examples:
let vec = Vector3::new(11, -15, 13); assert_eq!(vec.argmax(), (2, 13));
pub fn imax(&self) -> usize
[src]
Computes the index of the vector component with the largest value.
Examples:
let vec = Vector3::new(11, -15, 13); assert_eq!(vec.imax(), 2);
pub fn iamax(&self) -> usize where
N: Signed,
[src]
N: Signed,
Computes the index of the vector component with the largest absolute value.
Examples:
let vec = Vector3::new(11, -15, 13); assert_eq!(vec.iamax(), 1);
pub fn argmin(&self) -> (usize, N)
[src]
Computes the index and value of the vector component with the smallest value.
Examples:
let vec = Vector3::new(11, -15, 13); assert_eq!(vec.argmin(), (1, -15));
pub fn imin(&self) -> usize
[src]
Computes the index of the vector component with the smallest value.
Examples:
let vec = Vector3::new(11, -15, 13); assert_eq!(vec.imin(), 1);
pub fn iamin(&self) -> usize where
N: Signed,
[src]
N: Signed,
Computes the index of the vector component with the smallest absolute value.
Examples:
let vec = Vector3::new(11, -15, 13); assert_eq!(vec.iamin(), 0);
pub fn icamax_full(&self) -> (usize, usize)
[src]
Computes the index of the matrix component with the largest absolute value.
Examples:
let mat = Matrix2x3::new(Complex::new(11.0, 1.0), Complex::new(-12.0, 2.0), Complex::new(13.0, 3.0), Complex::new(21.0, 43.0), Complex::new(22.0, 5.0), Complex::new(-23.0, 0.0)); assert_eq!(mat.icamax_full(), (1, 0));
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));
pub fn dot<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
The dot product between two vectors or matrices (seen as vectors).
This is equal to self.transpose() * rhs
. For the sesquilinear complex dot product, use
self.dotc(rhs)
.
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 dotc<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N where
C2: Dim,
N: SimdComplexField,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
[src]
C2: Dim,
N: SimdComplexField,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
The conjugate-linear dot product between two vectors or matrices (seen as vectors).
This is equal to self.adjoint() * rhs
.
For real vectors, this is identical to self.dot(&rhs)
.
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 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0)); let vec2 = Vector2::new(Complex::new(0.4, 0.3), Complex::new(0.2, 0.1)); assert_eq!(vec1.dotc(&vec2), Complex::new(2.0, -1.0)); // Note that for complex vectors, we generally have: // vec1.dotc(&vec2) != vec2.dot(&vec2) assert_ne!(vec1.dotc(&vec2), vec1.dot(&vec2));
pub fn tr_dot<R2, C2, SB>(&self, rhs: &Matrix<N, R2, C2, SB>) -> N where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<C, R2>,
ShapeConstraint: DimEq<R, C2>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<C, R2>,
ShapeConstraint: DimEq<R, C2>,
The dot product between the transpose of self
and rhs
.
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);
pub fn axcpy<D2, SB>(&mut self, a: N, x: &Matrix<N, D2, U1, SB>, c: N, b: N) where
D2: Dim,
SB: Storage<N, D2, U1>,
ShapeConstraint: DimEq<D, D2>,
[src]
D2: Dim,
SB: Storage<N, D2, U1>,
ShapeConstraint: DimEq<D, D2>,
Computes self = a * x * c + b * self
.
If b
is zero, self
is never read from.
Examples:
let mut vec1 = Vector3::new(1.0, 2.0, 3.0); let vec2 = Vector3::new(0.1, 0.2, 0.3); vec1.axcpy(5.0, &vec2, 2.0, 5.0); assert_eq!(vec1, Vector3::new(6.0, 12.0, 18.0));
pub fn axpy<D2, SB>(&mut self, a: N, x: &Matrix<N, D2, U1, SB>, b: N) where
D2: Dim,
N: One,
SB: Storage<N, D2, U1>,
ShapeConstraint: DimEq<D, D2>,
[src]
D2: Dim,
N: One,
SB: Storage<N, D2, U1>,
ShapeConstraint: DimEq<D, D2>,
Computes self = a * x + b * self
.
If b
is zero, self
is never read from.
Examples:
let mut vec1 = Vector3::new(1.0, 2.0, 3.0); let vec2 = Vector3::new(0.1, 0.2, 0.3); vec1.axpy(10.0, &vec2, 5.0); assert_eq!(vec1, Vector3::new(6.0, 12.0, 18.0));
pub fn gemv<R2, C2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
C2: Dim,
D3: Dim,
N: One,
R2: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, R2>,
ShapeConstraint: AreMultipliable<R2, C2, D3, U1>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
C2: Dim,
D3: Dim,
N: One,
R2: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, R2>,
ShapeConstraint: AreMultipliable<R2, C2, D3, U1>,
Computes self = alpha * a * x + beta * self
, where a
is a matrix, x
a vector, and
alpha, beta
two scalars.
If beta
is zero, self
is never read.
Examples:
let mut vec1 = Vector2::new(1.0, 2.0); let vec2 = Vector2::new(0.1, 0.2); let mat = Matrix2::new(1.0, 2.0, 3.0, 4.0); vec1.gemv(10.0, &mat, &vec2, 5.0); assert_eq!(vec1, Vector2::new(10.0, 21.0));
pub fn gemv_symm<D2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, D2, D2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, D2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, D2>,
ShapeConstraint: AreMultipliable<D2, D2, D3, U1>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, D2, D2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, D2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, D2>,
ShapeConstraint: AreMultipliable<D2, D2, D3, U1>,
This is renamed sygemv
to match the original BLAS terminology.
Computes self = alpha * a * x + beta * self
, where a
is a symmetric matrix, x
a
vector, and alpha, beta
two scalars. DEPRECATED: use sygemv
instead.
pub fn sygemv<D2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, D2, D2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, D2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, D2>,
ShapeConstraint: AreMultipliable<D2, D2, D3, U1>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, D2, D2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, D2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, D2>,
ShapeConstraint: AreMultipliable<D2, D2, D3, U1>,
Computes self = alpha * a * x + beta * self
, where a
is a symmetric matrix, x
a
vector, and alpha, beta
two scalars.
For hermitian matrices, use .hegemv
instead.
If beta
is zero, self
is never read. If self
is read, only its lower-triangular part
(including the diagonal) is actually read.
Examples:
let mat = Matrix2::new(1.0, 2.0, 2.0, 4.0); let mut vec1 = Vector2::new(1.0, 2.0); let vec2 = Vector2::new(0.1, 0.2); vec1.sygemv(10.0, &mat, &vec2, 5.0); assert_eq!(vec1, Vector2::new(10.0, 20.0)); // The matrix upper-triangular elements can be garbage because it is never // read by this method. Therefore, it is not necessary for the caller to // fill the matrix struct upper-triangle. let mat = Matrix2::new(1.0, 9999999.9999999, 2.0, 4.0); let mut vec1 = Vector2::new(1.0, 2.0); vec1.sygemv(10.0, &mat, &vec2, 5.0); assert_eq!(vec1, Vector2::new(10.0, 20.0));
pub fn hegemv<D2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, D2, D2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: SimdComplexField,
SB: Storage<N, D2, D2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, D2>,
ShapeConstraint: AreMultipliable<D2, D2, D3, U1>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, D2, D2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: SimdComplexField,
SB: Storage<N, D2, D2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, D2>,
ShapeConstraint: AreMultipliable<D2, D2, D3, U1>,
Computes self = alpha * a * x + beta * self
, where a
is an hermitian matrix, x
a
vector, and alpha, beta
two scalars.
If beta
is zero, self
is never read. If self
is read, only its lower-triangular part
(including the diagonal) is actually read.
Examples:
let mat = Matrix2::new(Complex::new(1.0, 0.0), Complex::new(2.0, -0.1), Complex::new(2.0, 1.0), Complex::new(4.0, 0.0)); let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0)); let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4)); vec1.sygemv(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0)); assert_eq!(vec1, Vector2::new(Complex::new(-48.0, 44.0), Complex::new(-75.0, 110.0))); // The matrix upper-triangular elements can be garbage because it is never // read by this method. Therefore, it is not necessary for the caller to // fill the matrix struct upper-triangle. let mat = Matrix2::new(Complex::new(1.0, 0.0), Complex::new(99999999.9, 999999999.9), Complex::new(2.0, 1.0), Complex::new(4.0, 0.0)); let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0)); let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4)); vec1.sygemv(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0)); assert_eq!(vec1, Vector2::new(Complex::new(-48.0, 44.0), Complex::new(-75.0, 110.0)));
pub fn gemv_tr<R2, C2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
C2: Dim,
D3: Dim,
N: One,
R2: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, C2>,
ShapeConstraint: AreMultipliable<C2, R2, D3, U1>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
C2: Dim,
D3: Dim,
N: One,
R2: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, C2>,
ShapeConstraint: AreMultipliable<C2, R2, D3, U1>,
Computes self = alpha * a.transpose() * x + beta * self
, where a
is a matrix, x
a vector, and
alpha, beta
two scalars.
If beta
is zero, self
is never read.
Examples:
let mat = Matrix2::new(1.0, 3.0, 2.0, 4.0); let mut vec1 = Vector2::new(1.0, 2.0); let vec2 = Vector2::new(0.1, 0.2); let expected = mat.transpose() * vec2 * 10.0 + vec1 * 5.0; vec1.gemv_tr(10.0, &mat, &vec2, 5.0); assert_eq!(vec1, expected);
pub fn gemv_ad<R2, C2, D3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
C2: Dim,
D3: Dim,
N: SimdComplexField,
R2: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, C2>,
ShapeConstraint: AreMultipliable<C2, R2, D3, U1>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
x: &Matrix<N, D3, U1, SC>,
beta: N
) where
C2: Dim,
D3: Dim,
N: SimdComplexField,
R2: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<D, C2>,
ShapeConstraint: AreMultipliable<C2, R2, D3, U1>,
Computes self = alpha * a.adjoint() * x + beta * self
, where a
is a matrix, x
a vector, and
alpha, beta
two scalars.
For real matrices, this is the same as .gemv_tr
.
If beta
is zero, self
is never read.
Examples:
let mat = Matrix2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0), Complex::new(5.0, 6.0), Complex::new(7.0, 8.0)); let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0)); let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4)); let expected = mat.adjoint() * vec2 * Complex::new(10.0, 20.0) + vec1 * Complex::new(5.0, 15.0); vec1.gemv_ad(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0)); assert_eq!(vec1, expected);
pub fn ger<D2, D3, SB, SC>(
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
[src]
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
Computes self = alpha * x * y.transpose() + beta * self
.
If beta
is zero, self
is never read.
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 gerc<D2, D3, SB, SC>(
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: SimdComplexField,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
[src]
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: SimdComplexField,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
Computes self = alpha * x * y.adjoint() + beta * self
.
If beta
is zero, self
is never read.
Examples:
let mut mat = Matrix2x3::repeat(Complex::new(4.0, 5.0)); let vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0)); let vec2 = Vector3::new(Complex::new(0.6, 0.5), Complex::new(0.4, 0.5), Complex::new(0.2, 0.1)); let expected = vec1 * vec2.adjoint() * Complex::new(10.0, 20.0) + mat * Complex::new(5.0, 15.0); mat.gerc(Complex::new(10.0, 20.0), &vec1, &vec2, Complex::new(5.0, 15.0)); assert_eq!(mat, expected);
pub fn gemm<R2, C2, R3, C3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
C2: Dim,
C3: Dim,
N: One,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: AreMultipliable<R2, C2, R3, C3>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
C2: Dim,
C3: Dim,
N: One,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: AreMultipliable<R2, C2, R3, C3>,
Computes self = alpha * a * b + beta * self
, where a, b, self
are matrices.
alpha
and beta
are scalar.
If beta
is zero, self
is never read.
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, C2, R3, C3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
C2: Dim,
C3: Dim,
N: One,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: 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
C2: Dim,
C3: Dim,
N: One,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: 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_eq!(mat1, expected);
pub fn gemm_ad<R2, C2, R3, C3, SB, SC>(
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
C2: Dim,
C3: Dim,
N: SimdComplexField,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: 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
C2: Dim,
C3: Dim,
N: SimdComplexField,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: AreMultipliable<C2, R2, R3, C3>,
Computes self = alpha * a.adjoint() * 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(Complex::new(1.0, 4.0), Complex::new(7.0, 8.0), Complex::new(2.0, 5.0), Complex::new(9.0, 10.0), Complex::new(3.0, 6.0), Complex::new(11.0, 12.0)); let mat3 = Matrix3x4::new(Complex::new(0.1, 1.3), Complex::new(0.2, 1.4), Complex::new(0.3, 1.5), Complex::new(0.4, 1.6), Complex::new(0.5, 1.7), Complex::new(0.6, 1.8), Complex::new(0.7, 1.9), Complex::new(0.8, 2.0), Complex::new(0.9, 2.1), Complex::new(1.0, 2.2), Complex::new(1.1, 2.3), Complex::new(1.2, 2.4)); let expected = mat2.adjoint() * mat3 * Complex::new(10.0, 20.0) + mat1 * Complex::new(5.0, 15.0); mat1.gemm_ad(Complex::new(10.0, 20.0), &mat2, &mat3, Complex::new(5.0, 15.0)); assert_eq!(mat1, expected);
pub fn ger_symm<D2, D3, SB, SC>(
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
[src]
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
This is renamed syger
to match the original BLAS terminology.
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.
pub fn syger<D2, D3, SB, SC>(
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
[src]
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: One,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
Computes self = alpha * x * y.transpose() + beta * self
, where self
is a symmetric
matrix.
For hermitian complex matrices, use .hegerc
instead.
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.syger(10.0, &vec1, &vec2, 5.0); assert_eq!(mat.lower_triangle(), expected.lower_triangle()); assert_eq!(mat.m12, 99999.99999); // This was untouched.
pub fn hegerc<D2, D3, SB, SC>(
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: SimdComplexField,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
[src]
&mut self,
alpha: N,
x: &Matrix<N, D2, U1, SB>,
y: &Matrix<N, D3, U1, SC>,
beta: N
) where
D2: Dim,
D3: Dim,
N: SimdComplexField,
SB: Storage<N, D2, U1>,
SC: Storage<N, D3, U1>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
Computes self = alpha * x * y.adjoint() + beta * self
, where self
is an hermitian
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(Complex::new(1.0, 3.0), Complex::new(2.0, 4.0)); let vec2 = Vector2::new(Complex::new(0.2, 0.4), Complex::new(0.1, 0.3)); let expected = vec1 * vec2.adjoint() * Complex::new(10.0, 20.0) + mat * Complex::new(5.0, 15.0); mat.m12 = Complex::new(99999.99999, 88888.88888); // This component is on the upper-triangular part and will not be read/written. mat.hegerc(Complex::new(10.0, 20.0), &vec1, &vec2, Complex::new(5.0, 15.0)); assert_eq!(mat.lower_triangle(), expected.lower_triangle()); assert_eq!(mat.m12, Complex::new(99999.99999, 88888.88888)); // This was untouched.
pub fn quadform_tr_with_workspace<D2, S2, R3, C3, S3, D4, S4>(
&mut self,
work: &mut Matrix<N, D2, U1, S2>,
alpha: N,
lhs: &Matrix<N, R3, C3, S3>,
mid: &Matrix<N, D4, D4, S4>,
beta: N
) where
C3: Dim,
D2: Dim,
D4: Dim,
R3: Dim,
S2: StorageMut<N, D2, U1>,
S3: Storage<N, R3, C3>,
S4: Storage<N, D4, D4>,
ShapeConstraint: DimEq<D1, D2>,
ShapeConstraint: DimEq<D1, R3>,
ShapeConstraint: DimEq<D2, R3>,
ShapeConstraint: DimEq<C3, D4>,
[src]
&mut self,
work: &mut Matrix<N, D2, U1, S2>,
alpha: N,
lhs: &Matrix<N, R3, C3, S3>,
mid: &Matrix<N, D4, D4, S4>,
beta: N
) where
C3: Dim,
D2: Dim,
D4: Dim,
R3: Dim,
S2: StorageMut<N, D2, U1>,
S3: Storage<N, R3, C3>,
S4: Storage<N, D4, D4>,
ShapeConstraint: DimEq<D1, D2>,
ShapeConstraint: DimEq<D1, R3>,
ShapeConstraint: DimEq<D2, R3>,
ShapeConstraint: DimEq<C3, D4>,
Computes the quadratic form self = alpha * lhs * mid * lhs.transpose() + beta * self
.
This uses the provided workspace work
to avoid allocations for intermediate results.
Examples:
// Note that all those would also work with statically-sized matrices. // We use DMatrix/DVector since that's the only case where pre-allocating the // workspace is actually useful (assuming the same workspace is re-used for // several computations) because it avoids repeated dynamic allocations. let mut mat = DMatrix::identity(2, 2); let lhs = DMatrix::from_row_slice(2, 3, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]); let mid = DMatrix::from_row_slice(3, 3, &[0.1, 0.2, 0.3, 0.5, 0.6, 0.7, 0.9, 1.0, 1.1]); // The random shows that values on the workspace do not // matter as they will be overwritten. let mut workspace = DVector::new_random(2); let expected = &lhs * &mid * lhs.transpose() * 10.0 + &mat * 5.0; mat.quadform_tr_with_workspace(&mut workspace, 10.0, &lhs, &mid, 5.0); assert_relative_eq!(mat, expected);
pub fn quadform_tr<R3, C3, S3, D4, S4>(
&mut self,
alpha: N,
lhs: &Matrix<N, R3, C3, S3>,
mid: &Matrix<N, D4, D4, S4>,
beta: N
) where
C3: Dim,
D4: Dim,
R3: Dim,
S3: Storage<N, R3, C3>,
S4: Storage<N, D4, D4>,
ShapeConstraint: DimEq<D1, D1>,
ShapeConstraint: DimEq<D1, R3>,
ShapeConstraint: DimEq<C3, D4>,
DefaultAllocator: Allocator<N, D1, U1>,
[src]
&mut self,
alpha: N,
lhs: &Matrix<N, R3, C3, S3>,
mid: &Matrix<N, D4, D4, S4>,
beta: N
) where
C3: Dim,
D4: Dim,
R3: Dim,
S3: Storage<N, R3, C3>,
S4: Storage<N, D4, D4>,
ShapeConstraint: DimEq<D1, D1>,
ShapeConstraint: DimEq<D1, R3>,
ShapeConstraint: DimEq<C3, D4>,
DefaultAllocator: Allocator<N, D1, U1>,
Computes the quadratic form self = alpha * lhs * mid * lhs.transpose() + beta * self
.
This allocates a workspace vector of dimension D1 for intermediate results.
If D1
is a type-level integer, then the allocation is performed on the stack.
Use .quadform_tr_with_workspace(...)
instead to avoid allocations.
Examples:
let mut mat = Matrix2::identity(); let lhs = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); let mid = Matrix3::new(0.1, 0.2, 0.3, 0.5, 0.6, 0.7, 0.9, 1.0, 1.1); let expected = lhs * mid * lhs.transpose() * 10.0 + mat * 5.0; mat.quadform_tr(10.0, &lhs, &mid, 5.0); assert_relative_eq!(mat, expected);
pub fn quadform_with_workspace<D2, S2, D3, S3, R4, C4, S4>(
&mut self,
work: &mut Matrix<N, D2, U1, S2>,
alpha: N,
mid: &Matrix<N, D3, D3, S3>,
rhs: &Matrix<N, R4, C4, S4>,
beta: N
) where
C4: Dim,
D2: Dim,
D3: Dim,
R4: Dim,
S2: StorageMut<N, D2, U1>,
S3: Storage<N, D3, D3>,
S4: Storage<N, R4, C4>,
ShapeConstraint: DimEq<D3, R4>,
ShapeConstraint: DimEq<D1, C4>,
ShapeConstraint: DimEq<D2, D3>,
ShapeConstraint: AreMultipliable<C4, R4, D2, U1>,
[src]
&mut self,
work: &mut Matrix<N, D2, U1, S2>,
alpha: N,
mid: &Matrix<N, D3, D3, S3>,
rhs: &Matrix<N, R4, C4, S4>,
beta: N
) where
C4: Dim,
D2: Dim,
D3: Dim,
R4: Dim,
S2: StorageMut<N, D2, U1>,
S3: Storage<N, D3, D3>,
S4: Storage<N, R4, C4>,
ShapeConstraint: DimEq<D3, R4>,
ShapeConstraint: DimEq<D1, C4>,
ShapeConstraint: DimEq<D2, D3>,
ShapeConstraint: AreMultipliable<C4, R4, D2, U1>,
Computes the quadratic form self = alpha * rhs.transpose() * mid * rhs + beta * self
.
This uses the provided workspace work
to avoid allocations for intermediate results.
// Note that all those would also work with statically-sized matrices. // We use DMatrix/DVector since that's the only case where pre-allocating the // workspace is actually useful (assuming the same workspace is re-used for // several computations) because it avoids repeated dynamic allocations. let mut mat = DMatrix::identity(2, 2); let rhs = DMatrix::from_row_slice(3, 2, &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]); let mid = DMatrix::from_row_slice(3, 3, &[0.1, 0.2, 0.3, 0.5, 0.6, 0.7, 0.9, 1.0, 1.1]); // The random shows that values on the workspace do not // matter as they will be overwritten. let mut workspace = DVector::new_random(3); let expected = rhs.transpose() * &mid * &rhs * 10.0 + &mat * 5.0; mat.quadform_with_workspace(&mut workspace, 10.0, &mid, &rhs, 5.0); assert_relative_eq!(mat, expected);
pub fn quadform<D2, S2, R3, C3, S3>(
&mut self,
alpha: N,
mid: &Matrix<N, D2, D2, S2>,
rhs: &Matrix<N, R3, C3, S3>,
beta: N
) where
C3: Dim,
D2: Dim,
R3: Dim,
S2: Storage<N, D2, D2>,
S3: Storage<N, R3, C3>,
ShapeConstraint: DimEq<D2, R3>,
ShapeConstraint: DimEq<D1, C3>,
ShapeConstraint: AreMultipliable<C3, R3, D2, U1>,
DefaultAllocator: Allocator<N, D2, U1>,
[src]
&mut self,
alpha: N,
mid: &Matrix<N, D2, D2, S2>,
rhs: &Matrix<N, R3, C3, S3>,
beta: N
) where
C3: Dim,
D2: Dim,
R3: Dim,
S2: Storage<N, D2, D2>,
S3: Storage<N, R3, C3>,
ShapeConstraint: DimEq<D2, R3>,
ShapeConstraint: DimEq<D1, C3>,
ShapeConstraint: AreMultipliable<C3, R3, D2, U1>,
DefaultAllocator: Allocator<N, D2, U1>,
Computes the quadratic form self = alpha * rhs.transpose() * mid * rhs + beta * self
.
This allocates a workspace vector of dimension D2 for intermediate results.
If D2
is a type-level integer, then the allocation is performed on the stack.
Use .quadform_with_workspace(...)
instead to avoid allocations.
let mut mat = Matrix2::identity(); let rhs = Matrix3x2::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); let mid = Matrix3::new(0.1, 0.2, 0.3, 0.5, 0.6, 0.7, 0.9, 1.0, 1.1); let expected = rhs.transpose() * mid * rhs * 10.0 + mat * 5.0; mat.quadform(10.0, &mid, &rhs, 5.0); assert_relative_eq!(mat, expected);
pub fn tr_mul<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, C1, C2, <DefaultAllocator as Allocator<N, C1, C2>>::Buffer> where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, C1, C2, <DefaultAllocator as Allocator<N, C1, C2>>::Buffer> where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
Equivalent to self.transpose() * rhs
.
pub fn ad_mul<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, C1, C2, <DefaultAllocator as Allocator<N, C1, C2>>::Buffer> where
C2: Dim,
N: SimdComplexField,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, C1, C2, <DefaultAllocator as Allocator<N, C1, C2>>::Buffer> where
C2: Dim,
N: SimdComplexField,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
Equivalent to self.adjoint() * rhs
.
pub fn tr_mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: DimEq<C1, R3>,
ShapeConstraint: DimEq<C2, C3>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: DimEq<C1, R3>,
ShapeConstraint: DimEq<C2, C3>,
Equivalent to self.transpose() * rhs
but stores the result into out
to avoid
allocations.
pub fn ad_mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
N: SimdComplexField,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: DimEq<C1, R3>,
ShapeConstraint: DimEq<C2, C3>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
N: SimdComplexField,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: DimEq<C1, R3>,
ShapeConstraint: DimEq<C2, C3>,
Equivalent to self.adjoint() * rhs
but stores the result into out
to avoid
allocations.
pub fn mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1>,
ShapeConstraint: SameNumberOfColumns<C3, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1>,
ShapeConstraint: SameNumberOfColumns<C3, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
Equivalent to self * rhs
but stores the result into out
to avoid allocations.
pub fn kronecker<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output, <DefaultAllocator as Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>>::Buffer> where
C1: DimMul<C2>,
C2: Dim,
N: ClosedMul<N>,
R1: DimMul<R2>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output, <DefaultAllocator as Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>>::Buffer> where
C1: DimMul<C2>,
C2: Dim,
N: ClosedMul<N>,
R1: DimMul<R2>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>,
The kronecker product of two matrices (aka. tensor product of the corresponding linear maps).
#[must_use = "Did you mean to use add_scalar_mut()?"]pub fn add_scalar(
&self,
rhs: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&self,
rhs: N
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
Adds a scalar to self
.
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.
pub fn amax(&self) -> N where
N: Zero + SimdSigned + SimdPartialOrd,
[src]
N: Zero + SimdSigned + SimdPartialOrd,
Returns the absolute value of the component with the largest absolute value.
Example
assert_eq!(Vector3::new(-1.0, 2.0, 3.0).amax(), 3.0); assert_eq!(Vector3::new(-1.0, -2.0, -3.0).amax(), 3.0);
pub fn camax(&self) -> <N as SimdComplexField>::SimdRealField where
N: SimdComplexField,
[src]
N: SimdComplexField,
Returns the the 1-norm of the complex component with the largest 1-norm.
Example
assert_eq!(Vector3::new( Complex::new(-3.0, -2.0), Complex::new(1.0, 2.0), Complex::new(1.0, 3.0)).camax(), 5.0);
pub fn max(&self) -> N where
N: SimdPartialOrd + Zero,
[src]
N: SimdPartialOrd + Zero,
Returns the component with the largest value.
Example
assert_eq!(Vector3::new(-1.0, 2.0, 3.0).max(), 3.0); assert_eq!(Vector3::new(-1.0, -2.0, -3.0).max(), -1.0); assert_eq!(Vector3::new(5u32, 2, 3).max(), 5);
pub fn amin(&self) -> N where
N: Zero + SimdPartialOrd + SimdSigned,
[src]
N: Zero + SimdPartialOrd + SimdSigned,
Returns the absolute value of the component with the smallest absolute value.
Example
assert_eq!(Vector3::new(-1.0, 2.0, -3.0).amin(), 1.0); assert_eq!(Vector3::new(10.0, 2.0, 30.0).amin(), 2.0);
pub fn camin(&self) -> <N as SimdComplexField>::SimdRealField where
N: SimdComplexField,
[src]
N: SimdComplexField,
Returns the the 1-norm of the complex component with the smallest 1-norm.
Example
assert_eq!(Vector3::new( Complex::new(-3.0, -2.0), Complex::new(1.0, 2.0), Complex::new(1.0, 3.0)).camin(), 3.0);
pub fn min(&self) -> N where
N: SimdPartialOrd + Zero,
[src]
N: SimdPartialOrd + Zero,
Returns the component with the smallest value.
Example
assert_eq!(Vector3::new(-1.0, 2.0, 3.0).min(), -1.0); assert_eq!(Vector3::new(1.0, 2.0, 3.0).min(), 1.0); assert_eq!(Vector3::new(5u32, 2, 3).min(), 2);
#[must_use = "Did you mean to use append_scaling_mut()?"]pub fn append_scaling(
&self,
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
DefaultAllocator: Allocator<N, D, D>,
[src]
&self,
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
DefaultAllocator: Allocator<N, D, D>,
Computes the transformation equal to self
followed by an uniform scaling factor.
#[must_use = "Did you mean to use prepend_scaling_mut()?"]pub fn prepend_scaling(
&self,
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
DefaultAllocator: Allocator<N, D, D>,
[src]
&self,
scaling: N
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
DefaultAllocator: Allocator<N, D, D>,
Computes the transformation equal to an uniform scaling factor followed by self
.
#[must_use = "Did you mean to use append_nonuniform_scaling_mut()?"]pub fn append_nonuniform_scaling<SB>(
&self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
[src]
&self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
Computes the transformation equal to self
followed by a non-uniform scaling factor.
#[must_use = "Did you mean to use prepend_nonuniform_scaling_mut()?"]pub fn prepend_nonuniform_scaling<SB>(
&self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
[src]
&self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
Computes the transformation equal to a non-uniform scaling factor followed by self
.
#[must_use = "Did you mean to use append_translation_mut()?"]pub fn append_translation<SB>(
&self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
[src]
&self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
Computes the transformation equal to self
followed by a translation.
#[must_use = "Did you mean to use prepend_translation_mut()?"]pub fn prepend_translation<SB>(
&self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
[src]
&self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
Computes the transformation equal to a translation followed by self
.
pub fn append_scaling_mut(&mut self, scaling: N) where
D: DimNameSub<U1>,
[src]
D: DimNameSub<U1>,
Computes in-place the transformation equal to self
followed by an uniform scaling factor.
pub fn prepend_scaling_mut(&mut self, scaling: N) where
D: DimNameSub<U1>,
[src]
D: DimNameSub<U1>,
Computes in-place the transformation equal to an uniform scaling factor followed by self
.
pub fn append_nonuniform_scaling_mut<SB>(
&mut self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
[src]
&mut self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
Computes in-place the transformation equal to self
followed by a non-uniform scaling factor.
pub fn prepend_nonuniform_scaling_mut<SB>(
&mut self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
[src]
&mut self,
scaling: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
Computes in-place the transformation equal to a non-uniform scaling factor followed by self
.
pub fn append_translation_mut<SB>(
&mut self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
[src]
&mut self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
Computes the transformation equal to self
followed by a translation.
pub fn prepend_translation_mut<SB>(
&mut self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
[src]
&mut self,
shift: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, SB>
) where
D: DimNameSub<U1>,
SB: Storage<N, <D as DimNameSub<U1>>::Output, U1>,
DefaultAllocator: Allocator<N, <D as DimNameSub<U1>>::Output, U1>,
Computes the transformation equal to a translation followed by self
.
pub fn transform_vector(
&self,
v: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
) -> Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
[src]
&self,
v: &Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
) -> Matrix<N, <D as DimNameSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameSub<U1>>::Output, U1>>::Buffer>
Transforms the given vector, assuming the matrix self
uses homogeneous coordinates.
pub fn transform_point(
&self,
pt: &Point<N, <D as DimNameSub<U1>>::Output>
) -> Point<N, <D as DimNameSub<U1>>::Output>
[src]
&self,
pt: &Point<N, <D as DimNameSub<U1>>::Output>
) -> Point<N, <D as DimNameSub<U1>>::Output>
Transforms the given point, assuming the matrix self
uses homogeneous coordinates.
pub fn abs(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Signed,
DefaultAllocator: Allocator<N, R, C>,
[src]
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
N: Signed,
DefaultAllocator: Allocator<N, R, C>,
Computes the 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))
pub fn inf(
&self,
other: &Matrix<N, R, C, S>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
&self,
other: &Matrix<N, R, C, S>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Computes the infimum (aka. componentwise min) of two matrices/vectors.
pub fn sup(
&self,
other: &Matrix<N, R, C, S>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
[src]
&self,
other: &Matrix<N, R, C, S>
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>
Computes the supremum (aka. componentwise max) of two matrices/vectors.
pub fn inf_sup(
&self,
other: &Matrix<N, R, C, S>
) -> (Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>, Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>)
[src]
&self,
other: &Matrix<N, R, C, S>
) -> (Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>, Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>)
Computes the (infimum, supremum) of two matrices/vectors.
pub fn upper_triangle(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
Extracts the upper triangular part of this matrix (including the diagonal).
pub fn lower_triangle(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
Extracts the lower triangular part of this matrix (including the diagonal).
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, S2>(&mut self, diag: &Matrix<N, R2, U1, S2>) where
R: DimMin<C>,
R2: Dim,
S2: Storage<N, R2, U1>,
ShapeConstraint: DimEq<<R as DimMin<C>>::Output, R2>,
[src]
R: DimMin<C>,
R2: Dim,
S2: Storage<N, R2, U1>,
ShapeConstraint: DimEq<<R as DimMin<C>>::Output, R2>,
Fills the diagonal of this matrix with the content of the given vector.
pub fn set_partial_diagonal(&mut self, diag: impl Iterator<Item = N>)
[src]
Fills the diagonal of this matrix with the content of the given iterator.
This will fill as many diagonal elements as the iterator yields, up to the
minimum of the number of rows and columns of self
, and starting with the
diagonal element at index (0, 0).
pub fn set_row<C2, S2>(&mut self, i: usize, row: &Matrix<N, U1, C2, S2>) where
C2: Dim,
S2: Storage<N, U1, C2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
C2: Dim,
S2: Storage<N, U1, C2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Fills the selected row of this matrix with the content of the given vector.
pub fn set_column<R2, S2>(&mut self, i: usize, column: &Matrix<N, R2, U1, S2>) where
R2: Dim,
S2: Storage<N, R2, U1>,
ShapeConstraint: SameNumberOfRows<R, R2>,
[src]
R2: Dim,
S2: Storage<N, R2, U1>,
ShapeConstraint: SameNumberOfRows<R, R2>,
Fills the selected column of this matrix with the content of the given vector.
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.
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.
pub fn get<'a, I>(
&'a self,
index: I
) -> Option<<I as MatrixIndex<'a, N, R, C, S>>::Output> where
I: MatrixIndex<'a, N, R, C, S>,
[src]
&'a self,
index: I
) -> Option<<I as MatrixIndex<'a, N, R, C, S>>::Output> where
I: MatrixIndex<'a, N, R, C, S>,
Produces a view of the data at the given index, or
None
if the index is out of bounds.
pub fn get_mut<'a, I>(
&'a mut self,
index: I
) -> Option<<I as MatrixIndexMut<'a, N, R, C, S>>::OutputMut> where
I: MatrixIndexMut<'a, N, R, C, S>,
S: StorageMut<N, R, C>,
[src]
&'a mut self,
index: I
) -> Option<<I as MatrixIndexMut<'a, N, R, C, S>>::OutputMut> where
I: MatrixIndexMut<'a, N, R, C, S>,
S: StorageMut<N, R, C>,
Produces a mutable view of the data at the given index, or
None
if the index is out of bounds.
pub fn index<'a, I>(
&'a self,
index: I
) -> <I as MatrixIndex<'a, N, R, C, S>>::Output where
I: MatrixIndex<'a, N, R, C, S>,
[src]
&'a self,
index: I
) -> <I as MatrixIndex<'a, N, R, C, S>>::Output where
I: MatrixIndex<'a, N, R, C, S>,
Produces a view of the data at the given index, or panics if the index is out of bounds.
pub fn index_mut<'a, I>(
&'a mut self,
index: I
) -> <I as MatrixIndexMut<'a, N, R, C, S>>::OutputMut where
I: MatrixIndexMut<'a, N, R, C, S>,
S: StorageMut<N, R, C>,
[src]
&'a mut self,
index: I
) -> <I as MatrixIndexMut<'a, N, R, C, S>>::OutputMut where
I: MatrixIndexMut<'a, N, R, C, S>,
S: StorageMut<N, R, C>,
Produces a mutable view of the data at the given index, or panics if the index is out of bounds.
pub unsafe fn get_unchecked<'a, I>(
&'a self,
index: I
) -> <I as MatrixIndex<'a, N, R, C, S>>::Output where
I: MatrixIndex<'a, N, R, C, S>,
[src]
&'a self,
index: I
) -> <I as MatrixIndex<'a, N, R, C, S>>::Output where
I: MatrixIndex<'a, N, R, C, S>,
Produces a view of the data at the given index, without doing any bounds checking.
pub unsafe fn get_unchecked_mut<'a, I>(
&'a mut self,
index: I
) -> <I as MatrixIndexMut<'a, N, R, C, S>>::OutputMut where
I: MatrixIndexMut<'a, N, R, C, S>,
S: StorageMut<N, R, C>,
[src]
&'a mut self,
index: I
) -> <I as MatrixIndexMut<'a, N, R, C, S>>::OutputMut where
I: MatrixIndexMut<'a, N, R, C, S>,
S: StorageMut<N, R, C>,
Returns a mutable view of the data at the given index, without doing any bounds checking.
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));
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 row_iter(&self) -> RowIter<N, R, C, S>
[src]
Iterate through the rows of this matrix.
Example
let mut a = Matrix2x3::new(1, 2, 3, 4, 5, 6); for (i, row) in a.row_iter().enumerate() { assert_eq!(row, a.row(i)) }
pub fn column_iter(&self) -> ColumnIter<N, R, C, S>
[src]
Iterate through the columns of this matrix.
Example
let mut a = Matrix2x3::new(1, 2, 3, 4, 5, 6); for (i, column) in a.column_iter().enumerate() { assert_eq!(column, a.column(i)) }
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.
Example
let m = Matrix2::new(1, 2, 3, 4); let i = m.vector_to_matrix_index(3); assert_eq!(i, (1, 1)); assert_eq!(m[i], m[3]);
pub fn as_ptr(&self) -> *const N
[src]
Returns a pointer to the start of the matrix.
If the matrix is not empty, this pointer is guaranteed to be aligned and non-null.
Example
let m = Matrix2::new(1, 2, 3, 4); let ptr = m.as_ptr(); assert_eq!(unsafe { *ptr }, m[0]);
pub fn relative_eq<R2, C2, SB>(
&self,
other: &Matrix<N, R2, C2, SB>,
eps: <N as AbsDiffEq<N>>::Epsilon,
max_relative: <N as AbsDiffEq<N>>::Epsilon
) -> bool where
C2: Dim,
N: RelativeEq<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&self,
other: &Matrix<N, R2, C2, SB>,
eps: <N as AbsDiffEq<N>>::Epsilon,
max_relative: <N as AbsDiffEq<N>>::Epsilon
) -> bool where
C2: Dim,
N: RelativeEq<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are equal up to a given epsilon.
See relative_eq
from the RelativeEq
trait for more details.
pub fn eq<R2, C2, SB>(&self, other: &Matrix<N, R2, C2, SB>) -> bool where
C2: Dim,
N: PartialEq<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
C2: Dim,
N: PartialEq<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are exactly equal.
pub fn clone_owned(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
Clones this matrix to one that owns its data.
pub fn clone_owned_sum<R2, C2>(
&self
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where
C2: Dim,
R2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&self
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where
C2: Dim,
R2: Dim,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Clones this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.
pub fn map<N2, F>(
&self,
f: F
) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer> where
F: FnMut(N) -> N2,
N2: Scalar,
DefaultAllocator: Allocator<N2, R, C>,
[src]
&self,
f: F
) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer> where
F: FnMut(N) -> N2,
N2: Scalar,
DefaultAllocator: Allocator<N2, R, C>,
Returns a matrix containing the result of f
applied to each of its entries.
pub fn fold_with<N2>(
&self,
init_f: impl FnOnce(Option<&N>) -> N2,
f: impl FnMut(N2, &N) -> N2
) -> N2
[src]
&self,
init_f: impl FnOnce(Option<&N>) -> N2,
f: impl FnMut(N2, &N) -> N2
) -> N2
Similar to self.iter().fold(init, f)
except that init
is replaced by a closure.
The initialization closure is given the first component of this matrix:
- If the matrix has no component (0 rows or 0 columns) then
init_f
is called withNone
and its return value is the value returned by this method. - If the matrix has has least one component, then
init_f
is called with the first component to compute the initial value. Folding then continues on all the remaining components of the matrix.
pub fn map_with_location<N2, F>(
&self,
f: F
) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer> where
F: FnMut(usize, usize, N) -> N2,
N2: Scalar,
DefaultAllocator: Allocator<N2, R, C>,
[src]
&self,
f: F
) -> Matrix<N2, R, C, <DefaultAllocator as Allocator<N2, R, C>>::Buffer> where
F: FnMut(usize, usize, N) -> N2,
N2: Scalar,
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(row, col, value)
.
pub fn zip_map<N2, N3, S2, F>(
&self,
rhs: &Matrix<N2, R, C, S2>,
f: F
) -> Matrix<N3, R, C, <DefaultAllocator as Allocator<N3, R, C>>::Buffer> where
F: FnMut(N, N2) -> N3,
N2: Scalar,
N3: Scalar,
S2: Storage<N2, R, C>,
DefaultAllocator: Allocator<N3, R, C>,
[src]
&self,
rhs: &Matrix<N2, R, C, S2>,
f: F
) -> Matrix<N3, R, C, <DefaultAllocator as Allocator<N3, R, C>>::Buffer> where
F: FnMut(N, N2) -> N3,
N2: Scalar,
N3: Scalar,
S2: Storage<N2, R, C>,
DefaultAllocator: Allocator<N3, R, C>,
Returns a matrix containing the result of f
applied to each entries of self
and
rhs
.
pub fn zip_zip_map<N2, N3, N4, S2, S3, F>(
&self,
b: &Matrix<N2, R, C, S2>,
c: &Matrix<N3, R, C, S3>,
f: F
) -> Matrix<N4, R, C, <DefaultAllocator as Allocator<N4, R, C>>::Buffer> where
F: FnMut(N, N2, N3) -> N4,
N2: Scalar,
N3: Scalar,
N4: Scalar,
S2: Storage<N2, R, C>,
S3: Storage<N3, R, C>,
DefaultAllocator: Allocator<N4, R, C>,
[src]
&self,
b: &Matrix<N2, R, C, S2>,
c: &Matrix<N3, R, C, S3>,
f: F
) -> Matrix<N4, R, C, <DefaultAllocator as Allocator<N4, R, C>>::Buffer> where
F: FnMut(N, N2, N3) -> N4,
N2: Scalar,
N3: Scalar,
N4: Scalar,
S2: Storage<N2, R, C>,
S3: Storage<N3, R, C>,
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 fold<Acc>(&self, init: Acc, f: impl FnMut(Acc, N) -> Acc) -> Acc
[src]
Folds a function f
on each entry of self
.
pub fn zip_fold<N2, R2, C2, S2, Acc>(
&self,
rhs: &Matrix<N2, R2, C2, S2>,
init: Acc,
f: impl FnMut(Acc, N, N2) -> Acc
) -> Acc where
C2: Dim,
N2: Scalar,
R2: Dim,
S2: Storage<N2, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&self,
rhs: &Matrix<N2, R2, C2, S2>,
init: Acc,
f: impl FnMut(Acc, N, N2) -> Acc
) -> Acc where
C2: Dim,
N2: Scalar,
R2: Dim,
S2: Storage<N2, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Folds a function f
on each pairs of entries from self
and rhs
.
pub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>) where
C2: Dim,
R2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
[src]
C2: Dim,
R2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
Transposes self
and store the result into out
.
#[must_use = "Did you mean to use transpose_mut()?"]pub fn transpose(
&self
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where
DefaultAllocator: Allocator<N, C, R>,
[src]
&self
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where
DefaultAllocator: Allocator<N, C, R>,
Transposes self
.
pub fn iter_mut(&mut self) -> MatrixIterMut<N, R, C, S>
[src]
Mutably iterates through this matrix coordinates.
pub fn as_mut_ptr(&mut self) -> *mut N
[src]
Returns a mutable pointer to the start of the matrix.
If the matrix is not empty, this pointer is guaranteed to be aligned and non-null.
pub fn row_iter_mut(&mut self) -> RowIterMut<N, R, C, S>
[src]
Mutably iterates through this matrix rows.
Example
let mut a = Matrix2x3::new(1, 2, 3, 4, 5, 6); for (i, mut row) in a.row_iter_mut().enumerate() { row *= (i + 1) * 10; } let expected = Matrix2x3::new(10, 20, 30, 80, 100, 120); assert_eq!(a, expected);
pub fn column_iter_mut(&mut self) -> ColumnIterMut<N, R, C, S>
[src]
Mutably iterates through this matrix columns.
Example
let mut a = Matrix2x3::new(1, 2, 3, 4, 5, 6); for (i, mut col) in a.column_iter_mut().enumerate() { col *= (i + 1) * 10; } let expected = Matrix2x3::new(10, 40, 90, 40, 100, 180); assert_eq!(a, expected);
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
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Fills this matrix with the content of another one. Both must have the same shape.
pub fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<N, R2, C2, SB>) where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
Fills this matrix with the content of the transpose another one.
pub fn apply<F>(&mut self, f: F) where
F: FnMut(N) -> N,
[src]
F: FnMut(N) -> N,
Replaces each component of self
by the result of a closure f
applied on it.
pub fn zip_apply<N2, R2, C2, S2>(
&mut self,
rhs: &Matrix<N2, R2, C2, S2>,
f: impl FnMut(N, N2) -> N
) where
C2: Dim,
N2: Scalar,
R2: Dim,
S2: Storage<N2, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&mut self,
rhs: &Matrix<N2, R2, C2, S2>,
f: impl FnMut(N, N2) -> N
) where
C2: Dim,
N2: Scalar,
R2: Dim,
S2: Storage<N2, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Replaces each component of self
by the result of a closure f
applied on its components
joined with the components from rhs
.
pub fn zip_zip_apply<N2, R2, C2, S2, N3, R3, C3, S3>(
&mut self,
b: &Matrix<N2, R2, C2, S2>,
c: &Matrix<N3, R3, C3, S3>,
f: impl FnMut(N, N2, N3) -> N
) where
C2: Dim,
C3: Dim,
N2: Scalar,
N3: Scalar,
R2: Dim,
R3: Dim,
S2: Storage<N2, R2, C2>,
S3: Storage<N3, R3, C3>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&mut self,
b: &Matrix<N2, R2, C2, S2>,
c: &Matrix<N3, R3, C3, S3>,
f: impl FnMut(N, N2, N3) -> N
) where
C2: Dim,
C3: Dim,
N2: Scalar,
N3: Scalar,
R2: Dim,
R3: Dim,
S2: Storage<N2, R2, C2>,
S3: Storage<N3, R3, C3>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Replaces each component of self
by the result of a closure f
applied on its components
joined with the components from b
and c
.
pub unsafe fn vget_unchecked(&self, i: usize) -> &N
[src]
Gets a reference to the i-th element of this column vector without bound checking.
pub unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut N
[src]
Gets a mutable reference to the i-th element of this column vector without bound checking.
pub fn as_slice(&self) -> &[N]
[src]
Extracts a slice containing the entire matrix entries ordered column-by-columns.
pub fn as_mut_slice(&mut self) -> &mut [N]
[src]
Extracts a mutable slice containing the entire matrix entries ordered column-by-columns.
pub fn transpose_mut(&mut self)
[src]
Transposes the square matrix self
in-place.
pub fn adjoint_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>) where
C2: Dim,
R2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
[src]
C2: Dim,
R2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
Takes the adjoint (aka. conjugate-transpose) of self
and store the result into out
.
#[must_use = "Did you mean to use adjoint_mut()?"]pub fn adjoint(
&self
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where
DefaultAllocator: Allocator<N, C, R>,
[src]
&self
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where
DefaultAllocator: Allocator<N, C, R>,
The adjoint (aka. conjugate-transpose) of self
.
pub fn conjugate_transpose_to<R2, C2, SB>(
&self,
out: &mut Matrix<N, R2, C2, SB>
) where
C2: Dim,
R2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
[src]
&self,
out: &mut Matrix<N, R2, C2, SB>
) where
C2: Dim,
R2: Dim,
SB: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
Renamed self.adjoint_to(out)
.
Takes the conjugate and transposes self
and store the result into out
.
pub fn conjugate_transpose(
&self
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where
DefaultAllocator: Allocator<N, C, R>,
[src]
&self
) -> Matrix<N, C, R, <DefaultAllocator as Allocator<N, C, R>>::Buffer> where
DefaultAllocator: Allocator<N, C, R>,
Renamed self.adjoint()
.
The conjugate transposition of self
.
#[must_use = "Did you mean to use conjugate_mut()?"]pub fn conjugate(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
The conjugate of self
.
#[must_use = "Did you mean to use unscale_mut()?"]pub fn unscale(
&self,
real: <N as SimdComplexField>::SimdRealField
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&self,
real: <N as SimdComplexField>::SimdRealField
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
Divides each component of the complex matrix self
by the given real.
#[must_use = "Did you mean to use scale_mut()?"]pub fn scale(
&self,
real: <N as SimdComplexField>::SimdRealField
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&self,
real: <N as SimdComplexField>::SimdRealField
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
Multiplies each component of the complex matrix self
by the given real.
pub fn conjugate_mut(&mut self)
[src]
The conjugate of the complex matrix self
computed in-place.
pub fn unscale_mut(&mut self, real: <N as SimdComplexField>::SimdRealField)
[src]
Divides each component of the complex matrix self
by the given real.
pub fn scale_mut(&mut self, real: <N as SimdComplexField>::SimdRealField)
[src]
Multiplies each component of the complex matrix self
by the given real.
pub fn conjugate_transform_mut(&mut self)
[src]
Renamed to self.adjoint_mut()
.
Sets self
to its adjoint.
pub fn adjoint_mut(&mut self)
[src]
Sets self
to its adjoint (aka. conjugate-transpose).
pub fn diagonal(
&self
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where
DefaultAllocator: Allocator<N, D, U1>,
[src]
&self
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where
DefaultAllocator: Allocator<N, D, U1>,
The diagonal of this matrix.
pub fn map_diagonal<N2>(
&self,
f: impl FnMut(N) -> N2
) -> Matrix<N2, D, U1, <DefaultAllocator as Allocator<N2, D, U1>>::Buffer> where
N2: Scalar,
DefaultAllocator: Allocator<N2, D, U1>,
[src]
&self,
f: impl FnMut(N) -> N2
) -> Matrix<N2, D, U1, <DefaultAllocator as Allocator<N2, D, U1>>::Buffer> where
N2: Scalar,
DefaultAllocator: Allocator<N2, D, U1>,
Apply the given function to this matrix's diagonal and returns it.
This is a more efficient version of self.diagonal().map(f)
since this
allocates only once.
pub fn trace(&self) -> N where
N: Scalar + Zero + ClosedAdd<N>,
[src]
N: Scalar + Zero + ClosedAdd<N>,
Computes a trace of a square matrix, i.e., the sum of its diagonal elements.
pub fn symmetric_part(
&self
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
DefaultAllocator: Allocator<N, D, D>,
[src]
&self
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
DefaultAllocator: Allocator<N, D, D>,
The symmetric part of self
, i.e., 0.5 * (self + self.transpose())
.
pub fn hermitian_part(
&self
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
DefaultAllocator: Allocator<N, D, D>,
[src]
&self
) -> Matrix<N, D, D, <DefaultAllocator as Allocator<N, D, D>>::Buffer> where
DefaultAllocator: Allocator<N, D, D>,
The hermitian part of self
, i.e., 0.5 * (self + self.adjoint())
.
pub fn to_homogeneous(
&self
) -> Matrix<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>>::Buffer> where
DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>,
[src]
&self
) -> Matrix<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>>::Buffer> where
DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, <D as DimAdd<U1>>::Output>,
Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and
and setting the diagonal element to 1
.
pub fn to_homogeneous(
&self
) -> Matrix<N, <D as DimAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, U1>>::Buffer> where
DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, U1>,
[src]
&self
) -> Matrix<N, <D as DimAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, U1>>::Buffer> where
DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, U1>,
Computes the coordinates in projective space of this vector, i.e., appends a 0
to its
coordinates.
pub fn push(
&self,
element: N
) -> Matrix<N, <D as DimAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, U1>>::Buffer> where
DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, U1>,
[src]
&self,
element: N
) -> Matrix<N, <D as DimAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimAdd<U1>>::Output, U1>>::Buffer> where
DefaultAllocator: Allocator<N, <D as DimAdd<U1>>::Output, U1>,
Constructs a new vector of higher dimension by appending element
to the end of self
.
pub fn perp<R2, C2, SB>(&self, b: &Matrix<N, R2, C2, SB>) -> N where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, U2>,
ShapeConstraint: SameNumberOfColumns<C, U1>,
ShapeConstraint: SameNumberOfRows<R2, U2>,
ShapeConstraint: SameNumberOfColumns<C2, U1>,
[src]
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, U2>,
ShapeConstraint: SameNumberOfColumns<C, U1>,
ShapeConstraint: SameNumberOfRows<R2, U2>,
ShapeConstraint: SameNumberOfColumns<C2, U1>,
The perpendicular product between two 2D column vectors, i.e. a.x * b.y - a.y * b.x
.
pub fn cross<R2, C2, SB>(
&self,
b: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&self,
b: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
The 3D cross product between two vectors.
Panics if the shape is not 3D vector. In the future, this will be implemented only for dynamically-sized matrices and statically-sized 3D matrices.
pub fn cross_matrix(
&self
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U3, <DefaultAllocator as Allocator<N, U3, U3>>::Buffer>
Computes the matrix M
such that for all vector v
we have M * v == self.cross(&v)
.
pub fn angle<R2, C2, SB>(
&self,
other: &Matrix<N, R2, C2, SB>
) -> <N as SimdComplexField>::SimdRealField where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
[src]
&self,
other: &Matrix<N, R2, C2, SB>
) -> <N as SimdComplexField>::SimdRealField where
C2: Dim,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
The smallest angle between two vectors.
pub fn lerp<S2>(
&self,
rhs: &Matrix<N, D, U1, S2>,
t: N
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where
S2: Storage<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
[src]
&self,
rhs: &Matrix<N, D, U1, S2>,
t: N
) -> Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer> where
S2: Storage<N, D, U1>,
DefaultAllocator: Allocator<N, D, U1>,
Returns self * (1.0 - t) + rhs * t
, i.e., the linear blend of the vectors x and y using the scalar value a.
The value for a is not restricted to the range [0, 1]
.
Examples:
let x = Vector3::new(1.0, 2.0, 3.0); let y = Vector3::new(10.0, 20.0, 30.0); assert_eq!(x.lerp(&y, 0.1), Vector3::new(1.9, 3.8, 5.7));
pub fn slice_range<RowRange, ColRange>(
&self,
rows: RowRange,
cols: ColRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorage<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
ColRange: SliceRange<C>,
RowRange: SliceRange<R>,
[src]
&self,
rows: RowRange,
cols: ColRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorage<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
ColRange: SliceRange<C>,
RowRange: SliceRange<R>,
Slices a sub-matrix containing the rows indexed by the range rows
and the columns indexed
by the range cols
.
pub fn rows_range<RowRange>(
&self,
rows: RowRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, C, SliceStorage<N, <RowRange as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RowRange: SliceRange<R>,
[src]
&self,
rows: RowRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, C, SliceStorage<N, <RowRange as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RowRange: SliceRange<R>,
Slice containing all the rows indexed by the range rows
.
pub fn columns_range<ColRange>(
&self,
cols: ColRange
) -> Matrix<N, R, <ColRange as SliceRange<C>>::Size, SliceStorage<N, R, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
ColRange: SliceRange<C>,
[src]
&self,
cols: ColRange
) -> Matrix<N, R, <ColRange as SliceRange<C>>::Size, SliceStorage<N, R, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
ColRange: SliceRange<C>,
Slice containing all the columns indexed by the range rows
.
pub fn slice_range_mut<RowRange, ColRange>(
&mut self,
rows: RowRange,
cols: ColRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorageMut<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
ColRange: SliceRange<C>,
RowRange: SliceRange<R>,
[src]
&mut self,
rows: RowRange,
cols: ColRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorageMut<N, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
ColRange: SliceRange<C>,
RowRange: SliceRange<R>,
Slices a mutable sub-matrix containing the rows indexed by the range rows
and the columns
indexed by the range cols
.
pub fn rows_range_mut<RowRange>(
&mut self,
rows: RowRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, C, SliceStorageMut<N, <RowRange as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RowRange: SliceRange<R>,
[src]
&mut self,
rows: RowRange
) -> Matrix<N, <RowRange as SliceRange<R>>::Size, C, SliceStorageMut<N, <RowRange as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RowRange: SliceRange<R>,
Slice containing all the rows indexed by the range rows
.
pub fn columns_range_mut<ColRange>(
&mut self,
cols: ColRange
) -> Matrix<N, R, <ColRange as SliceRange<C>>::Size, SliceStorageMut<N, R, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
ColRange: SliceRange<C>,
[src]
&mut self,
cols: ColRange
) -> Matrix<N, R, <ColRange as SliceRange<C>>::Size, SliceStorageMut<N, R, <ColRange as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
ColRange: SliceRange<C>,
Slice containing all the columns indexed by the range cols
.
pub fn norm_squared(&self) -> <N as SimdComplexField>::SimdRealField
[src]
The squared L2 norm of this vector.
pub fn norm(&self) -> <N as SimdComplexField>::SimdRealField
[src]
The L2 norm of this matrix.
Use .apply_norm
to apply a custom norm.
pub fn metric_distance<R2, C2, S2>(
&self,
rhs: &Matrix<N, R2, C2, S2>
) -> <N as SimdComplexField>::SimdRealField where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, S2>
) -> <N as SimdComplexField>::SimdRealField where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Compute the distance between self
and rhs
using the metric induced by the euclidean norm.
Use .apply_metric_distance
to apply a custom norm.
pub fn apply_norm(
&self,
norm: &impl Norm<N>
) -> <N as SimdComplexField>::SimdRealField
[src]
&self,
norm: &impl Norm<N>
) -> <N as SimdComplexField>::SimdRealField
Uses the given norm
to compute the norm of self
.
Example
let v = Vector3::new(1.0, 2.0, 3.0); assert_eq!(v.apply_norm(&UniformNorm), 3.0); assert_eq!(v.apply_norm(&LpNorm(1)), 6.0); assert_eq!(v.apply_norm(&EuclideanNorm), v.norm());
pub fn apply_metric_distance<R2, C2, S2>(
&self,
rhs: &Matrix<N, R2, C2, S2>,
norm: &impl Norm<N>
) -> <N as SimdComplexField>::SimdRealField where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, S2>,
norm: &impl Norm<N>
) -> <N as SimdComplexField>::SimdRealField where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Uses the metric induced by the given norm
to compute the metric distance between self
and rhs
.
Example
let v1 = Vector3::new(1.0, 2.0, 3.0); let v2 = Vector3::new(10.0, 20.0, 30.0); assert_eq!(v1.apply_metric_distance(&v2, &UniformNorm), 27.0); assert_eq!(v1.apply_metric_distance(&v2, &LpNorm(1)), 27.0 + 18.0 + 9.0); assert_eq!(v1.apply_metric_distance(&v2, &EuclideanNorm), (v1 - v2).norm());
pub fn magnitude(&self) -> <N as SimdComplexField>::SimdRealField
[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 as SimdComplexField>::SimdRealField
[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 set_magnitude(
&mut self,
magnitude: <N as SimdComplexField>::SimdRealField
) where
S: StorageMut<N, R, C>,
[src]
&mut self,
magnitude: <N as SimdComplexField>::SimdRealField
) where
S: StorageMut<N, R, C>,
Sets the magnitude of this vector.
#[must_use = "Did you mean to use normalize_mut()?"]pub fn normalize(
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&self
) -> Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer> where
DefaultAllocator: Allocator<N, R, C>,
Returns a normalized version of this matrix.
pub fn lp_norm(&self, p: i32) -> <N as SimdComplexField>::SimdRealField
[src]
The Lp norm of this matrix.
#[must_use = "Did you mean to use simd_try_normalize_mut()?"]pub fn simd_try_normalize(
&self,
min_norm: <N as SimdComplexField>::SimdRealField
) -> SimdOption<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> where
<N as SimdValue>::Element: Scalar,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<<N as SimdValue>::Element, R, C>,
[src]
&self,
min_norm: <N as SimdComplexField>::SimdRealField
) -> SimdOption<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> where
<N as SimdValue>::Element: Scalar,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<<N as SimdValue>::Element, R, C>,
Attempts to normalize self
.
The components of this matrix can be SIMD types.
pub fn try_set_magnitude(
&mut self,
magnitude: <N as ComplexField>::RealField,
min_magnitude: <N as ComplexField>::RealField
) where
S: StorageMut<N, R, C>,
[src]
&mut self,
magnitude: <N as ComplexField>::RealField,
min_magnitude: <N as ComplexField>::RealField
) where
S: StorageMut<N, R, C>,
Sets the magnitude of this vector unless it is smaller than min_magnitude
.
If self.magnitude()
is smaller than min_magnitude
, it will be left unchanged.
Otherwise this is equivalent to: `*self = self.normalize() * magnitude.
#[must_use = "Did you mean to use try_normalize_mut()?"]pub fn try_normalize(
&self,
min_norm: <N as ComplexField>::RealField
) -> Option<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> where
DefaultAllocator: Allocator<N, R, C>,
[src]
&self,
min_norm: <N as ComplexField>::RealField
) -> Option<Matrix<N, R, C, <DefaultAllocator as Allocator<N, R, C>>::Buffer>> where
DefaultAllocator: Allocator<N, R, C>,
Returns a normalized version of this matrix unless its norm as smaller or equal to eps
.
The components of this matrix cannot be SIMD types (see simd_try_normalize
) instead.
pub fn normalize_mut(&mut self) -> <N as SimdComplexField>::SimdRealField
[src]
Normalizes this matrix in-place and returns its norm.
The components of the matrix cannot be SIMD types (see simd_try_normalize_mut
instead).
#[must_use = "Did you mean to use simd_try_normalize_mut()?"]pub fn simd_try_normalize_mut(
&mut self,
min_norm: <N as SimdComplexField>::SimdRealField
) -> SimdOption<<N as SimdComplexField>::SimdRealField> where
<N as SimdValue>::Element: Scalar,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<<N as SimdValue>::Element, R, C>,
[src]
&mut self,
min_norm: <N as SimdComplexField>::SimdRealField
) -> SimdOption<<N as SimdComplexField>::SimdRealField> where
<N as SimdValue>::Element: Scalar,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<<N as SimdValue>::Element, R, C>,
Normalizes this matrix in-place and return its norm.
The components of the matrix can be SIMD types.
pub fn try_normalize_mut(
&mut self,
min_norm: <N as ComplexField>::RealField
) -> Option<<N as ComplexField>::RealField>
[src]
&mut self,
min_norm: <N as ComplexField>::RealField
) -> Option<<N as ComplexField>::RealField>
Normalizes this matrix in-place or does nothing if its norm is smaller or equal to eps
.
If the normalization succeeded, returns the old norm of this matrix.
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 as AbsDiffEq<N>>::Epsilon) -> bool where
N: Zero + One + RelativeEq<N>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
[src]
N: Zero + One + RelativeEq<N>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
Indicated if this is the identity matrix within a relative error of eps
.
If the matrix is diagonal, this checks that diagonal elements (i.e. at coordinates (i, i)
for i from 0
to min(R, C)
) are equal one; and that all other elements are zero.
pub fn is_orthogonal(&self, eps: <N as AbsDiffEq<N>>::Epsilon) -> bool where
N: Zero + One + ClosedAdd<N> + ClosedMul<N> + RelativeEq<N>,
S: Storage<N, R, C>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
DefaultAllocator: Allocator<N, R, C>,
DefaultAllocator: Allocator<N, C, C>,
[src]
N: Zero + One + ClosedAdd<N> + ClosedMul<N> + RelativeEq<N>,
S: Storage<N, R, C>,
<N as AbsDiffEq<N>>::Epsilon: Copy,
DefaultAllocator: Allocator<N, R, C>,
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
.
pub fn is_special_orthogonal(&self, eps: N) -> bool where
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
[src]
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
Checks that this matrix is orthogonal and has a determinant equal to 1.
pub fn is_invertible(&self) -> bool
[src]
Returns true
if this matrix is invertible.
pub fn compress_rows(
&self,
f: impl Fn(Matrix<N, R, U1, SliceStorage<N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) -> N
) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where
DefaultAllocator: Allocator<N, U1, C>,
[src]
&self,
f: impl Fn(Matrix<N, R, U1, SliceStorage<N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) -> N
) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where
DefaultAllocator: Allocator<N, U1, C>,
Returns a row vector where each element is the result of the application of f
on the
corresponding column of the original matrix.
pub fn compress_rows_tr(
&self,
f: impl Fn(Matrix<N, R, U1, SliceStorage<N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) -> N
) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where
DefaultAllocator: Allocator<N, C, U1>,
[src]
&self,
f: impl Fn(Matrix<N, R, U1, SliceStorage<N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) -> N
) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where
DefaultAllocator: Allocator<N, C, U1>,
Returns a column vector where each element is the result of the application of f
on the
corresponding column of the original matrix.
This is the same as self.compress_rows(f).transpose()
.
pub fn compress_columns(
&self,
init: Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>,
f: impl Fn(&mut Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>, Matrix<N, R, U1, SliceStorage<N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>)
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
DefaultAllocator: Allocator<N, R, U1>,
[src]
&self,
init: Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>,
f: impl Fn(&mut Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer>, Matrix<N, R, U1, SliceStorage<N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>)
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
DefaultAllocator: Allocator<N, R, U1>,
Returns a column vector resulting from the folding of f
on each column of this matrix.
pub fn sum(&self) -> N
[src]
The sum of all the elements of this matrix.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_eq!(m.sum(), 21.0);
pub fn row_sum(
&self
) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where
DefaultAllocator: Allocator<N, U1, C>,
[src]
&self
) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where
DefaultAllocator: Allocator<N, U1, C>,
The sum of all the rows of this matrix.
Use .row_variance_tr
if you need the result in a column vector instead.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_eq!(m.row_sum(), RowVector3::new(5.0, 7.0, 9.0)); let mint = Matrix3x2::new(1,2,3,4,5,6); assert_eq!(mint.row_sum(), RowVector2::new(9,12));
pub fn row_sum_tr(
&self
) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where
DefaultAllocator: Allocator<N, C, U1>,
[src]
&self
) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where
DefaultAllocator: Allocator<N, C, U1>,
The sum of all the rows of this matrix. The result is transposed and returned as a column vector.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_eq!(m.row_sum_tr(), Vector3::new(5.0, 7.0, 9.0)); let mint = Matrix3x2::new(1,2,3,4,5,6); assert_eq!(mint.row_sum_tr(), Vector2::new(9,12));
pub fn column_sum(
&self
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
DefaultAllocator: Allocator<N, R, U1>,
[src]
&self
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
DefaultAllocator: Allocator<N, R, U1>,
The sum of all the columns of this matrix.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_eq!(m.column_sum(), Vector2::new(6.0, 15.0)); let mint = Matrix3x2::new(1,2,3,4,5,6); assert_eq!(mint.column_sum(), Vector3::new(3,7,11));
pub fn variance(&self) -> N
[src]
The variance of all the elements of this matrix.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_relative_eq!(m.variance(), 35.0 / 12.0, epsilon = 1.0e-8);
pub fn row_variance(
&self
) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where
DefaultAllocator: Allocator<N, U1, C>,
[src]
&self
) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where
DefaultAllocator: Allocator<N, U1, C>,
The variance of all the rows of this matrix.
Use .row_variance_tr
if you need the result in a column vector instead.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_eq!(m.row_variance(), RowVector3::new(2.25, 2.25, 2.25));
pub fn row_variance_tr(
&self
) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where
DefaultAllocator: Allocator<N, C, U1>,
[src]
&self
) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where
DefaultAllocator: Allocator<N, C, U1>,
The variance of all the rows of this matrix. The result is transposed and returned as a column vector.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_eq!(m.row_variance_tr(), Vector3::new(2.25, 2.25, 2.25));
pub fn column_variance(
&self
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
DefaultAllocator: Allocator<N, R, U1>,
[src]
&self
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
DefaultAllocator: Allocator<N, R, U1>,
The variance of all the columns of this matrix.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_relative_eq!(m.column_variance(), Vector2::new(2.0 / 3.0, 2.0 / 3.0), epsilon = 1.0e-8);
pub fn mean(&self) -> N
[src]
The mean of all the elements of this matrix.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_eq!(m.mean(), 3.5);
pub fn row_mean(
&self
) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where
DefaultAllocator: Allocator<N, U1, C>,
[src]
&self
) -> Matrix<N, U1, C, <DefaultAllocator as Allocator<N, U1, C>>::Buffer> where
DefaultAllocator: Allocator<N, U1, C>,
The mean of all the rows of this matrix.
Use .row_mean_tr
if you need the result in a column vector instead.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_eq!(m.row_mean(), RowVector3::new(2.5, 3.5, 4.5));
pub fn row_mean_tr(
&self
) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where
DefaultAllocator: Allocator<N, C, U1>,
[src]
&self
) -> Matrix<N, C, U1, <DefaultAllocator as Allocator<N, C, U1>>::Buffer> where
DefaultAllocator: Allocator<N, C, U1>,
The mean of all the rows of this matrix. The result is transposed and returned as a column vector.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_eq!(m.row_mean_tr(), Vector3::new(2.5, 3.5, 4.5));
pub fn column_mean(
&self
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
DefaultAllocator: Allocator<N, R, U1>,
[src]
&self
) -> Matrix<N, R, U1, <DefaultAllocator as Allocator<N, R, U1>>::Buffer> where
DefaultAllocator: Allocator<N, R, U1>,
The mean of all the columns of this matrix.
Example
let m = Matrix2x3::new(1.0, 2.0, 3.0, 4.0, 5.0, 6.0); assert_eq!(m.column_mean(), Vector2::new(2.0, 5.0));
pub fn convolve_full<D2, S2>(
&self,
kernel: Matrix<N, D2, U1, S2>
) -> Matrix<N, <<D1 as DimAdd<D2>>::Output as DimSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <<D1 as DimAdd<D2>>::Output as DimSub<U1>>::Output, U1>>::Buffer> where
D1: DimAdd<D2>,
D2: DimAdd<D1, Output = <D1 as DimAdd<D2>>::Output>,
S2: Storage<N, D2, U1>,
<D1 as DimAdd<D2>>::Output: DimSub<U1>,
DefaultAllocator: Allocator<N, <<D1 as DimAdd<D2>>::Output as DimSub<U1>>::Output, U1>,
[src]
&self,
kernel: Matrix<N, D2, U1, S2>
) -> Matrix<N, <<D1 as DimAdd<D2>>::Output as DimSub<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <<D1 as DimAdd<D2>>::Output as DimSub<U1>>::Output, U1>>::Buffer> where
D1: DimAdd<D2>,
D2: DimAdd<D1, Output = <D1 as DimAdd<D2>>::Output>,
S2: Storage<N, D2, U1>,
<D1 as DimAdd<D2>>::Output: DimSub<U1>,
DefaultAllocator: Allocator<N, <<D1 as DimAdd<D2>>::Output as DimSub<U1>>::Output, U1>,
Returns the convolution of the target vector and a kernel.
Arguments
kernel
- A Vector with size > 0
Errors
Inputs must satisfy vector.len() >= kernel.len() > 0
.
pub fn convolve_valid<D2, S2>(
&self,
kernel: Matrix<N, D2, U1, S2>
) -> Matrix<N, <<D1 as DimAdd<U1>>::Output as DimSub<D2>>::Output, U1, <DefaultAllocator as Allocator<N, <<D1 as DimAdd<U1>>::Output as DimSub<D2>>::Output, U1>>::Buffer> where
D1: DimAdd<U1>,
D2: Dim,
S2: Storage<N, D2, U1>,
<D1 as DimAdd<U1>>::Output: DimSub<D2>,
DefaultAllocator: Allocator<N, <<D1 as DimAdd<U1>>::Output as DimSub<D2>>::Output, U1>,
[src]
&self,
kernel: Matrix<N, D2, U1, S2>
) -> Matrix<N, <<D1 as DimAdd<U1>>::Output as DimSub<D2>>::Output, U1, <DefaultAllocator as Allocator<N, <<D1 as DimAdd<U1>>::Output as DimSub<D2>>::Output, U1>>::Buffer> where
D1: DimAdd<U1>,
D2: Dim,
S2: Storage<N, D2, U1>,
<D1 as DimAdd<U1>>::Output: DimSub<D2>,
DefaultAllocator: Allocator<N, <<D1 as DimAdd<U1>>::Output as DimSub<D2>>::Output, U1>,
Returns the convolution of the target vector and a kernel.
The output convolution consists only of those elements that do not rely on the zero-padding.
Arguments
kernel
- A Vector with size > 0
Errors
Inputs must satisfy self.len() >= kernel.len() > 0
.
pub fn convolve_same<D2, S2>(
&self,
kernel: Matrix<N, D2, U1, S2>
) -> Matrix<N, D1, U1, <DefaultAllocator as Allocator<N, D1, U1>>::Buffer> where
D2: Dim,
S2: Storage<N, D2, U1>,
DefaultAllocator: Allocator<N, D1, U1>,
[src]
&self,
kernel: Matrix<N, D2, U1, S2>
) -> Matrix<N, D1, U1, <DefaultAllocator as Allocator<N, D1, U1>>::Buffer> where
D2: Dim,
S2: Storage<N, D2, U1>,
DefaultAllocator: Allocator<N, D1, U1>,
pub fn determinant(&self) -> N where
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
[src]
DefaultAllocator: Allocator<N, D, D>,
DefaultAllocator: Allocator<(usize, usize), D, U1>,
Computes the matrix determinant.
If the matrix has a dimension larger than 3, an LU decomposition is used.
pub fn try_inverse_mut(&mut self) -> bool where
DefaultAllocator: Allocator<N, D, D>,
[src]
DefaultAllocator: Allocator<N, D, D>,
Attempts to invert this matrix in-place. Returns false
and leaves self
untouched if
inversion fails.
pub fn eigenvalues(
&self
) -> Option<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>
[src]
&self
) -> Option<Matrix<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>>
Computes the eigenvalues of this matrix.
pub fn complex_eigenvalues(
&self
) -> Matrix<Complex<N>, D, U1, <DefaultAllocator as Allocator<Complex<N>, D, U1>>::Buffer> where
N: RealField,
DefaultAllocator: Allocator<Complex<N>, D, U1>,
[src]
&self
) -> Matrix<Complex<N>, D, U1, <DefaultAllocator as Allocator<Complex<N>, D, U1>>::Buffer> where
N: RealField,
DefaultAllocator: Allocator<Complex<N>, D, U1>,
Computes the eigenvalues of this matrix.
pub fn solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self . x = b
where x
is the unknown and only
the lower-triangular part of self
(including the diagonal) is considered not-zero.
pub fn solve_upper_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self . x = b
where x
is the unknown and only
the upper-triangular part of self
(including the diagonal) is considered not-zero.
pub fn solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self . x = b
where x
is the unknown and only the
lower-triangular part of self
(including the diagonal) is considered not-zero.
pub fn solve_lower_triangular_with_diag_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>,
diag: N
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>,
diag: N
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self . x = b
where x
is the unknown and only the
lower-triangular part of self
is considered not-zero. The diagonal is never read as it is
assumed to be equal to diag
. Returns false
and does not modify its inputs if diag
is zero.
pub fn solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self . x = b
where x
is the unknown and only the
upper-triangular part of self
(including the diagonal) is considered not-zero.
pub fn tr_solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self.transpose() . x = b
where x
is the unknown and only
the lower-triangular part of self
(including the diagonal) is considered not-zero.
pub fn tr_solve_upper_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self.transpose() . x = b
where x
is the unknown and only
the upper-triangular part of self
(including the diagonal) is considered not-zero.
pub fn tr_solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self.transpose() . x = b
where x
is the unknown and only the
lower-triangular part of self
(including the diagonal) is considered not-zero.
pub fn tr_solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self.transpose() . x = b
where x
is the unknown and only the
upper-triangular part of self
(including the diagonal) is considered not-zero.
pub fn ad_solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self.adjoint() . x = b
where x
is the unknown and only
the lower-triangular part of self
(including the diagonal) is considered not-zero.
pub fn ad_solve_upper_triangular<R2, C2, S2>(
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &Matrix<N, R2, C2, S2>
) -> Option<Matrix<N, R2, C2, <DefaultAllocator as Allocator<N, R2, C2>>::Buffer>> where
C2: Dim,
R2: Dim,
S2: Storage<N, R2, C2>,
DefaultAllocator: Allocator<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self.adjoint() . x = b
where x
is the unknown and only
the upper-triangular part of self
(including the diagonal) is considered not-zero.
pub fn ad_solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self.adjoint() . x = b
where x
is the unknown and only the
lower-triangular part of self
(including the diagonal) is considered not-zero.
pub fn ad_solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
[src]
&self,
b: &mut Matrix<N, R2, C2, S2>
) -> bool where
C2: Dim,
R2: Dim,
S2: StorageMut<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Solves the linear system self.adjoint() . x = b
where x
is the unknown and only the
upper-triangular part of self
(including the diagonal) is considered not-zero.
pub fn singular_values(
&self
) -> Matrix<<N as ComplexField>::RealField, <R as DimMin<C>>::Output, U1, <DefaultAllocator as Allocator<<N as ComplexField>::RealField, <R as DimMin<C>>::Output, U1>>::Buffer>
[src]
&self
) -> Matrix<<N as ComplexField>::RealField, <R as DimMin<C>>::Output, U1, <DefaultAllocator as Allocator<<N as ComplexField>::RealField, <R as DimMin<C>>::Output, U1>>::Buffer>
Computes the singular values of this matrix.
pub fn rank(&self, eps: <N as ComplexField>::RealField) -> usize
[src]
Computes the rank of this matrix.
All singular values below eps
are considered equal to 0.
pub fn symmetric_eigenvalues(
&self
) -> Matrix<<N as ComplexField>::RealField, D, U1, <DefaultAllocator as Allocator<<N as ComplexField>::RealField, D, U1>>::Buffer>
[src]
&self
) -> Matrix<<N as ComplexField>::RealField, D, U1, <DefaultAllocator as Allocator<<N as ComplexField>::RealField, D, U1>>::Buffer>
Computes the eigenvalues of this symmetric matrix.
Only the lower-triangular part of the matrix is read.
pub fn add_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
pub fn sub_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>,
out: &mut Matrix<N, R3, C3, SC>
) where
C2: Dim,
C3: Dim,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: StorageMut<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
pub fn component_mul<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer> where
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer> where
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
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);
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
C2: Dim,
C3: Dim,
N: ClosedMul<N, Output = N> + Zero<Output = N> + Mul<N> + Add<N>,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
C2: Dim,
C3: Dim,
N: ClosedMul<N, Output = N> + Zero<Output = N> + Mul<N> + Add<N>,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: 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
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
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
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C2: Dim,
N: ClosedMul<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
This is renamed using the _assign
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);
pub fn component_div<R2, C2, SB>(
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer> where
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
&self,
rhs: &Matrix<N, R2, C2, SB>
) -> Matrix<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<N, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer> where
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
DefaultAllocator: SameShapeAllocator<N, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
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);
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
C2: Dim,
C3: Dim,
N: ClosedDiv<N> + Zero<Output = N> + Mul<N, Output = N> + Add<N>,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
[src]
&mut self,
alpha: N,
a: &Matrix<N, R2, C2, SB>,
b: &Matrix<N, R3, C3, SC>,
beta: N
) where
C2: Dim,
C3: Dim,
N: ClosedDiv<N> + Zero<Output = N> + Mul<N, Output = N> + Add<N>,
R2: Dim,
R3: Dim,
SB: Storage<N, R2, C2>,
SC: Storage<N, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: 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
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
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
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
[src]
C2: Dim,
N: ClosedDiv<N>,
R2: Dim,
SB: Storage<N, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
This is renamed using the _assign
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);
pub fn row(
&self,
i: usize
) -> Matrix<N, U1, C, SliceStorage<N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&self,
i: usize
) -> Matrix<N, U1, C, SliceStorage<N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the i-th row of this matrix.
pub fn row_part(
&self,
i: usize,
n: usize
) -> Matrix<N, U1, Dynamic, SliceStorage<N, U1, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&self,
i: usize,
n: usize
) -> Matrix<N, U1, Dynamic, SliceStorage<N, U1, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the n
first elements of the i-th row of this matrix.
pub fn rows(
&self,
first_row: usize,
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorage<N, Dynamic, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&self,
first_row: usize,
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorage<N, Dynamic, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive rows.
pub fn rows_with_step(
&self,
first_row: usize,
nrows: usize,
step: usize
) -> Matrix<N, Dynamic, C, SliceStorage<N, Dynamic, C, Dynamic, <S as Storage<N, R, C>>::CStride>>
[src]
&self,
first_row: usize,
nrows: usize,
step: usize
) -> Matrix<N, Dynamic, C, SliceStorage<N, Dynamic, C, Dynamic, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive rows regularly skipping step
rows.
pub fn fixed_rows<RSlice>(
&self,
first_row: usize
) -> Matrix<N, RSlice, C, SliceStorage<N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RSlice: DimName,
[src]
&self,
first_row: usize
) -> Matrix<N, RSlice, C, SliceStorage<N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RSlice: DimName,
Extracts a compile-time number of consecutive rows from this matrix.
pub fn fixed_rows_with_step<RSlice>(
&self,
first_row: usize,
step: usize
) -> Matrix<N, RSlice, C, SliceStorage<N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where
RSlice: DimName,
[src]
&self,
first_row: usize,
step: usize
) -> Matrix<N, RSlice, C, SliceStorage<N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where
RSlice: DimName,
Extracts from this matrix a compile-time number of rows regularly skipping step
rows.
pub fn rows_generic<RSlice>(
&self,
row_start: usize,
nrows: RSlice
) -> Matrix<N, RSlice, C, SliceStorage<N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RSlice: Dim,
[src]
&self,
row_start: usize,
nrows: RSlice
) -> Matrix<N, RSlice, C, SliceStorage<N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RSlice: Dim,
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
pub fn rows_generic_with_step<RSlice>(
&self,
row_start: usize,
nrows: RSlice,
step: usize
) -> Matrix<N, RSlice, C, SliceStorage<N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where
RSlice: Dim,
[src]
&self,
row_start: usize,
nrows: RSlice,
step: usize
) -> Matrix<N, RSlice, C, SliceStorage<N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where
RSlice: Dim,
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
pub fn column(
&self,
i: usize
) -> Matrix<N, R, U1, SliceStorage<N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&self,
i: usize
) -> Matrix<N, R, U1, SliceStorage<N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the i-th column of this matrix.
pub fn column_part(
&self,
i: usize,
n: usize
) -> Matrix<N, Dynamic, U1, SliceStorage<N, Dynamic, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&self,
i: usize,
n: usize
) -> Matrix<N, Dynamic, U1, SliceStorage<N, Dynamic, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the n
first elements of the i-th column of this matrix.
pub fn columns(
&self,
first_col: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorage<N, R, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&self,
first_col: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorage<N, R, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive columns.
pub fn columns_with_step(
&self,
first_col: usize,
ncols: usize,
step: usize
) -> Matrix<N, R, Dynamic, SliceStorage<N, R, Dynamic, <S as Storage<N, R, C>>::RStride, Dynamic>>
[src]
&self,
first_col: usize,
ncols: usize,
step: usize
) -> Matrix<N, R, Dynamic, SliceStorage<N, R, Dynamic, <S as Storage<N, R, C>>::RStride, Dynamic>>
Extracts from this matrix a set of consecutive columns regularly skipping step
columns.
pub fn fixed_columns<CSlice>(
&self,
first_col: usize
) -> Matrix<N, R, CSlice, SliceStorage<N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: DimName,
[src]
&self,
first_col: usize
) -> Matrix<N, R, CSlice, SliceStorage<N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: DimName,
Extracts a compile-time number of consecutive columns from this matrix.
pub fn fixed_columns_with_step<CSlice>(
&self,
first_col: usize,
step: usize
) -> Matrix<N, R, CSlice, SliceStorage<N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where
CSlice: DimName,
[src]
&self,
first_col: usize,
step: usize
) -> Matrix<N, R, CSlice, SliceStorage<N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where
CSlice: DimName,
Extracts from this matrix a compile-time number of columns regularly skipping
step
columns.
pub fn columns_generic<CSlice>(
&self,
first_col: usize,
ncols: CSlice
) -> Matrix<N, R, CSlice, SliceStorage<N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: Dim,
[src]
&self,
first_col: usize,
ncols: CSlice
) -> Matrix<N, R, CSlice, SliceStorage<N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: Dim,
Extracts from this matrix ncols
columns. The number of columns may or may not be
known at compile-time.
pub fn columns_generic_with_step<CSlice>(
&self,
first_col: usize,
ncols: CSlice,
step: usize
) -> Matrix<N, R, CSlice, SliceStorage<N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where
CSlice: Dim,
[src]
&self,
first_col: usize,
ncols: CSlice,
step: usize
) -> Matrix<N, R, CSlice, SliceStorage<N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where
CSlice: Dim,
Extracts from this matrix ncols
columns skipping step
columns. Both argument may
or may not be values known at compile-time.
pub fn slice(
&self,
start: (usize, usize),
shape: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<N, Dynamic, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&self,
start: (usize, usize),
shape: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<N, Dynamic, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Slices this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
pub fn slice_with_steps(
&self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<N, Dynamic, Dynamic, Dynamic, Dynamic>>
[src]
&self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorage<N, Dynamic, Dynamic, Dynamic, Dynamic>>
Slices this matrix starting at its component (start.0, start.1)
and with
(shape.0, shape.1)
components. Each row (resp. column) of the sliced matrix is
separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of the
original matrix.
pub fn fixed_slice<RSlice, CSlice>(
&self,
irow: usize,
icol: usize
) -> Matrix<N, RSlice, CSlice, SliceStorage<N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: DimName,
RSlice: DimName,
[src]
&self,
irow: usize,
icol: usize
) -> Matrix<N, RSlice, CSlice, SliceStorage<N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: DimName,
RSlice: DimName,
Slices this matrix starting at its component (irow, icol)
and with (R::dim(), CSlice::dim())
consecutive components.
pub fn fixed_slice_with_steps<RSlice, CSlice>(
&self,
start: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorage<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: DimName,
RSlice: DimName,
[src]
&self,
start: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorage<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: DimName,
RSlice: DimName,
Slices this matrix starting at its component (start.0, start.1)
and with
(R::dim(), CSlice::dim())
components. Each row (resp. column) of the sliced
matrix is separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of
the original matrix.
pub fn generic_slice<RSlice, CSlice>(
&self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> Matrix<N, RSlice, CSlice, SliceStorage<N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: Dim,
RSlice: Dim,
[src]
&self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> Matrix<N, RSlice, CSlice, SliceStorage<N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: Dim,
RSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
pub fn generic_slice_with_steps<RSlice, CSlice>(
&self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorage<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: Dim,
RSlice: Dim,
[src]
&self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorage<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: Dim,
RSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
pub fn rows_range_pair<Range1, Range2>(
&self,
r1: Range1,
r2: Range2
) -> (Matrix<N, <Range1 as SliceRange<R>>::Size, C, SliceStorage<N, <Range1 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, <Range2 as SliceRange<R>>::Size, C, SliceStorage<N, <Range2 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where
Range1: SliceRange<R>,
Range2: SliceRange<R>,
[src]
&self,
r1: Range1,
r2: Range2
) -> (Matrix<N, <Range1 as SliceRange<R>>::Size, C, SliceStorage<N, <Range1 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, <Range2 as SliceRange<R>>::Size, C, SliceStorage<N, <Range2 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where
Range1: SliceRange<R>,
Range2: SliceRange<R>,
Splits this NxM matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
pub fn columns_range_pair<Range1, Range2>(
&self,
r1: Range1,
r2: Range2
) -> (Matrix<N, R, <Range1 as SliceRange<C>>::Size, SliceStorage<N, R, <Range1 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, R, <Range2 as SliceRange<C>>::Size, SliceStorage<N, R, <Range2 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where
Range1: SliceRange<C>,
Range2: SliceRange<C>,
[src]
&self,
r1: Range1,
r2: Range2
) -> (Matrix<N, R, <Range1 as SliceRange<C>>::Size, SliceStorage<N, R, <Range1 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, R, <Range2 as SliceRange<C>>::Size, SliceStorage<N, R, <Range2 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where
Range1: SliceRange<C>,
Range2: SliceRange<C>,
Splits this NxM matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
pub fn row_mut(
&mut self,
i: usize
) -> Matrix<N, U1, C, SliceStorageMut<N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&mut self,
i: usize
) -> Matrix<N, U1, C, SliceStorageMut<N, U1, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the i-th row of this matrix.
pub fn row_part_mut(
&mut self,
i: usize,
n: usize
) -> Matrix<N, U1, Dynamic, SliceStorageMut<N, U1, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&mut self,
i: usize,
n: usize
) -> Matrix<N, U1, Dynamic, SliceStorageMut<N, U1, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the n
first elements of the i-th row of this matrix.
pub fn rows_mut(
&mut self,
first_row: usize,
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<N, Dynamic, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&mut self,
first_row: usize,
nrows: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<N, Dynamic, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive rows.
pub fn rows_with_step_mut(
&mut self,
first_row: usize,
nrows: usize,
step: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<N, Dynamic, C, Dynamic, <S as Storage<N, R, C>>::CStride>>
[src]
&mut self,
first_row: usize,
nrows: usize,
step: usize
) -> Matrix<N, Dynamic, C, SliceStorageMut<N, Dynamic, C, Dynamic, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive rows regularly skipping step
rows.
pub fn fixed_rows_mut<RSlice>(
&mut self,
first_row: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RSlice: DimName,
[src]
&mut self,
first_row: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RSlice: DimName,
Extracts a compile-time number of consecutive rows from this matrix.
pub fn fixed_rows_with_step_mut<RSlice>(
&mut self,
first_row: usize,
step: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where
RSlice: DimName,
[src]
&mut self,
first_row: usize,
step: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where
RSlice: DimName,
Extracts from this matrix a compile-time number of rows regularly skipping step
rows.
pub fn rows_generic_mut<RSlice>(
&mut self,
row_start: usize,
nrows: RSlice
) -> Matrix<N, RSlice, C, SliceStorageMut<N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RSlice: Dim,
[src]
&mut self,
row_start: usize,
nrows: RSlice
) -> Matrix<N, RSlice, C, SliceStorageMut<N, RSlice, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
RSlice: Dim,
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
pub fn rows_generic_with_step_mut<RSlice>(
&mut self,
row_start: usize,
nrows: RSlice,
step: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where
RSlice: Dim,
[src]
&mut self,
row_start: usize,
nrows: RSlice,
step: usize
) -> Matrix<N, RSlice, C, SliceStorageMut<N, RSlice, C, Dynamic, <S as Storage<N, R, C>>::CStride>> where
RSlice: Dim,
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
pub fn column_mut(
&mut self,
i: usize
) -> Matrix<N, R, U1, SliceStorageMut<N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&mut self,
i: usize
) -> Matrix<N, R, U1, SliceStorageMut<N, R, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the i-th column of this matrix.
pub fn column_part_mut(
&mut self,
i: usize,
n: usize
) -> Matrix<N, Dynamic, U1, SliceStorageMut<N, Dynamic, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&mut self,
i: usize,
n: usize
) -> Matrix<N, Dynamic, U1, SliceStorageMut<N, Dynamic, U1, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Returns a slice containing the n
first elements of the i-th column of this matrix.
pub fn columns_mut(
&mut self,
first_col: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<N, R, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&mut self,
first_col: usize,
ncols: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<N, R, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Extracts from this matrix a set of consecutive columns.
pub fn columns_with_step_mut(
&mut self,
first_col: usize,
ncols: usize,
step: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<N, R, Dynamic, <S as Storage<N, R, C>>::RStride, Dynamic>>
[src]
&mut self,
first_col: usize,
ncols: usize,
step: usize
) -> Matrix<N, R, Dynamic, SliceStorageMut<N, R, Dynamic, <S as Storage<N, R, C>>::RStride, Dynamic>>
Extracts from this matrix a set of consecutive columns regularly skipping step
columns.
pub fn fixed_columns_mut<CSlice>(
&mut self,
first_col: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: DimName,
[src]
&mut self,
first_col: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: DimName,
Extracts a compile-time number of consecutive columns from this matrix.
pub fn fixed_columns_with_step_mut<CSlice>(
&mut self,
first_col: usize,
step: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where
CSlice: DimName,
[src]
&mut self,
first_col: usize,
step: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where
CSlice: DimName,
Extracts from this matrix a compile-time number of columns regularly skipping
step
columns.
pub fn columns_generic_mut<CSlice>(
&mut self,
first_col: usize,
ncols: CSlice
) -> Matrix<N, R, CSlice, SliceStorageMut<N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: Dim,
[src]
&mut self,
first_col: usize,
ncols: CSlice
) -> Matrix<N, R, CSlice, SliceStorageMut<N, R, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: Dim,
Extracts from this matrix ncols
columns. The number of columns may or may not be
known at compile-time.
pub fn columns_generic_with_step_mut<CSlice>(
&mut self,
first_col: usize,
ncols: CSlice,
step: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where
CSlice: Dim,
[src]
&mut self,
first_col: usize,
ncols: CSlice,
step: usize
) -> Matrix<N, R, CSlice, SliceStorageMut<N, R, CSlice, <S as Storage<N, R, C>>::RStride, Dynamic>> where
CSlice: Dim,
Extracts from this matrix ncols
columns skipping step
columns. Both argument may
or may not be values known at compile-time.
pub fn slice_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<N, Dynamic, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
[src]
&mut self,
start: (usize, usize),
shape: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<N, Dynamic, Dynamic, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>
Slices this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
pub fn slice_with_steps_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<N, Dynamic, Dynamic, Dynamic, Dynamic>>
[src]
&mut self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, Dynamic, Dynamic, SliceStorageMut<N, Dynamic, Dynamic, Dynamic, Dynamic>>
Slices this matrix starting at its component (start.0, start.1)
and with
(shape.0, shape.1)
components. Each row (resp. column) of the sliced matrix is
separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of the
original matrix.
pub fn fixed_slice_mut<RSlice, CSlice>(
&mut self,
irow: usize,
icol: usize
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: DimName,
RSlice: DimName,
[src]
&mut self,
irow: usize,
icol: usize
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: DimName,
RSlice: DimName,
Slices this matrix starting at its component (irow, icol)
and with (R::dim(), CSlice::dim())
consecutive components.
pub fn fixed_slice_with_steps_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: DimName,
RSlice: DimName,
[src]
&mut self,
start: (usize, usize),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: DimName,
RSlice: DimName,
Slices this matrix starting at its component (start.0, start.1)
and with
(R::dim(), CSlice::dim())
components. Each row (resp. column) of the sliced
matrix is separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of
the original matrix.
pub fn generic_slice_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: Dim,
RSlice: Dim,
[src]
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<N, RSlice, CSlice, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>> where
CSlice: Dim,
RSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
pub fn generic_slice_with_steps_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: Dim,
RSlice: Dim,
[src]
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice),
steps: (usize, usize)
) -> Matrix<N, RSlice, CSlice, SliceStorageMut<N, RSlice, CSlice, Dynamic, Dynamic>> where
CSlice: Dim,
RSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
pub fn rows_range_pair_mut<Range1, Range2>(
&mut self,
r1: Range1,
r2: Range2
) -> (Matrix<N, <Range1 as SliceRange<R>>::Size, C, SliceStorageMut<N, <Range1 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, <Range2 as SliceRange<R>>::Size, C, SliceStorageMut<N, <Range2 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where
Range1: SliceRange<R>,
Range2: SliceRange<R>,
[src]
&mut self,
r1: Range1,
r2: Range2
) -> (Matrix<N, <Range1 as SliceRange<R>>::Size, C, SliceStorageMut<N, <Range1 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, <Range2 as SliceRange<R>>::Size, C, SliceStorageMut<N, <Range2 as SliceRange<R>>::Size, C, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where
Range1: SliceRange<R>,
Range2: SliceRange<R>,
Splits this NxM matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
pub fn columns_range_pair_mut<Range1, Range2>(
&mut self,
r1: Range1,
r2: Range2
) -> (Matrix<N, R, <Range1 as SliceRange<C>>::Size, SliceStorageMut<N, R, <Range1 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, R, <Range2 as SliceRange<C>>::Size, SliceStorageMut<N, R, <Range2 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where
Range1: SliceRange<C>,
Range2: SliceRange<C>,
[src]
&mut self,
r1: Range1,
r2: Range2
) -> (Matrix<N, R, <Range1 as SliceRange<C>>::Size, SliceStorageMut<N, R, <Range1 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>, Matrix<N, R, <Range2 as SliceRange<C>>::Size, SliceStorageMut<N, R, <Range2 as SliceRange<C>>::Size, <S as Storage<N, R, C>>::RStride, <S as Storage<N, R, C>>::CStride>>) where
Range1: SliceRange<C>,
Range2: SliceRange<C>,
Splits this NxM matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
pub fn xx(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xxx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xy(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yx(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yy(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xxy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xyx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xyy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yxx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yxy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yyx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yyy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xz(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yz(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zx(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zy(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zz(
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xxz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xyz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xzx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xzy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn xzz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yxz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yyz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yzx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yzy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn yzz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zxx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zxy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zxz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zyx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zyy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zyz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zzx(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zzy(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
pub fn zzz(
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
[src]
&self
) -> Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>
Builds a new vector from components of self
.
Trait Implementations
impl AbstractRotation<f64, U3> for Skew3
[src]
fn identity() -> Skew3
[src]
fn inverse(&self) -> Skew3
[src]
fn inverse_mut(&mut self)
[src]
fn transform_vector(
&self,
v: &Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
) -> Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
[src]
&self,
v: &Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
) -> Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
fn transform_point(&self, p: &Point<f64, U3>) -> Point<f64, U3>
[src]
fn inverse_transform_vector(
&self,
v: &Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
) -> Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
[src]
&self,
v: &Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
) -> Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
fn inverse_transform_point(&self, p: &Point<f64, U3>) -> Point<f64, U3>
[src]
impl AsMut<Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>> for Skew3
[src]
fn as_mut(
&mut self
) -> &mut Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
[src]
&mut self
) -> &mut Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
impl AsRef<Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>> for Skew3
[src]
fn as_ref(
&self
) -> &Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
[src]
&self
) -> &Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
impl Clone for Skew3
[src]
impl Copy for Skew3
[src]
impl Debug for Skew3
[src]
impl Deref for Skew3
[src]
type Target = Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
The resulting type after dereferencing.
fn deref(&self) -> &<Skew3 as Deref>::Target
[src]
impl DerefMut for Skew3
[src]
impl From<Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>> for Skew3
[src]
fn from(
original: Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
) -> Skew3
[src]
original: Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
) -> Skew3
impl From<Rotation<f64, U3>> for Skew3
[src]
This is the log map.
impl From<Skew3> for Rotation<f64, U3>
[src]
This is the exponential map.
impl From<Skew3> for Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
[src]
fn from(
original: Skew3
) -> Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
[src]
original: Skew3
) -> Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3, U1>>::Buffer>
impl Mul<Skew3> for Skew3
[src]
type Output = Skew3
The resulting type after applying the *
operator.
fn mul(self, rhs: Skew3) -> Skew3
[src]
impl MulAssign<Skew3> for Skew3
[src]
fn mul_assign(&mut self, rhs: Skew3)
[src]
impl PartialEq<Skew3> for Skew3
[src]
impl PartialOrd<Skew3> for Skew3
[src]
fn partial_cmp(&self, other: &Skew3) -> Option<Ordering>
[src]
fn lt(&self, other: &Skew3) -> bool
[src]
fn le(&self, other: &Skew3) -> bool
[src]
fn gt(&self, other: &Skew3) -> bool
[src]
fn ge(&self, other: &Skew3) -> bool
[src]
impl StructuralPartialEq for Skew3
[src]
Auto Trait Implementations
impl RefUnwindSafe for Skew3
impl Send for Skew3
impl Sync for Skew3
impl Unpin for Skew3
impl UnwindSafe for Skew3
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, Right> ClosedMul<Right> for T where
T: Mul<Right, Output = T> + MulAssign<Right>,
T: Mul<Right, Output = T> + MulAssign<Right>,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> Scalar for T where
T: PartialEq<T> + Copy + Any + Debug,
[src]
T: PartialEq<T> + Copy + Any + Debug,
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
fn is_in_subset(&self) -> bool
fn to_subset_unchecked(&self) -> SS
fn from_subset(element: &SS) -> SP
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,