Struct heron::rapier_plugin::rapier2d::prelude::nalgebra::Matrix [−][src]
#[repr(C)]pub struct Matrix<T, R, C, S> {
pub data: S,
// some fields omitted
}
Expand description
The most generic column-major matrix (and vector) type.
Methods summary
Because Matrix
is the most generic types used as a common representation of all matrices and
vectors of nalgebra this documentation page contains every single matrix/vector-related
method. In order to make browsing this page simpler, the next subsections contain direct links
to groups of methods related to a specific topic.
Vector and matrix construction
- Constructors of statically-sized vectors or statically-sized matrices
(
Vector3
,Matrix3x6
…) - Constructors of fully dynamic matrices (
DMatrix
) - Constructors of dynamic vectors and matrices with a dynamic number of rows
(
DVector
,MatrixXx3
…) - Constructors of matrices with a dynamic number of columns
(
Matrix2xX
…) - Generic constructors (For code generic wrt. the vectors or matrices dimensions.)
Computer graphics utilities for transformations
- 2D transformations as a Matrix3
new_rotation
… - 3D transformations as a Matrix4
new_rotation
,new_perspective
,look_at_rh
… - Translation and scaling in any dimension
new_scaling
,new_translation
… - Append/prepend translation and scaling
append_scaling
,prepend_translation_mut
… - Transformation of vectors and points
transform_vector
,transform_point
…
Common math operations
- Componentwise operations
component_mul
,component_div
,inf
… - Special multiplications
tr_mul
,ad_mul
,kronecker
… - Dot/scalar product
dot
,dotc
,tr_dot
… - Cross product
cross
,perp
… - Magnitude and norms
norm
,normalize
,metric_distance
… - In-place normalization
normalize_mut
,try_normalize_mut
… - Interpolation
lerp
,slerp
… - BLAS functions
gemv
,gemm
,syger
… - Swizzling
xx
,yxz
…
Statistics
- Common operations
row_sum
,column_mean
,variance
… - Find the min and max components
min
,max
,amin
,amax
,camin
,cmax
… - Find the min and max components (vector-specific methods)
argmin
,argmax
,icamin
,icamax
…
Iteration, map, and fold
- Iteration on components, rows, and columns
iter
,column_iter
… - Elementwise mapping and folding
map
,fold
,zip_map
… - Folding or columns and rows
compress_rows
,compress_columns
…
Vector and matrix slicing
- Creating matrix slices from
&[T]
from_slice
,from_slice_with_strides
… - Creating mutable matrix slices from
&mut [T]
from_slice_mut
,from_slice_with_strides_mut
… - Slicing based on index and length
row
,columns
,slice
… - Mutable slicing based on index and length
row_mut
,columns_mut
,slice_mut
… - Slicing based on ranges
rows_range
,columns_range
… - Mutable slicing based on ranges
rows_range_mut
,columns_range_mut
…
In-place modification of a single matrix or vector
- In-place filling
fill
,fill_diagonal
,fill_with_identity
… - In-place swapping
swap
,swap_columns
… - Set rows, columns, and diagonal
set_column
,set_diagonal
…
Vector and matrix size modification
- Rows and columns insertion
insert_row
,insert_column
… - Rows and columns removal
remove_row
,remove column
… - Rows and columns extraction
select_rows
,select_columns
… - Resizing and reshaping
resize
,reshape_generic
… - In-place resizing
resize_mut
,resize_vertically_mut
…
Matrix decomposition
- Rectangular matrix decomposition
qr
,lu
,svd
… - Square matrix decomposition
cholesky
,symmetric_eigen
…
Vector basis computation
Type parameters
The generic Matrix
type has four type parameters:
T
: for the matrix components scalar type.R
: for the matrix number of rows.C
: for the matrix number of columns.S
: for the matrix data storage, i.e., the buffer that actually contains the matrix components.
The matrix dimensions parameters R
and C
can either be:
- type-level unsigned integer constants (e.g.
U1
,U124
) from thenalgebra::
root module. All numbers from 0 to 127 are defined that way. - type-level unsigned integer constants (e.g.
U1024
,U10000
) from thetypenum::
crate. Using those, you will not get error messages as nice as for numbers smaller than 128 defined on thenalgebra::
module. - the special value
Dynamic
from thenalgebra::
root module. This indicates that the specified dimension is not known at compile-time. Note that this will generally imply that the matrix data storageS
performs a dynamic allocation and contains extra metadata for the matrix shape.
Note that mixing Dynamic
with type-level unsigned integers is allowed. Actually, a
dynamically-sized column vector should be represented as a Matrix<T, Dynamic, U1, S>
(given
some concrete types for T
and a compatible data storage type S
).
Fields
data: S
The data storage that contains all the matrix components. Disappointed?
Well, if you came here to see how you can access the matrix components,
you may be in luck: you can access the individual components of all vectors with compile-time
dimensions <= 6 using field notation like this:
vec.x
, vec.y
, vec.z
, vec.w
, vec.a
, vec.b
. Reference and assignation work too:
let mut vec = Vector3::new(1.0, 2.0, 3.0);
vec.x = 10.0;
vec.y += 30.0;
assert_eq!(vec.x, 10.0);
assert_eq!(vec.y + 100.0, 132.0);
Similarly, for matrices with compile-time dimensions <= 6, you can use field notation
like this: mat.m11
, mat.m42
, etc. The first digit identifies the row to address
and the second digit identifies the column to address. So mat.m13
identifies the component
at the first row and third column (note that the count of rows and columns start at 1 instead
of 0 here. This is so we match the mathematical notation).
For all matrices and vectors, independently from their size, individual components can
be accessed and modified using indexing: vec[20]
, mat[(20, 19)]
. Here the indexing
starts at 0 as you would expect.
Implementations
pub fn dot<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T where
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
pub fn dot<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T where
R2: Dim,
C2: Dim,
SB: RawStorage<T, 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<T, R2, C2, SB>) -> T where
R2: Dim,
C2: Dim,
T: SimdComplexField,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
pub fn dotc<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T where
R2: Dim,
C2: Dim,
T: SimdComplexField,
SB: RawStorage<T, 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<T, R2, C2, SB>) -> T where
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: DimEq<C, R2>,
ShapeConstraint: DimEq<R, C2>,
pub fn tr_dot<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T where
R2: Dim,
C2: Dim,
SB: RawStorage<T, 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);
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));
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: T,
a: &Matrix<T, R2, C2, SB>,
x: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
D3: Dim,
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<D, R2>,
ShapeConstraint: AreMultipliable<R2, C2, D3, Const<1_usize>>,
pub fn gemv<R2, C2, D3, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
x: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
D3: Dim,
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<D, R2>,
ShapeConstraint: AreMultipliable<R2, C2, D3, Const<1_usize>>,
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 sygemv<D2, D3, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, D2, D2, SB>,
x: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: One,
SB: Storage<T, D2, D2>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<D, D2>,
ShapeConstraint: AreMultipliable<D2, D2, D3, Const<1_usize>>,
pub fn sygemv<D2, D3, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, D2, D2, SB>,
x: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: One,
SB: Storage<T, D2, D2>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<D, D2>,
ShapeConstraint: AreMultipliable<D2, D2, D3, Const<1_usize>>,
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: T,
a: &Matrix<T, D2, D2, SB>,
x: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: SimdComplexField,
SB: Storage<T, D2, D2>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<D, D2>,
ShapeConstraint: AreMultipliable<D2, D2, D3, Const<1_usize>>,
pub fn hegemv<D2, D3, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, D2, D2, SB>,
x: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: SimdComplexField,
SB: Storage<T, D2, D2>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<D, D2>,
ShapeConstraint: AreMultipliable<D2, D2, D3, Const<1_usize>>,
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: T,
a: &Matrix<T, R2, C2, SB>,
x: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
D3: Dim,
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<D, C2>,
ShapeConstraint: AreMultipliable<C2, R2, D3, Const<1_usize>>,
pub fn gemv_tr<R2, C2, D3, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
x: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
D3: Dim,
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<D, C2>,
ShapeConstraint: AreMultipliable<C2, R2, D3, Const<1_usize>>,
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: T,
a: &Matrix<T, R2, C2, SB>,
x: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
D3: Dim,
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<D, C2>,
ShapeConstraint: AreMultipliable<C2, R2, D3, Const<1_usize>>,
pub fn gemv_ad<R2, C2, D3, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
x: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
D3: Dim,
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<D, C2>,
ShapeConstraint: AreMultipliable<C2, R2, D3, Const<1_usize>>,
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: T,
x: &Matrix<T, D2, Const<1_usize>, SB>,
y: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: One,
SB: Storage<T, D2, Const<1_usize>>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
pub fn ger<D2, D3, SB, SC>(
&mut self,
alpha: T,
x: &Matrix<T, D2, Const<1_usize>, SB>,
y: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: One,
SB: Storage<T, D2, Const<1_usize>>,
SC: Storage<T, D3, Const<1_usize>>,
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: T,
x: &Matrix<T, D2, Const<1_usize>, SB>,
y: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: SimdComplexField,
SB: Storage<T, D2, Const<1_usize>>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
pub fn gerc<D2, D3, SB, SC>(
&mut self,
alpha: T,
x: &Matrix<T, D2, Const<1_usize>, SB>,
y: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: SimdComplexField,
SB: Storage<T, D2, Const<1_usize>>,
SC: Storage<T, D3, Const<1_usize>>,
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: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: AreMultipliable<R2, C2, R3, C3>,
pub fn gemm<R2, C2, R3, C3, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, 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: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: AreMultipliable<C2, R2, R3, C3>,
pub fn gemm_tr<R2, C2, R3, C3, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, 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: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
ShapeConstraint: AreMultipliable<C2, R2, R3, C3>,
pub fn gemm_ad<R2, C2, R3, C3, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: Storage<T, 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: T,
x: &Matrix<T, D2, Const<1_usize>, SB>,
y: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: One,
SB: Storage<T, D2, Const<1_usize>>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
👎 Deprecated: This is renamed syger
to match the original BLAS terminology.
pub fn ger_symm<D2, D3, SB, SC>(
&mut self,
alpha: T,
x: &Matrix<T, D2, Const<1_usize>, SB>,
y: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: One,
SB: Storage<T, D2, Const<1_usize>>,
SC: Storage<T, D3, Const<1_usize>>,
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: T,
x: &Matrix<T, D2, Const<1_usize>, SB>,
y: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: One,
SB: Storage<T, D2, Const<1_usize>>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
pub fn syger<D2, D3, SB, SC>(
&mut self,
alpha: T,
x: &Matrix<T, D2, Const<1_usize>, SB>,
y: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: One,
SB: Storage<T, D2, Const<1_usize>>,
SC: Storage<T, D3, Const<1_usize>>,
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: T,
x: &Matrix<T, D2, Const<1_usize>, SB>,
y: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: SimdComplexField,
SB: Storage<T, D2, Const<1_usize>>,
SC: Storage<T, D3, Const<1_usize>>,
ShapeConstraint: DimEq<R1, D2>,
ShapeConstraint: DimEq<C1, D3>,
pub fn hegerc<D2, D3, SB, SC>(
&mut self,
alpha: T,
x: &Matrix<T, D2, Const<1_usize>, SB>,
y: &Matrix<T, D3, Const<1_usize>, SC>,
beta: T
) where
D2: Dim,
D3: Dim,
T: SimdComplexField,
SB: Storage<T, D2, Const<1_usize>>,
SC: Storage<T, D3, Const<1_usize>>,
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<T, D2, Const<1_usize>, S2>,
alpha: T,
lhs: &Matrix<T, R3, C3, S3>,
mid: &Matrix<T, D4, D4, S4>,
beta: T
) where
D2: Dim,
R3: Dim,
C3: Dim,
D4: Dim,
S2: StorageMut<T, D2, Const<1_usize>>,
S3: Storage<T, R3, C3>,
S4: Storage<T, D4, D4>,
ShapeConstraint: DimEq<D1, D2>,
ShapeConstraint: DimEq<D1, R3>,
ShapeConstraint: DimEq<D2, R3>,
ShapeConstraint: DimEq<C3, D4>,
pub fn quadform_tr_with_workspace<D2, S2, R3, C3, S3, D4, S4>(
&mut self,
work: &mut Matrix<T, D2, Const<1_usize>, S2>,
alpha: T,
lhs: &Matrix<T, R3, C3, S3>,
mid: &Matrix<T, D4, D4, S4>,
beta: T
) where
D2: Dim,
R3: Dim,
C3: Dim,
D4: Dim,
S2: StorageMut<T, D2, Const<1_usize>>,
S3: Storage<T, R3, C3>,
S4: Storage<T, 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: T,
lhs: &Matrix<T, R3, C3, S3>,
mid: &Matrix<T, D4, D4, S4>,
beta: T
) where
R3: Dim,
C3: Dim,
D4: Dim,
S3: Storage<T, R3, C3>,
S4: Storage<T, D4, D4>,
ShapeConstraint: DimEq<D1, D1>,
ShapeConstraint: DimEq<D1, R3>,
ShapeConstraint: DimEq<C3, D4>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
pub fn quadform_tr<R3, C3, S3, D4, S4>(
&mut self,
alpha: T,
lhs: &Matrix<T, R3, C3, S3>,
mid: &Matrix<T, D4, D4, S4>,
beta: T
) where
R3: Dim,
C3: Dim,
D4: Dim,
S3: Storage<T, R3, C3>,
S4: Storage<T, D4, D4>,
ShapeConstraint: DimEq<D1, D1>,
ShapeConstraint: DimEq<D1, R3>,
ShapeConstraint: DimEq<C3, D4>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
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<T, D2, Const<1_usize>, S2>,
alpha: T,
mid: &Matrix<T, D3, D3, S3>,
rhs: &Matrix<T, R4, C4, S4>,
beta: T
) where
D2: Dim,
D3: Dim,
R4: Dim,
C4: Dim,
S2: StorageMut<T, D2, Const<1_usize>>,
S3: Storage<T, D3, D3>,
S4: Storage<T, R4, C4>,
ShapeConstraint: DimEq<D3, R4>,
ShapeConstraint: DimEq<D1, C4>,
ShapeConstraint: DimEq<D2, D3>,
ShapeConstraint: AreMultipliable<C4, R4, D2, Const<1_usize>>,
pub fn quadform_with_workspace<D2, S2, D3, S3, R4, C4, S4>(
&mut self,
work: &mut Matrix<T, D2, Const<1_usize>, S2>,
alpha: T,
mid: &Matrix<T, D3, D3, S3>,
rhs: &Matrix<T, R4, C4, S4>,
beta: T
) where
D2: Dim,
D3: Dim,
R4: Dim,
C4: Dim,
S2: StorageMut<T, D2, Const<1_usize>>,
S3: Storage<T, D3, D3>,
S4: Storage<T, R4, C4>,
ShapeConstraint: DimEq<D3, R4>,
ShapeConstraint: DimEq<D1, C4>,
ShapeConstraint: DimEq<D2, D3>,
ShapeConstraint: AreMultipliable<C4, R4, D2, Const<1_usize>>,
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: T,
mid: &Matrix<T, D2, D2, S2>,
rhs: &Matrix<T, R3, C3, S3>,
beta: T
) where
D2: Dim,
R3: Dim,
C3: Dim,
S2: Storage<T, D2, D2>,
S3: Storage<T, R3, C3>,
ShapeConstraint: DimEq<D2, R3>,
ShapeConstraint: DimEq<D1, C3>,
ShapeConstraint: AreMultipliable<C3, R3, D2, Const<1_usize>>,
DefaultAllocator: Allocator<T, D2, Const<1_usize>>,
pub fn quadform<D2, S2, R3, C3, S3>(
&mut self,
alpha: T,
mid: &Matrix<T, D2, D2, S2>,
rhs: &Matrix<T, R3, C3, S3>,
beta: T
) where
D2: Dim,
R3: Dim,
C3: Dim,
S2: Storage<T, D2, D2>,
S3: Storage<T, R3, C3>,
ShapeConstraint: DimEq<D2, R3>,
ShapeConstraint: DimEq<D1, C3>,
ShapeConstraint: AreMultipliable<C3, R3, D2, Const<1_usize>>,
DefaultAllocator: Allocator<T, D2, Const<1_usize>>,
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<T, R2, C2, SB>
) -> Matrix<T, C1, C2, <DefaultAllocator as Allocator<T, C1, C2>>::Buffer> where
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
pub fn tr_mul<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> Matrix<T, C1, C2, <DefaultAllocator as Allocator<T, C1, C2>>::Buffer> where
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
Equivalent to self.transpose() * rhs
.
pub fn ad_mul<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> Matrix<T, C1, C2, <DefaultAllocator as Allocator<T, C1, C2>>::Buffer> where
R2: Dim,
C2: Dim,
T: SimdComplexField,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
pub fn ad_mul<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> Matrix<T, C1, C2, <DefaultAllocator as Allocator<T, C1, C2>>::Buffer> where
R2: Dim,
C2: Dim,
T: SimdComplexField,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: DimEq<C1, R3>,
ShapeConstraint: DimEq<C2, C3>,
pub fn tr_mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, 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<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: DimEq<C1, R3>,
ShapeConstraint: DimEq<C2, C3>,
pub fn ad_mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, 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<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1>,
ShapeConstraint: SameNumberOfColumns<C3, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
pub fn mul_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, 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<T, R2, C2, SB>
) -> Matrix<T, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output, <DefaultAllocator as Allocator<T, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>>::Buffer> where
R2: Dim,
C2: Dim,
T: ClosedMul<T>,
R1: DimMul<R2>,
C1: DimMul<C2>,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>,
pub fn kronecker<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> Matrix<T, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output, <DefaultAllocator as Allocator<T, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>>::Buffer> where
R2: Dim,
C2: Dim,
T: ClosedMul<T>,
R1: DimMul<R2>,
C1: DimMul<C2>,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, <R1 as DimMul<R2>>::Output, <C1 as DimMul<C2>>::Output>,
The kronecker product of two matrices (aka. tensor product of the corresponding linear maps).
pub fn new_scaling(
scaling: T
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>
pub fn new_scaling(
scaling: T
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>
Creates a new homogeneous matrix that applies the same scaling factor on each dimension.
pub fn new_nonuniform_scaling<SB>(
scaling: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn new_nonuniform_scaling<SB>(
scaling: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
Creates a new homogeneous matrix that applies a distinct scaling factor for each dimension.
pub fn new_translation<SB>(
translation: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn new_translation<SB>(
translation: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
Creates a new homogeneous matrix that applies a pure translation.
pub fn new_rotation(
angle: T
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 3_usize, 3_usize>>
pub fn new_rotation(
angle: T
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 3_usize, 3_usize>>
Builds a 2 dimensional homogeneous rotation matrix from an angle in radian.
pub fn new_nonuniform_scaling_wrt_point(
scaling: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 2_usize, 1_usize>>,
pt: &OPoint<T, Const<2_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 3_usize, 3_usize>>
pub fn new_nonuniform_scaling_wrt_point(
scaling: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 2_usize, 1_usize>>,
pt: &OPoint<T, Const<2_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 3_usize, 3_usize>>
Creates a new homogeneous matrix that applies a scaling factor for each dimension with respect to point.
Can be used to implement zoom_to
functionality.
pub fn new_rotation(
axisangle: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn new_rotation(
axisangle: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
Returns the identity matrix if the given argument is zero.
pub fn new_rotation_wrt_point(
axisangle: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>,
pt: OPoint<T, Const<3_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn new_rotation_wrt_point(
axisangle: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>,
pt: OPoint<T, Const<3_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
Returns the identity matrix if the given argument is zero.
pub fn new_nonuniform_scaling_wrt_point(
scaling: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>,
pt: &OPoint<T, Const<3_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn new_nonuniform_scaling_wrt_point(
scaling: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>,
pt: &OPoint<T, Const<3_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Creates a new homogeneous matrix that applies a scaling factor for each dimension with respect to point.
Can be used to implement zoom_to
functionality.
pub fn from_scaled_axis(
axisangle: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn from_scaled_axis(
axisangle: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
Returns the identity matrix if the given argument is zero.
This is identical to Self::new_rotation
.
pub fn from_euler_angles(
roll: T,
pitch: T,
yaw: T
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn from_euler_angles(
roll: T,
pitch: T,
yaw: T
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Creates a new rotation from Euler angles.
The primitive rotations are applied in order: 1 roll − 2 pitch − 3 yaw.
pub fn from_axis_angle(
axis: &Unit<Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>>,
angle: T
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn from_axis_angle(
axis: &Unit<Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>>,
angle: T
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Builds a 3D homogeneous rotation matrix from an axis and a rotation angle.
pub fn new_orthographic(
left: T,
right: T,
bottom: T,
top: T,
znear: T,
zfar: T
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn new_orthographic(
left: T,
right: T,
bottom: T,
top: T,
znear: T,
zfar: T
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Creates a new homogeneous matrix for an orthographic projection.
pub fn new_perspective(
aspect: T,
fovy: T,
znear: T,
zfar: T
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn new_perspective(
aspect: T,
fovy: T,
znear: T,
zfar: T
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Creates a new homogeneous matrix for a perspective projection.
pub fn face_towards(
eye: &OPoint<T, Const<3_usize>>,
target: &OPoint<T, Const<3_usize>>,
up: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn face_towards(
eye: &OPoint<T, Const<3_usize>>,
target: &OPoint<T, Const<3_usize>>,
up: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Creates an isometry that corresponds to the local frame of an observer standing at the
point eye
and looking toward target
.
It maps the view direction target - eye
to the positive z
axis and the origin to the
eye
.
pub fn new_observer_frame(
eye: &OPoint<T, Const<3_usize>>,
target: &OPoint<T, Const<3_usize>>,
up: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
👎 Deprecated: renamed to face_towards
pub fn new_observer_frame(
eye: &OPoint<T, Const<3_usize>>,
target: &OPoint<T, Const<3_usize>>,
up: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
renamed to face_towards
Deprecated: Use Matrix4::face_towards
instead.
pub fn look_at_rh(
eye: &OPoint<T, Const<3_usize>>,
target: &OPoint<T, Const<3_usize>>,
up: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn look_at_rh(
eye: &OPoint<T, Const<3_usize>>,
target: &OPoint<T, Const<3_usize>>,
up: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Builds a right-handed look-at view matrix.
pub fn look_at_lh(
eye: &OPoint<T, Const<3_usize>>,
target: &OPoint<T, Const<3_usize>>,
up: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn look_at_lh(
eye: &OPoint<T, Const<3_usize>>,
target: &OPoint<T, Const<3_usize>>,
up: &Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Builds a left-handed look-at view matrix.
pub fn append_scaling(
&self,
scaling: T
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
pub fn append_scaling(
&self,
scaling: T
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
Computes the transformation equal to self
followed by an uniform scaling factor.
pub fn prepend_scaling(
&self,
scaling: T
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
pub fn prepend_scaling(
&self,
scaling: T
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
Computes the transformation equal to an uniform scaling factor followed by self
.
pub fn append_nonuniform_scaling<SB>(
&self,
scaling: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
pub fn append_nonuniform_scaling<SB>(
&self,
scaling: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
Computes the transformation equal to self
followed by a non-uniform scaling factor.
pub fn prepend_nonuniform_scaling<SB>(
&self,
scaling: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
pub fn prepend_nonuniform_scaling<SB>(
&self,
scaling: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
Computes the transformation equal to a non-uniform scaling factor followed by self
.
pub fn append_translation<SB>(
&self,
shift: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
pub fn append_translation<SB>(
&self,
shift: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
Computes the transformation equal to self
followed by a translation.
pub fn prepend_translation<SB>(
&self,
shift: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn prepend_translation<SB>(
&self,
shift: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
Computes the transformation equal to a translation followed by self
.
pub fn append_scaling_mut(&mut self, scaling: T) where
S: StorageMut<T, D, D>,
D: DimNameSub<Const<1_usize>>,
pub fn append_scaling_mut(&mut self, scaling: T) where
S: StorageMut<T, D, D>,
D: DimNameSub<Const<1_usize>>,
Computes in-place the transformation equal to self
followed by an uniform scaling factor.
pub fn prepend_scaling_mut(&mut self, scaling: T) where
S: StorageMut<T, D, D>,
D: DimNameSub<Const<1_usize>>,
pub fn prepend_scaling_mut(&mut self, scaling: T) where
S: StorageMut<T, D, D>,
D: DimNameSub<Const<1_usize>>,
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<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) where
S: StorageMut<T, D, D>,
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn append_nonuniform_scaling_mut<SB>(
&mut self,
scaling: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) where
S: StorageMut<T, D, D>,
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
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<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) where
S: StorageMut<T, D, D>,
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn prepend_nonuniform_scaling_mut<SB>(
&mut self,
scaling: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) where
S: StorageMut<T, D, D>,
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
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<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) where
S: StorageMut<T, D, D>,
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn append_translation_mut<SB>(
&mut self,
shift: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) where
S: StorageMut<T, D, D>,
D: DimNameSub<Const<1_usize>>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
Computes the transformation equal to self
followed by a translation.
pub fn prepend_translation_mut<SB>(
&mut self,
shift: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) where
D: DimNameSub<Const<1_usize>>,
S: StorageMut<T, D, D>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn prepend_translation_mut<SB>(
&mut self,
shift: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, SB>
) where
D: DimNameSub<Const<1_usize>>,
S: StorageMut<T, D, D>,
SB: Storage<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
Computes the transformation equal to a translation followed by self
.
impl<T, D, S> Matrix<T, D, D, S> where
T: RealField,
D: DimNameSub<Const<1_usize>>,
S: Storage<T, D, D>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, <D as DimNameSub<Const<1_usize>>>::Output>,
impl<T, D, S> Matrix<T, D, D, S> where
T: RealField,
D: DimNameSub<Const<1_usize>>,
S: Storage<T, D, D>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, <D as DimNameSub<Const<1_usize>>>::Output>,
pub fn transform_vector(
&self,
v: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
) -> Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
pub fn transform_vector(
&self,
v: &Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
) -> Matrix<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <D as DimNameSub<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
Transforms the given vector, assuming the matrix self
uses homogeneous coordinates.
pub fn abs(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Signed,
DefaultAllocator: Allocator<T, R, C>,
pub fn abs(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Signed,
DefaultAllocator: Allocator<T, 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 component_mul<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer> where
T: ClosedMul<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
pub fn component_mul<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer> where
T: ClosedMul<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, 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: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
) where
T: ClosedMul<T, Output = T> + Zero<Output = T> + Mul<T> + Add<T>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
pub fn cmpy<R2, C2, SB, R3, C3, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
) where
T: ClosedMul<T, Output = T> + Zero<Output = T> + Mul<T> + Add<T>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
SC: Storage<T, 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<T, R2, C2, SB>) where
T: ClosedMul<T>,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
pub fn component_mul_assign<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>) where
T: ClosedMul<T>,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, 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<T, R2, C2, SB>) where
T: ClosedMul<T>,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
👎 Deprecated: This is renamed using the _assign
suffix instead of the _mut
suffix.
pub fn component_mul_mut<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>) where
T: ClosedMul<T>,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, 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<T, R2, C2, SB>
) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer> where
T: ClosedDiv<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
pub fn component_div<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer> where
T: ClosedDiv<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, 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: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
) where
T: ClosedDiv<T> + Zero<Output = T> + Mul<T, Output = T> + Add<T>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
pub fn cdpy<R2, C2, SB, R3, C3, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
) where
T: ClosedDiv<T> + Zero<Output = T> + Mul<T, Output = T> + Add<T>,
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
SC: Storage<T, 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<T, R2, C2, SB>) where
T: ClosedDiv<T>,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
pub fn component_div_assign<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>) where
T: ClosedDiv<T>,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, 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<T, R2, C2, SB>) where
T: ClosedDiv<T>,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
👎 Deprecated: This is renamed using the _assign
suffix instead of the _mut
suffix.
pub fn component_div_mut<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>) where
T: ClosedDiv<T>,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, 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 inf(
&self,
other: &Matrix<T, R1, C1, SA>
) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<T, R1, C1>>::Buffer> where
T: SimdPartialOrd,
DefaultAllocator: Allocator<T, R1, C1>,
pub fn inf(
&self,
other: &Matrix<T, R1, C1, SA>
) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<T, R1, C1>>::Buffer> where
T: SimdPartialOrd,
DefaultAllocator: Allocator<T, R1, C1>,
Computes the infimum (aka. componentwise min) of two matrices/vectors.
Example
let u = Matrix2::new(4.0, 2.0, 1.0, -2.0);
let v = Matrix2::new(2.0, 4.0, -2.0, 1.0);
let expected = Matrix2::new(2.0, 2.0, -2.0, -2.0);
assert_eq!(u.inf(&v), expected)
pub fn sup(
&self,
other: &Matrix<T, R1, C1, SA>
) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<T, R1, C1>>::Buffer> where
T: SimdPartialOrd,
DefaultAllocator: Allocator<T, R1, C1>,
pub fn sup(
&self,
other: &Matrix<T, R1, C1, SA>
) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<T, R1, C1>>::Buffer> where
T: SimdPartialOrd,
DefaultAllocator: Allocator<T, R1, C1>,
Computes the supremum (aka. componentwise max) of two matrices/vectors.
Example
let u = Matrix2::new(4.0, 2.0, 1.0, -2.0);
let v = Matrix2::new(2.0, 4.0, -2.0, 1.0);
let expected = Matrix2::new(4.0, 4.0, 1.0, 1.0);
assert_eq!(u.sup(&v), expected)
pub fn inf_sup(
&self,
other: &Matrix<T, R1, C1, SA>
) -> (Matrix<T, R1, C1, <DefaultAllocator as Allocator<T, R1, C1>>::Buffer>, Matrix<T, R1, C1, <DefaultAllocator as Allocator<T, R1, C1>>::Buffer>) where
T: SimdPartialOrd,
DefaultAllocator: Allocator<T, R1, C1>,
pub fn inf_sup(
&self,
other: &Matrix<T, R1, C1, SA>
) -> (Matrix<T, R1, C1, <DefaultAllocator as Allocator<T, R1, C1>>::Buffer>, Matrix<T, R1, C1, <DefaultAllocator as Allocator<T, R1, C1>>::Buffer>) where
T: SimdPartialOrd,
DefaultAllocator: Allocator<T, R1, C1>,
Computes the (infimum, supremum) of two matrices/vectors.
Example
let u = Matrix2::new(4.0, 2.0, 1.0, -2.0);
let v = Matrix2::new(2.0, 4.0, -2.0, 1.0);
let expected = (Matrix2::new(2.0, 2.0, -2.0, -2.0), Matrix2::new(4.0, 4.0, 1.0, 1.0));
assert_eq!(u.inf_sup(&v), expected)
pub fn add_scalar(
&self,
rhs: T
) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<T, R1, C1>>::Buffer> where
T: ClosedAdd<T>,
DefaultAllocator: Allocator<T, R1, C1>,
pub fn add_scalar(
&self,
rhs: T
) -> Matrix<T, R1, C1, <DefaultAllocator as Allocator<T, R1, C1>>::Buffer> where
T: ClosedAdd<T>,
DefaultAllocator: Allocator<T, R1, C1>,
Adds a scalar to self
.
Example
let u = Matrix2::new(1.0, 2.0, 3.0, 4.0);
let s = 10.0;
let expected = Matrix2::new(11.0, 12.0, 13.0, 14.0);
assert_eq!(u.add_scalar(s), expected)
Adds a scalar to self
in-place.
Example
let mut u = Matrix2::new(1.0, 2.0, 3.0, 4.0);
let s = 10.0;
u.add_scalar_mut(s);
let expected = Matrix2::new(11.0, 12.0, 13.0, 14.0);
assert_eq!(u, expected)
impl<T, R, C> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<T, R, C>>::BufferUninit> where
T: Scalar,
R: Dim,
C: Dim,
DefaultAllocator: Allocator<T, R, C>,
impl<T, R, C> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<T, R, C>>::BufferUninit> where
T: Scalar,
R: Dim,
C: Dim,
DefaultAllocator: Allocator<T, R, C>,
pub fn uninit(
nrows: R,
ncols: C
) -> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<T, R, C>>::BufferUninit>
pub fn uninit(
nrows: R,
ncols: C
) -> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<T, R, C>>::BufferUninit>
Builds a matrix with uninitialized elements of type MaybeUninit<T>
.
impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar,
R: Dim,
C: Dim,
DefaultAllocator: Allocator<T, R, C>,
impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar,
R: Dim,
C: Dim,
DefaultAllocator: Allocator<T, R, C>,
Generic constructors
This set of matrix and vector construction functions are all generic with-regard to the matrix dimensions. They all expect to be given the dimension as inputs.
These functions should only be used when working on dimension-generic code.
pub fn from_element_generic(
nrows: R,
ncols: C,
elem: T
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
pub fn from_element_generic(
nrows: R,
ncols: C,
elem: T
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
Creates a matrix with all its elements set to elem
.
pub fn repeat_generic(
nrows: R,
ncols: C,
elem: T
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
pub fn repeat_generic(
nrows: R,
ncols: C,
elem: T
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
Creates a matrix with all its elements set to elem
.
Same as from_element_generic
.
pub fn zeros_generic(
nrows: R,
ncols: C
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero,
pub fn zeros_generic(
nrows: R,
ncols: C
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero,
Creates a matrix with all its elements set to 0.
pub fn from_iterator_generic<I>(
nrows: R,
ncols: C,
iter: I
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
I: IntoIterator<Item = T>,
pub fn from_iterator_generic<I>(
nrows: R,
ncols: C,
iter: I
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
I: IntoIterator<Item = T>,
Creates a matrix with all its elements filled by an iterator.
pub fn from_row_slice_generic(
nrows: R,
ncols: C,
slice: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
pub fn from_row_slice_generic(
nrows: R,
ncols: C,
slice: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
pub fn from_column_slice_generic(
nrows: R,
ncols: C,
slice: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
pub fn from_column_slice_generic(
nrows: R,
ncols: C,
slice: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice. The components must have the same layout as the matrix data storage (i.e. column-major).
pub fn from_fn_generic<F>(
nrows: R,
ncols: C,
f: F
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
F: FnMut(usize, usize) -> T,
pub fn from_fn_generic<F>(
nrows: R,
ncols: C,
f: F
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
F: FnMut(usize, usize) -> T,
Creates a matrix filled with the results of a function applied to each of its component coordinates.
pub fn identity_generic(
nrows: R,
ncols: C
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero + One,
pub fn identity_generic(
nrows: R,
ncols: C
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero + One,
Creates a new identity matrix.
If the matrix is not square, the largest square submatrix starting at index (0, 0)
is set
to the identity matrix. All other entries are set to zero.
pub fn from_diagonal_element_generic(
nrows: R,
ncols: C,
elt: T
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero + One,
pub fn from_diagonal_element_generic(
nrows: R,
ncols: C,
elt: T
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero + One,
Creates a new matrix with its diagonal filled with copies of elt
.
If the matrix is not square, the largest square submatrix starting at index (0, 0)
is set
to the identity matrix. All other entries are set to zero.
pub fn from_partial_diagonal_generic(
nrows: R,
ncols: C,
elts: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero,
pub fn from_partial_diagonal_generic(
nrows: R,
ncols: C,
elts: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero,
Creates a new matrix that may be rectangular. The first elts.len()
diagonal elements are
filled with the content of elts
. Others are set to 0.
Panics if elts.len()
is larger than the minimum among nrows
and ncols
.
Builds a new matrix from its rows.
Panics if not enough rows are provided (for statically-sized matrices), or if all rows do not have the same dimensions.
Example
let m = Matrix3::from_rows(&[ RowVector3::new(1.0, 2.0, 3.0), RowVector3::new(4.0, 5.0, 6.0), RowVector3::new(7.0, 8.0, 9.0) ]);
assert!(m.m11 == 1.0 && m.m12 == 2.0 && m.m13 == 3.0 &&
m.m21 == 4.0 && m.m22 == 5.0 && m.m23 == 6.0 &&
m.m31 == 7.0 && m.m32 == 8.0 && m.m33 == 9.0);
pub fn from_columns<SB>(
columns: &[Matrix<T, R, Const<1_usize>, SB>]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
SB: RawStorage<T, R, Const<1_usize>>,
pub fn from_columns<SB>(
columns: &[Matrix<T, R, Const<1_usize>, SB>]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
SB: RawStorage<T, R, Const<1_usize>>,
Builds a new matrix from its columns.
Panics if not enough columns are provided (for statically-sized matrices), or if all columns do not have the same dimensions.
Example
let m = Matrix3::from_columns(&[ Vector3::new(1.0, 2.0, 3.0), Vector3::new(4.0, 5.0, 6.0), Vector3::new(7.0, 8.0, 9.0) ]);
assert!(m.m11 == 1.0 && m.m12 == 4.0 && m.m13 == 7.0 &&
m.m21 == 2.0 && m.m22 == 5.0 && m.m23 == 8.0 &&
m.m31 == 3.0 && m.m32 == 6.0 && m.m33 == 9.0);
pub fn from_vec_generic(
nrows: R,
ncols: C,
data: Vec<T, Global>
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
pub fn from_vec_generic(
nrows: R,
ncols: C,
data: Vec<T, Global>
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
Example
let vec = vec![0, 1, 2, 3, 4, 5];
let vec_ptr = vec.as_ptr();
let matrix = Matrix::from_vec_generic(Dynamic::new(vec.len()), Const::<1>, vec);
let matrix_storage_ptr = matrix.data.as_vec().as_ptr();
// `matrix` is backed by exactly the same `Vec` as it was constructed from.
assert_eq!(matrix_storage_ptr, vec_ptr);
impl<T, D> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: Dim,
T: Scalar,
DefaultAllocator: Allocator<T, D, D>,
impl<T, D> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
D: Dim,
T: Scalar,
DefaultAllocator: Allocator<T, D, D>,
pub fn from_diagonal<SB>(
diag: &Matrix<T, D, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
SB: RawStorage<T, D, Const<1_usize>>,
T: Zero,
pub fn from_diagonal<SB>(
diag: &Matrix<T, D, Const<1_usize>, SB>
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
SB: RawStorage<T, D, Const<1_usize>>,
T: Zero,
Creates a square matrix with its diagonal set to diag
and all other entries set to 0.
Example
let m = Matrix3::from_diagonal(&Vector3::new(1.0, 2.0, 3.0));
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal(&DVector::from_row_slice(&[1.0, 2.0, 3.0]));
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 3.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 3.0);
impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<T, R, C>,
impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<T, R, C>,
pub fn from_element(
elem: T
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
pub fn from_element(
elem: T
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Creates a matrix or vector with all its elements set to 0
.
Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
pub fn from_iterator<I>(
iter: I
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
I: IntoIterator<Item = T>,
pub fn from_iterator<I>(
iter: I
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
I: IntoIterator<Item = T>,
Creates a matrix or vector with all its elements filled by an iterator.
The output matrix is filled column-by-column.
Example
let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
pub fn from_diagonal_element(
elt: T
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero + One,
pub fn from_diagonal_element(
elt: T
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero + One,
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
pub fn from_partial_diagonal(
elts: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero,
pub fn from_partial_diagonal(
elts: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Zero,
Creates a new matrix that may be rectangular. The first elts.len()
diagonal
elements are filled with the content of elts
. Others are set to 0.
Panics if elts.len()
is larger than the minimum among nrows
and ncols
.
Example
let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
pub fn from_element(
ncols: usize,
elem: T
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer>
pub fn from_element(
ncols: usize,
elem: T
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Creates a matrix or vector with all its elements set to 0
.
Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
pub fn from_iterator<I>(
ncols: usize,
iter: I
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
I: IntoIterator<Item = T>,
pub fn from_iterator<I>(
ncols: usize,
iter: I
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
I: IntoIterator<Item = T>,
Creates a matrix or vector with all its elements filled by an iterator.
The output matrix is filled column-by-column.
Example
let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
Creates a new matrix that may be rectangular. The first elts.len()
diagonal
elements are filled with the content of elts
. Others are set to 0.
Panics if elts.len()
is larger than the minimum among nrows
and ncols
.
Example
let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
pub fn from_element(
nrows: usize,
elem: T
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer>
pub fn from_element(
nrows: usize,
elem: T
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer>
Creates a matrix or vector with all its elements set to elem
.
Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Creates a matrix or vector with all its elements set to 0
.
Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
pub fn from_iterator<I>(
nrows: usize,
iter: I
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
I: IntoIterator<Item = T>,
pub fn from_iterator<I>(
nrows: usize,
iter: I
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
I: IntoIterator<Item = T>,
Creates a matrix or vector with all its elements filled by an iterator.
The output matrix is filled column-by-column.
Example
let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
Creates a new matrix that may be rectangular. The first elts.len()
diagonal
elements are filled with the content of elts
. Others are set to 0.
Panics if elts.len()
is larger than the minimum among nrows
and ncols
.
Example
let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
Creates a matrix or vector with all its elements set to elem
.
Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
Creates a matrix or vector with all its elements set to 0
.
Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
pub fn from_iterator<I>(
nrows: usize,
ncols: usize,
iter: I
) -> Matrix<T, Dynamic, Dynamic, <DefaultAllocator as Allocator<T, Dynamic, Dynamic>>::Buffer> where
I: IntoIterator<Item = T>,
pub fn from_iterator<I>(
nrows: usize,
ncols: usize,
iter: I
) -> Matrix<T, Dynamic, Dynamic, <DefaultAllocator as Allocator<T, Dynamic, Dynamic>>::Buffer> where
I: IntoIterator<Item = T>,
Creates a matrix or vector with all its elements filled by an iterator.
The output matrix is filled column-by-column.
Example
let v = Vector3::from_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_iterator(2, 3, (0..6).into_iter());
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
Creates a new matrix that may be rectangular. The first elts.len()
diagonal
elements are filled with the content of elts
. Others are set to 0.
Panics if elts.len()
is larger than the minimum among nrows
and ncols
.
Example
let m = Matrix3::from_partial_diagonal(&[1.0, 2.0]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_partial_diagonal(3, 3, &[1.0, 2.0]);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
m.m31 == 0.0 && m.m32 == 0.0 && m.m33 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 0.0 &&
dm[(2, 0)] == 0.0 && dm[(2, 1)] == 0.0 && dm[(2, 2)] == 0.0);
The column vector with val
as its i-th component.
The column unit vector with T::one()
as its i-th component.
The column vector with a 1 as its first component, and zero elsewhere.
The column vector with a 1 as its second component, and zero elsewhere.
The column vector with a 1 as its third component, and zero elsewhere.
The column vector with a 1 as its fourth component, and zero elsewhere.
The column vector with a 1 as its fifth component, and zero elsewhere.
The column vector with a 1 as its sixth component, and zero elsewhere.
The unit column vector with a 1 as its first component, and zero elsewhere.
The unit column vector with a 1 as its second component, and zero elsewhere.
The unit column vector with a 1 as its third component, and zero elsewhere.
The unit column vector with a 1 as its fourth component, and zero elsewhere.
The unit column vector with a 1 as its fifth component, and zero elsewhere.
The unit column vector with a 1 as its sixth component, and zero elsewhere.
pub unsafe fn from_slice_with_strides_generic_unchecked(
data: &'a [T],
start: usize,
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>>
pub unsafe fn from_slice_with_strides_generic_unchecked(
data: &'a [T],
start: usize,
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>>
Creates, without bound-checking, a matrix slice from an array and with dimensions and strides specified by generic types instances.
Safety
This method is unsafe because the input data array is not checked to contain enough elements.
The generic types R
, C
, RStride
, CStride
can either be type-level integers or integers wrapped with Dynamic::new()
.
pub fn from_slice_with_strides_generic(
data: &'a [T],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>>
pub fn from_slice_with_strides_generic(
data: &'a [T],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>>
Creates a matrix slice from an array and with dimensions and strides specified by generic types instances.
Panics if the input data array dose not contain enough elements.
The generic types R
, C
, RStride
, CStride
can either be type-level integers or integers wrapped with Dynamic::new()
.
pub unsafe fn from_slice_generic_unchecked(
data: &'a [T],
start: usize,
nrows: R,
ncols: C
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Const<1_usize>, R>>
pub unsafe fn from_slice_generic_unchecked(
data: &'a [T],
start: usize,
nrows: R,
ncols: C
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Const<1_usize>, R>>
Creates, without bound-checking, a matrix slice from an array and with dimensions specified by generic types instances.
Safety
This method is unsafe because the input data array is not checked to contain enough elements.
The generic types R
and C
can either be type-level integers or integers wrapped with Dynamic::new()
.
pub fn from_slice_generic(
data: &'a [T],
nrows: R,
ncols: C
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Const<1_usize>, R>>
pub fn from_slice_generic(
data: &'a [T],
nrows: R,
ncols: C
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Const<1_usize>, R>>
Creates a matrix slice from an array and with dimensions and strides specified by generic types instances.
Panics if the input data array dose not contain enough elements.
The generic types R
and C
can either be type-level integers or integers wrapped with Dynamic::new()
.
pub unsafe fn from_slice_with_strides_generic_unchecked(
data: &'a mut [T],
start: usize,
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>
pub unsafe fn from_slice_with_strides_generic_unchecked(
data: &'a mut [T],
start: usize,
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>
Creates, without bound-checking, a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.
Safety
This method is unsafe because the input data array is not checked to contain enough elements.
The generic types R
, C
, RStride
, CStride
can either be type-level integers or integers wrapped with Dynamic::new()
.
pub fn from_slice_with_strides_generic(
data: &'a mut [T],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>
pub fn from_slice_with_strides_generic(
data: &'a mut [T],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>
Creates a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.
Panics if the input data array dose not contain enough elements.
The generic types R
, C
, RStride
, CStride
can either be type-level integers or integers wrapped with Dynamic::new()
.
pub unsafe fn from_slice_generic_unchecked(
data: &'a mut [T],
start: usize,
nrows: R,
ncols: C
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Const<1_usize>, R>>
pub unsafe fn from_slice_generic_unchecked(
data: &'a mut [T],
start: usize,
nrows: R,
ncols: C
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Const<1_usize>, R>>
Creates, without bound-checking, a mutable matrix slice from an array and with dimensions specified by generic types instances.
Safety
This method is unsafe because the input data array is not checked to contain enough elements.
The generic types R
and C
can either be type-level integers or integers wrapped with Dynamic::new()
.
pub fn from_slice_generic(
data: &'a mut [T],
nrows: R,
ncols: C
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Const<1_usize>, R>>
pub fn from_slice_generic(
data: &'a mut [T],
nrows: R,
ncols: C
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Const<1_usize>, R>>
Creates a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.
Panics if the input data array dose not contain enough elements.
The generic types R
and C
can either be type-level integers or integers wrapped with Dynamic::new()
.
pub fn upper_triangle(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
DefaultAllocator: Allocator<T, R, C>,
pub fn upper_triangle(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
DefaultAllocator: Allocator<T, R, C>,
Extracts the upper triangular part of this matrix (including the diagonal).
pub fn lower_triangle(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
DefaultAllocator: Allocator<T, R, C>,
pub fn lower_triangle(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
DefaultAllocator: Allocator<T, R, C>,
Extracts the lower triangular part of this matrix (including the diagonal).
pub fn select_rows<'a, I>(
&self,
irows: I
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
I: IntoIterator<Item = &'a usize>,
<I as IntoIterator>::IntoIter: ExactSizeIterator,
<I as IntoIterator>::IntoIter: Clone,
DefaultAllocator: Allocator<T, Dynamic, C>,
pub fn select_rows<'a, I>(
&self,
irows: I
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
I: IntoIterator<Item = &'a usize>,
<I as IntoIterator>::IntoIter: ExactSizeIterator,
<I as IntoIterator>::IntoIter: Clone,
DefaultAllocator: Allocator<T, Dynamic, C>,
Creates a new matrix by extracting the given set of rows from self
.
pub fn select_columns<'a, I>(
&self,
icols: I
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
I: IntoIterator<Item = &'a usize>,
<I as IntoIterator>::IntoIter: ExactSizeIterator,
DefaultAllocator: Allocator<T, R, Dynamic>,
pub fn select_columns<'a, I>(
&self,
icols: I
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
I: IntoIterator<Item = &'a usize>,
<I as IntoIterator>::IntoIter: ExactSizeIterator,
DefaultAllocator: Allocator<T, R, Dynamic>,
Creates a new matrix by extracting the given set of columns from self
.
pub fn set_diagonal<R2, S2>(&mut self, diag: &Matrix<T, R2, Const<1_usize>, S2>) where
R2: Dim,
R: DimMin<C>,
S2: RawStorage<T, R2, Const<1_usize>>,
ShapeConstraint: DimEq<<R as DimMin<C>>::Output, R2>,
pub fn set_diagonal<R2, S2>(&mut self, diag: &Matrix<T, R2, Const<1_usize>, S2>) where
R2: Dim,
R: DimMin<C>,
S2: RawStorage<T, R2, Const<1_usize>>,
ShapeConstraint: DimEq<<R as DimMin<C>>::Output, R2>,
Fills the diagonal of this matrix with the content of the given vector.
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<T, Const<1_usize>, C2, S2>
) where
C2: Dim,
S2: RawStorage<T, Const<1_usize>, C2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn set_row<C2, S2>(
&mut self,
i: usize,
row: &Matrix<T, Const<1_usize>, C2, S2>
) where
C2: Dim,
S2: RawStorage<T, Const<1_usize>, 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<T, R2, Const<1_usize>, S2>
) where
R2: Dim,
S2: RawStorage<T, R2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<R, R2>,
pub fn set_column<R2, S2>(
&mut self,
i: usize,
column: &Matrix<T, R2, Const<1_usize>, S2>
) where
R2: Dim,
S2: RawStorage<T, R2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<R, R2>,
Fills the selected column of this matrix with the content of the given vector.
Sets all the elements of this matrix to the value returned by the closure.
Fills self
with the identity matrix.
Sets all the diagonal elements of this matrix to val
.
Sets all the elements of the selected row to val
.
Sets all the elements of the selected column to val
.
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.
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.
Copies the upper-triangle of this matrix to its lower-triangular part.
This makes the matrix symmetric. Panics if the matrix is not square.
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 remove_column(
self,
i: usize
) -> Matrix<T, R, <C as DimSub<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, R, <C as DimSub<Const<1_usize>>>::Output>>::Buffer> where
C: DimSub<Const<1_usize>>,
DefaultAllocator: Reallocator<T, R, C, R, <C as DimSub<Const<1_usize>>>::Output>,
pub fn remove_column(
self,
i: usize
) -> Matrix<T, R, <C as DimSub<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, R, <C as DimSub<Const<1_usize>>>::Output>>::Buffer> where
C: DimSub<Const<1_usize>>,
DefaultAllocator: Reallocator<T, R, C, R, <C as DimSub<Const<1_usize>>>::Output>,
Removes the i
-th column from this matrix.
pub fn remove_columns_at(
self,
indices: &[usize]
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
C: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
pub fn remove_columns_at(
self,
indices: &[usize]
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
C: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
Removes all columns in indices
pub fn remove_rows_at(
self,
indices: &[usize]
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
R: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
pub fn remove_rows_at(
self,
indices: &[usize]
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
R: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
Removes all rows in indices
Removes D::dim()
consecutive columns from this matrix, starting with the i
-th
(included).
pub fn remove_columns(
self,
i: usize,
n: usize
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
C: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
pub fn remove_columns(
self,
i: usize,
n: usize
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
C: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
Removes n
consecutive columns from this matrix, starting with the i
-th (included).
pub fn remove_columns_generic<D>(
self,
i: usize,
nremove: D
) -> Matrix<T, R, <C as DimSub<D>>::Output, <DefaultAllocator as Allocator<T, R, <C as DimSub<D>>::Output>>::Buffer> where
D: Dim,
C: DimSub<D>,
DefaultAllocator: Reallocator<T, R, C, R, <C as DimSub<D>>::Output>,
pub fn remove_columns_generic<D>(
self,
i: usize,
nremove: D
) -> Matrix<T, R, <C as DimSub<D>>::Output, <DefaultAllocator as Allocator<T, R, <C as DimSub<D>>::Output>>::Buffer> where
D: Dim,
C: DimSub<D>,
DefaultAllocator: Reallocator<T, R, C, R, <C as DimSub<D>>::Output>,
Removes nremove.value()
columns from this matrix, starting with the i
-th (included).
This is the generic implementation of .remove_columns(...)
and
.remove_fixed_columns(...)
which have nicer API interfaces.
pub fn remove_row(
self,
i: usize
) -> Matrix<T, <R as DimSub<Const<1_usize>>>::Output, C, <DefaultAllocator as Allocator<T, <R as DimSub<Const<1_usize>>>::Output, C>>::Buffer> where
R: DimSub<Const<1_usize>>,
DefaultAllocator: Reallocator<T, R, C, <R as DimSub<Const<1_usize>>>::Output, C>,
pub fn remove_row(
self,
i: usize
) -> Matrix<T, <R as DimSub<Const<1_usize>>>::Output, C, <DefaultAllocator as Allocator<T, <R as DimSub<Const<1_usize>>>::Output, C>>::Buffer> where
R: DimSub<Const<1_usize>>,
DefaultAllocator: Reallocator<T, R, C, <R as DimSub<Const<1_usize>>>::Output, C>,
Removes the i
-th row from this matrix.
Removes D::dim()
consecutive rows from this matrix, starting with the i
-th (included).
pub fn remove_rows(
self,
i: usize,
n: usize
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
R: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
pub fn remove_rows(
self,
i: usize,
n: usize
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
R: DimSub<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
Removes n
consecutive rows from this matrix, starting with the i
-th (included).
pub fn remove_rows_generic<D>(
self,
i: usize,
nremove: D
) -> Matrix<T, <R as DimSub<D>>::Output, C, <DefaultAllocator as Allocator<T, <R as DimSub<D>>::Output, C>>::Buffer> where
D: Dim,
R: DimSub<D>,
DefaultAllocator: Reallocator<T, R, C, <R as DimSub<D>>::Output, C>,
pub fn remove_rows_generic<D>(
self,
i: usize,
nremove: D
) -> Matrix<T, <R as DimSub<D>>::Output, C, <DefaultAllocator as Allocator<T, <R as DimSub<D>>::Output, C>>::Buffer> where
D: Dim,
R: DimSub<D>,
DefaultAllocator: Reallocator<T, R, C, <R as DimSub<D>>::Output, C>,
Removes nremove.value()
rows from this matrix, starting with the i
-th (included).
This is the generic implementation of .remove_rows(...)
and .remove_fixed_rows(...)
which have nicer API interfaces.
pub fn insert_column(
self,
i: usize,
val: T
) -> Matrix<T, R, <C as DimAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, R, <C as DimAdd<Const<1_usize>>>::Output>>::Buffer> where
C: DimAdd<Const<1_usize>>,
DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<Const<1_usize>>>::Output>,
pub fn insert_column(
self,
i: usize,
val: T
) -> Matrix<T, R, <C as DimAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, R, <C as DimAdd<Const<1_usize>>>::Output>>::Buffer> where
C: DimAdd<Const<1_usize>>,
DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<Const<1_usize>>>::Output>,
Inserts a column filled with val
at the i-th
position.
pub fn insert_fixed_columns<const D: usize>(
self,
i: usize,
val: T
) -> Matrix<T, R, <C as DimAdd<Const<D>>>::Output, <DefaultAllocator as Allocator<T, R, <C as DimAdd<Const<D>>>::Output>>::Buffer> where
C: DimAdd<Const<D>>,
DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<Const<D>>>::Output>,
pub fn insert_fixed_columns<const D: usize>(
self,
i: usize,
val: T
) -> Matrix<T, R, <C as DimAdd<Const<D>>>::Output, <DefaultAllocator as Allocator<T, R, <C as DimAdd<Const<D>>>::Output>>::Buffer> where
C: DimAdd<Const<D>>,
DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<Const<D>>>::Output>,
Inserts D
columns filled with val
starting at the i-th
position.
pub fn insert_columns(
self,
i: usize,
n: usize,
val: T
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
C: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
pub fn insert_columns(
self,
i: usize,
n: usize,
val: T
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
C: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
Inserts n
columns filled with val
starting at the i-th
position.
pub unsafe fn insert_columns_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> Matrix<MaybeUninit<T>, R, <C as DimAdd<D>>::Output, <DefaultAllocator as Allocator<T, R, <C as DimAdd<D>>::Output>>::BufferUninit> where
D: Dim,
C: DimAdd<D>,
DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<D>>::Output>,
pub unsafe fn insert_columns_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> Matrix<MaybeUninit<T>, R, <C as DimAdd<D>>::Output, <DefaultAllocator as Allocator<T, R, <C as DimAdd<D>>::Output>>::BufferUninit> where
D: Dim,
C: DimAdd<D>,
DefaultAllocator: Reallocator<T, R, C, R, <C as DimAdd<D>>::Output>,
Inserts ninsert.value()
columns starting at the i-th
place of this matrix.
Safety
The output matrix has all its elements initialized except for the the components of the added columns.
pub fn insert_row(
self,
i: usize,
val: T
) -> Matrix<T, <R as DimAdd<Const<1_usize>>>::Output, C, <DefaultAllocator as Allocator<T, <R as DimAdd<Const<1_usize>>>::Output, C>>::Buffer> where
R: DimAdd<Const<1_usize>>,
DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<Const<1_usize>>>::Output, C>,
pub fn insert_row(
self,
i: usize,
val: T
) -> Matrix<T, <R as DimAdd<Const<1_usize>>>::Output, C, <DefaultAllocator as Allocator<T, <R as DimAdd<Const<1_usize>>>::Output, C>>::Buffer> where
R: DimAdd<Const<1_usize>>,
DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<Const<1_usize>>>::Output, C>,
Inserts a row filled with val
at the i-th
position.
pub fn insert_fixed_rows<const D: usize>(
self,
i: usize,
val: T
) -> Matrix<T, <R as DimAdd<Const<D>>>::Output, C, <DefaultAllocator as Allocator<T, <R as DimAdd<Const<D>>>::Output, C>>::Buffer> where
R: DimAdd<Const<D>>,
DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<Const<D>>>::Output, C>,
pub fn insert_fixed_rows<const D: usize>(
self,
i: usize,
val: T
) -> Matrix<T, <R as DimAdd<Const<D>>>::Output, C, <DefaultAllocator as Allocator<T, <R as DimAdd<Const<D>>>::Output, C>>::Buffer> where
R: DimAdd<Const<D>>,
DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<Const<D>>>::Output, C>,
Inserts D::dim()
rows filled with val
starting at the i-th
position.
pub fn insert_rows(
self,
i: usize,
n: usize,
val: T
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
R: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
pub fn insert_rows(
self,
i: usize,
n: usize,
val: T
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
R: DimAdd<Dynamic, Output = Dynamic>,
DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
Inserts n
rows filled with val
starting at the i-th
position.
pub unsafe fn insert_rows_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> Matrix<MaybeUninit<T>, <R as DimAdd<D>>::Output, C, <DefaultAllocator as Allocator<T, <R as DimAdd<D>>::Output, C>>::BufferUninit> where
D: Dim,
R: DimAdd<D>,
DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<D>>::Output, C>,
pub unsafe fn insert_rows_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> Matrix<MaybeUninit<T>, <R as DimAdd<D>>::Output, C, <DefaultAllocator as Allocator<T, <R as DimAdd<D>>::Output, C>>::BufferUninit> where
D: Dim,
R: DimAdd<D>,
DefaultAllocator: Reallocator<T, R, C, <R as DimAdd<D>>::Output, C>,
Inserts ninsert.value()
rows at the i-th
place of this matrix.
Safety
The added rows values are not initialized.
This is the generic implementation of .insert_rows(...)
and
.insert_fixed_rows(...)
which have nicer API interfaces.
Resizes this matrix so that it contains new_nrows
rows and new_ncols
columns.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
rows and/or columns than self
, then the extra rows or columns are filled with val
.
pub fn resize_vertically(
self,
new_nrows: usize,
val: T
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
pub fn resize_vertically(
self,
new_nrows: usize,
val: T
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer> where
DefaultAllocator: Reallocator<T, R, C, Dynamic, C>,
Resizes this matrix vertically, i.e., so that it contains new_nrows
rows while keeping the same number of columns.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
rows than self
, then the extra rows are filled with val
.
pub fn resize_horizontally(
self,
new_ncols: usize,
val: T
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
pub fn resize_horizontally(
self,
new_ncols: usize,
val: T
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer> where
DefaultAllocator: Reallocator<T, R, C, R, Dynamic>,
Resizes this matrix horizontally, i.e., so that it contains new_ncolumns
columns while keeping the same number of columns.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
columns than self
, then the extra columns are filled with val
.
pub fn fixed_resize<const R2: usize, const C2: usize>(
self,
val: T
) -> Matrix<T, Const<R2>, Const<C2>, <DefaultAllocator as Allocator<T, Const<R2>, Const<C2>>>::Buffer> where
DefaultAllocator: Reallocator<T, R, C, Const<R2>, Const<C2>>,
pub fn fixed_resize<const R2: usize, const C2: usize>(
self,
val: T
) -> Matrix<T, Const<R2>, Const<C2>, <DefaultAllocator as Allocator<T, Const<R2>, Const<C2>>>::Buffer> where
DefaultAllocator: Reallocator<T, R, C, Const<R2>, Const<C2>>,
Resizes this matrix so that it contains R2::value()
rows and C2::value()
columns.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
rows and/or columns than self
, then the extra rows or columns are filled with val
.
pub fn resize_generic<R2, C2>(
self,
new_nrows: R2,
new_ncols: C2,
val: T
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
DefaultAllocator: Reallocator<T, R, C, R2, C2>,
pub fn resize_generic<R2, C2>(
self,
new_nrows: R2,
new_ncols: C2,
val: T
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
DefaultAllocator: Reallocator<T, R, C, R2, C2>,
Resizes self
such that it has dimensions new_nrows × new_ncols
.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
rows and/or columns than self
, then the extra rows or columns are filled with val
.
pub fn reshape_generic<R2, C2>(
self,
new_nrows: R2,
new_ncols: C2
) -> Matrix<T, R2, C2, <S as ReshapableStorage<T, R, C, R2, C2>>::Output> where
R2: Dim,
C2: Dim,
S: ReshapableStorage<T, R, C, R2, C2>,
pub fn reshape_generic<R2, C2>(
self,
new_nrows: R2,
new_ncols: C2
) -> Matrix<T, R2, C2, <S as ReshapableStorage<T, R, C, R2, C2>>::Output> where
R2: Dim,
C2: Dim,
S: ReshapableStorage<T, R, C, R2, C2>,
Reshapes self
such that it has dimensions new_nrows × new_ncols
.
This will reinterpret self
as if it is a matrix with new_nrows
rows and new_ncols
columns. The arrangements of the component in the output matrix are the same as what
would be obtained by Matrix::from_slice_generic(self.as_slice(), new_nrows, new_ncols)
.
If self
is a dynamically-sized matrix, then its components are neither copied nor moved.
If self
is staticyll-sized, then a copy may happen in some situations.
This function will panic if the given dimensions are such that the number of elements of
the input matrix are not equal to the number of elements of the output matrix.
Examples
let m1 = Matrix2x3::new(
1.1, 1.2, 1.3,
2.1, 2.2, 2.3
);
let m2 = Matrix3x2::new(
1.1, 2.2,
2.1, 1.3,
1.2, 2.3
);
let reshaped = m1.reshape_generic(Const::<3>, Const::<2>);
assert_eq!(reshaped, m2);
let dm1 = DMatrix::from_row_slice(
4,
3,
&[
1.0, 0.0, 0.0,
0.0, 0.0, 1.0,
0.0, 0.0, 0.0,
0.0, 1.0, 0.0
],
);
let dm2 = DMatrix::from_row_slice(
6,
2,
&[
1.0, 0.0,
0.0, 1.0,
0.0, 0.0,
0.0, 1.0,
0.0, 0.0,
0.0, 0.0,
],
);
let reshaped = dm1.reshape_generic(Dynamic::new(6), Dynamic::new(2));
assert_eq!(reshaped, dm2);
pub fn resize_mut(&mut self, new_nrows: usize, new_ncols: usize, val: T) where
DefaultAllocator: Reallocator<T, Dynamic, Dynamic, Dynamic, Dynamic>,
pub fn resize_mut(&mut self, new_nrows: usize, new_ncols: usize, val: T) where
DefaultAllocator: Reallocator<T, Dynamic, Dynamic, Dynamic, Dynamic>,
Resizes this matrix in-place.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
rows and/or columns than self
, then the extra rows or columns are filled with val
.
Defined only for owned fully-dynamic matrices, i.e., DMatrix
.
pub fn resize_vertically_mut(&mut self, new_nrows: usize, val: T) where
DefaultAllocator: Reallocator<T, Dynamic, C, Dynamic, C>,
pub fn resize_vertically_mut(&mut self, new_nrows: usize, val: T) where
DefaultAllocator: Reallocator<T, Dynamic, C, Dynamic, C>,
Changes the number of rows of this matrix in-place.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
rows than self
, then the extra rows are filled with val
.
Defined only for owned matrices with a dynamic number of rows (for example, DVector
).
pub fn resize_horizontally_mut(&mut self, new_ncols: usize, val: T) where
DefaultAllocator: Reallocator<T, R, Dynamic, R, Dynamic>,
pub fn resize_horizontally_mut(&mut self, new_ncols: usize, val: T) where
DefaultAllocator: Reallocator<T, R, Dynamic, R, Dynamic>,
Changes the number of column of this matrix in-place.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
columns than self
, then the extra columns are filled with val
.
Defined only for owned matrices with a dynamic number of columns (for example, DVector
).
Slicing based on ranges
Indices to Individual Elements
Two-Dimensional Indices
let matrix = Matrix2::new(0, 2,
1, 3);
assert_eq!(matrix.index((0, 0)), &0);
assert_eq!(matrix.index((1, 0)), &1);
assert_eq!(matrix.index((0, 1)), &2);
assert_eq!(matrix.index((1, 1)), &3);
Linear Address Indexing
let matrix = Matrix2::new(0, 2,
1, 3);
assert_eq!(matrix.get(0), Some(&0));
assert_eq!(matrix.get(1), Some(&1));
assert_eq!(matrix.get(2), Some(&2));
assert_eq!(matrix.get(3), Some(&3));
Indices to Individual Rows and Columns
Index to a Row
let matrix = Matrix2::new(0, 2,
1, 3);
assert!(matrix.index((0, ..))
.eq(&Matrix1x2::new(0, 2)));
Index to a Column
let matrix = Matrix2::new(0, 2,
1, 3);
assert!(matrix.index((.., 0))
.eq(&Matrix2x1::new(0,
1)));
Indices to Parts of Individual Rows and Columns
Index to a Partial Row
let matrix = Matrix3::new(0, 3, 6,
1, 4, 7,
2, 5, 8);
assert!(matrix.index((0, ..2))
.eq(&Matrix1x2::new(0, 3)));
Index to a Partial Column
let matrix = Matrix3::new(0, 3, 6,
1, 4, 7,
2, 5, 8);
assert!(matrix.index((..2, 0))
.eq(&Matrix2x1::new(0,
1)));
assert!(matrix.index((Const::<1>.., 0))
.eq(&Matrix2x1::new(1,
2)));
Indices to Ranges of Rows and Columns
Index to a Range of Rows
let matrix = Matrix3::new(0, 3, 6,
1, 4, 7,
2, 5, 8);
assert!(matrix.index((1..3, ..))
.eq(&Matrix2x3::new(1, 4, 7,
2, 5, 8)));
Index to a Range of Columns
let matrix = Matrix3::new(0, 3, 6,
1, 4, 7,
2, 5, 8);
assert!(matrix.index((.., 1..3))
.eq(&Matrix3x2::new(3, 6,
4, 7,
5, 8)));
pub fn get<'a, I>(
&'a self,
index: I
) -> Option<<I as MatrixIndex<'a, T, R, C, S>>::Output> where
I: MatrixIndex<'a, T, R, C, S>,
pub fn get<'a, I>(
&'a self,
index: I
) -> Option<<I as MatrixIndex<'a, T, R, C, S>>::Output> where
I: MatrixIndex<'a, T, 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, T, R, C, S>>::OutputMut> where
S: RawStorageMut<T, R, C>,
I: MatrixIndexMut<'a, T, R, C, S>,
pub fn get_mut<'a, I>(
&'a mut self,
index: I
) -> Option<<I as MatrixIndexMut<'a, T, R, C, S>>::OutputMut> where
S: RawStorageMut<T, R, C>,
I: MatrixIndexMut<'a, T, R, C, S>,
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, T, R, C, S>>::Output where
I: MatrixIndex<'a, T, R, C, S>,
pub fn index<'a, I>(
&'a self,
index: I
) -> <I as MatrixIndex<'a, T, R, C, S>>::Output where
I: MatrixIndex<'a, T, 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, T, R, C, S>>::OutputMut where
S: RawStorageMut<T, R, C>,
I: MatrixIndexMut<'a, T, R, C, S>,
pub fn index_mut<'a, I>(
&'a mut self,
index: I
) -> <I as MatrixIndexMut<'a, T, R, C, S>>::OutputMut where
S: RawStorageMut<T, R, C>,
I: MatrixIndexMut<'a, T, R, C, S>,
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, T, R, C, S>>::Output where
I: MatrixIndex<'a, T, R, C, S>,
pub unsafe fn get_unchecked<'a, I>(
&'a self,
index: I
) -> <I as MatrixIndex<'a, T, R, C, S>>::Output where
I: MatrixIndex<'a, T, 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, T, R, C, S>>::OutputMut where
S: RawStorageMut<T, R, C>,
I: MatrixIndexMut<'a, T, R, C, S>,
pub unsafe fn get_unchecked_mut<'a, I>(
&'a mut self,
index: I
) -> <I as MatrixIndexMut<'a, T, R, C, S>>::OutputMut where
S: RawStorageMut<T, R, C>,
I: MatrixIndexMut<'a, T, R, C, S>,
Returns a mutable view of the data at the given index, without doing any bounds checking.
Creates a new matrix with the given data without statically checking that the matrix dimension matches the storage dimension.
pub const fn from_array_storage(
storage: ArrayStorage<T, R, C>
) -> Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
pub const fn from_array_storage(
storage: ArrayStorage<T, R, C>
) -> Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
Creates a new statically-allocated matrix from the given ArrayStorage
.
This method exists primarily as a workaround for the fact that from_data
can not
work in const fn
contexts.
pub const fn from_vec_storage(
storage: VecStorage<T, Dynamic, Dynamic>
) -> Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>
pub const fn from_vec_storage(
storage: VecStorage<T, Dynamic, Dynamic>
) -> Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>
Creates a new heap-allocated matrix from the given VecStorage
.
This method exists primarily as a workaround for the fact that from_data
can not
work in const fn
contexts.
pub const fn from_vec_storage(
storage: VecStorage<T, Dynamic, Const<1_usize>>
) -> Matrix<T, Dynamic, Const<1_usize>, VecStorage<T, Dynamic, Const<1_usize>>>
pub const fn from_vec_storage(
storage: VecStorage<T, Dynamic, Const<1_usize>>
) -> Matrix<T, Dynamic, Const<1_usize>, VecStorage<T, Dynamic, Const<1_usize>>>
Creates a new heap-allocated matrix from the given VecStorage
.
This method exists primarily as a workaround for the fact that from_data
can not
work in const fn
contexts.
impl<T, R, C> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<T, R, C>>::BufferUninit> where
R: Dim,
C: Dim,
DefaultAllocator: Allocator<T, R, C>,
impl<T, R, C> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<T, R, C>>::BufferUninit> where
R: Dim,
C: Dim,
DefaultAllocator: Allocator<T, R, C>,
pub unsafe fn assume_init(
self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
pub unsafe fn assume_init(
self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
Assumes a matrix’s entries to be initialized. This operation should be near zero-cost.
For the similar method that operates on matrix slices, see [slice_assume_init
].
Safety
The user must make sure that every single entry of the buffer has been initialized, or Undefined Behavior will immediately occur.
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));
The shape of this matrix wrapped into their representative types (Const
or Dynamic
).
The number of rows of this matrix.
Examples:
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.nrows(), 3);
The number of columns of this matrix.
Examples:
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.ncols(), 4);
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));
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]);
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<T, R2, C2, SB>,
eps: <T as AbsDiffEq<T>>::Epsilon,
max_relative: <T as AbsDiffEq<T>>::Epsilon
) -> bool where
T: RelativeEq<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
<T as AbsDiffEq<T>>::Epsilon: Clone,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn relative_eq<R2, C2, SB>(
&self,
other: &Matrix<T, R2, C2, SB>,
eps: <T as AbsDiffEq<T>>::Epsilon,
max_relative: <T as AbsDiffEq<T>>::Epsilon
) -> bool where
T: RelativeEq<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
<T as AbsDiffEq<T>>::Epsilon: Clone,
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<T, R2, C2, SB>) -> bool where
T: PartialEq<T>,
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn eq<R2, C2, SB>(&self, other: &Matrix<T, R2, C2, SB>) -> bool where
T: PartialEq<T>,
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are exactly equal.
pub fn into_owned(
self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar,
S: Storage<T, R, C>,
DefaultAllocator: Allocator<T, R, C>,
pub fn into_owned(
self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar,
S: Storage<T, R, C>,
DefaultAllocator: Allocator<T, R, C>,
Moves this matrix into one that owns its data.
pub fn into_owned_sum<R2, C2>(
self
) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where
T: Scalar,
S: Storage<T, R, C>,
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<T, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn into_owned_sum<R2, C2>(
self
) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where
T: Scalar,
S: Storage<T, R, C>,
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<T, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Moves this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.
pub fn clone_owned(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar,
S: Storage<T, R, C>,
DefaultAllocator: Allocator<T, R, C>,
pub fn clone_owned(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar,
S: Storage<T, R, C>,
DefaultAllocator: Allocator<T, R, C>,
Clones this matrix to one that owns its data.
pub fn clone_owned_sum<R2, C2>(
&self
) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where
T: Scalar,
S: Storage<T, R, C>,
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<T, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn clone_owned_sum<R2, C2>(
&self
) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where
T: Scalar,
S: Storage<T, R, C>,
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<T, 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 transpose_to<R2, C2, SB>(&self, out: &mut Matrix<T, R2, C2, SB>) where
T: Scalar,
R2: Dim,
C2: Dim,
SB: RawStorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
pub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<T, R2, C2, SB>) where
T: Scalar,
R2: Dim,
C2: Dim,
SB: RawStorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
Transposes self
and store the result into out
.
pub fn transpose(
&self
) -> Matrix<T, C, R, <DefaultAllocator as Allocator<T, C, R>>::Buffer> where
T: Scalar,
DefaultAllocator: Allocator<T, C, R>,
pub fn transpose(
&self
) -> Matrix<T, C, R, <DefaultAllocator as Allocator<T, C, R>>::Buffer> where
T: Scalar,
DefaultAllocator: Allocator<T, C, R>,
Transposes self
.
Returns a matrix containing the result of f
applied to each of its entries.
pub fn cast<T2>(
self
) -> Matrix<T2, R, C, <DefaultAllocator as Allocator<T2, R, C>>::Buffer> where
T2: Scalar,
T: Scalar,
Matrix<T2, R, C, <DefaultAllocator as Allocator<T2, R, C>>::Buffer>: SupersetOf<Matrix<T, R, C, S>>,
DefaultAllocator: Allocator<T2, R, C>,
pub fn cast<T2>(
self
) -> Matrix<T2, R, C, <DefaultAllocator as Allocator<T2, R, C>>::Buffer> where
T2: Scalar,
T: Scalar,
Matrix<T2, R, C, <DefaultAllocator as Allocator<T2, R, C>>::Buffer>: SupersetOf<Matrix<T, R, C, S>>,
DefaultAllocator: Allocator<T2, R, C>,
Cast the components of self
to another type.
Example
let q = Vector3::new(1.0f64, 2.0, 3.0);
let q2 = q.cast::<f32>();
assert_eq!(q2, Vector3::new(1.0f32, 2.0, 3.0));
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<T2, F>(
&self,
f: F
) -> Matrix<T2, R, C, <DefaultAllocator as Allocator<T2, R, C>>::Buffer> where
T2: Scalar,
F: FnMut(usize, usize, T) -> T2,
T: Scalar,
DefaultAllocator: Allocator<T2, R, C>,
pub fn map_with_location<T2, F>(
&self,
f: F
) -> Matrix<T2, R, C, <DefaultAllocator as Allocator<T2, R, C>>::Buffer> where
T2: Scalar,
F: FnMut(usize, usize, T) -> T2,
T: Scalar,
DefaultAllocator: Allocator<T2, 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<T2, N3, S2, F>(
&self,
rhs: &Matrix<T2, R, C, S2>,
f: F
) -> Matrix<N3, R, C, <DefaultAllocator as Allocator<N3, R, C>>::Buffer> where
T: Scalar,
T2: Scalar,
N3: Scalar,
S2: RawStorage<T2, R, C>,
F: FnMut(T, T2) -> N3,
DefaultAllocator: Allocator<N3, R, C>,
pub fn zip_map<T2, N3, S2, F>(
&self,
rhs: &Matrix<T2, R, C, S2>,
f: F
) -> Matrix<N3, R, C, <DefaultAllocator as Allocator<N3, R, C>>::Buffer> where
T: Scalar,
T2: Scalar,
N3: Scalar,
S2: RawStorage<T2, R, C>,
F: FnMut(T, T2) -> N3,
DefaultAllocator: Allocator<N3, R, C>,
Returns a matrix containing the result of f
applied to each entries of self
and
rhs
.
pub fn zip_zip_map<T2, N3, N4, S2, S3, F>(
&self,
b: &Matrix<T2, R, C, S2>,
c: &Matrix<N3, R, C, S3>,
f: F
) -> Matrix<N4, R, C, <DefaultAllocator as Allocator<N4, R, C>>::Buffer> where
T: Scalar,
T2: Scalar,
N3: Scalar,
N4: Scalar,
S2: RawStorage<T2, R, C>,
S3: RawStorage<N3, R, C>,
F: FnMut(T, T2, N3) -> N4,
DefaultAllocator: Allocator<N4, R, C>,
pub fn zip_zip_map<T2, N3, N4, S2, S3, F>(
&self,
b: &Matrix<T2, R, C, S2>,
c: &Matrix<N3, R, C, S3>,
f: F
) -> Matrix<N4, R, C, <DefaultAllocator as Allocator<N4, R, C>>::Buffer> where
T: Scalar,
T2: Scalar,
N3: Scalar,
N4: Scalar,
S2: RawStorage<T2, R, C>,
S3: RawStorage<N3, R, C>,
F: FnMut(T, T2, N3) -> N4,
DefaultAllocator: Allocator<N4, R, C>,
Returns a matrix containing the result of f
applied to each entries of self
and
b
, and c
.
Folds a function f
on each entry of self
.
pub fn zip_fold<T2, R2, C2, S2, Acc>(
&self,
rhs: &Matrix<T2, R2, C2, S2>,
init: Acc,
f: impl FnMut(Acc, T, T2) -> Acc
) -> Acc where
T: Scalar,
T2: Scalar,
R2: Dim,
C2: Dim,
S2: RawStorage<T2, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn zip_fold<T2, R2, C2, S2, Acc>(
&self,
rhs: &Matrix<T2, R2, C2, S2>,
init: Acc,
f: impl FnMut(Acc, T, T2) -> Acc
) -> Acc where
T: Scalar,
T2: Scalar,
R2: Dim,
C2: Dim,
S2: RawStorage<T2, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
Folds a function f
on each pairs of entries from self
and rhs
.
Applies a closure f
to modify each component of self
.
pub fn zip_apply<T2, R2, C2, S2>(
&mut self,
rhs: &Matrix<T2, R2, C2, S2>,
f: impl FnMut(&mut T, T2)
) where
S: RawStorageMut<T, R, C>,
T2: Scalar,
R2: Dim,
C2: Dim,
S2: RawStorage<T2, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn zip_apply<T2, R2, C2, S2>(
&mut self,
rhs: &Matrix<T2, R2, C2, S2>,
f: impl FnMut(&mut T, T2)
) where
S: RawStorageMut<T, R, C>,
T2: Scalar,
R2: Dim,
C2: Dim,
S2: RawStorage<T2, 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<T2, R2, C2, S2, N3, R3, C3, S3>(
&mut self,
b: &Matrix<T2, R2, C2, S2>,
c: &Matrix<N3, R3, C3, S3>,
f: impl FnMut(&mut T, T2, N3)
) where
S: RawStorageMut<T, R, C>,
T2: Scalar,
R2: Dim,
C2: Dim,
S2: RawStorage<T2, R2, C2>,
N3: Scalar,
R3: Dim,
C3: Dim,
S3: RawStorage<N3, R3, C3>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn zip_zip_apply<T2, R2, C2, S2, N3, R3, C3, S3>(
&mut self,
b: &Matrix<T2, R2, C2, S2>,
c: &Matrix<N3, R3, C3, S3>,
f: impl FnMut(&mut T, T2, N3)
) where
S: RawStorageMut<T, R, C>,
T2: Scalar,
R2: Dim,
C2: Dim,
S2: RawStorage<T2, R2, C2>,
N3: Scalar,
R3: Dim,
C3: Dim,
S3: RawStorage<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 fn iter(&self) -> MatrixIter<'_, T, R, C, S>ⓘNotable traits for MatrixIter<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for MatrixIter<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorage<T, R, C>, type Item = &'a T;
pub fn iter(&self) -> MatrixIter<'_, T, R, C, S>ⓘNotable traits for MatrixIter<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for MatrixIter<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorage<T, R, C>, type Item = &'a T;
impl<'a, T, R, C, S> Iterator for MatrixIter<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorage<T, R, C>, type Item = &'a T;
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<'_, T, R, C, S>ⓘNotable traits for RowIter<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for RowIter<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorage<T, R, C>, type Item = Matrix<T, Const<1_usize>, C, SliceStorage<'a, T, Const<1_usize>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
pub fn row_iter(&self) -> RowIter<'_, T, R, C, S>ⓘNotable traits for RowIter<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for RowIter<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorage<T, R, C>, type Item = Matrix<T, Const<1_usize>, C, SliceStorage<'a, T, Const<1_usize>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
impl<'a, T, R, C, S> Iterator for RowIter<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorage<T, R, C>, type Item = Matrix<T, Const<1_usize>, C, SliceStorage<'a, T, Const<1_usize>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
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<'_, T, R, C, S>ⓘNotable traits for ColumnIter<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for ColumnIter<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorage<T, R, C>, type Item = Matrix<T, R, Const<1_usize>, SliceStorage<'a, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
pub fn column_iter(&self) -> ColumnIter<'_, T, R, C, S>ⓘNotable traits for ColumnIter<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for ColumnIter<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorage<T, R, C>, type Item = Matrix<T, R, Const<1_usize>, SliceStorage<'a, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
impl<'a, T, R, C, S> Iterator for ColumnIter<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorage<T, R, C>, type Item = Matrix<T, R, Const<1_usize>, SliceStorage<'a, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
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 iter_mut(&mut self) -> MatrixIterMut<'_, T, R, C, S>ⓘNotable traits for MatrixIterMut<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for MatrixIterMut<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorageMut<T, R, C>, type Item = &'a mut T;
where
S: RawStorageMut<T, R, C>,
pub fn iter_mut(&mut self) -> MatrixIterMut<'_, T, R, C, S>ⓘNotable traits for MatrixIterMut<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for MatrixIterMut<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorageMut<T, R, C>, type Item = &'a mut T;
where
S: RawStorageMut<T, R, C>,
impl<'a, T, R, C, S> Iterator for MatrixIterMut<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorageMut<T, R, C>, type Item = &'a mut T;
Mutably iterates through this matrix coordinates.
pub fn row_iter_mut(&mut self) -> RowIterMut<'_, T, R, C, S>ⓘNotable traits for RowIterMut<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for RowIterMut<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorageMut<T, R, C>, type Item = Matrix<T, Const<1_usize>, C, SliceStorageMut<'a, T, Const<1_usize>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
where
S: RawStorageMut<T, R, C>,
pub fn row_iter_mut(&mut self) -> RowIterMut<'_, T, R, C, S>ⓘNotable traits for RowIterMut<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for RowIterMut<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorageMut<T, R, C>, type Item = Matrix<T, Const<1_usize>, C, SliceStorageMut<'a, T, Const<1_usize>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
where
S: RawStorageMut<T, R, C>,
impl<'a, T, R, C, S> Iterator for RowIterMut<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorageMut<T, R, C>, type Item = Matrix<T, Const<1_usize>, C, SliceStorageMut<'a, T, Const<1_usize>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
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<'_, T, R, C, S>ⓘNotable traits for ColumnIterMut<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for ColumnIterMut<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorageMut<T, R, C>, type Item = Matrix<T, R, Const<1_usize>, SliceStorageMut<'a, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
where
S: RawStorageMut<T, R, C>,
pub fn column_iter_mut(&mut self) -> ColumnIterMut<'_, T, R, C, S>ⓘNotable traits for ColumnIterMut<'a, T, R, C, S>impl<'a, T, R, C, S> Iterator for ColumnIterMut<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorageMut<T, R, C>, type Item = Matrix<T, R, Const<1_usize>, SliceStorageMut<'a, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
where
S: RawStorageMut<T, R, C>,
impl<'a, T, R, C, S> Iterator for ColumnIterMut<'a, T, R, C, S> where
R: Dim,
C: Dim,
S: 'a + RawStorageMut<T, R, C>, type Item = Matrix<T, R, Const<1_usize>, SliceStorageMut<'a, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>;
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);
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.
Swaps two entries without bound-checking.
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<T, R2, C2, SB>) where
T: Scalar,
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn copy_from<R2, C2, SB>(&mut self, other: &Matrix<T, R2, C2, SB>) where
T: Scalar,
R2: Dim,
C2: Dim,
SB: RawStorage<T, 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<T, R2, C2, SB>) where
T: Scalar,
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: DimEq<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
pub fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<T, R2, C2, SB>) where
T: Scalar,
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: DimEq<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
Fills this matrix with the content of the transpose another one.
Returns self
with each of its components replaced by the result of a closure f
applied on it.
Gets a reference to the i-th element of this column vector without bound checking.
Gets a mutable reference to the i-th element of this column vector without bound checking.
impl<T, R, C, S> Matrix<T, R, C, S> where
R: Dim,
C: Dim,
S: RawStorage<T, R, C> + IsContiguous,
impl<T, R, C, S> Matrix<T, R, C, S> where
R: Dim,
C: Dim,
S: RawStorage<T, R, C> + IsContiguous,
impl<T, R, C, S> Matrix<T, R, C, S> where
R: Dim,
C: Dim,
S: RawStorageMut<T, R, C> + IsContiguous,
impl<T, R, C, S> Matrix<T, R, C, S> where
R: Dim,
C: Dim,
S: RawStorageMut<T, R, C> + IsContiguous,
Extracts a mutable slice containing the entire matrix entries ordered column-by-columns.
Transposes the square matrix self
in-place.
impl<T, R, C, S> Matrix<T, R, C, S> where
T: SimdComplexField,
R: Dim,
C: Dim,
S: RawStorage<T, R, C>,
impl<T, R, C, S> Matrix<T, R, C, S> where
T: SimdComplexField,
R: Dim,
C: Dim,
S: RawStorage<T, R, C>,
pub fn adjoint_to<R2, C2, SB>(&self, out: &mut Matrix<T, R2, C2, SB>) where
R2: Dim,
C2: Dim,
SB: RawStorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
pub fn adjoint_to<R2, C2, SB>(&self, out: &mut Matrix<T, R2, C2, SB>) where
R2: Dim,
C2: Dim,
SB: RawStorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
Takes the adjoint (aka. conjugate-transpose) of self
and store the result into out
.
pub fn adjoint(
&self
) -> Matrix<T, C, R, <DefaultAllocator as Allocator<T, C, R>>::Buffer> where
DefaultAllocator: Allocator<T, C, R>,
pub fn adjoint(
&self
) -> Matrix<T, C, R, <DefaultAllocator as Allocator<T, C, R>>::Buffer> where
DefaultAllocator: Allocator<T, C, R>,
The adjoint (aka. conjugate-transpose) of self
.
pub fn conjugate_transpose_to<R2, C2, SB>(
&self,
out: &mut Matrix<T, R2, C2, SB>
) where
R2: Dim,
C2: Dim,
SB: RawStorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, C2>,
ShapeConstraint: SameNumberOfColumns<C, R2>,
👎 Deprecated: Renamed self.adjoint_to(out)
.
pub fn conjugate_transpose_to<R2, C2, SB>(
&self,
out: &mut Matrix<T, R2, C2, SB>
) where
R2: Dim,
C2: Dim,
SB: RawStorageMut<T, 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<T, C, R, <DefaultAllocator as Allocator<T, C, R>>::Buffer> where
DefaultAllocator: Allocator<T, C, R>,
👎 Deprecated: Renamed self.adjoint()
.
pub fn conjugate_transpose(
&self
) -> Matrix<T, C, R, <DefaultAllocator as Allocator<T, C, R>>::Buffer> where
DefaultAllocator: Allocator<T, C, R>,
Renamed self.adjoint()
.
The conjugate transposition of self
.
pub fn conjugate(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
DefaultAllocator: Allocator<T, R, C>,
pub fn conjugate(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
DefaultAllocator: Allocator<T, R, C>,
The conjugate of self
.
pub fn unscale(
&self,
real: <T as SimdComplexField>::SimdRealField
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
DefaultAllocator: Allocator<T, R, C>,
pub fn unscale(
&self,
real: <T as SimdComplexField>::SimdRealField
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
DefaultAllocator: Allocator<T, R, C>,
Divides each component of the complex matrix self
by the given real.
pub fn scale(
&self,
real: <T as SimdComplexField>::SimdRealField
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
DefaultAllocator: Allocator<T, R, C>,
pub fn scale(
&self,
real: <T as SimdComplexField>::SimdRealField
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
DefaultAllocator: Allocator<T, R, C>,
Multiplies each component of the complex matrix self
by the given real.
impl<T, R, C, S> Matrix<T, R, C, S> where
T: SimdComplexField,
R: Dim,
C: Dim,
S: RawStorageMut<T, R, C>,
impl<T, R, C, S> Matrix<T, R, C, S> where
T: SimdComplexField,
R: Dim,
C: Dim,
S: RawStorageMut<T, R, C>,
The conjugate of the complex matrix self
computed in-place.
Divides each component of the complex matrix self
by the given real.
Multiplies each component of the complex matrix self
by the given real.
👎 Deprecated: Renamed to self.adjoint_mut()
.
Renamed to self.adjoint_mut()
.
Sets self
to its adjoint.
Sets self
to its adjoint (aka. conjugate-transpose).
The diagonal of this matrix.
pub fn map_diagonal<T2>(
&self,
f: impl FnMut(T) -> T2
) -> Matrix<T2, D, Const<1_usize>, <DefaultAllocator as Allocator<T2, D, Const<1_usize>>>::Buffer> where
T2: Scalar,
DefaultAllocator: Allocator<T2, D, Const<1_usize>>,
pub fn map_diagonal<T2>(
&self,
f: impl FnMut(T) -> T2
) -> Matrix<T2, D, Const<1_usize>, <DefaultAllocator as Allocator<T2, D, Const<1_usize>>>::Buffer> where
T2: Scalar,
DefaultAllocator: Allocator<T2, D, Const<1_usize>>,
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 symmetric_part(
&self
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
DefaultAllocator: Allocator<T, D, D>,
pub fn symmetric_part(
&self
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
DefaultAllocator: Allocator<T, D, D>,
The symmetric part of self
, i.e., 0.5 * (self + self.transpose())
.
pub fn hermitian_part(
&self
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
DefaultAllocator: Allocator<T, D, D>,
pub fn hermitian_part(
&self
) -> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
DefaultAllocator: Allocator<T, D, D>,
The hermitian part of self
, i.e., 0.5 * (self + self.adjoint())
.
impl<T, D, S> Matrix<T, D, D, S> where
T: Scalar + Zero + One,
D: DimAdd<Const<1_usize>> + IsNotStaticOne,
S: RawStorage<T, D, D>,
impl<T, D, S> Matrix<T, D, D, S> where
T: Scalar + Zero + One,
D: DimAdd<Const<1_usize>> + IsNotStaticOne,
S: RawStorage<T, D, D>,
pub fn to_homogeneous(
&self
) -> Matrix<T, <D as DimAdd<Const<1_usize>>>::Output, <D as DimAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <D as DimAdd<Const<1_usize>>>::Output, <D as DimAdd<Const<1_usize>>>::Output>>::Buffer> where
DefaultAllocator: Allocator<T, <D as DimAdd<Const<1_usize>>>::Output, <D as DimAdd<Const<1_usize>>>::Output>,
pub fn to_homogeneous(
&self
) -> Matrix<T, <D as DimAdd<Const<1_usize>>>::Output, <D as DimAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <D as DimAdd<Const<1_usize>>>::Output, <D as DimAdd<Const<1_usize>>>::Output>>::Buffer> where
DefaultAllocator: Allocator<T, <D as DimAdd<Const<1_usize>>>::Output, <D as DimAdd<Const<1_usize>>>::Output>,
Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and
and setting the diagonal element to 1
.
Computes the coordinates in projective space of this vector, i.e., appends a 0
to its
coordinates.
pub fn from_homogeneous<SB>(
v: Matrix<T, <D as DimAdd<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Option<Matrix<T, D, Const<1_usize>, <DefaultAllocator as Allocator<T, D, Const<1_usize>>>::Buffer>> where
SB: RawStorage<T, <D as DimAdd<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
pub fn from_homogeneous<SB>(
v: Matrix<T, <D as DimAdd<Const<1_usize>>>::Output, Const<1_usize>, SB>
) -> Option<Matrix<T, D, Const<1_usize>, <DefaultAllocator as Allocator<T, D, Const<1_usize>>>::Buffer>> where
SB: RawStorage<T, <D as DimAdd<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
Constructs a vector from coordinates in projective space, i.e., removes a 0
at the end of
self
. Returns None
if this last component is not zero.
Constructs a new vector of higher dimension by appending element
to the end of self
.
pub fn perp<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> T where
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, Const<{_: usize}>>,
ShapeConstraint: SameNumberOfColumns<C, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<R2, Const<{_: usize}>>,
ShapeConstraint: SameNumberOfColumns<C2, Const<1_usize>>,
pub fn perp<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> T where
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, Const<{_: usize}>>,
ShapeConstraint: SameNumberOfColumns<C, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<R2, Const<{_: usize}>>,
ShapeConstraint: SameNumberOfColumns<C2, Const<1_usize>>,
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<T, R2, C2, SB>
) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn cross<R2, C2, SB>(
&self,
b: &Matrix<T, R2, C2, SB>
) -> Matrix<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C, C2>>::Representative>>::Buffer> where
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, 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<T, Const<{_: usize}>, Const<{_: usize}>, <DefaultAllocator as Allocator<T, Const<{_: usize}>, Const<{_: usize}>>>::Buffer>
pub fn cross_matrix(
&self
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, <DefaultAllocator as Allocator<T, Const<{_: usize}>, Const<{_: usize}>>>::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<T, R2, C2, SB>
) -> <T as SimdComplexField>::SimdRealField where
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
pub fn angle<R2, C2, SB>(
&self,
other: &Matrix<T, R2, C2, SB>
) -> <T as SimdComplexField>::SimdRealField where
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
ShapeConstraint: DimEq<R, R2>,
ShapeConstraint: DimEq<C, C2>,
The smallest angle between two vectors.
pub fn row(
&self,
i: usize
) -> Matrix<T, Const<1_usize>, C, SliceStorage<'_, T, Const<1_usize>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn row(
&self,
i: usize
) -> Matrix<T, Const<1_usize>, C, SliceStorage<'_, T, Const<1_usize>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
Returns a slice containing the i-th row of this matrix.
pub fn row_part(
&self,
i: usize,
n: usize
) -> Matrix<T, Const<1_usize>, Dynamic, SliceStorage<'_, T, Const<1_usize>, Dynamic, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn row_part(
&self,
i: usize,
n: usize
) -> Matrix<T, Const<1_usize>, Dynamic, SliceStorage<'_, T, Const<1_usize>, Dynamic, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, Dynamic, C, SliceStorage<'_, T, Dynamic, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn rows(
&self,
first_row: usize,
nrows: usize
) -> Matrix<T, Dynamic, C, SliceStorage<'_, T, Dynamic, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, Dynamic, C, SliceStorage<'_, T, Dynamic, C, Dynamic, <S as RawStorage<T, R, C>>::CStride>>
pub fn rows_with_step(
&self,
first_row: usize,
nrows: usize,
step: usize
) -> Matrix<T, Dynamic, C, SliceStorage<'_, T, Dynamic, C, Dynamic, <S as RawStorage<T, R, C>>::CStride>>
Extracts from this matrix a set of consecutive rows regularly skipping step
rows.
pub fn fixed_rows<const RSLICE: usize>(
&self,
first_row: usize
) -> Matrix<T, Const<RSLICE>, C, SliceStorage<'_, T, Const<RSLICE>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn fixed_rows<const RSLICE: usize>(
&self,
first_row: usize
) -> Matrix<T, Const<RSLICE>, C, SliceStorage<'_, T, Const<RSLICE>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
Extracts a compile-time number of consecutive rows from this matrix.
pub fn fixed_rows_with_step<const RSLICE: usize>(
&self,
first_row: usize,
step: usize
) -> Matrix<T, Const<RSLICE>, C, SliceStorage<'_, T, Const<RSLICE>, C, Dynamic, <S as RawStorage<T, R, C>>::CStride>>
pub fn fixed_rows_with_step<const RSLICE: usize>(
&self,
first_row: usize,
step: usize
) -> Matrix<T, Const<RSLICE>, C, SliceStorage<'_, T, Const<RSLICE>, C, Dynamic, <S as RawStorage<T, R, C>>::CStride>>
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<T, RSlice, C, SliceStorage<'_, T, RSlice, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RSlice: Dim,
pub fn rows_generic<RSlice>(
&self,
row_start: usize,
nrows: RSlice
) -> Matrix<T, RSlice, C, SliceStorage<'_, T, RSlice, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, RSlice, C, SliceStorage<'_, T, RSlice, C, Dynamic, <S as RawStorage<T, R, C>>::CStride>> where
RSlice: Dim,
pub fn rows_generic_with_step<RSlice>(
&self,
row_start: usize,
nrows: RSlice,
step: usize
) -> Matrix<T, RSlice, C, SliceStorage<'_, T, RSlice, C, Dynamic, <S as RawStorage<T, 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<T, R, Const<1_usize>, SliceStorage<'_, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn column(
&self,
i: usize
) -> Matrix<T, R, Const<1_usize>, SliceStorage<'_, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
Returns a slice containing the i-th column of this matrix.
pub fn column_part(
&self,
i: usize,
n: usize
) -> Matrix<T, Dynamic, Const<1_usize>, SliceStorage<'_, T, Dynamic, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn column_part(
&self,
i: usize,
n: usize
) -> Matrix<T, Dynamic, Const<1_usize>, SliceStorage<'_, T, Dynamic, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, R, Dynamic, SliceStorage<'_, T, R, Dynamic, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn columns(
&self,
first_col: usize,
ncols: usize
) -> Matrix<T, R, Dynamic, SliceStorage<'_, T, R, Dynamic, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, R, Dynamic, SliceStorage<'_, T, R, Dynamic, <S as RawStorage<T, R, C>>::RStride, Dynamic>>
pub fn columns_with_step(
&self,
first_col: usize,
ncols: usize,
step: usize
) -> Matrix<T, R, Dynamic, SliceStorage<'_, T, R, Dynamic, <S as RawStorage<T, R, C>>::RStride, Dynamic>>
Extracts from this matrix a set of consecutive columns regularly skipping step
columns.
pub fn fixed_columns<const CSLICE: usize>(
&self,
first_col: usize
) -> Matrix<T, R, Const<CSLICE>, SliceStorage<'_, T, R, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn fixed_columns<const CSLICE: usize>(
&self,
first_col: usize
) -> Matrix<T, R, Const<CSLICE>, SliceStorage<'_, T, R, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
Extracts a compile-time number of consecutive columns from this matrix.
pub fn fixed_columns_with_step<const CSLICE: usize>(
&self,
first_col: usize,
step: usize
) -> Matrix<T, R, Const<CSLICE>, SliceStorage<'_, T, R, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, Dynamic>>
pub fn fixed_columns_with_step<const CSLICE: usize>(
&self,
first_col: usize,
step: usize
) -> Matrix<T, R, Const<CSLICE>, SliceStorage<'_, T, R, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, Dynamic>>
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<T, R, CSlice, SliceStorage<'_, T, R, CSlice, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
CSlice: Dim,
pub fn columns_generic<CSlice>(
&self,
first_col: usize,
ncols: CSlice
) -> Matrix<T, R, CSlice, SliceStorage<'_, T, R, CSlice, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, R, CSlice, SliceStorage<'_, T, R, CSlice, <S as RawStorage<T, R, C>>::RStride, Dynamic>> where
CSlice: Dim,
pub fn columns_generic_with_step<CSlice>(
&self,
first_col: usize,
ncols: CSlice,
step: usize
) -> Matrix<T, R, CSlice, SliceStorage<'_, T, R, CSlice, <S as RawStorage<T, 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.
Slices this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
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<const RSLICE: usize, const CSLICE: usize>(
&self,
irow: usize,
icol: usize
) -> Matrix<T, Const<RSLICE>, Const<CSLICE>, SliceStorage<'_, T, Const<RSLICE>, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn fixed_slice<const RSLICE: usize, const CSLICE: usize>(
&self,
irow: usize,
icol: usize
) -> Matrix<T, Const<RSLICE>, Const<CSLICE>, SliceStorage<'_, T, Const<RSLICE>, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
Slices this matrix starting at its component (irow, icol)
and with (R::dim(), CSlice::dim())
consecutive components.
Slices this matrix starting at its component (start.0, start.1)
and with
(RSLICE, CSLICE)
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<T, RSlice, CSlice, SliceStorage<'_, T, RSlice, CSlice, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RSlice: Dim,
CSlice: Dim,
pub fn generic_slice<RSlice, CSlice>(
&self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> Matrix<T, RSlice, CSlice, SliceStorage<'_, T, RSlice, CSlice, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RSlice: Dim,
CSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
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<T, <Range1 as SliceRange<R>>::Size, C, SliceStorage<'_, T, <Range1 as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, <Range2 as SliceRange<R>>::Size, C, SliceStorage<'_, T, <Range2 as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>) where
Range1: SliceRange<R>,
Range2: SliceRange<R>,
pub fn rows_range_pair<Range1, Range2>(
&self,
r1: Range1,
r2: Range2
) -> (Matrix<T, <Range1 as SliceRange<R>>::Size, C, SliceStorage<'_, T, <Range1 as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, <Range2 as SliceRange<R>>::Size, C, SliceStorage<'_, T, <Range2 as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, R, <Range1 as SliceRange<C>>::Size, SliceStorage<'_, T, R, <Range1 as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, R, <Range2 as SliceRange<C>>::Size, SliceStorage<'_, T, R, <Range2 as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>) where
Range1: SliceRange<C>,
Range2: SliceRange<C>,
pub fn columns_range_pair<Range1, Range2>(
&self,
r1: Range1,
r2: Range2
) -> (Matrix<T, R, <Range1 as SliceRange<C>>::Size, SliceStorage<'_, T, R, <Range1 as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, R, <Range2 as SliceRange<C>>::Size, SliceStorage<'_, T, R, <Range2 as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, Const<1_usize>, C, SliceStorageMut<'_, T, Const<1_usize>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn row_mut(
&mut self,
i: usize
) -> Matrix<T, Const<1_usize>, C, SliceStorageMut<'_, T, Const<1_usize>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, Const<1_usize>, Dynamic, SliceStorageMut<'_, T, Const<1_usize>, Dynamic, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn row_part_mut(
&mut self,
i: usize,
n: usize
) -> Matrix<T, Const<1_usize>, Dynamic, SliceStorageMut<'_, T, Const<1_usize>, Dynamic, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, Dynamic, C, SliceStorageMut<'_, T, Dynamic, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn rows_mut(
&mut self,
first_row: usize,
nrows: usize
) -> Matrix<T, Dynamic, C, SliceStorageMut<'_, T, Dynamic, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, Dynamic, C, SliceStorageMut<'_, T, Dynamic, C, Dynamic, <S as RawStorage<T, R, C>>::CStride>>
pub fn rows_with_step_mut(
&mut self,
first_row: usize,
nrows: usize,
step: usize
) -> Matrix<T, Dynamic, C, SliceStorageMut<'_, T, Dynamic, C, Dynamic, <S as RawStorage<T, R, C>>::CStride>>
Extracts from this matrix a set of consecutive rows regularly skipping step
rows.
pub fn fixed_rows_mut<const RSLICE: usize>(
&mut self,
first_row: usize
) -> Matrix<T, Const<RSLICE>, C, SliceStorageMut<'_, T, Const<RSLICE>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn fixed_rows_mut<const RSLICE: usize>(
&mut self,
first_row: usize
) -> Matrix<T, Const<RSLICE>, C, SliceStorageMut<'_, T, Const<RSLICE>, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
Extracts a compile-time number of consecutive rows from this matrix.
pub fn fixed_rows_with_step_mut<const RSLICE: usize>(
&mut self,
first_row: usize,
step: usize
) -> Matrix<T, Const<RSLICE>, C, SliceStorageMut<'_, T, Const<RSLICE>, C, Dynamic, <S as RawStorage<T, R, C>>::CStride>>
pub fn fixed_rows_with_step_mut<const RSLICE: usize>(
&mut self,
first_row: usize,
step: usize
) -> Matrix<T, Const<RSLICE>, C, SliceStorageMut<'_, T, Const<RSLICE>, C, Dynamic, <S as RawStorage<T, R, C>>::CStride>>
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<T, RSlice, C, SliceStorageMut<'_, T, RSlice, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RSlice: Dim,
pub fn rows_generic_mut<RSlice>(
&mut self,
row_start: usize,
nrows: RSlice
) -> Matrix<T, RSlice, C, SliceStorageMut<'_, T, RSlice, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, RSlice, C, SliceStorageMut<'_, T, RSlice, C, Dynamic, <S as RawStorage<T, R, C>>::CStride>> where
RSlice: Dim,
pub fn rows_generic_with_step_mut<RSlice>(
&mut self,
row_start: usize,
nrows: RSlice,
step: usize
) -> Matrix<T, RSlice, C, SliceStorageMut<'_, T, RSlice, C, Dynamic, <S as RawStorage<T, 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<T, R, Const<1_usize>, SliceStorageMut<'_, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn column_mut(
&mut self,
i: usize
) -> Matrix<T, R, Const<1_usize>, SliceStorageMut<'_, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, Dynamic, Const<1_usize>, SliceStorageMut<'_, T, Dynamic, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn column_part_mut(
&mut self,
i: usize,
n: usize
) -> Matrix<T, Dynamic, Const<1_usize>, SliceStorageMut<'_, T, Dynamic, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, R, Dynamic, SliceStorageMut<'_, T, R, Dynamic, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn columns_mut(
&mut self,
first_col: usize,
ncols: usize
) -> Matrix<T, R, Dynamic, SliceStorageMut<'_, T, R, Dynamic, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, R, Dynamic, SliceStorageMut<'_, T, R, Dynamic, <S as RawStorage<T, R, C>>::RStride, Dynamic>>
pub fn columns_with_step_mut(
&mut self,
first_col: usize,
ncols: usize,
step: usize
) -> Matrix<T, R, Dynamic, SliceStorageMut<'_, T, R, Dynamic, <S as RawStorage<T, R, C>>::RStride, Dynamic>>
Extracts from this matrix a set of consecutive columns regularly skipping step
columns.
pub fn fixed_columns_mut<const CSLICE: usize>(
&mut self,
first_col: usize
) -> Matrix<T, R, Const<CSLICE>, SliceStorageMut<'_, T, R, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn fixed_columns_mut<const CSLICE: usize>(
&mut self,
first_col: usize
) -> Matrix<T, R, Const<CSLICE>, SliceStorageMut<'_, T, R, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
Extracts a compile-time number of consecutive columns from this matrix.
pub fn fixed_columns_with_step_mut<const CSLICE: usize>(
&mut self,
first_col: usize,
step: usize
) -> Matrix<T, R, Const<CSLICE>, SliceStorageMut<'_, T, R, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, Dynamic>>
pub fn fixed_columns_with_step_mut<const CSLICE: usize>(
&mut self,
first_col: usize,
step: usize
) -> Matrix<T, R, Const<CSLICE>, SliceStorageMut<'_, T, R, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, Dynamic>>
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<T, R, CSlice, SliceStorageMut<'_, T, R, CSlice, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
CSlice: Dim,
pub fn columns_generic_mut<CSlice>(
&mut self,
first_col: usize,
ncols: CSlice
) -> Matrix<T, R, CSlice, SliceStorageMut<'_, T, R, CSlice, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, R, CSlice, SliceStorageMut<'_, T, R, CSlice, <S as RawStorage<T, R, C>>::RStride, Dynamic>> where
CSlice: Dim,
pub fn columns_generic_with_step_mut<CSlice>(
&mut self,
first_col: usize,
ncols: CSlice,
step: usize
) -> Matrix<T, R, CSlice, SliceStorageMut<'_, T, R, CSlice, <S as RawStorage<T, 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.
Slices this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
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<const RSLICE: usize, const CSLICE: usize>(
&mut self,
irow: usize,
icol: usize
) -> Matrix<T, Const<RSLICE>, Const<CSLICE>, SliceStorageMut<'_, T, Const<RSLICE>, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
pub fn fixed_slice_mut<const RSLICE: usize, const CSLICE: usize>(
&mut self,
irow: usize,
icol: usize
) -> Matrix<T, Const<RSLICE>, Const<CSLICE>, SliceStorageMut<'_, T, Const<RSLICE>, Const<CSLICE>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>
Slices this matrix starting at its component (irow, icol)
and with (R::dim(), CSlice::dim())
consecutive components.
Slices this matrix starting at its component (start.0, start.1)
and with
(RSLICE, CSLICE)
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<T, RSlice, CSlice, SliceStorageMut<'_, T, RSlice, CSlice, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RSlice: Dim,
CSlice: Dim,
pub fn generic_slice_mut<RSlice, CSlice>(
&mut self,
start: (usize, usize),
shape: (RSlice, CSlice)
) -> Matrix<T, RSlice, CSlice, SliceStorageMut<'_, T, RSlice, CSlice, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RSlice: Dim,
CSlice: Dim,
Creates a slice that may or may not have a fixed size and stride.
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<T, <Range1 as SliceRange<R>>::Size, C, SliceStorageMut<'_, T, <Range1 as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, <Range2 as SliceRange<R>>::Size, C, SliceStorageMut<'_, T, <Range2 as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>) where
Range1: SliceRange<R>,
Range2: SliceRange<R>,
pub fn rows_range_pair_mut<Range1, Range2>(
&mut self,
r1: Range1,
r2: Range2
) -> (Matrix<T, <Range1 as SliceRange<R>>::Size, C, SliceStorageMut<'_, T, <Range1 as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, <Range2 as SliceRange<R>>::Size, C, SliceStorageMut<'_, T, <Range2 as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, R, <Range1 as SliceRange<C>>::Size, SliceStorageMut<'_, T, R, <Range1 as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, R, <Range2 as SliceRange<C>>::Size, SliceStorageMut<'_, T, R, <Range2 as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>) where
Range1: SliceRange<C>,
Range2: SliceRange<C>,
pub fn columns_range_pair_mut<Range1, Range2>(
&mut self,
r1: Range1,
r2: Range2
) -> (Matrix<T, R, <Range1 as SliceRange<C>>::Size, SliceStorageMut<'_, T, R, <Range1 as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>, Matrix<T, R, <Range2 as SliceRange<C>>::Size, SliceStorageMut<'_, T, R, <Range2 as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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 slice_range<RowRange, ColRange>(
&self,
rows: RowRange,
cols: ColRange
) -> Matrix<T, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorage<'_, T, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
pub fn slice_range<RowRange, ColRange>(
&self,
rows: RowRange,
cols: ColRange
) -> Matrix<T, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorage<'_, T, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
Slices a sub-matrix containing the rows indexed by the range rows
and the columns indexed
by the range cols
.
pub fn rows_range<RowRange>(
&self,
rows: RowRange
) -> Matrix<T, <RowRange as SliceRange<R>>::Size, C, SliceStorage<'_, T, <RowRange as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RowRange: SliceRange<R>,
pub fn rows_range<RowRange>(
&self,
rows: RowRange
) -> Matrix<T, <RowRange as SliceRange<R>>::Size, C, SliceStorage<'_, T, <RowRange as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, R, <ColRange as SliceRange<C>>::Size, SliceStorage<'_, T, R, <ColRange as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
ColRange: SliceRange<C>,
pub fn columns_range<ColRange>(
&self,
cols: ColRange
) -> Matrix<T, R, <ColRange as SliceRange<C>>::Size, SliceStorage<'_, T, R, <ColRange as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorageMut<'_, T, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
pub fn slice_range_mut<RowRange, ColRange>(
&mut self,
rows: RowRange,
cols: ColRange
) -> Matrix<T, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, SliceStorageMut<'_, T, <RowRange as SliceRange<R>>::Size, <ColRange as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RowRange: SliceRange<R>,
ColRange: SliceRange<C>,
Slices a mutable sub-matrix containing the rows indexed by the range rows
and the columns
indexed by the range cols
.
pub fn rows_range_mut<RowRange>(
&mut self,
rows: RowRange
) -> Matrix<T, <RowRange as SliceRange<R>>::Size, C, SliceStorageMut<'_, T, <RowRange as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
RowRange: SliceRange<R>,
pub fn rows_range_mut<RowRange>(
&mut self,
rows: RowRange
) -> Matrix<T, <RowRange as SliceRange<R>>::Size, C, SliceStorageMut<'_, T, <RowRange as SliceRange<R>>::Size, C, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, 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<T, R, <ColRange as SliceRange<C>>::Size, SliceStorageMut<'_, T, R, <ColRange as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
ColRange: SliceRange<C>,
pub fn columns_range_mut<ColRange>(
&mut self,
cols: ColRange
) -> Matrix<T, R, <ColRange as SliceRange<C>>::Size, SliceStorageMut<'_, T, R, <ColRange as SliceRange<C>>::Size, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>> where
ColRange: SliceRange<C>,
Slice containing all the columns indexed by the range cols
.
pub fn norm_squared(&self) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
pub fn norm_squared(&self) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
The squared L2 norm of this vector.
The L2 norm of this matrix.
Use .apply_norm
to apply a custom norm.
pub fn metric_distance<R2, C2, S2>(
&self,
rhs: &Matrix<T, R2, C2, S2>
) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn metric_distance<R2, C2, S2>(
&self,
rhs: &Matrix<T, R2, C2, S2>
) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
R2: Dim,
C2: Dim,
S2: Storage<T, 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<T>
) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
pub fn apply_norm(
&self,
norm: &impl Norm<T>
) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
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<T, R2, C2, S2>,
norm: &impl Norm<T>
) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2>,
ShapeConstraint: SameNumberOfColumns<C, C2>,
pub fn apply_metric_distance<R2, C2, S2>(
&self,
rhs: &Matrix<T, R2, C2, S2>,
norm: &impl Norm<T>
) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
R2: Dim,
C2: Dim,
S2: Storage<T, 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());
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) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
pub fn magnitude_squared(&self) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
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: <T as SimdComplexField>::SimdRealField
) where
T: SimdComplexField,
S: StorageMut<T, R, C>,
pub fn set_magnitude(
&mut self,
magnitude: <T as SimdComplexField>::SimdRealField
) where
T: SimdComplexField,
S: StorageMut<T, R, C>,
Sets the magnitude of this vector.
pub fn normalize(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: SimdComplexField,
DefaultAllocator: Allocator<T, R, C>,
pub fn normalize(
&self
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: SimdComplexField,
DefaultAllocator: Allocator<T, R, C>,
Returns a normalized version of this matrix.
pub fn lp_norm(&self, p: i32) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
pub fn lp_norm(&self, p: i32) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
The Lp norm of this matrix.
pub fn simd_try_normalize(
&self,
min_norm: <T as SimdComplexField>::SimdRealField
) -> SimdOption<Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>> where
T: SimdComplexField,
<T as SimdValue>::Element: Scalar,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
pub fn simd_try_normalize(
&self,
min_norm: <T as SimdComplexField>::SimdRealField
) -> SimdOption<Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>> where
T: SimdComplexField,
<T as SimdValue>::Element: Scalar,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T 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: <T as ComplexField>::RealField,
min_magnitude: <T as ComplexField>::RealField
) where
T: ComplexField,
S: StorageMut<T, R, C>,
pub fn try_set_magnitude(
&mut self,
magnitude: <T as ComplexField>::RealField,
min_magnitude: <T as ComplexField>::RealField
) where
T: ComplexField,
S: StorageMut<T, 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.
pub fn cap_magnitude(
&self,
max: <T as ComplexField>::RealField
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: ComplexField,
DefaultAllocator: Allocator<T, R, C>,
pub fn cap_magnitude(
&self,
max: <T as ComplexField>::RealField
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: ComplexField,
DefaultAllocator: Allocator<T, R, C>,
Returns a new vector with the same magnitude as self
clamped between 0.0
and max
.
pub fn simd_cap_magnitude(
&self,
max: <T as SimdComplexField>::SimdRealField
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: SimdComplexField,
<T as SimdValue>::Element: Scalar,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
pub fn simd_cap_magnitude(
&self,
max: <T as SimdComplexField>::SimdRealField
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: SimdComplexField,
<T as SimdValue>::Element: Scalar,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
Returns a new vector with the same magnitude as self
clamped between 0.0
and max
.
pub fn try_normalize(
&self,
min_norm: <T as ComplexField>::RealField
) -> Option<Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>> where
T: ComplexField,
DefaultAllocator: Allocator<T, R, C>,
pub fn try_normalize(
&self,
min_norm: <T as ComplexField>::RealField
) -> Option<Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>> where
T: ComplexField,
DefaultAllocator: Allocator<T, 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) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
pub fn normalize_mut(&mut self) -> <T as SimdComplexField>::SimdRealField where
T: SimdComplexField,
Normalizes this matrix in-place and returns its norm.
The components of the matrix cannot be SIMD types (see simd_try_normalize_mut
instead).
pub fn simd_try_normalize_mut(
&mut self,
min_norm: <T as SimdComplexField>::SimdRealField
) -> SimdOption<<T as SimdComplexField>::SimdRealField> where
T: SimdComplexField,
<T as SimdValue>::Element: Scalar,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
pub fn simd_try_normalize_mut(
&mut self,
min_norm: <T as SimdComplexField>::SimdRealField
) -> SimdOption<<T as SimdComplexField>::SimdRealField> where
T: SimdComplexField,
<T as SimdValue>::Element: Scalar,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T 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: <T as ComplexField>::RealField
) -> Option<<T as ComplexField>::RealField> where
T: ComplexField,
pub fn try_normalize_mut(
&mut self,
min_norm: <T as ComplexField>::RealField
) -> Option<<T as ComplexField>::RealField> where
T: ComplexField,
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.
impl<T, D> Matrix<T, D, Const<1_usize>, <DefaultAllocator as Allocator<T, D, Const<1_usize>>>::Buffer> where
T: ComplexField,
D: DimName,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
impl<T, D> Matrix<T, D, Const<1_usize>, <DefaultAllocator as Allocator<T, D, Const<1_usize>>>::Buffer> where
T: ComplexField,
D: DimName,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
Orthonormalizes the given family of vectors. The largest free family of vectors is moved at the beginning of the array and its size is returned. Vectors at an indices larger or equal to this length can be modified to an arbitrary value.
Applies the given closure to each element of the orthonormal basis of the subspace
orthogonal to free family of vectors vs
. If vs
is not a free family, the result is
unspecified.
The total number of elements of this matrix.
Examples:
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.len(), 12);
Returns true if the matrix contains no elements.
Examples:
let mat = Matrix3x4::<f32>::zeros();
assert!(!mat.is_empty());
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: <T as AbsDiffEq<T>>::Epsilon) -> bool where
T: Zero + One + ClosedAdd<T> + ClosedMul<T> + RelativeEq<T>,
S: Storage<T, R, C>,
<T as AbsDiffEq<T>>::Epsilon: Clone,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, C, C>,
pub fn is_orthogonal(&self, eps: <T as AbsDiffEq<T>>::Epsilon) -> bool where
T: Zero + One + ClosedAdd<T> + ClosedMul<T> + RelativeEq<T>,
S: Storage<T, R, C>,
<T as AbsDiffEq<T>>::Epsilon: Clone,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, 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
.
Checks that this matrix is orthogonal and has a determinant equal to 1.
Returns true
if this matrix is invertible.
pub fn compress_rows(
&self,
f: impl Fn(Matrix<T, R, Const<1_usize>, SliceStorage<'_, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>) -> T
) -> Matrix<T, Const<1_usize>, C, <DefaultAllocator as Allocator<T, Const<1_usize>, C>>::Buffer> where
DefaultAllocator: Allocator<T, Const<1_usize>, C>,
pub fn compress_rows(
&self,
f: impl Fn(Matrix<T, R, Const<1_usize>, SliceStorage<'_, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>) -> T
) -> Matrix<T, Const<1_usize>, C, <DefaultAllocator as Allocator<T, Const<1_usize>, C>>::Buffer> where
DefaultAllocator: Allocator<T, Const<1_usize>, 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<T, R, Const<1_usize>, SliceStorage<'_, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>) -> T
) -> Matrix<T, C, Const<1_usize>, <DefaultAllocator as Allocator<T, C, Const<1_usize>>>::Buffer> where
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
pub fn compress_rows_tr(
&self,
f: impl Fn(Matrix<T, R, Const<1_usize>, SliceStorage<'_, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>) -> T
) -> Matrix<T, C, Const<1_usize>, <DefaultAllocator as Allocator<T, C, Const<1_usize>>>::Buffer> where
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
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<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer>,
f: impl Fn(&mut Matrix<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer>, Matrix<T, R, Const<1_usize>, SliceStorage<'_, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>)
) -> Matrix<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer> where
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
pub fn compress_columns(
&self,
init: Matrix<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer>,
f: impl Fn(&mut Matrix<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer>, Matrix<T, R, Const<1_usize>, SliceStorage<'_, T, R, Const<1_usize>, <S as RawStorage<T, R, C>>::RStride, <S as RawStorage<T, R, C>>::CStride>>)
) -> Matrix<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer> where
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
Returns a column vector resulting from the folding of f
on each column of this matrix.
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);
The sum of all the rows of this matrix.
Use .row_sum_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<T, C, Const<1_usize>, <DefaultAllocator as Allocator<T, C, Const<1_usize>>>::Buffer> where
T: ClosedAdd<T> + Zero,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
pub fn row_sum_tr(
&self
) -> Matrix<T, C, Const<1_usize>, <DefaultAllocator as Allocator<T, C, Const<1_usize>>>::Buffer> where
T: ClosedAdd<T> + Zero,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
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<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer> where
T: ClosedAdd<T> + Zero,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
pub fn column_sum(
&self
) -> Matrix<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer> where
T: ClosedAdd<T> + Zero,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
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));
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<T, Const<1_usize>, C, <DefaultAllocator as Allocator<T, Const<1_usize>, C>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, Const<1_usize>, C>,
pub fn row_variance(
&self
) -> Matrix<T, Const<1_usize>, C, <DefaultAllocator as Allocator<T, Const<1_usize>, C>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, Const<1_usize>, 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<T, C, Const<1_usize>, <DefaultAllocator as Allocator<T, C, Const<1_usize>>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
pub fn row_variance_tr(
&self
) -> Matrix<T, C, Const<1_usize>, <DefaultAllocator as Allocator<T, C, Const<1_usize>>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
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<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
pub fn column_variance(
&self
) -> Matrix<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
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);
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<T, Const<1_usize>, C, <DefaultAllocator as Allocator<T, Const<1_usize>, C>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, Const<1_usize>, C>,
pub fn row_mean(
&self
) -> Matrix<T, Const<1_usize>, C, <DefaultAllocator as Allocator<T, Const<1_usize>, C>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, Const<1_usize>, 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<T, C, Const<1_usize>, <DefaultAllocator as Allocator<T, C, Const<1_usize>>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
pub fn row_mean_tr(
&self
) -> Matrix<T, C, Const<1_usize>, <DefaultAllocator as Allocator<T, C, Const<1_usize>>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
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<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
pub fn column_mean(
&self
) -> Matrix<T, R, Const<1_usize>, <DefaultAllocator as Allocator<T, R, Const<1_usize>>>::Buffer> where
T: Field + SupersetOf<f64>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
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));
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
Builds a new vector from components of self
.
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));
Computes the spherical linear interpolation between two non-zero vectors.
The result is a unit vector.
Examples:
let v1 =Vector2::new(1.0, 2.0);
let v2 = Vector2::new(2.0, -3.0);
let v = v1.slerp(&v2, 1.0);
assert_eq!(v, v2.normalize());
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);
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);
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);
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);
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);
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);
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));
impl<T, R, C, S> Matrix<T, R, C, S> where
T: Scalar + PartialOrd<T> + Signed,
R: Dim,
C: Dim,
S: RawStorage<T, R, C>,
impl<T, R, C, S> Matrix<T, R, C, S> where
T: Scalar + PartialOrd<T> + Signed,
R: Dim,
C: Dim,
S: RawStorage<T, R, C>,
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);
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));
Computes the index of the vector component with the largest value.
Examples:
let vec = Vector3::new(11, -15, 13);
assert_eq!(vec.imax(), 2);
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);
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));
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 convolve_full<D2, S2>(
&self,
kernel: Matrix<T, D2, Const<1_usize>, S2>
) -> Matrix<T, <<D1 as DimAdd<D2>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <<D1 as DimAdd<D2>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer> where
D1: DimAdd<D2>,
D2: DimAdd<D1, Output = <D1 as DimAdd<D2>>::Output>,
S2: Storage<T, D2, Const<1_usize>>,
<D1 as DimAdd<D2>>::Output: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, <<D1 as DimAdd<D2>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn convolve_full<D2, S2>(
&self,
kernel: Matrix<T, D2, Const<1_usize>, S2>
) -> Matrix<T, <<D1 as DimAdd<D2>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <<D1 as DimAdd<D2>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer> where
D1: DimAdd<D2>,
D2: DimAdd<D1, Output = <D1 as DimAdd<D2>>::Output>,
S2: Storage<T, D2, Const<1_usize>>,
<D1 as DimAdd<D2>>::Output: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, <<D1 as DimAdd<D2>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn convolve_valid<D2, S2>(
&self,
kernel: Matrix<T, D2, Const<1_usize>, S2>
) -> Matrix<T, <<D1 as DimAdd<Const<1_usize>>>::Output as DimSub<D2>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <<D1 as DimAdd<Const<1_usize>>>::Output as DimSub<D2>>::Output, Const<1_usize>>>::Buffer> where
D1: DimAdd<Const<1_usize>>,
D2: Dim,
S2: Storage<T, D2, Const<1_usize>>,
<D1 as DimAdd<Const<1_usize>>>::Output: DimSub<D2>,
DefaultAllocator: Allocator<T, <<D1 as DimAdd<Const<1_usize>>>::Output as DimSub<D2>>::Output, Const<1_usize>>,
pub fn convolve_valid<D2, S2>(
&self,
kernel: Matrix<T, D2, Const<1_usize>, S2>
) -> Matrix<T, <<D1 as DimAdd<Const<1_usize>>>::Output as DimSub<D2>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <<D1 as DimAdd<Const<1_usize>>>::Output as DimSub<D2>>::Output, Const<1_usize>>>::Buffer> where
D1: DimAdd<Const<1_usize>>,
D2: Dim,
S2: Storage<T, D2, Const<1_usize>>,
<D1 as DimAdd<Const<1_usize>>>::Output: DimSub<D2>,
DefaultAllocator: Allocator<T, <<D1 as DimAdd<Const<1_usize>>>::Output as DimSub<D2>>::Output, Const<1_usize>>,
impl<T, D, S> Matrix<T, D, D, S> where
T: ComplexField,
D: DimMin<D, Output = D>,
S: Storage<T, D, D>,
impl<T, D, S> Matrix<T, D, D, S> where
T: ComplexField,
D: DimMin<D, Output = D>,
S: Storage<T, D, D>,
pub fn determinant(&self) -> T where
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<(usize, usize), D, Const<1_usize>>,
pub fn determinant(&self) -> T where
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<(usize, usize), D, Const<1_usize>>,
Computes the matrix determinant.
If the matrix has a dimension larger than 3, an LU decomposition is used.
Rectangular matrix decomposition
This section contains the methods for computing some common decompositions of rectangular matrices with real or complex components. The following are currently supported:
Decomposition | Factors | Details |
---|---|---|
QR | Q * R | Q is an unitary matrix, and R is upper-triangular. |
QR with column pivoting | Q * R * P⁻¹ | Q is an unitary matrix, and R is upper-triangular. P is a permutation matrix. |
LU with partial pivoting | P⁻¹ * L * U | L is lower-triangular with a diagonal filled with 1 and U is upper-triangular. P is a permutation matrix. |
LU with full pivoting | P⁻¹ * L * U * Q⁻¹ | L is lower-triangular with a diagonal filled with 1 and U is upper-triangular. P and Q are permutation matrices. |
SVD | U * Σ * Vᵀ | U and V are two orthogonal matrices and Σ is a diagonal matrix containing the singular values. |
pub fn bidiagonalize(self) -> Bidiagonal<T, R, C> where
R: DimMin<C>,
<R as DimMin<C>>::Output: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn bidiagonalize(self) -> Bidiagonal<T, R, C> where
R: DimMin<C>,
<R as DimMin<C>>::Output: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
Computes the bidiagonalization using householder reflections.
pub fn full_piv_lu(self) -> FullPivLU<T, R, C> where
R: DimMin<C>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, Const<1_usize>>,
pub fn full_piv_lu(self) -> FullPivLU<T, R, C> where
R: DimMin<C>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, Const<1_usize>>,
Computes the LU decomposition with full pivoting of matrix
.
This effectively computes P, L, U, Q
such that P * matrix * Q = LU
.
Computes the LU decomposition with partial (row) pivoting of matrix
.
pub fn qr(self) -> QR<T, R, C> where
R: DimMin<C>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
pub fn qr(self) -> QR<T, R, C> where
R: DimMin<C>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
Computes the QR decomposition of this matrix.
pub fn col_piv_qr(self) -> ColPivQR<T, R, C> where
R: DimMin<C>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, Const<1_usize>>,
pub fn col_piv_qr(self) -> ColPivQR<T, R, C> where
R: DimMin<C>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<(usize, usize), <R as DimMin<C>>::Output, Const<1_usize>>,
Computes the QR decomposition (with column pivoting) of this matrix.
pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<T, R, C> where
R: DimMin<C>,
<R as DimMin<C>>::Output: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, C>,
DefaultAllocator: Allocator<T, R, <R as DimMin<C>>::Output>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<T, R, C> where
R: DimMin<C>,
<R as DimMin<C>>::Output: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, C>,
DefaultAllocator: Allocator<T, R, <R as DimMin<C>>::Output>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
Computes the Singular Value Decomposition using implicit shift.
pub fn try_svd(
self,
compute_u: bool,
compute_v: bool,
eps: <T as ComplexField>::RealField,
max_niter: usize
) -> Option<SVD<T, R, C>> where
R: DimMin<C>,
<R as DimMin<C>>::Output: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, C>,
DefaultAllocator: Allocator<T, R, <R as DimMin<C>>::Output>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn try_svd(
self,
compute_u: bool,
compute_v: bool,
eps: <T as ComplexField>::RealField,
max_niter: usize
) -> Option<SVD<T, R, C>> where
R: DimMin<C>,
<R as DimMin<C>>::Output: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, C>,
DefaultAllocator: Allocator<T, R, <R as DimMin<C>>::Output>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
Attempts to compute the Singular Value Decomposition of matrix
using implicit shift.
Arguments
compute_u
− set this totrue
to enable the computation of left-singular vectors.compute_v
− set this totrue
to enable the computation of right-singular vectors.eps
− tolerance used to determine when a value converged to 0.max_niter
− maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded,None
is returned. Ifniter == 0
, then the algorithm continues indefinitely until convergence.
Square matrix decomposition
This section contains the methods for computing some common decompositions of square matrices with real or complex components. The following are currently supported:
Decomposition | Factors | Details |
---|---|---|
Hessenberg | Q * H * Qᵀ | Q is a unitary matrix and H an upper-Hessenberg matrix. |
Cholesky | L * Lᵀ | L is a lower-triangular matrix. |
UDU | U * D * Uᵀ | U is a upper-triangular matrix, and D a diagonal matrix. |
Schur decomposition | Q * T * Qᵀ | Q is an unitary matrix and T a quasi-upper-triangular matrix. |
Symmetric eigendecomposition | Q ~ Λ ~ Qᵀ | Q is an unitary matrix, and Λ is a real diagonal matrix. |
Symmetric tridiagonalization | Q ~ T ~ Qᵀ | Q is an unitary matrix, and T is a tridiagonal matrix. |
Attempts to compute the Cholesky decomposition of this matrix.
Returns None
if the input matrix is not definite-positive. The input matrix is assumed
to be symmetric and only the lower-triangular part is read.
pub fn udu(self) -> Option<UDU<T, D>> where
T: RealField,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
pub fn udu(self) -> Option<UDU<T, D>> where
T: RealField,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
Attempts to compute the UDU decomposition of this matrix.
The input matrix self
is assumed to be symmetric and this decomposition will only read
the upper-triangular part of self
.
pub fn hessenberg(self) -> Hessenberg<T, D> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn hessenberg(self) -> Hessenberg<T, D> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
Computes the Hessenberg decomposition of this matrix using householder reflections.
pub fn schur(self) -> Schur<T, D> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, <D as DimSub<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
pub fn schur(self) -> Schur<T, D> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, <D as DimSub<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
Computes the Schur decomposition of a square matrix.
pub fn try_schur(
self,
eps: <T as ComplexField>::RealField,
max_niter: usize
) -> Option<Schur<T, D>> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, <D as DimSub<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
pub fn try_schur(
self,
eps: <T as ComplexField>::RealField,
max_niter: usize
) -> Option<Schur<T, D>> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, <D as DimSub<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
Attempts to compute the Schur decomposition of a square matrix.
If only eigenvalues are needed, it is more efficient to call the matrix method
.eigenvalues()
instead.
Arguments
eps
− tolerance used to determine when a value converged to 0.max_niter
− maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded,None
is returned. Ifniter == 0
, then the algorithm continues indefinitely until convergence.
pub fn symmetric_eigen(self) -> SymmetricEigen<T, D> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, D, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn symmetric_eigen(self) -> SymmetricEigen<T, D> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, D, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
Computes the eigendecomposition of this symmetric matrix.
Only the lower-triangular part (including the diagonal) of m
is read.
pub fn try_symmetric_eigen(
self,
eps: <T as ComplexField>::RealField,
max_niter: usize
) -> Option<SymmetricEigen<T, D>> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, D, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn try_symmetric_eigen(
self,
eps: <T as ComplexField>::RealField,
max_niter: usize
) -> Option<SymmetricEigen<T, D>> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, D, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
Computes the eigendecomposition of the given symmetric matrix with user-specified convergence parameters.
Only the lower-triangular part (including the diagonal) of m
is read.
Arguments
eps
− tolerance used to determine when a value converged to 0.max_niter
− maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded,None
is returned. Ifniter == 0
, then the algorithm continues indefinitely until convergence.
pub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<T, D> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<T, D> where
D: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
Computes the tridiagonalization of this symmetric matrix.
Only the lower-triangular part (including the diagonal) of m
is read.
impl<T, D> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
T: ComplexField,
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<(usize, usize), <D as DimMin<D>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, D, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, D, D>,
impl<T, D> Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer> where
T: ComplexField,
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<(usize, usize), <D as DimMin<D>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, D, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, D, D>,
pub fn try_inverse(
self
) -> Option<Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>> where
DefaultAllocator: Allocator<T, D, D>,
pub fn try_inverse(
self
) -> Option<Matrix<T, D, D, <DefaultAllocator as Allocator<T, D, D>>::Buffer>> where
DefaultAllocator: Allocator<T, D, D>,
Attempts to invert this matrix.
Attempts to invert this matrix in-place. Returns false
and leaves self
untouched if
inversion fails.
impl<T, D, S> Matrix<T, D, D, S> where
T: ComplexField,
D: DimMin<D, Output = D>,
S: StorageMut<T, D, D>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
impl<T, D, S> Matrix<T, D, D, S> where
T: ComplexField,
D: DimMin<D, Output = D>,
S: StorageMut<T, D, D>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
Attempts to raise this matrix to an integral power e
in-place. If this
matrix is non-invertible and e
is negative, it leaves this matrix
untouched and returns false
. Otherwise, it returns true
and
overwrites this matrix with the result.
impl<T, D, S> Matrix<T, D, D, S> where
T: ComplexField,
S: Storage<T, D, D> + StorageMut<T, D, D>,
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
impl<T, D, S> Matrix<T, D, D, S> where
T: ComplexField,
S: Storage<T, D, D> + StorageMut<T, D, D>,
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
Attempts to raise this matrix to an integral power e
. If this matrix
is non-invertible and e
is negative, it returns None
. Otherwise, it
returns the result as a new matrix. Uses exponentiation by squares.
impl<T, D, S> Matrix<T, D, D, S> where
T: ComplexField,
D: Dim + DimSub<Const<1_usize>>,
S: Storage<T, D, D>,
DefaultAllocator: Allocator<T, D, <D as DimSub<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
impl<T, D, S> Matrix<T, D, D, S> where
T: ComplexField,
D: Dim + DimSub<Const<1_usize>>,
S: Storage<T, D, D>,
DefaultAllocator: Allocator<T, D, <D as DimSub<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
pub fn eigenvalues(
&self
) -> Option<Matrix<T, D, Const<1_usize>, <DefaultAllocator as Allocator<T, D, Const<1_usize>>>::Buffer>>
pub fn eigenvalues(
&self
) -> Option<Matrix<T, D, Const<1_usize>, <DefaultAllocator as Allocator<T, D, Const<1_usize>>>::Buffer>>
Computes the eigenvalues of this matrix.
pub fn complex_eigenvalues(
&self
) -> Matrix<Complex<T>, D, Const<1_usize>, <DefaultAllocator as Allocator<Complex<T>, D, Const<1_usize>>>::Buffer> where
T: RealField,
DefaultAllocator: Allocator<Complex<T>, D, Const<1_usize>>,
pub fn complex_eigenvalues(
&self
) -> Matrix<Complex<T>, D, Const<1_usize>, <DefaultAllocator as Allocator<Complex<T>, D, Const<1_usize>>>::Buffer> where
T: RealField,
DefaultAllocator: Allocator<Complex<T>, D, Const<1_usize>>,
Computes the eigenvalues of this matrix.
pub fn solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_upper_triangular<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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<T, R2, C2, S2>,
diag: T
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular_with_diag_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>,
diag: T
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_upper_triangular<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_lower_triangular<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_upper_triangular<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer>> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_lower_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_upper_triangular_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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 solve_lower_triangular_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_upper_triangular_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>,
diag: T
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular_with_diag_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>,
diag: T
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_upper_triangular_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_lower_triangular_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_upper_triangular_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_lower_triangular_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_upper_triangular_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_lower_triangular_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_upper_triangular_unchecked<R2, C2, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Matrix<T, R2, C2, <DefaultAllocator as Allocator<T, R2, C2>>::Buffer> where
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, 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_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_lower_triangular_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_upper_triangular_unchecked_mut<R2, C2, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) where
R2: Dim,
C2: Dim,
S2: StorageMut<T, 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.
impl<T, R, C, S> Matrix<T, R, C, S> where
T: ComplexField,
R: DimMin<C>,
C: Dim,
S: Storage<T, R, C>,
<R as DimMin<C>>::Output: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, C>,
DefaultAllocator: Allocator<T, R, <R as DimMin<C>>::Output>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
impl<T, R, C, S> Matrix<T, R, C, S> where
T: ComplexField,
R: DimMin<C>,
C: Dim,
S: Storage<T, R, C>,
<R as DimMin<C>>::Output: DimSub<Const<1_usize>>,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<T, C, Const<1_usize>>,
DefaultAllocator: Allocator<T, R, Const<1_usize>>,
DefaultAllocator: Allocator<T, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, C>,
DefaultAllocator: Allocator<T, R, <R as DimMin<C>>::Output>,
DefaultAllocator: Allocator<T, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <<R as DimMin<C>>::Output as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn singular_values(
&self
) -> Matrix<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1_usize>>>::Buffer>
pub fn singular_values(
&self
) -> Matrix<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<<T as ComplexField>::RealField, <R as DimMin<C>>::Output, Const<1_usize>>>::Buffer>
Computes the singular values of this matrix.
Computes the rank of this matrix.
All singular values below eps
are considered equal to 0.
pub fn pseudo_inverse(
self,
eps: <T as ComplexField>::RealField
) -> Result<Matrix<T, C, R, <DefaultAllocator as Allocator<T, C, R>>::Buffer>, &'static str> where
DefaultAllocator: Allocator<T, C, R>,
pub fn pseudo_inverse(
self,
eps: <T as ComplexField>::RealField
) -> Result<Matrix<T, C, R, <DefaultAllocator as Allocator<T, C, R>>::Buffer>, &'static str> where
DefaultAllocator: Allocator<T, C, R>,
Computes the pseudo-inverse of this matrix.
All singular values below eps
are considered equal to 0.
impl<T, D, S> Matrix<T, D, D, S> where
T: ComplexField,
D: DimSub<Const<1_usize>>,
S: Storage<T, D, D>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, D, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
impl<T, D, S> Matrix<T, D, D, S> where
T: ComplexField,
D: DimSub<Const<1_usize>>,
S: Storage<T, D, D>,
DefaultAllocator: Allocator<T, D, D>,
DefaultAllocator: Allocator<T, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, D, Const<1_usize>>,
DefaultAllocator: Allocator<<T as ComplexField>::RealField, <D as DimSub<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn symmetric_eigenvalues(
&self
) -> Matrix<<T as ComplexField>::RealField, D, Const<1_usize>, <DefaultAllocator as Allocator<<T as ComplexField>::RealField, D, Const<1_usize>>>::Buffer>
pub fn symmetric_eigenvalues(
&self
) -> Matrix<<T as ComplexField>::RealField, D, Const<1_usize>, <DefaultAllocator as Allocator<<T as ComplexField>::RealField, D, Const<1_usize>>>::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<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
pub fn add_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, 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<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
pub fn sub_to<R2, C2, SB, R3, C3, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
) where
R2: Dim,
C2: Dim,
R3: Dim,
C3: Dim,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R3>,
ShapeConstraint: SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<T, R, C>,
impl<T, R, C> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar,
R: DimName,
C: DimName,
DefaultAllocator: Allocator<T, R, C>,
pub fn from_row_slice(
data: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
pub fn from_row_slice(
data: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
Example
let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(&[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
pub fn from_column_slice(
data: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
pub fn from_column_slice(
data: &[T]
) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in column-major order.
Example
let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(&[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
pub fn from_row_slice(
data: &[T]
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer>
pub fn from_row_slice(
data: &[T]
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
Example
let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(&[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
pub fn from_column_slice(
data: &[T]
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer>
pub fn from_column_slice(
data: &[T]
) -> Matrix<T, R, Dynamic, <DefaultAllocator as Allocator<T, R, Dynamic>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in column-major order.
Example
let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(&[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
pub fn from_row_slice(
data: &[T]
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer>
pub fn from_row_slice(
data: &[T]
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
Example
let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(&[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
pub fn from_column_slice(
data: &[T]
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer>
pub fn from_column_slice(
data: &[T]
) -> Matrix<T, Dynamic, C, <DefaultAllocator as Allocator<T, Dynamic, C>>::Buffer>
Creates a matrix with its elements filled with the components provided by a slice in column-major order.
Example
let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(&[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
Example
let v = Vector3::from_row_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_row_slice(&[0, 1, 2]);
let m = Matrix2x3::from_row_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
Creates a matrix with its elements filled with the components provided by a slice in column-major order.
Example
let v = Vector3::from_column_slice(&[0, 1, 2]);
// The additional argument represents the vector dimension.
let dv = DVector::from_column_slice(&[0, 1, 2]);
let m = Matrix2x3::from_column_slice(&[0, 1, 2, 3, 4, 5]);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_column_slice(2, 3, &[0, 1, 2, 3, 4, 5]);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
pub const fn new(
m11: T,
m12: T,
m13: T,
m14: T,
m15: T,
m21: T,
m22: T,
m23: T,
m24: T,
m25: T,
m31: T,
m32: T,
m33: T,
m34: T,
m35: T,
m41: T,
m42: T,
m43: T,
m44: T,
m45: T,
m51: T,
m52: T,
m53: T,
m54: T,
m55: T
) -> Matrix<T, Const<5_usize>, Const<5_usize>, ArrayStorage<T, 5_usize, 5_usize>>
pub const fn new(
m11: T,
m12: T,
m13: T,
m14: T,
m15: T,
m21: T,
m22: T,
m23: T,
m24: T,
m25: T,
m31: T,
m32: T,
m33: T,
m34: T,
m35: T,
m41: T,
m42: T,
m43: T,
m44: T,
m45: T,
m51: T,
m52: T,
m53: T,
m54: T,
m55: T
) -> Matrix<T, Const<5_usize>, Const<5_usize>, ArrayStorage<T, 5_usize, 5_usize>>
Initializes this matrix from its components.
pub const fn new(
m11: T,
m12: T,
m13: T,
m14: T,
m15: T,
m16: T,
m21: T,
m22: T,
m23: T,
m24: T,
m25: T,
m26: T,
m31: T,
m32: T,
m33: T,
m34: T,
m35: T,
m36: T,
m41: T,
m42: T,
m43: T,
m44: T,
m45: T,
m46: T,
m51: T,
m52: T,
m53: T,
m54: T,
m55: T,
m56: T,
m61: T,
m62: T,
m63: T,
m64: T,
m65: T,
m66: T
) -> Matrix<T, Const<6_usize>, Const<6_usize>, ArrayStorage<T, 6_usize, 6_usize>>
pub const fn new(
m11: T,
m12: T,
m13: T,
m14: T,
m15: T,
m16: T,
m21: T,
m22: T,
m23: T,
m24: T,
m25: T,
m26: T,
m31: T,
m32: T,
m33: T,
m34: T,
m35: T,
m36: T,
m41: T,
m42: T,
m43: T,
m44: T,
m45: T,
m46: T,
m51: T,
m52: T,
m53: T,
m54: T,
m55: T,
m56: T,
m61: T,
m62: T,
m63: T,
m64: T,
m65: T,
m66: T
) -> Matrix<T, Const<6_usize>, Const<6_usize>, ArrayStorage<T, 6_usize, 6_usize>>
Initializes this matrix from its components.
Initializes this matrix from its components.
Initializes this matrix from its components.
Initializes this matrix from its components.
pub const fn new(
m11: T,
m12: T,
m13: T,
m14: T,
m15: T,
m16: T,
m21: T,
m22: T,
m23: T,
m24: T,
m25: T,
m26: T,
m31: T,
m32: T,
m33: T,
m34: T,
m35: T,
m36: T,
m41: T,
m42: T,
m43: T,
m44: T,
m45: T,
m46: T,
m51: T,
m52: T,
m53: T,
m54: T,
m55: T,
m56: T
) -> Matrix<T, Const<5_usize>, Const<6_usize>, ArrayStorage<T, 5_usize, 6_usize>>
pub const fn new(
m11: T,
m12: T,
m13: T,
m14: T,
m15: T,
m16: T,
m21: T,
m22: T,
m23: T,
m24: T,
m25: T,
m26: T,
m31: T,
m32: T,
m33: T,
m34: T,
m35: T,
m36: T,
m41: T,
m42: T,
m43: T,
m44: T,
m45: T,
m46: T,
m51: T,
m52: T,
m53: T,
m54: T,
m55: T,
m56: T
) -> Matrix<T, Const<5_usize>, Const<6_usize>, ArrayStorage<T, 5_usize, 6_usize>>
Initializes this matrix from its components.
Initializes this matrix from its components.
pub const fn new(
m11: T,
m12: T,
m13: T,
m14: T,
m15: T,
m21: T,
m22: T,
m23: T,
m24: T,
m25: T,
m31: T,
m32: T,
m33: T,
m34: T,
m35: T,
m41: T,
m42: T,
m43: T,
m44: T,
m45: T,
m51: T,
m52: T,
m53: T,
m54: T,
m55: T,
m61: T,
m62: T,
m63: T,
m64: T,
m65: T
) -> Matrix<T, Const<6_usize>, Const<5_usize>, ArrayStorage<T, 6_usize, 5_usize>>
pub const fn new(
m11: T,
m12: T,
m13: T,
m14: T,
m15: T,
m21: T,
m22: T,
m23: T,
m24: T,
m25: T,
m31: T,
m32: T,
m33: T,
m34: T,
m35: T,
m41: T,
m42: T,
m43: T,
m44: T,
m45: T,
m51: T,
m52: T,
m53: T,
m54: T,
m55: T,
m61: T,
m62: T,
m63: T,
m64: T,
m65: T
) -> Matrix<T, Const<6_usize>, Const<5_usize>, ArrayStorage<T, 6_usize, 5_usize>>
Initializes this matrix from its components.
pub fn from_slice(
data: &'a [T]
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Const<1_usize>, R>>
pub fn from_slice(
data: &'a [T]
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Const<1_usize>, R>>
Creates a new matrix slice from the given data array.
Panics if data
does not contain enough elements.
pub unsafe fn from_slice_unchecked(
data: &'a [T],
start: usize
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Const<1_usize>, R>>
pub unsafe fn from_slice_unchecked(
data: &'a [T],
start: usize
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Const<1_usize>, R>>
Creates, without bound checking, a new matrix slice from the given data array.
pub fn from_slice_with_strides(
data: &'a [T],
rstride: usize,
cstride: usize
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Dynamic, Dynamic>>
pub fn from_slice_with_strides(
data: &'a [T],
rstride: usize,
cstride: usize
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Dynamic, Dynamic>>
Creates a new matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a [T],
start: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a [T],
start: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, Dynamic, Dynamic>>
Creates, without bound checking, a new matrix slice with the specified strides from the given data array.
pub fn from_slice(
data: &'a [T],
ncols: usize
) -> Matrix<T, R, Dynamic, SliceStorage<'a, T, R, Dynamic, Const<1_usize>, R>>
pub fn from_slice(
data: &'a [T],
ncols: usize
) -> Matrix<T, R, Dynamic, SliceStorage<'a, T, R, Dynamic, Const<1_usize>, R>>
Creates a new matrix slice from the given data array.
Panics if data
does not contain enough elements.
pub unsafe fn from_slice_unchecked(
data: &'a [T],
start: usize,
ncols: usize
) -> Matrix<T, R, Dynamic, SliceStorage<'a, T, R, Dynamic, Const<1_usize>, R>>
pub unsafe fn from_slice_unchecked(
data: &'a [T],
start: usize,
ncols: usize
) -> Matrix<T, R, Dynamic, SliceStorage<'a, T, R, Dynamic, Const<1_usize>, R>>
Creates, without bound checking, a new matrix slice from the given data array.
Creates a new matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
Creates, without bound checking, a new matrix slice with the specified strides from the given data array.
pub fn from_slice(
data: &'a [T],
nrows: usize
) -> Matrix<T, Dynamic, C, SliceStorage<'a, T, Dynamic, C, Const<1_usize>, Dynamic>>
pub fn from_slice(
data: &'a [T],
nrows: usize
) -> Matrix<T, Dynamic, C, SliceStorage<'a, T, Dynamic, C, Const<1_usize>, Dynamic>>
Creates a new matrix slice from the given data array.
Panics if data
does not contain enough elements.
Creates a new matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
Creates, without bound checking, a new matrix slice with the specified strides from the given data array.
Creates a new matrix slice from the given data array.
Panics if data
does not contain enough elements.
Creates a new matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
Creates, without bound checking, a new matrix slice with the specified strides from the given data array.
pub fn from_slice(
data: &'a mut [T]
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Const<1_usize>, R>>
pub fn from_slice(
data: &'a mut [T]
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Const<1_usize>, R>>
Creates a new mutable matrix slice from the given data array.
Panics if data
does not contain enough elements.
pub unsafe fn from_slice_unchecked(
data: &'a mut [T],
start: usize
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Const<1_usize>, R>>
pub unsafe fn from_slice_unchecked(
data: &'a mut [T],
start: usize
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Const<1_usize>, R>>
Creates, without bound checking, a new mutable matrix slice from the given data array.
pub fn from_slice_with_strides_mut(
data: &'a mut [T],
rstride: usize,
cstride: usize
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Dynamic, Dynamic>>
pub fn from_slice_with_strides_mut(
data: &'a mut [T],
rstride: usize,
cstride: usize
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Dynamic, Dynamic>>
Creates a new mutable matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [T],
start: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [T],
start: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, R, C, SliceStorageMut<'a, T, R, C, Dynamic, Dynamic>>
Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.
pub fn from_slice(
data: &'a mut [T],
ncols: usize
) -> Matrix<T, R, Dynamic, SliceStorageMut<'a, T, R, Dynamic, Const<1_usize>, R>>
pub fn from_slice(
data: &'a mut [T],
ncols: usize
) -> Matrix<T, R, Dynamic, SliceStorageMut<'a, T, R, Dynamic, Const<1_usize>, R>>
Creates a new mutable matrix slice from the given data array.
Panics if data
does not contain enough elements.
pub unsafe fn from_slice_unchecked(
data: &'a mut [T],
start: usize,
ncols: usize
) -> Matrix<T, R, Dynamic, SliceStorageMut<'a, T, R, Dynamic, Const<1_usize>, R>>
pub unsafe fn from_slice_unchecked(
data: &'a mut [T],
start: usize,
ncols: usize
) -> Matrix<T, R, Dynamic, SliceStorageMut<'a, T, R, Dynamic, Const<1_usize>, R>>
Creates, without bound checking, a new mutable matrix slice from the given data array.
pub fn from_slice_with_strides_mut(
data: &'a mut [T],
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, R, Dynamic, SliceStorageMut<'a, T, R, Dynamic, Dynamic, Dynamic>>
pub fn from_slice_with_strides_mut(
data: &'a mut [T],
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, R, Dynamic, SliceStorageMut<'a, T, R, Dynamic, Dynamic, Dynamic>>
Creates a new mutable matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [T],
start: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, R, Dynamic, SliceStorageMut<'a, T, R, Dynamic, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [T],
start: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, R, Dynamic, SliceStorageMut<'a, T, R, Dynamic, Dynamic, Dynamic>>
Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.
pub fn from_slice(
data: &'a mut [T],
nrows: usize
) -> Matrix<T, Dynamic, C, SliceStorageMut<'a, T, Dynamic, C, Const<1_usize>, Dynamic>>
pub fn from_slice(
data: &'a mut [T],
nrows: usize
) -> Matrix<T, Dynamic, C, SliceStorageMut<'a, T, Dynamic, C, Const<1_usize>, Dynamic>>
Creates a new mutable matrix slice from the given data array.
Panics if data
does not contain enough elements.
pub unsafe fn from_slice_unchecked(
data: &'a mut [T],
start: usize,
nrows: usize
) -> Matrix<T, Dynamic, C, SliceStorageMut<'a, T, Dynamic, C, Const<1_usize>, Dynamic>>
pub unsafe fn from_slice_unchecked(
data: &'a mut [T],
start: usize,
nrows: usize
) -> Matrix<T, Dynamic, C, SliceStorageMut<'a, T, Dynamic, C, Const<1_usize>, Dynamic>>
Creates, without bound checking, a new mutable matrix slice from the given data array.
pub fn from_slice_with_strides_mut(
data: &'a mut [T],
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, Dynamic, C, SliceStorageMut<'a, T, Dynamic, C, Dynamic, Dynamic>>
pub fn from_slice_with_strides_mut(
data: &'a mut [T],
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, Dynamic, C, SliceStorageMut<'a, T, Dynamic, C, Dynamic, Dynamic>>
Creates a new mutable matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [T],
start: usize,
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, Dynamic, C, SliceStorageMut<'a, T, Dynamic, C, Dynamic, Dynamic>>
pub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [T],
start: usize,
nrows: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, Dynamic, C, SliceStorageMut<'a, T, Dynamic, C, Dynamic, Dynamic>>
Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.
pub fn from_slice(
data: &'a mut [T],
nrows: usize,
ncols: usize
) -> Matrix<T, Dynamic, Dynamic, SliceStorageMut<'a, T, Dynamic, Dynamic, Const<1_usize>, Dynamic>>
pub fn from_slice(
data: &'a mut [T],
nrows: usize,
ncols: usize
) -> Matrix<T, Dynamic, Dynamic, SliceStorageMut<'a, T, Dynamic, Dynamic, Const<1_usize>, Dynamic>>
Creates a new mutable matrix slice from the given data array.
Panics if data
does not contain enough elements.
pub unsafe fn from_slice_unchecked(
data: &'a mut [T],
start: usize,
nrows: usize,
ncols: usize
) -> Matrix<T, Dynamic, Dynamic, SliceStorageMut<'a, T, Dynamic, Dynamic, Const<1_usize>, Dynamic>>
pub unsafe fn from_slice_unchecked(
data: &'a mut [T],
start: usize,
nrows: usize,
ncols: usize
) -> Matrix<T, Dynamic, Dynamic, SliceStorageMut<'a, T, Dynamic, Dynamic, Const<1_usize>, Dynamic>>
Creates, without bound checking, a new mutable matrix slice from the given data array.
pub fn from_slice_with_strides_mut(
data: &'a mut [T],
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, Dynamic, Dynamic, SliceStorageMut<'a, T, Dynamic, Dynamic, Dynamic, Dynamic>>
pub fn from_slice_with_strides_mut(
data: &'a mut [T],
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Matrix<T, Dynamic, Dynamic, SliceStorageMut<'a, T, Dynamic, Dynamic, Dynamic, Dynamic>>
Creates a new mutable matrix slice with the specified strides from the given data array.
Panics if data
does not contain enough elements.
Creates, without bound checking, a new mutable matrix slice with the specified strides from the given data array.
Trait Implementations
type Epsilon = <T as AbsDiffEq<T>>::Epsilon
type Epsilon = <T as AbsDiffEq<T>>::Epsilon
Used for specifying relative comparisons.
The default tolerance to use when testing values that are close together. Read more
A test for equality that uses the absolute difference to compute the approximate equality of two numbers. Read more
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
The inverse of [AbsDiffEq::abs_diff_eq
].
impl<'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1_usize>, SB>> for OPoint<T, D1> where
T: Scalar + ClosedAdd<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1_usize>, SB>> for OPoint<T, D1> where
T: Scalar + ClosedAdd<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'a, 'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1_usize>, SB>> for &'a OPoint<T, D1> where
T: Scalar + ClosedAdd<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'a, 'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1_usize>, SB>> for &'a OPoint<T, D1> where
T: Scalar + ClosedAdd<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'b, T, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<'b, T, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
The resulting type after applying the +
operator.
impl<'a, 'b, T, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<'a, 'b, T, R1, C1, R2, C2, SA, SB> Add<&'b Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
The resulting type after applying the +
operator.
impl<T, D1, D2, SB> Add<Matrix<T, D2, Const<1_usize>, SB>> for OPoint<T, D1> where
T: Scalar + ClosedAdd<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<T, D1, D2, SB> Add<Matrix<T, D2, Const<1_usize>, SB>> for OPoint<T, D1> where
T: Scalar + ClosedAdd<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'a, T, D1, D2, SB> Add<Matrix<T, D2, Const<1_usize>, SB>> for &'a OPoint<T, D1> where
T: Scalar + ClosedAdd<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'a, T, D1, D2, SB> Add<Matrix<T, D2, Const<1_usize>, SB>> for &'a OPoint<T, D1> where
T: Scalar + ClosedAdd<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<T, R1, C1, R2, C2, SA, SB> Add<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<T, R1, C1, R2, C2, SA, SB> Add<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
The resulting type after applying the +
operator.
impl<'a, T, R1, C1, R2, C2, SA, SB> Add<Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1>,
ShapeConstraint: SameNumberOfColumns<C2, C1>,
impl<'a, T, R1, C1, R2, C2, SA, SB> Add<Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1>,
ShapeConstraint: SameNumberOfColumns<C2, C1>,
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer>
The resulting type after applying the +
operator.
Performs the +=
operation. Read more
impl<'b, T, R1, C1, R2, C2, SA, SB> AddAssign<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<'b, T, R1, C1, R2, C2, SA, SB> AddAssign<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
Performs the +=
operation. Read more
Performs the +=
operation. Read more
impl<T, R1, C1, R2, C2, SA, SB> AddAssign<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<T, R1, C1, R2, C2, SA, SB> AddAssign<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedAdd<T>,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
Performs the +=
operation. Read more
returns the largest finite number this type can represent
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> Deref for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorage<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<1_usize>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<1_usize>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<1_usize>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<1_usize>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<T, S> DerefMut for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, S> where
T: Scalar,
S: RawStorageMut<T, Const<{_: usize}>, Const<{_: usize}>> + IsContiguous,
impl<'a, 'b, T, R1, C1, SA, const D2: usize> Div<&'b Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<'a, 'b, T, R1, C1, SA, const D2: usize> Div<&'b Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<'b, T, R1, C1, SA, const D2: usize> Div<&'b Rotation<T, D2>> for Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<'b, T, R1, C1, SA, const D2: usize> Div<&'b Rotation<T, D2>> for Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<'a, T, R1, C1, SA, const D2: usize> Div<Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<'a, T, R1, C1, SA, const D2: usize> Div<Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
Performs the /=
operation. Read more
Performs the /=
operation. Read more
Performs the /=
operation. Read more
pub fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = Matrix<T, RV, Const<1_usize>, SV>>,
pub fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = Matrix<T, RV, Const<1_usize>, SV>>,
Extends the number of columns of a Matrix
with Vector
s
from a given iterator.
Example
let data = vec![0, 1, 2, // column 1
3, 4, 5]; // column 2
let mut matrix = DMatrix::from_vec(3, 2, data);
matrix.extend(
vec![Vector3::new(6, 7, 8), // column 3
Vector3::new(9, 10, 11)]); // column 4
assert!(matrix.eq(&Matrix3x4::new(0, 3, 6, 9,
1, 4, 7, 10,
2, 5, 8, 11)));
Panics
This function panics if the dimension of each Vector
yielded
by the given iterator is not equal to the number of rows of
this Matrix
.
let mut matrix =
DMatrix::from_vec(3, 2,
vec![0, 1, 2, // column 1
3, 4, 5]); // column 2
// The following panics because this matrix can only be extended with 3-dimensional vectors.
matrix.extend(
vec![Vector2::new(6, 7)]); // too few dimensions!
let mut matrix =
DMatrix::from_vec(3, 2,
vec![0, 1, 2, // column 1
3, 4, 5]); // column 2
// The following panics because this matrix can only be extended with 3-dimensional vectors.
matrix.extend(
vec![Vector4::new(6, 7, 8, 9)]); // too few dimensions!
extend_one
)Extends a collection with exactly one element.
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<T, R, RV, SV> Extend<Matrix<T, RV, Const<1_usize>, SV>> for VecStorage<T, R, Dynamic> where
T: Scalar,
R: Dim,
RV: Dim,
SV: RawStorage<T, RV, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<R, RV>,
impl<T, R, RV, SV> Extend<Matrix<T, RV, Const<1_usize>, SV>> for VecStorage<T, R, Dynamic> where
T: Scalar,
R: Dim,
RV: Dim,
SV: RawStorage<T, RV, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<R, RV>,
pub fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = Matrix<T, RV, Const<1_usize>, SV>>,
pub fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = Matrix<T, RV, Const<1_usize>, SV>>,
Extends the number of columns of the VecStorage
with vectors
from the given iterator.
Panics
This function panics if the number of rows of each Vector
yielded by the iterator is not equal to the number of rows
of this VecStorage
.
extend_one
)Extends a collection with exactly one element.
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
Extend the number of columns of the Matrix
with elements from
a given iterator.
Extend the number of columns of the Matrix
with elements
from the given iterator.
Example
let data = vec![0, 1, 2, // column 1
3, 4, 5]; // column 2
let mut matrix = DMatrix::from_vec(3, 2, data);
matrix.extend(vec![6, 7, 8]); // column 3
assert!(matrix.eq(&Matrix3::new(0, 3, 6,
1, 4, 7,
2, 5, 8)));
Panics
This function panics if the number of elements yielded by the
given iterator is not a multiple of the number of rows of the
Matrix
.
let data = vec![0, 1, 2, // column 1
3, 4, 5]; // column 2
let mut matrix = DMatrix::from_vec(3, 2, data);
// The following panics because the vec length is not a multiple of 3.
matrix.extend(vec![6, 7, 8, 9]);
extend_one
)Extends a collection with exactly one element.
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
Extend the number of rows of the Vector
with elements from
a given iterator.
Extend the number of rows of a Vector
with elements
from the given iterator.
Example
let mut vector = DVector::from_vec(vec![0, 1, 2]);
vector.extend(vec![3, 4, 5]);
assert!(vector.eq(&DVector::from_vec(vec![0, 1, 2, 3, 4, 5])));
extend_one
)Extends a collection with exactly one element.
extend_one
)Reserves capacity in a collection for the given number of additional elements. Read more
impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a Matrix<T, R, C, S>> for Matrix<T, RSlice, CSlice, SliceStorage<'a, T, RSlice, CSlice, RStride, CStride>> where
T: Scalar,
R: Dim,
C: Dim,
RSlice: Dim,
CSlice: Dim,
RStride: Dim,
CStride: Dim,
S: RawStorage<T, R, C>,
ShapeConstraint: DimEq<R, RSlice>,
ShapeConstraint: DimEq<C, CSlice>,
ShapeConstraint: DimEq<RStride, <S as RawStorage<T, R, C>>::RStride>,
ShapeConstraint: DimEq<CStride, <S as RawStorage<T, R, C>>::CStride>,
impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a Matrix<T, R, C, S>> for Matrix<T, RSlice, CSlice, SliceStorage<'a, T, RSlice, CSlice, RStride, CStride>> where
T: Scalar,
R: Dim,
C: Dim,
RSlice: Dim,
CSlice: Dim,
RStride: Dim,
CStride: Dim,
S: RawStorage<T, R, C>,
ShapeConstraint: DimEq<R, RSlice>,
ShapeConstraint: DimEq<C, CSlice>,
ShapeConstraint: DimEq<RStride, <S as RawStorage<T, R, C>>::RStride>,
ShapeConstraint: DimEq<CStride, <S as RawStorage<T, R, C>>::CStride>,
pub fn from(
m: &'a Matrix<T, R, C, S>
) -> Matrix<T, RSlice, CSlice, SliceStorage<'a, T, RSlice, CSlice, RStride, CStride>>
pub fn from(
m: &'a Matrix<T, R, C, S>
) -> Matrix<T, RSlice, CSlice, SliceStorage<'a, T, RSlice, CSlice, RStride, CStride>>
Performs the conversion.
impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>> for Matrix<T, RSlice, CSlice, SliceStorage<'a, T, RSlice, CSlice, RStride, CStride>> where
T: Scalar,
R: Dim,
C: Dim,
RSlice: Dim,
CSlice: Dim,
RStride: Dim,
CStride: Dim,
S: RawStorage<T, R, C>,
ShapeConstraint: DimEq<R, RSlice>,
ShapeConstraint: DimEq<C, CSlice>,
ShapeConstraint: DimEq<RStride, <S as RawStorage<T, R, C>>::RStride>,
ShapeConstraint: DimEq<CStride, <S as RawStorage<T, R, C>>::CStride>,
impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>> for Matrix<T, RSlice, CSlice, SliceStorage<'a, T, RSlice, CSlice, RStride, CStride>> where
T: Scalar,
R: Dim,
C: Dim,
RSlice: Dim,
CSlice: Dim,
RStride: Dim,
CStride: Dim,
S: RawStorage<T, R, C>,
ShapeConstraint: DimEq<R, RSlice>,
ShapeConstraint: DimEq<C, CSlice>,
ShapeConstraint: DimEq<RStride, <S as RawStorage<T, R, C>>::RStride>,
ShapeConstraint: DimEq<CStride, <S as RawStorage<T, R, C>>::CStride>,
pub fn from(
m: &'a mut Matrix<T, R, C, S>
) -> Matrix<T, RSlice, CSlice, SliceStorage<'a, T, RSlice, CSlice, RStride, CStride>>
pub fn from(
m: &'a mut Matrix<T, R, C, S>
) -> Matrix<T, RSlice, CSlice, SliceStorage<'a, T, RSlice, CSlice, RStride, CStride>>
Performs the conversion.
impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>> for Matrix<T, RSlice, CSlice, SliceStorageMut<'a, T, RSlice, CSlice, RStride, CStride>> where
T: Scalar,
R: Dim,
C: Dim,
RSlice: Dim,
CSlice: Dim,
RStride: Dim,
CStride: Dim,
S: RawStorageMut<T, R, C>,
ShapeConstraint: DimEq<R, RSlice>,
ShapeConstraint: DimEq<C, CSlice>,
ShapeConstraint: DimEq<RStride, <S as RawStorage<T, R, C>>::RStride>,
ShapeConstraint: DimEq<CStride, <S as RawStorage<T, R, C>>::CStride>,
impl<'a, T, R, C, RSlice, CSlice, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>> for Matrix<T, RSlice, CSlice, SliceStorageMut<'a, T, RSlice, CSlice, RStride, CStride>> where
T: Scalar,
R: Dim,
C: Dim,
RSlice: Dim,
CSlice: Dim,
RStride: Dim,
CStride: Dim,
S: RawStorageMut<T, R, C>,
ShapeConstraint: DimEq<R, RSlice>,
ShapeConstraint: DimEq<C, CSlice>,
ShapeConstraint: DimEq<RStride, <S as RawStorage<T, R, C>>::RStride>,
ShapeConstraint: DimEq<CStride, <S as RawStorage<T, R, C>>::CStride>,
pub fn from(
m: &'a mut Matrix<T, R, C, S>
) -> Matrix<T, RSlice, CSlice, SliceStorageMut<'a, T, RSlice, CSlice, RStride, CStride>>
pub fn from(
m: &'a mut Matrix<T, R, C, S>
) -> Matrix<T, RSlice, CSlice, SliceStorageMut<'a, T, RSlice, CSlice, RStride, CStride>>
Performs the conversion.
impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 16]> for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 16]>,
R: Dim,
C: Dim,
<T as SimdValue>::Element: Scalar,
<T as SimdValue>::Element: SimdValue,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 16]> for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 16]>,
R: Dim,
C: Dim,
<T as SimdValue>::Element: Scalar,
<T as SimdValue>::Element: SimdValue,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 2]> for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 2]>,
R: Dim,
C: Dim,
<T as SimdValue>::Element: Scalar,
<T as SimdValue>::Element: SimdValue,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 2]> for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 2]>,
R: Dim,
C: Dim,
<T as SimdValue>::Element: Scalar,
<T as SimdValue>::Element: SimdValue,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 4]> for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 4]>,
R: Dim,
C: Dim,
<T as SimdValue>::Element: Scalar,
<T as SimdValue>::Element: SimdValue,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 4]> for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 4]>,
R: Dim,
C: Dim,
<T as SimdValue>::Element: Scalar,
<T as SimdValue>::Element: SimdValue,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 8]> for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 8]>,
R: Dim,
C: Dim,
<T as SimdValue>::Element: Scalar,
<T as SimdValue>::Element: SimdValue,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
impl<T, R, C> From<[Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>; 8]> for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: Scalar + PrimitiveSimdValue + From<[<T as SimdValue>::Element; 8]>,
R: Dim,
C: Dim,
<T as SimdValue>::Element: Scalar,
<T as SimdValue>::Element: SimdValue,
DefaultAllocator: Allocator<T, R, C>,
DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,
impl<T, R, const D: usize> From<Isometry<T, R, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer> where
T: SimdRealField,
R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>>,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
impl<T, R, const D: usize> From<Isometry<T, R, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer> where
T: SimdRealField,
R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>>,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
pub fn from(
iso: Isometry<T, R, D>
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
pub fn from(
iso: Isometry<T, R, D>
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
Performs the conversion.
impl<T, R, const D: usize> From<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Isometry<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
impl<T, R, const D: usize> From<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Isometry<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
impl<T> From<Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>> for Quaternion<T> where
T: Scalar,
impl<T> From<Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>> for Quaternion<T> where
T: Scalar,
pub fn from(
coords: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>
) -> Quaternion<T>
pub fn from(
coords: Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 4_usize, 1_usize>>
) -> Quaternion<T>
Performs the conversion.
pub fn from(
matrix_slice: Matrix<T, Dynamic, C, SliceStorage<'a, T, Dynamic, C, RStride, CStride>>
) -> Matrix<T, Dynamic, C, VecStorage<T, Dynamic, C>>
pub fn from(
matrix_slice: Matrix<T, Dynamic, C, SliceStorage<'a, T, Dynamic, C, RStride, CStride>>
) -> Matrix<T, Dynamic, C, VecStorage<T, Dynamic, C>>
Performs the conversion.
pub fn from(
matrix_slice: Matrix<T, Dynamic, C, SliceStorageMut<'a, T, Dynamic, C, RStride, CStride>>
) -> Matrix<T, Dynamic, C, VecStorage<T, Dynamic, C>>
pub fn from(
matrix_slice: Matrix<T, Dynamic, C, SliceStorageMut<'a, T, Dynamic, C, RStride, CStride>>
) -> Matrix<T, Dynamic, C, VecStorage<T, Dynamic, C>>
Performs the conversion.
impl<'a, T, R, C, RStride, CStride> From<Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>> for Matrix<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>> where
R: Dim,
C: Dim,
RStride: Dim,
CStride: Dim,
impl<'a, T, R, C, RStride, CStride> From<Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>> for Matrix<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>> where
R: Dim,
C: Dim,
RStride: Dim,
CStride: Dim,
pub fn from(
slice_mut: Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>>
pub fn from(
slice_mut: Matrix<T, R, C, SliceStorageMut<'a, T, R, C, RStride, CStride>>
) -> Matrix<T, R, C, SliceStorage<'a, T, R, C, RStride, CStride>>
Performs the conversion.
pub fn from(
matrix_slice: Matrix<T, R, Dynamic, SliceStorage<'a, T, R, Dynamic, RStride, CStride>>
) -> Matrix<T, R, Dynamic, VecStorage<T, R, Dynamic>>
pub fn from(
matrix_slice: Matrix<T, R, Dynamic, SliceStorage<'a, T, R, Dynamic, RStride, CStride>>
) -> Matrix<T, R, Dynamic, VecStorage<T, R, Dynamic>>
Performs the conversion.
pub fn from(
matrix_slice: Matrix<T, R, Dynamic, SliceStorageMut<'a, T, R, Dynamic, RStride, CStride>>
) -> Matrix<T, R, Dynamic, VecStorage<T, R, Dynamic>>
pub fn from(
matrix_slice: Matrix<T, R, Dynamic, SliceStorageMut<'a, T, R, Dynamic, RStride, CStride>>
) -> Matrix<T, R, Dynamic, VecStorage<T, R, Dynamic>>
Performs the conversion.
impl<T, D> From<OPoint<T, D>> for Matrix<T, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer> where
T: Scalar + Zero + One,
D: DimName + DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
impl<T, D> From<OPoint<T, D>> for Matrix<T, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer> where
T: Scalar + Zero + One,
D: DimName + DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T, D, Const<1_usize>>,
pub fn from(
t: OPoint<T, D>
) -> Matrix<T, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
pub fn from(
t: OPoint<T, D>
) -> Matrix<T, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
Performs the conversion.
impl<T> From<Orthographic3<T>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>> where
T: RealField,
impl<T> From<Orthographic3<T>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>> where
T: RealField,
pub fn from(
orth: Orthographic3<T>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn from(
orth: Orthographic3<T>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Performs the conversion.
impl<T> From<Perspective3<T>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>> where
T: RealField,
impl<T> From<Perspective3<T>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>> where
T: RealField,
pub fn from(
pers: Perspective3<T>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn from(
pers: Perspective3<T>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Performs the conversion.
impl<T, R, const D: usize> From<Similarity<T, R, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer> where
T: SimdRealField,
R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>>,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
impl<T, R, const D: usize> From<Similarity<T, R, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer> where
T: SimdRealField,
R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>>,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
pub fn from(
sim: Similarity<T, R, D>
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
pub fn from(
sim: Similarity<T, R, D>
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
Performs the conversion.
impl<T, C, const D: usize> From<Transform<T, C, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer> where
T: RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
impl<T, C, const D: usize> From<Transform<T, C, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer> where
T: RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
pub fn from(
t: Transform<T, C, D>
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
pub fn from(
t: Transform<T, C, D>
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
Performs the conversion.
impl<T, const D: usize> From<Translation<T, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer> where
T: Scalar + Zero + One,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T, Const<D>, Const<1_usize>>,
impl<T, const D: usize> From<Translation<T, D>> for Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer> where
T: Scalar + Zero + One,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T, Const<D>, Const<1_usize>>,
pub fn from(
t: Translation<T, D>
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
pub fn from(
t: Translation<T, D>
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
Performs the conversion.
impl<T> From<Unit<Complex<T>>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 2_usize, 2_usize>> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
impl<T> From<Unit<Complex<T>>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 2_usize, 2_usize>> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
impl<T> From<Unit<Complex<T>>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 3_usize, 3_usize>> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
impl<T> From<Unit<Complex<T>>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 3_usize, 3_usize>> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
impl<T> From<Unit<DualQuaternion<T>>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>> where
T: SimdRealField + RealField,
<T as SimdValue>::Element: SimdRealField,
impl<T> From<Unit<DualQuaternion<T>>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>> where
T: SimdRealField + RealField,
<T as SimdValue>::Element: SimdRealField,
pub fn from(
dq: Unit<DualQuaternion<T>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn from(
dq: Unit<DualQuaternion<T>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Performs the conversion.
impl<T> From<Unit<Quaternion<T>>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
impl<T> From<Unit<Quaternion<T>>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
pub fn from(
q: Unit<Quaternion<T>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
pub fn from(
q: Unit<Quaternion<T>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 4_usize, 4_usize>>
Performs the conversion.
impl<T> From<Unit<Quaternion<T>>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 3_usize, 3_usize>> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
impl<T> From<Unit<Quaternion<T>>> for Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 3_usize, 3_usize>> where
T: SimdRealField,
<T as SimdValue>::Element: SimdRealField,
pub fn from(
q: Unit<Quaternion<T>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 3_usize, 3_usize>>
pub fn from(
q: Unit<Quaternion<T>>
) -> Matrix<T, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T, 3_usize, 3_usize>>
Performs the conversion.
impl<'a, T, R, C, S> IntoIterator for &'a mut Matrix<T, R, C, S> where
T: Scalar,
R: Dim,
C: Dim,
S: RawStorageMut<T, R, C>,
impl<'a, T, R, C, S> IntoIterator for &'a mut Matrix<T, R, C, S> where
T: Scalar,
R: Dim,
C: Dim,
S: RawStorageMut<T, R, C>,
type IntoIter = MatrixIterMut<'a, T, R, C, S>
type IntoIter = MatrixIterMut<'a, T, R, C, S>
Which kind of iterator are we turning this into?
impl<'a, T, R, C, S> IntoIterator for &'a Matrix<T, R, C, S> where
T: Scalar,
R: Dim,
C: Dim,
S: RawStorage<T, R, C>,
impl<'a, T, R, C, S> IntoIterator for &'a Matrix<T, R, C, S> where
T: Scalar,
R: Dim,
C: Dim,
S: RawStorage<T, R, C>,
type IntoIter = MatrixIter<'a, T, R, C, S>
type IntoIter = MatrixIter<'a, T, R, C, S>
Which kind of iterator are we turning this into?
impl IntoRapier<Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 2_usize, 1_usize>>> for Vec2
impl IntoRapier<Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 2_usize, 1_usize>>> for Vec2
pub fn into_rapier(
self
) -> Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 2_usize, 1_usize>>
impl IntoRapier<Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 2_usize, 1_usize>>> for Vec3
impl IntoRapier<Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 2_usize, 1_usize>>> for Vec3
pub fn into_rapier(
self
) -> Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 2_usize, 1_usize>>
impl IntoRapier<Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 3_usize, 1_usize>>> for Vec3
impl IntoRapier<Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 3_usize, 1_usize>>> for Vec3
pub fn into_rapier(
self
) -> Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 3_usize, 1_usize>>
impl IntoRapier<Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 3_usize, 1_usize>>> for AxisAngle
impl IntoRapier<Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 3_usize, 1_usize>>> for AxisAngle
pub fn into_rapier(
self
) -> Matrix<f32, Const<{_: usize}>, Const<1_usize>, ArrayStorage<f32, 3_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 2_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 2_usize, 1_usize>>
The resulting type after applying the *
operator.
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 2_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 2_usize, 1_usize>>
The resulting type after applying the *
operator.
impl<'a, 'b, T, SB> Mul<&'b Matrix<T, Const<3_usize>, Const<1_usize>, SB>> for &'a Unit<Quaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<3_usize>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
impl<'a, 'b, T, SB> Mul<&'b Matrix<T, Const<3_usize>, Const<1_usize>, SB>> for &'a Unit<Quaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<3_usize>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
The resulting type after applying the *
operator.
impl<'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Isometry<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
impl<'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Isometry<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
impl<'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Similarity<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
impl<'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Similarity<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
right: &'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> <Similarity<T, R, D> as Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>>>::Output
pub fn mul(
self,
right: &'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> <Similarity<T, R, D> as Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>>>::Output
Performs the *
operation. Read more
impl<'a, 'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Isometry<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
impl<'a, 'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Isometry<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
impl<'b, T, C, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Transform<T, C, D> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
impl<'b, T, C, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Transform<T, C, D> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
impl<'a, 'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Similarity<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
impl<'a, 'b, T, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Similarity<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
right: &'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> <&'a Similarity<T, R, D> as Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>>>::Output
pub fn mul(
self,
right: &'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> <&'a Similarity<T, R, D> as Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>>>::Output
Performs the *
operation. Read more
impl<'a, 'b, T, C, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Transform<T, C, D> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
impl<'a, 'b, T, C, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Transform<T, C, D> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
impl<'b, T, SB> Mul<&'b Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for Unit<DualQuaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
impl<'b, T, SB> Mul<&'b Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for Unit<DualQuaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
The resulting type after applying the *
operator.
impl<'a, 'b, T, SB> Mul<&'b Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for &'a Unit<DualQuaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
impl<'a, 'b, T, SB> Mul<&'b Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for &'a Unit<DualQuaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
The resulting type after applying the *
operator.
impl<'b, T, SB> Mul<&'b Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for Unit<Quaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<3_usize>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
impl<'b, T, SB> Mul<&'b Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for Unit<Quaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<3_usize>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
The resulting type after applying the *
operator.
impl<'a, 'b, T, R2, C2, SB, const D1: usize> Mul<&'b Matrix<T, R2, C2, SB>> for &'a Rotation<T, D1> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
impl<'a, 'b, T, R2, C2, SB, const D1: usize> Mul<&'b Matrix<T, R2, C2, SB>> for &'a Rotation<T, D1> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
The resulting type after applying the *
operator.
impl<'a, 'b, T, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'a, 'b, T, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'b, T, R2, C2, SB, const D1: usize> Mul<&'b Matrix<T, R2, C2, SB>> for Rotation<T, D1> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
impl<'b, T, R2, C2, SB, const D1: usize> Mul<&'b Matrix<T, R2, C2, SB>> for Rotation<T, D1> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
The resulting type after applying the *
operator.
impl<'b, T, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'b, T, R1, C1, R2, C2, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'a, 'b, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<&'b OPoint<T, Const<D2>>> for &'a Matrix<T, Const<R1>, Const<C1>, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1_usize>>,
impl<'a, 'b, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<&'b OPoint<T, Const<D2>>> for &'a Matrix<T, Const<R1>, Const<C1>, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1_usize>>,
impl<'b, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<&'b OPoint<T, Const<D2>>> for Matrix<T, Const<R1>, Const<C1>, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1_usize>>,
impl<'b, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<&'b OPoint<T, Const<D2>>> for Matrix<T, Const<R1>, Const<C1>, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1_usize>>,
impl<'b, T, R1, C1, SA, const D2: usize> Mul<&'b Rotation<T, D2>> for Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<'b, T, R1, C1, SA, const D2: usize> Mul<&'b Rotation<T, D2>> for Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<'a, 'b, T, R1, C1, SA, const D2: usize> Mul<&'b Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<'a, 'b, T, R1, C1, SA, const D2: usize> Mul<&'b Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>> for SdpMatrix2<N> where
N: SimdRealField + Copy,
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>> for SdpMatrix2<N> where
N: SimdRealField + Copy,
type Output = Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
type Output = Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> <SdpMatrix2<N> as Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>>>::Output
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> <SdpMatrix2<N> as Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>>>::Output
Performs the *
operation. Read more
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>> for SdpMatrix2<N> where
N: SimdRealField + Copy,
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>> for SdpMatrix2<N> where
N: SimdRealField + Copy,
type Output = Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
type Output = Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> <SdpMatrix2<N> as Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>>>::Output
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> <SdpMatrix2<N> as Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>>>::Output
Performs the *
operation. Read more
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
type Output = Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
type Output = Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>>>::Output
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>>>::Output
Performs the *
operation. Read more
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
type Output = Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
type Output = Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>>>::Output
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>>>::Output
Performs the *
operation. Read more
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
type Output = Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>
type Output = Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>>>::Output
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>>>::Output
Performs the *
operation. Read more
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
type Output = Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>
type Output = Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>>>::Output
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 2_usize>>>>::Output
Performs the *
operation. Read more
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
type Output = Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>
type Output = Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>>>::Output
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>>>::Output
Performs the *
operation. Read more
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
impl<N> Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>> for SdpMatrix3<N> where
N: SimdRealField + Copy,
type Output = Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>
type Output = Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>>>::Output
pub fn mul(
self,
rhs: Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>
) -> <SdpMatrix3<N> as Mul<Matrix<N, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<N, 3_usize, 3_usize>>>>::Output
Performs the *
operation. Read more
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 2_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 2_usize, 1_usize>>
The resulting type after applying the *
operator.
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 2_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 2_usize, 1_usize>>
The resulting type after applying the *
operator.
impl<T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Similarity<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
impl<T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Similarity<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
right: Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> <Similarity<T, R, D> as Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>>>::Output
pub fn mul(
self,
right: Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> <Similarity<T, R, D> as Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>>>::Output
Performs the *
operation. Read more
impl<'a, T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Similarity<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
impl<'a, T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Similarity<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
pub fn mul(
self,
right: Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> <&'a Similarity<T, R, D> as Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>>>::Output
pub fn mul(
self,
right: Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> <&'a Similarity<T, R, D> as Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>>>::Output
Performs the *
operation. Read more
impl<'a, T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Isometry<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
impl<'a, T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Isometry<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
impl<T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Isometry<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
impl<T, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Isometry<T, R, D> where
T: SimdRealField,
R: AbstractRotation<T, D>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
impl<'a, T, C, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Transform<T, C, D> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
impl<'a, T, C, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for &'a Transform<T, C, D> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
impl<T, C, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Transform<T, C, D> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
impl<T, C, const D: usize> Mul<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>> for Transform<T, C, D> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T> + RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
type Output = Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
The resulting type after applying the *
operator.
impl<T, SB> Mul<Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for Unit<DualQuaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
impl<T, SB> Mul<Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for Unit<DualQuaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
The resulting type after applying the *
operator.
impl<T, SB> Mul<Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for Unit<Quaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<3_usize>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
impl<T, SB> Mul<Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for Unit<Quaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<3_usize>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
The resulting type after applying the *
operator.
impl<'a, T, SB> Mul<Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for &'a Unit<Quaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<3_usize>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
impl<'a, T, SB> Mul<Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for &'a Unit<Quaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<3_usize>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
The resulting type after applying the *
operator.
impl<'a, T, SB> Mul<Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for &'a Unit<DualQuaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
impl<'a, T, SB> Mul<Matrix<T, Const<{_: usize}>, Const<1_usize>, SB>> for &'a Unit<DualQuaternion<T>> where
T: SimdRealField,
SB: Storage<T, Const<{_: usize}>, Const<1_usize>>,
<T as SimdValue>::Element: SimdRealField,
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
type Output = Matrix<T, Const<{_: usize}>, Const<1_usize>, ArrayStorage<T, 3_usize, 1_usize>>
The resulting type after applying the *
operator.
impl<'a, T, R1, C1, R2, C2, SA, SB> Mul<Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'a, T, R1, C1, R2, C2, SA, SB> Mul<Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'a, T, R2, C2, SB, const D1: usize> Mul<Matrix<T, R2, C2, SB>> for &'a Rotation<T, D1> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
impl<'a, T, R2, C2, SB, const D1: usize> Mul<Matrix<T, R2, C2, SB>> for &'a Rotation<T, D1> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<T, Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
impl<T, R1, C1, R2, C2, SA, SB> Mul<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<T, R1, C1, R2, C2, SA, SB> Mul<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'a, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<OPoint<T, Const<D2>>> for &'a Matrix<T, Const<R1>, Const<C1>, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1_usize>>,
impl<'a, T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<OPoint<T, Const<D2>>> for &'a Matrix<T, Const<R1>, Const<C1>, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1_usize>>,
impl<T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<OPoint<T, Const<D2>>> for Matrix<T, Const<R1>, Const<C1>, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1_usize>>,
impl<T, SA, const D2: usize, const R1: usize, const C1: usize> Mul<OPoint<T, Const<D2>>> for Matrix<T, Const<R1>, Const<C1>, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, Const<1_usize>>,
impl<'a, T, R1, C1, SA, const D2: usize> Mul<Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<'a, T, R1, C1, SA, const D2: usize> Mul<Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA> where
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<T, R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<'b, T, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<T, R2, C1, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SB: Storage<T, R2, C1>,
SA: StorageMut<T, R1, C1> + IsContiguous + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<T, R1, C1>,
<DefaultAllocator as Allocator<T, R1, C1>>::Buffer == SA,
impl<'b, T, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<T, R2, C1, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SB: Storage<T, R2, C1>,
SA: StorageMut<T, R1, C1> + IsContiguous + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<T, R1, C1>,
<DefaultAllocator as Allocator<T, R1, C1>>::Buffer == SA,
Performs the *=
operation. Read more
Performs the *=
operation. Read more
impl<T, R1, C1, R2, SA, SB> MulAssign<Matrix<T, R2, C1, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SB: Storage<T, R2, C1>,
SA: StorageMut<T, R1, C1> + IsContiguous + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<T, R1, C1>,
<DefaultAllocator as Allocator<T, R1, C1>>::Buffer == SA,
impl<T, R1, C1, R2, SA, SB> MulAssign<Matrix<T, R2, C1, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
T: Scalar + Zero + One + ClosedAdd<T> + ClosedMul<T>,
SB: Storage<T, R2, C1>,
SA: StorageMut<T, R1, C1> + IsContiguous + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<T, R1, C1>,
<DefaultAllocator as Allocator<T, R1, C1>>::Buffer == SA,
Performs the *=
operation. Read more
Performs the *=
operation. Read more
Performs the *=
operation. Read more
impl<T, R, C> Normed for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: SimdComplexField,
R: Dim,
C: Dim,
DefaultAllocator: Allocator<T, R, C>,
impl<T, R, C> Normed for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where
T: SimdComplexField,
R: Dim,
C: Dim,
DefaultAllocator: Allocator<T, R, C>,
type Norm = <T as SimdComplexField>::SimdRealField
type Norm = <T as SimdComplexField>::SimdRealField
The type of the norm.
Computes the norm.
Computes the squared norm.
Multiply self
by n.
pub fn unscale_mut(
&mut self,
n: <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as Normed>::Norm
)
pub fn unscale_mut(
&mut self,
n: <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as Normed>::Norm
)
Divides self
by n.
Returns the multiplicative identity element of Self
, 1
. Read more
impl<T, R, C, S> PartialOrd<Matrix<T, R, C, S>> for Matrix<T, R, C, S> where
R: Dim,
C: Dim,
T: Scalar + PartialOrd<T>,
S: RawStorage<T, R, C>,
impl<T, R, C, S> PartialOrd<Matrix<T, R, C, S>> for Matrix<T, R, C, S> where
R: Dim,
C: Dim,
T: Scalar + PartialOrd<T>,
S: RawStorage<T, R, C>,
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
Method which takes an iterator and generates Self
from the elements by
multiplying the items. Read more
pub fn default_max_relative(
) -> <Matrix<T, R, C, S> as AbsDiffEq<Matrix<T, R, C, S>>>::Epsilon
pub fn default_max_relative(
) -> <Matrix<T, R, C, S> as AbsDiffEq<Matrix<T, R, C, S>>>::Epsilon
The default relative tolerance for testing values that are far-apart. Read more
A test for equality that uses a relative comparison if the values are far apart.
fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
The inverse of [RelativeEq::relative_eq
].
The type of the elements of each lane of this SIMD value.
Type of the result of comparing two SIMD values like self
.
Initializes an SIMD value with each lanes set to val
.
Extracts the i-th lane of self
. Read more
pub unsafe fn extract_unchecked(
&self,
i: usize
) -> <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as SimdValue>::Element
pub unsafe fn extract_unchecked(
&self,
i: usize
) -> <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as SimdValue>::Element
Extracts the i-th lane of self
without bound-checking.
Replaces the i-th lane of self
by val
. Read more
pub unsafe fn replace_unchecked(
&mut self,
i: usize,
val: <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as SimdValue>::Element
)
pub unsafe fn replace_unchecked(
&mut self,
i: usize,
val: <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as SimdValue>::Element
)
Replaces the i-th lane of self
by val
without bound-checking.
Merges self
and other
depending on the lanes of cond
. Read more
Applies a function to each lane of self
. Read more
impl<'a, 'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1_usize>, SB>> for &'a OPoint<T, D1> where
T: Scalar + ClosedSub<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'a, 'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1_usize>, SB>> for &'a OPoint<T, D1> where
T: Scalar + ClosedSub<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1_usize>, SB>> for OPoint<T, D1> where
T: Scalar + ClosedSub<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1_usize>, SB>> for OPoint<T, D1> where
T: Scalar + ClosedSub<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'a, 'b, T, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<'a, 'b, T, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
The resulting type after applying the -
operator.
impl<'b, T, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<'b, T, R1, C1, R2, C2, SA, SB> Sub<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
The resulting type after applying the -
operator.
impl<T, D1, D2, SB> Sub<Matrix<T, D2, Const<1_usize>, SB>> for OPoint<T, D1> where
T: Scalar + ClosedSub<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<T, D1, D2, SB> Sub<Matrix<T, D2, Const<1_usize>, SB>> for OPoint<T, D1> where
T: Scalar + ClosedSub<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'a, T, D1, D2, SB> Sub<Matrix<T, D2, Const<1_usize>, SB>> for &'a OPoint<T, D1> where
T: Scalar + ClosedSub<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<'a, T, D1, D2, SB> Sub<Matrix<T, D2, Const<1_usize>, SB>> for &'a OPoint<T, D1> where
T: Scalar + ClosedSub<T>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2, Const<1_usize>>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
ShapeConstraint: SameNumberOfColumns<Const<1_usize>, Const<1_usize>>,
DefaultAllocator: Allocator<T, D1, Const<1_usize>>,
<ShapeConstraint as SameNumberOfRows<D1, D2>>::Representative == D1,
<ShapeConstraint as SameNumberOfColumns<Const<1_usize>, Const<1_usize>>>::Representative == Const<1_usize>,
impl<T, R1, C1, R2, C2, SA, SB> Sub<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<T, R1, C1, R2, C2, SA, SB> Sub<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer>
The resulting type after applying the -
operator.
impl<'a, T, R1, C1, R2, C2, SA, SB> Sub<Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1>,
ShapeConstraint: SameNumberOfColumns<C2, C1>,
impl<'a, T, R1, C1, R2, C2, SA, SB> Sub<Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<T, R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1>,
ShapeConstraint: SameNumberOfColumns<C2, C1>,
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer>
The resulting type after applying the -
operator.
Performs the -=
operation. Read more
impl<'b, T, R1, C1, R2, C2, SA, SB> SubAssign<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<'b, T, R1, C1, R2, C2, SA, SB> SubAssign<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
Performs the -=
operation. Read more
Performs the -=
operation. Read more
impl<T, R1, C1, R2, C2, SA, SB> SubAssign<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<T, R1, C1, R2, C2, SA, SB> SubAssign<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T: Scalar + ClosedSub<T>,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
Performs the -=
operation. Read more
impl<T1, T2, R, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> for Isometry<T1, R, D> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
R: AbstractRotation<T1, D> + SubsetOf<Matrix<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> + SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>>,
Const<D>: DimNameAdd<Const<1_usize>>,
Const<D>: DimMin<Const<D>>,
DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
<Const<D> as DimMin<Const<D>>>::Output == Const<D>,
impl<T1, T2, R, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> for Isometry<T1, R, D> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
R: AbstractRotation<T1, D> + SubsetOf<Matrix<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> + SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>>,
Const<D>: DimNameAdd<Const<1_usize>>,
Const<D>: DimMin<Const<D>>,
DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
<Const<D> as DimMin<Const<D>>>::Output == Const<D>,
pub fn to_superset(
&self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
pub fn to_superset(
&self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
The inclusion map: converts self
to the equivalent element of its superset.
pub fn is_in_subset(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> bool
pub fn is_in_subset(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
pub fn from_superset_unchecked(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> Isometry<T1, R, D>
pub fn from_superset_unchecked(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> Isometry<T1, R, D>
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
impl<T1, T2, R, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> for Similarity<T1, R, D> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
R: AbstractRotation<T1, D> + SubsetOf<Matrix<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> + SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>>,
Const<D>: DimNameAdd<Const<1_usize>>,
Const<D>: DimMin<Const<D>>,
DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
<Const<D> as DimMin<Const<D>>>::Output == Const<D>,
impl<T1, T2, R, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> for Similarity<T1, R, D> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
R: AbstractRotation<T1, D> + SubsetOf<Matrix<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> + SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>>,
Const<D>: DimNameAdd<Const<1_usize>>,
Const<D>: DimMin<Const<D>>,
DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
<Const<D> as DimMin<Const<D>>>::Output == Const<D>,
pub fn to_superset(
&self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
pub fn to_superset(
&self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
The inclusion map: converts self
to the equivalent element of its superset.
pub fn is_in_subset(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> bool
pub fn is_in_subset(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
pub fn from_superset_unchecked(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> Similarity<T1, R, D>
pub fn from_superset_unchecked(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> Similarity<T1, R, D>
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> for Translation<T1, D> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> for Translation<T1, D> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
pub fn to_superset(
&self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
pub fn to_superset(
&self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
The inclusion map: converts self
to the equivalent element of its superset.
pub fn is_in_subset(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> bool
pub fn is_in_subset(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
pub fn from_superset_unchecked(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> Translation<T1, D>
pub fn from_superset_unchecked(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> Translation<T1, D>
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
impl<T1, T2, C, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> for Transform<T1, C, D> where
T1: RealField + SubsetOf<T2>,
T2: RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
<T1 as AbsDiffEq<T1>>::Epsilon: Copy,
<T2 as AbsDiffEq<T2>>::Epsilon: Copy,
impl<T1, T2, C, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> for Transform<T1, C, D> where
T1: RealField + SubsetOf<T2>,
T2: RealField,
C: TCategory,
Const<D>: DimNameAdd<Const<1_usize>>,
DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
<T1 as AbsDiffEq<T1>>::Epsilon: Copy,
<T2 as AbsDiffEq<T2>>::Epsilon: Copy,
pub fn to_superset(
&self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
pub fn to_superset(
&self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
The inclusion map: converts self
to the equivalent element of its superset.
pub fn is_in_subset(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> bool
pub fn is_in_subset(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
pub fn from_superset_unchecked(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> Transform<T1, C, D>
pub fn from_superset_unchecked(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> Transform<T1, C, D>
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> for Rotation<T1, D> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
Const<D>: DimNameAdd<Const<1_usize>>,
Const<D>: DimMin<Const<D>>,
DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
<Const<D> as DimMin<Const<D>>>::Output == Const<D>,
impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>> for Rotation<T1, D> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
Const<D>: DimNameAdd<Const<1_usize>>,
Const<D>: DimMin<Const<D>>,
DefaultAllocator: Allocator<T1, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
DefaultAllocator: Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>,
<Const<D> as DimMin<Const<D>>>::Output == Const<D>,
pub fn to_superset(
&self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
pub fn to_superset(
&self
) -> Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
The inclusion map: converts self
to the equivalent element of its superset.
pub fn is_in_subset(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> bool
pub fn is_in_subset(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
pub fn from_superset_unchecked(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> Rotation<T1, D>
pub fn from_superset_unchecked(
m: &Matrix<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T2, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>
) -> Rotation<T1, D>
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
impl<T1, T2, D> SubsetOf<Matrix<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>> for OPoint<T1, D> where
D: DimNameAdd<Const<1_usize>>,
T1: Scalar,
T2: Scalar + Zero + One + ClosedDiv<T2> + SupersetOf<T1>,
DefaultAllocator: Allocator<T1, D, Const<1_usize>>,
DefaultAllocator: Allocator<T2, D, Const<1_usize>>,
DefaultAllocator: Allocator<T1, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,
impl<T1, T2, D> SubsetOf<Matrix<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>> for OPoint<T1, D> where
D: DimNameAdd<Const<1_usize>>,
T1: Scalar,
T2: Scalar + Zero + One + ClosedDiv<T2> + SupersetOf<T1>,
DefaultAllocator: Allocator<T1, D, Const<1_usize>>,
DefaultAllocator: Allocator<T2, D, Const<1_usize>>,
DefaultAllocator: Allocator<T1, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,
DefaultAllocator: Allocator<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>,
pub fn to_superset(
&self
) -> Matrix<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
pub fn to_superset(
&self
) -> Matrix<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
The inclusion map: converts self
to the equivalent element of its superset.
pub fn is_in_subset(
v: &Matrix<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
) -> bool
pub fn is_in_subset(
v: &Matrix<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
pub fn from_superset_unchecked(
v: &Matrix<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
) -> OPoint<T1, D>
pub fn from_superset_unchecked(
v: &Matrix<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>, <DefaultAllocator as Allocator<T2, <D as DimNameAdd<Const<1_usize>>>::Output, Const<1_usize>>>::Buffer>
) -> OPoint<T1, D>
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
pub fn to_superset(
&self
) -> Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 3_usize, 3_usize>>
pub fn to_superset(
&self
) -> Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 3_usize, 3_usize>>
The inclusion map: converts self
to the equivalent element of its superset.
pub fn is_in_subset(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 3_usize, 3_usize>>
) -> bool
pub fn is_in_subset(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 3_usize, 3_usize>>
) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
pub fn from_superset_unchecked(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 3_usize, 3_usize>>
) -> Unit<Complex<T1>>
pub fn from_superset_unchecked(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 3_usize, 3_usize>>
) -> Unit<Complex<T1>>
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
impl<T1, T2> SubsetOf<Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>> for Unit<DualQuaternion<T1>> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
impl<T1, T2> SubsetOf<Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>> for Unit<DualQuaternion<T1>> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
pub fn to_superset(
&self
) -> Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
pub fn to_superset(
&self
) -> Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
The inclusion map: converts self
to the equivalent element of its superset.
pub fn is_in_subset(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
) -> bool
pub fn is_in_subset(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
pub fn from_superset_unchecked(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
) -> Unit<DualQuaternion<T1>>
pub fn from_superset_unchecked(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
) -> Unit<DualQuaternion<T1>>
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
impl<T1, T2> SubsetOf<Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>> for Unit<Quaternion<T1>> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
impl<T1, T2> SubsetOf<Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>> for Unit<Quaternion<T1>> where
T1: RealField,
T2: RealField + SupersetOf<T1>,
pub fn to_superset(
&self
) -> Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
pub fn to_superset(
&self
) -> Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
The inclusion map: converts self
to the equivalent element of its superset.
pub fn is_in_subset(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
) -> bool
pub fn is_in_subset(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
pub fn from_superset_unchecked(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
) -> Unit<Quaternion<T1>>
pub fn from_superset_unchecked(
m: &Matrix<T2, Const<{_: usize}>, Const<{_: usize}>, ArrayStorage<T2, 4_usize, 4_usize>>
) -> Unit<Quaternion<T1>>
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
impl<T1, T2, R1, C1, R2, C2> SubsetOf<Matrix<T2, R2, C2, <DefaultAllocator as Allocator<T2, R2, C2>>::Buffer>> for Matrix<T1, R1, C1, <DefaultAllocator as Allocator<T1, R1, C1>>::Buffer> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T1: Scalar,
T2: Scalar + SupersetOf<T1>,
DefaultAllocator: Allocator<T2, R2, C2>,
DefaultAllocator: Allocator<T1, R1, C1>,
DefaultAllocator: SameShapeAllocator<T1, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
impl<T1, T2, R1, C1, R2, C2> SubsetOf<Matrix<T2, R2, C2, <DefaultAllocator as Allocator<T2, R2, C2>>::Buffer>> for Matrix<T1, R1, C1, <DefaultAllocator as Allocator<T1, R1, C1>>::Buffer> where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T1: Scalar,
T2: Scalar + SupersetOf<T1>,
DefaultAllocator: Allocator<T2, R2, C2>,
DefaultAllocator: Allocator<T1, R1, C1>,
DefaultAllocator: SameShapeAllocator<T1, R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
ShapeConstraint: SameNumberOfColumns<C1, C2>,
pub fn to_superset(
&self
) -> Matrix<T2, R2, C2, <DefaultAllocator as Allocator<T2, R2, C2>>::Buffer>
pub fn to_superset(
&self
) -> Matrix<T2, R2, C2, <DefaultAllocator as Allocator<T2, R2, C2>>::Buffer>
The inclusion map: converts self
to the equivalent element of its superset.
pub fn is_in_subset(
m: &Matrix<T2, R2, C2, <DefaultAllocator as Allocator<T2, R2, C2>>::Buffer>
) -> bool
pub fn is_in_subset(
m: &Matrix<T2, R2, C2, <DefaultAllocator as Allocator<T2, R2, C2>>::Buffer>
) -> bool
Checks if element
is actually part of the subset Self
(and can be converted to it).
pub fn from_superset_unchecked(
m: &Matrix<T2, R2, C2, <DefaultAllocator as Allocator<T2, R2, C2>>::Buffer>
) -> Matrix<T1, R1, C1, <DefaultAllocator as Allocator<T1, R1, C1>>::Buffer>
pub fn from_superset_unchecked(
m: &Matrix<T2, R2, C2, <DefaultAllocator as Allocator<T2, R2, C2>>::Buffer>
) -> Matrix<T1, R1, C1, <DefaultAllocator as Allocator<T1, R1, C1>>::Buffer>
Use with care! Same as self.to_superset
but without any property checks. Always succeeds.
fn from_superset(element: &T) -> Option<Self>
fn from_superset(element: &T) -> Option<Self>
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
Example
assert_eq!(vec![DVector::repeat(3, 1.0f64),
DVector::repeat(3, 1.0f64),
DVector::repeat(3, 1.0f64)].into_iter().sum::<DVector<f64>>(),
DVector::repeat(3, 1.0f64) + DVector::repeat(3, 1.0f64) + DVector::repeat(3, 1.0f64));
Panics
Panics if the iterator is empty:
iter::empty::<DMatrix<f64>>().sum::<DMatrix<f64>>(); // panics!
The default ULPs to tolerate when testing values that are far-apart. Read more
A test for equality that uses units in the last place (ULP) if the values are far apart.
impl<N> WBasis for Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>> where
N: SimdRealField + Copy + WSign<N>,
impl<N> WBasis for Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>> where
N: SimdRealField + Copy + WSign<N>,
The type of the array of orthonormal vectors.
pub fn orthonormal_basis(
self
) -> [Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>; 2]
pub fn orthonormal_basis(
self
) -> [Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>; 2]
Computes the vectors which, when combined with self
, form an orthonormal basis.
pub fn orthonormal_vector(
self
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn orthonormal_vector(
self
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Computes a vector orthogonal to self
with a unit length (if self
has a unit length).
impl<N> WBasis for Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>> where
N: SimdRealField + Copy,
impl<N> WBasis for Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>> where
N: SimdRealField + Copy,
The type of the array of orthonormal vectors.
pub fn orthonormal_basis(
self
) -> [Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>; 1]
pub fn orthonormal_basis(
self
) -> [Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>; 1]
Computes the vectors which, when combined with self
, form an orthonormal basis.
pub fn orthonormal_vector(
self
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn orthonormal_vector(
self
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Computes a vector orthogonal to self
with a unit length (if self
has a unit length).
impl<N> WBasis for Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>> where
N: SimdRealField + Copy + WSign<N>,
impl<N> WBasis for Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>> where
N: SimdRealField + Copy + WSign<N>,
The type of the array of orthonormal vectors.
pub fn orthonormal_basis(
self
) -> [Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>; 2]
pub fn orthonormal_basis(
self
) -> [Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>; 2]
Computes the vectors which, when combined with self
, form an orthonormal basis.
pub fn orthonormal_vector(
self
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn orthonormal_vector(
self
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Computes a vector orthogonal to self
with a unit length (if self
has a unit length).
impl<N> WBasis for Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>> where
N: SimdRealField + Copy,
impl<N> WBasis for Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>> where
N: SimdRealField + Copy,
The type of the array of orthonormal vectors.
pub fn orthonormal_basis(
self
) -> [Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>; 1]
pub fn orthonormal_basis(
self
) -> [Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>; 1]
Computes the vectors which, when combined with self
, form an orthonormal basis.
pub fn orthonormal_vector(
self
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn orthonormal_vector(
self
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Computes a vector orthogonal to self
with a unit length (if self
has a unit length).
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
Returns the additive identity element of Self
, 0
. Read more
Auto Trait Implementations
impl<T, R, C, S> RefUnwindSafe for Matrix<T, R, C, S> where
C: RefUnwindSafe,
R: RefUnwindSafe,
S: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, R, C, S> UnwindSafe for Matrix<T, R, C, S> where
C: UnwindSafe,
R: UnwindSafe,
S: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more
impl<T> Downcast for T where
T: Any,
impl<T> Downcast for T where
T: Any,
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
pub fn into_any_rc(self: Rc<T>) -> Rc<dyn Any + 'static>
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
pub fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
impl<T> DynHash for T where
T: DynEq + Hash,
impl<T> DynHash for T where
T: DynEq + Hash,
impl<T> FromWorld for T where
T: Default,
impl<T> FromWorld for T where
T: Default,
pub fn from_world(_world: &mut World) -> T
pub fn from_world(_world: &mut World) -> T
Creates Self
using data from the given [World]
impl<T> Pointable for T
impl<T> Pointable for T
impl<T> SimdPartialOrd for T where
T: SimdValue<Element = T, SimdBool = bool> + PartialOrd<T>,
impl<T> SimdPartialOrd for T where
T: SimdValue<Element = T, SimdBool = bool> + PartialOrd<T>,
Lanewise greater or equal >=
comparison.
pub fn simd_max(self, other: T) -> T
pub fn simd_max(self, other: T) -> T
Lanewise max value.
pub fn simd_min(self, other: T) -> T
pub fn simd_min(self, other: T) -> T
Lanewise min value.
pub fn simd_clamp(self, min: T, max: T) -> T
pub fn simd_clamp(self, min: T, max: T) -> T
Clamps each lane of self
between the corresponding lane of min
and max
.
pub fn simd_horizontal_min(self) -> <T as SimdValue>::Element
pub fn simd_horizontal_min(self) -> <T as SimdValue>::Element
The min value among all lanes of self
.
pub fn simd_horizontal_max(self) -> <T as SimdValue>::Element
pub fn simd_horizontal_max(self) -> <T as SimdValue>::Element
The max value among all lanes of self
.
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
The inverse inclusion map: attempts to construct self
from the equivalent element of its
superset. Read more
pub fn is_in_subset(&self) -> bool
pub fn is_in_subset(&self) -> bool
Checks if self
is actually part of its subset T
(and can be converted to it).
pub fn to_subset_unchecked(&self) -> SS
pub fn to_subset_unchecked(&self) -> SS
Use with care! Same as self.to_subset
but without any property checks. Always succeeds.
pub fn from_subset(element: &SS) -> SP
pub fn from_subset(element: &SS) -> SP
The inclusion map: converts self
to the equivalent element of its superset.
pub fn clone_type_data(&self) -> Box<dyn TypeData + 'static, Global>
pub fn vzip(self) -> V
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 2_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
pub fn copy_sign_to(
self,
to: Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
) -> Matrix<N, Const<{_: usize}>, Const<1_usize>, ArrayStorage<N, 3_usize, 1_usize>>
Copy the sign of each component of self
to the corresponding component of to
.
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more