#[repr(C)]pub struct Matrix<T, R, C, S> {
pub data: S,
/* private fields */
}
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
… - Triangular matrix extraction
upper_triangle
,lower_triangle
§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
… - Parallel iterators using rayon
par_column_iter
,par_column_iter_mut
… - Elementwise mapping and folding
map
,fold
,zip_map
… - Folding or columns and rows
compress_rows
,compress_columns
…
§Vector and matrix views
- Creating matrix views from
&[T]
from_slice
,from_slice_with_strides
… - Creating mutable matrix views from
&mut [T]
from_slice_mut
,from_slice_with_strides_mut
… - Views based on index and length
row
,columns
,view
… - Mutable views based on index and length
row_mut
,columns_mut
,view_mut
… - Views based on ranges
rows_range
,columns_range
… - Mutable views 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
Dyn
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 Dyn
with type-level unsigned integers is allowed. Actually, a
dynamically-sized column vector should be represented as a Matrix<T, Dyn, 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§
source§impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
§Dot/scalar product
sourcepub fn dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
pub fn dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
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.
§Example
let vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
assert_eq!(vec1.dot(&vec2), 1.4);
let mat1 = Matrix2x3::new(1.0, 2.0, 3.0,
4.0, 5.0, 6.0);
let mat2 = Matrix2x3::new(0.1, 0.2, 0.3,
0.4, 0.5, 0.6);
assert_eq!(mat1.dot(&mat2), 9.1);
sourcepub fn dotc<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
pub fn dotc<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
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.
§Example
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));
sourcepub fn tr_dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
pub fn tr_dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
The dot product between the transpose of self
and rhs
.
§Example
let vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = RowVector3::new(0.1, 0.2, 0.3);
assert_eq!(vec1.tr_dot(&vec2), 1.4);
let mat1 = Matrix2x3::new(1.0, 2.0, 3.0,
4.0, 5.0, 6.0);
let mat2 = Matrix3x2::new(0.1, 0.4,
0.2, 0.5,
0.3, 0.6);
assert_eq!(mat1.tr_dot(&mat2), 9.1);
source§impl<T, D: Dim, S> Matrix<T, D, Const<1>, S>
impl<T, D: Dim, S> Matrix<T, D, Const<1>, S>
§BLAS functions
sourcepub fn axcpy<D2: Dim, SB>(&mut self, a: T, x: &Vector<T, D2, SB>, c: T, b: T)
pub fn axcpy<D2: Dim, SB>(&mut self, a: T, x: &Vector<T, D2, SB>, c: T, b: T)
Computes self = a * x * c + b * self
.
If b
is zero, self
is never read from.
§Example
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));
sourcepub fn axpy<D2: Dim, SB>(&mut self, a: T, x: &Vector<T, D2, SB>, b: T)
pub fn axpy<D2: Dim, SB>(&mut self, a: T, x: &Vector<T, D2, SB>, b: T)
Computes self = a * x + b * self
.
If b
is zero, self
is never read from.
§Example
let mut vec1 = Vector3::new(1.0, 2.0, 3.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
vec1.axpy(10.0, &vec2, 5.0);
assert_eq!(vec1, Vector3::new(6.0, 12.0, 18.0));
sourcepub fn gemv<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
x: &Vector<T, D3, SC>,
beta: T
)where
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<D, R2> + AreMultipliable<R2, C2, D3, U1>,
pub fn gemv<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
x: &Vector<T, D3, SC>,
beta: T
)where
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<D, R2> + AreMultipliable<R2, C2, D3, U1>,
Computes self = alpha * a * x + beta * self
, where a
is a matrix, x
a vector, and
alpha, beta
two scalars.
If beta
is zero, self
is never read.
§Example
let mut vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector2::new(0.1, 0.2);
let mat = Matrix2::new(1.0, 2.0,
3.0, 4.0);
vec1.gemv(10.0, &mat, &vec2, 5.0);
assert_eq!(vec1, Vector2::new(10.0, 21.0));
sourcepub fn sygemv<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &SquareMatrix<T, D2, SB>,
x: &Vector<T, D3, SC>,
beta: T
)where
T: One,
SB: Storage<T, D2, D2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
pub fn sygemv<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &SquareMatrix<T, D2, SB>,
x: &Vector<T, D3, SC>,
beta: T
)where
T: One,
SB: Storage<T, D2, D2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
Computes self = alpha * a * x + beta * self
, where a
is a symmetric matrix, x
a
vector, and alpha, beta
two scalars.
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));
sourcepub fn hegemv<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &SquareMatrix<T, D2, SB>,
x: &Vector<T, D3, SC>,
beta: T
)where
T: SimdComplexField,
SB: Storage<T, D2, D2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
pub fn hegemv<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &SquareMatrix<T, D2, SB>,
x: &Vector<T, D3, SC>,
beta: T
)where
T: SimdComplexField,
SB: Storage<T, D2, D2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<D, D2> + AreMultipliable<D2, D2, D3, U1>,
Computes self = alpha * a * x + beta * self
, where a
is an hermitian matrix, x
a
vector, and alpha, beta
two scalars.
If beta
is zero, self
is never read. If self
is read, only its lower-triangular part
(including the diagonal) is actually read.
§Examples
let mat = Matrix2::new(Complex::new(1.0, 0.0), Complex::new(2.0, -0.1),
Complex::new(2.0, 1.0), Complex::new(4.0, 0.0));
let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4));
vec1.sygemv(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0));
assert_eq!(vec1, Vector2::new(Complex::new(-48.0, 44.0), Complex::new(-75.0, 110.0)));
// The matrix upper-triangular elements can be garbage because it is never
// read by this method. Therefore, it is not necessary for the caller to
// fill the matrix struct upper-triangle.
let mat = Matrix2::new(Complex::new(1.0, 0.0), Complex::new(99999999.9, 999999999.9),
Complex::new(2.0, 1.0), Complex::new(4.0, 0.0));
let mut vec1 = Vector2::new(Complex::new(1.0, 2.0), Complex::new(3.0, 4.0));
let vec2 = Vector2::new(Complex::new(0.1, 0.2), Complex::new(0.3, 0.4));
vec1.sygemv(Complex::new(10.0, 20.0), &mat, &vec2, Complex::new(5.0, 15.0));
assert_eq!(vec1, Vector2::new(Complex::new(-48.0, 44.0), Complex::new(-75.0, 110.0)));
sourcepub fn gemv_tr<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
x: &Vector<T, D3, SC>,
beta: T
)where
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
pub fn gemv_tr<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
x: &Vector<T, D3, SC>,
beta: T
)where
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
Computes self = alpha * a.transpose() * x + beta * self
, where a
is a matrix, x
a vector, and
alpha, beta
two scalars.
If beta
is zero, self
is never read.
§Example
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);
sourcepub fn gemv_ad<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
x: &Vector<T, D3, SC>,
beta: T
)where
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
pub fn gemv_ad<R2: Dim, C2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
x: &Vector<T, D3, SC>,
beta: T
)where
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<D, C2> + AreMultipliable<C2, R2, D3, U1>,
Computes self = alpha * a.adjoint() * x + beta * self
, where a
is a matrix, x
a vector, and
alpha, beta
two scalars.
For real matrices, this is the same as .gemv_tr
.
If beta
is zero, self
is never read.
§Example
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);
source§impl<T, R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>> Matrix<T, R1, C1, S>
impl<T, R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>> Matrix<T, R1, C1, S>
sourcepub fn ger<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
x: &Vector<T, D2, SB>,
y: &Vector<T, D3, SC>,
beta: T
)
pub fn ger<D2: Dim, D3: Dim, SB, SC>( &mut self, alpha: T, x: &Vector<T, D2, SB>, y: &Vector<T, D3, SC>, beta: T )
Computes self = alpha * x * y.transpose() + beta * self
.
If beta
is zero, self
is never read.
§Example
let mut mat = Matrix2x3::repeat(4.0);
let vec1 = Vector2::new(1.0, 2.0);
let vec2 = Vector3::new(0.1, 0.2, 0.3);
let expected = vec1 * vec2.transpose() * 10.0 + mat * 5.0;
mat.ger(10.0, &vec1, &vec2, 5.0);
assert_eq!(mat, expected);
sourcepub fn gerc<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
x: &Vector<T, D2, SB>,
y: &Vector<T, D3, SC>,
beta: T
)where
T: SimdComplexField,
SB: Storage<T, D2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
pub fn gerc<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
x: &Vector<T, D2, SB>,
y: &Vector<T, D3, SC>,
beta: T
)where
T: SimdComplexField,
SB: Storage<T, D2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
Computes self = alpha * x * y.adjoint() + beta * self
.
If beta
is zero, self
is never read.
§Example
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);
sourcepub fn gemm<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
)where
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C3> + AreMultipliable<R2, C2, R3, C3>,
pub fn gemm<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
)where
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C3> + AreMultipliable<R2, C2, R3, C3>,
Computes self = alpha * a * b + beta * self
, where a, b, self
are matrices.
alpha
and beta
are scalar.
If beta
is zero, self
is never read.
§Example
let mut mat1 = Matrix2x4::identity();
let mat2 = Matrix2x3::new(1.0, 2.0, 3.0,
4.0, 5.0, 6.0);
let mat3 = Matrix3x4::new(0.1, 0.2, 0.3, 0.4,
0.5, 0.6, 0.7, 0.8,
0.9, 1.0, 1.1, 1.2);
let expected = mat2 * mat3 * 10.0 + mat1 * 5.0;
mat1.gemm(10.0, &mat2, &mat3, 5.0);
assert_relative_eq!(mat1, expected);
sourcepub fn gemm_tr<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
)where
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + AreMultipliable<C2, R2, R3, C3>,
pub fn gemm_tr<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
)where
T: One,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + AreMultipliable<C2, R2, R3, C3>,
Computes self = alpha * a.transpose() * b + beta * self
, where a, b, self
are matrices.
alpha
and beta
are scalar.
If beta
is zero, self
is never read.
§Example
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);
sourcepub fn gemm_ad<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
)where
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + AreMultipliable<C2, R2, R3, C3>,
pub fn gemm_ad<R2: Dim, C2: Dim, R3: Dim, C3: Dim, SB, SC>(
&mut self,
alpha: T,
a: &Matrix<T, R2, C2, SB>,
b: &Matrix<T, R3, C3, SC>,
beta: T
)where
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: Storage<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, C2> + SameNumberOfColumns<C1, C3> + 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.
§Example
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);
source§impl<T, R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>> Matrix<T, R1, C1, S>
impl<T, R1: Dim, C1: Dim, S: StorageMut<T, R1, C1>> Matrix<T, R1, C1, S>
sourcepub fn ger_symm<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
x: &Vector<T, D2, SB>,
y: &Vector<T, D3, SC>,
beta: T
)
👎Deprecated: This is renamed syger
to match the original BLAS terminology.
pub fn ger_symm<D2: Dim, D3: Dim, SB, SC>( &mut self, alpha: T, x: &Vector<T, D2, SB>, y: &Vector<T, D3, SC>, beta: T )
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.
§Example
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.
sourcepub fn syger<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
x: &Vector<T, D2, SB>,
y: &Vector<T, D3, SC>,
beta: T
)
pub fn syger<D2: Dim, D3: Dim, SB, SC>( &mut self, alpha: T, x: &Vector<T, D2, SB>, y: &Vector<T, D3, SC>, beta: T )
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.
§Example
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.
sourcepub fn hegerc<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
x: &Vector<T, D2, SB>,
y: &Vector<T, D3, SC>,
beta: T
)where
T: SimdComplexField,
SB: Storage<T, D2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<R1, D2> + DimEq<C1, D3>,
pub fn hegerc<D2: Dim, D3: Dim, SB, SC>(
&mut self,
alpha: T,
x: &Vector<T, D2, SB>,
y: &Vector<T, D3, SC>,
beta: T
)where
T: SimdComplexField,
SB: Storage<T, D2>,
SC: Storage<T, D3>,
ShapeConstraint: DimEq<R1, D2> + 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.
§Example
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.
source§impl<T, D1: Dim, S: StorageMut<T, D1, D1>> Matrix<T, D1, D1, S>
impl<T, D1: Dim, S: StorageMut<T, D1, D1>> Matrix<T, D1, D1, S>
sourcepub fn quadform_tr_with_workspace<D2, S2, R3, C3, S3, D4, S4>(
&mut self,
work: &mut Vector<T, D2, S2>,
alpha: T,
lhs: &Matrix<T, R3, C3, S3>,
mid: &SquareMatrix<T, D4, S4>,
beta: T
)
pub fn quadform_tr_with_workspace<D2, S2, R3, C3, S3, D4, S4>( &mut self, work: &mut Vector<T, D2, S2>, alpha: T, lhs: &Matrix<T, R3, C3, S3>, mid: &SquareMatrix<T, D4, S4>, beta: T )
Computes the quadratic form self = alpha * lhs * mid * lhs.transpose() + beta * self
.
This uses the provided workspace work
to avoid allocations for intermediate results.
§Example
// Note that all those would also work with statically-sized matrices.
// We use DMatrix/DVector since that's the only case where pre-allocating the
// workspace is actually useful (assuming the same workspace is re-used for
// several computations) because it avoids repeated dynamic allocations.
let mut mat = DMatrix::identity(2, 2);
let lhs = DMatrix::from_row_slice(2, 3, &[1.0, 2.0, 3.0,
4.0, 5.0, 6.0]);
let mid = DMatrix::from_row_slice(3, 3, &[0.1, 0.2, 0.3,
0.5, 0.6, 0.7,
0.9, 1.0, 1.1]);
// The random shows that values on the workspace do not
// matter as they will be overwritten.
let mut workspace = DVector::new_random(2);
let expected = &lhs * &mid * lhs.transpose() * 10.0 + &mat * 5.0;
mat.quadform_tr_with_workspace(&mut workspace, 10.0, &lhs, &mid, 5.0);
assert_relative_eq!(mat, expected);
sourcepub fn quadform_tr<R3, C3, S3, D4, S4>(
&mut self,
alpha: T,
lhs: &Matrix<T, R3, C3, S3>,
mid: &SquareMatrix<T, D4, S4>,
beta: T
)
pub fn quadform_tr<R3, C3, S3, D4, S4>( &mut self, alpha: T, lhs: &Matrix<T, R3, C3, S3>, mid: &SquareMatrix<T, D4, S4>, beta: T )
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.
§Example
let mut mat = Matrix2::identity();
let lhs = Matrix2x3::new(1.0, 2.0, 3.0,
4.0, 5.0, 6.0);
let mid = Matrix3::new(0.1, 0.2, 0.3,
0.5, 0.6, 0.7,
0.9, 1.0, 1.1);
let expected = lhs * mid * lhs.transpose() * 10.0 + mat * 5.0;
mat.quadform_tr(10.0, &lhs, &mid, 5.0);
assert_relative_eq!(mat, expected);
sourcepub fn quadform_with_workspace<D2, S2, D3, S3, R4, C4, S4>(
&mut self,
work: &mut Vector<T, D2, S2>,
alpha: T,
mid: &SquareMatrix<T, D3, S3>,
rhs: &Matrix<T, R4, C4, S4>,
beta: T
)where
D2: Dim,
D3: Dim,
R4: Dim,
C4: Dim,
S2: StorageMut<T, D2>,
S3: Storage<T, D3, D3>,
S4: Storage<T, R4, C4>,
ShapeConstraint: DimEq<D3, R4> + DimEq<D1, C4> + DimEq<D2, D3> + AreMultipliable<C4, R4, D2, U1>,
pub fn quadform_with_workspace<D2, S2, D3, S3, R4, C4, S4>(
&mut self,
work: &mut Vector<T, D2, S2>,
alpha: T,
mid: &SquareMatrix<T, D3, S3>,
rhs: &Matrix<T, R4, C4, S4>,
beta: T
)where
D2: Dim,
D3: Dim,
R4: Dim,
C4: Dim,
S2: StorageMut<T, D2>,
S3: Storage<T, D3, D3>,
S4: Storage<T, R4, C4>,
ShapeConstraint: DimEq<D3, R4> + DimEq<D1, C4> + DimEq<D2, D3> + AreMultipliable<C4, R4, D2, U1>,
Computes the quadratic form self = alpha * rhs.transpose() * mid * rhs + beta * self
.
This uses the provided workspace work
to avoid allocations for intermediate results.
§Example
// Note that all those would also work with statically-sized matrices.
// We use DMatrix/DVector since that's the only case where pre-allocating the
// workspace is actually useful (assuming the same workspace is re-used for
// several computations) because it avoids repeated dynamic allocations.
let mut mat = DMatrix::identity(2, 2);
let rhs = DMatrix::from_row_slice(3, 2, &[1.0, 2.0,
3.0, 4.0,
5.0, 6.0]);
let mid = DMatrix::from_row_slice(3, 3, &[0.1, 0.2, 0.3,
0.5, 0.6, 0.7,
0.9, 1.0, 1.1]);
// The random shows that values on the workspace do not
// matter as they will be overwritten.
let mut workspace = DVector::new_random(3);
let expected = rhs.transpose() * &mid * &rhs * 10.0 + &mat * 5.0;
mat.quadform_with_workspace(&mut workspace, 10.0, &mid, &rhs, 5.0);
assert_relative_eq!(mat, expected);
sourcepub fn quadform<D2, S2, R3, C3, S3>(
&mut self,
alpha: T,
mid: &SquareMatrix<T, 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> + DimEq<D1, C3> + AreMultipliable<C3, R3, D2, U1>,
DefaultAllocator: Allocator<D2>,
pub fn quadform<D2, S2, R3, C3, S3>(
&mut self,
alpha: T,
mid: &SquareMatrix<T, 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> + DimEq<D1, C3> + AreMultipliable<C3, R3, D2, U1>,
DefaultAllocator: Allocator<D2>,
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.
§Example
let mut mat = Matrix2::identity();
let rhs = Matrix3x2::new(1.0, 2.0,
3.0, 4.0,
5.0, 6.0);
let mid = Matrix3::new(0.1, 0.2, 0.3,
0.5, 0.6, 0.7,
0.9, 1.0, 1.1);
let expected = rhs.transpose() * mid * rhs * 10.0 + mat * 5.0;
mat.quadform(10.0, &mid, &rhs, 5.0);
assert_relative_eq!(mat, expected);
source§impl<T, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>where
T: Scalar + ClosedAddAssign,
impl<T, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>where
T: Scalar + ClosedAddAssign,
sourcepub fn add_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
)where
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
pub fn add_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
)where
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
source§impl<T, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>where
T: Scalar + ClosedSubAssign,
impl<T, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>where
T: Scalar + ClosedSubAssign,
sourcepub fn sub_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
)where
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
pub fn sub_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
)where
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Equivalent to self + rhs
but stores the result into out
to avoid allocations.
source§impl<T, R1: Dim, C1: Dim, SA> Matrix<T, R1, C1, SA>
impl<T, R1: Dim, C1: Dim, SA> Matrix<T, R1, C1, SA>
§Special multiplications.
sourcepub fn tr_mul<R2: Dim, C2: Dim, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> OMatrix<T, C1, C2>where
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
pub fn tr_mul<R2: Dim, C2: Dim, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> OMatrix<T, C1, C2>where
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
Equivalent to self.transpose() * rhs
.
sourcepub fn ad_mul<R2: Dim, C2: Dim, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> OMatrix<T, C1, C2>where
T: SimdComplexField,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
pub fn ad_mul<R2: Dim, C2: Dim, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> OMatrix<T, C1, C2>where
T: SimdComplexField,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<C1, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2>,
Equivalent to self.adjoint() * rhs
.
sourcepub fn tr_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
)where
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
pub fn tr_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
)where
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
Equivalent to self.transpose() * rhs
but stores the result into out
to avoid
allocations.
sourcepub fn ad_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
)where
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
pub fn ad_mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
)where
T: SimdComplexField,
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R1, R2> + DimEq<C1, R3> + DimEq<C2, C3>,
Equivalent to self.adjoint() * rhs
but stores the result into out
to avoid
allocations.
sourcepub fn mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
)where
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1> + SameNumberOfColumns<C3, C2> + AreMultipliable<R1, C1, R2, C2>,
pub fn mul_to<R2: Dim, C2: Dim, SB, R3: Dim, C3: Dim, SC>(
&self,
rhs: &Matrix<T, R2, C2, SB>,
out: &mut Matrix<T, R3, C3, SC>
)where
SB: Storage<T, R2, C2>,
SC: StorageMut<T, R3, C3>,
ShapeConstraint: SameNumberOfRows<R3, R1> + SameNumberOfColumns<C3, C2> + AreMultipliable<R1, C1, R2, C2>,
Equivalent to self * rhs
but stores the result into out
to avoid allocations.
sourcepub fn kronecker<R2: Dim, C2: Dim, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> OMatrix<T, DimProd<R1, R2>, DimProd<C1, C2>>where
T: ClosedMulAssign,
R1: DimMul<R2>,
C1: DimMul<C2>,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<DimProd<R1, R2>, DimProd<C1, C2>>,
pub fn kronecker<R2: Dim, C2: Dim, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> OMatrix<T, DimProd<R1, R2>, DimProd<C1, C2>>where
T: ClosedMulAssign,
R1: DimMul<R2>,
C1: DimMul<C2>,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<DimProd<R1, R2>, DimProd<C1, C2>>,
The kronecker product of two matrices (aka. tensor product of the corresponding linear maps).
source§impl<T, D: DimName> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
impl<T, D: DimName> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
§Translation and scaling in any dimension
sourcepub fn new_scaling(scaling: T) -> Self
pub fn new_scaling(scaling: T) -> Self
Creates a new homogeneous matrix that applies the same scaling factor on each dimension.
sourcepub fn new_nonuniform_scaling<SB>(
scaling: &Vector<T, DimNameDiff<D, U1>, SB>
) -> Self
pub fn new_nonuniform_scaling<SB>( scaling: &Vector<T, DimNameDiff<D, U1>, SB> ) -> Self
Creates a new homogeneous matrix that applies a distinct scaling factor for each dimension.
sourcepub fn new_translation<SB>(
translation: &Vector<T, DimNameDiff<D, U1>, SB>
) -> Self
pub fn new_translation<SB>( translation: &Vector<T, DimNameDiff<D, U1>, SB> ) -> Self
Creates a new homogeneous matrix that applies a pure translation.
source§impl<T: RealField> Matrix<T, Const<3>, Const<3>, ArrayStorage<T, 3, 3>>
impl<T: RealField> Matrix<T, Const<3>, Const<3>, ArrayStorage<T, 3, 3>>
§2D transformations as a Matrix3
sourcepub fn new_rotation(angle: T) -> Self
pub fn new_rotation(angle: T) -> Self
Builds a 2 dimensional homogeneous rotation matrix from an angle in radian.
sourcepub fn new_nonuniform_scaling_wrt_point(
scaling: &Vector2<T>,
pt: &Point2<T>
) -> Self
pub fn new_nonuniform_scaling_wrt_point( scaling: &Vector2<T>, pt: &Point2<T> ) -> Self
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.
source§impl<T: RealField> Matrix<T, Const<4>, Const<4>, ArrayStorage<T, 4, 4>>
impl<T: RealField> Matrix<T, Const<4>, Const<4>, ArrayStorage<T, 4, 4>>
§3D transformations as a Matrix4
sourcepub fn new_rotation(axisangle: Vector3<T>) -> Self
pub fn new_rotation(axisangle: Vector3<T>) -> Self
Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
Returns the identity matrix if the given argument is zero.
sourcepub fn new_rotation_wrt_point(axisangle: Vector3<T>, pt: Point3<T>) -> Self
pub fn new_rotation_wrt_point(axisangle: Vector3<T>, pt: Point3<T>) -> Self
Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
Returns the identity matrix if the given argument is zero.
sourcepub fn new_nonuniform_scaling_wrt_point(
scaling: &Vector3<T>,
pt: &Point3<T>
) -> Self
pub fn new_nonuniform_scaling_wrt_point( scaling: &Vector3<T>, pt: &Point3<T> ) -> Self
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.
sourcepub fn from_scaled_axis(axisangle: Vector3<T>) -> Self
pub fn from_scaled_axis(axisangle: Vector3<T>) -> Self
Builds a 3D homogeneous rotation matrix from an axis and an angle (multiplied together).
Returns the identity matrix if the given argument is zero.
This is identical to Self::new_rotation
.
sourcepub fn from_euler_angles(roll: T, pitch: T, yaw: T) -> Self
pub fn from_euler_angles(roll: T, pitch: T, yaw: T) -> Self
Creates a new rotation from Euler angles.
The primitive rotations are applied in order: 1 roll − 2 pitch − 3 yaw.
sourcepub fn from_axis_angle(axis: &Unit<Vector3<T>>, angle: T) -> Self
pub fn from_axis_angle(axis: &Unit<Vector3<T>>, angle: T) -> Self
Builds a 3D homogeneous rotation matrix from an axis and a rotation angle.
sourcepub fn new_orthographic(
left: T,
right: T,
bottom: T,
top: T,
znear: T,
zfar: T
) -> Self
pub fn new_orthographic( left: T, right: T, bottom: T, top: T, znear: T, zfar: T ) -> Self
Creates a new homogeneous matrix for an orthographic projection.
sourcepub fn new_perspective(aspect: T, fovy: T, znear: T, zfar: T) -> Self
pub fn new_perspective(aspect: T, fovy: T, znear: T, zfar: T) -> Self
Creates a new homogeneous matrix for a perspective projection.
sourcepub fn face_towards(
eye: &Point3<T>,
target: &Point3<T>,
up: &Vector3<T>
) -> Self
pub fn face_towards( eye: &Point3<T>, target: &Point3<T>, up: &Vector3<T> ) -> Self
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
.
sourcepub fn new_observer_frame(
eye: &Point3<T>,
target: &Point3<T>,
up: &Vector3<T>
) -> Self
👎Deprecated: renamed to face_towards
pub fn new_observer_frame( eye: &Point3<T>, target: &Point3<T>, up: &Vector3<T> ) -> Self
face_towards
Deprecated: Use Matrix4::face_towards
instead.
sourcepub fn look_at_rh(eye: &Point3<T>, target: &Point3<T>, up: &Vector3<T>) -> Self
pub fn look_at_rh(eye: &Point3<T>, target: &Point3<T>, up: &Vector3<T>) -> Self
Builds a right-handed look-at view matrix.
sourcepub fn look_at_lh(eye: &Point3<T>, target: &Point3<T>, up: &Vector3<T>) -> Self
pub fn look_at_lh(eye: &Point3<T>, target: &Point3<T>, up: &Vector3<T>) -> Self
Builds a left-handed look-at view matrix.
source§impl<T: Scalar + Zero + One + ClosedMulAssign + ClosedAddAssign, D: DimName, S: Storage<T, D, D>> Matrix<T, D, D, S>
impl<T: Scalar + Zero + One + ClosedMulAssign + ClosedAddAssign, D: DimName, S: Storage<T, D, D>> Matrix<T, D, D, S>
§Append/prepend translation and scaling
sourcepub fn append_scaling(&self, scaling: T) -> OMatrix<T, D, D>
pub fn append_scaling(&self, scaling: T) -> OMatrix<T, D, D>
Computes the transformation equal to self
followed by an uniform scaling factor.
sourcepub fn prepend_scaling(&self, scaling: T) -> OMatrix<T, D, D>
pub fn prepend_scaling(&self, scaling: T) -> OMatrix<T, D, D>
Computes the transformation equal to an uniform scaling factor followed by self
.
sourcepub fn append_nonuniform_scaling<SB>(
&self,
scaling: &Vector<T, DimNameDiff<D, U1>, SB>
) -> OMatrix<T, D, D>
pub fn append_nonuniform_scaling<SB>( &self, scaling: &Vector<T, DimNameDiff<D, U1>, SB> ) -> OMatrix<T, D, D>
Computes the transformation equal to self
followed by a non-uniform scaling factor.
sourcepub fn prepend_nonuniform_scaling<SB>(
&self,
scaling: &Vector<T, DimNameDiff<D, U1>, SB>
) -> OMatrix<T, D, D>
pub fn prepend_nonuniform_scaling<SB>( &self, scaling: &Vector<T, DimNameDiff<D, U1>, SB> ) -> OMatrix<T, D, D>
Computes the transformation equal to a non-uniform scaling factor followed by self
.
sourcepub fn append_translation<SB>(
&self,
shift: &Vector<T, DimNameDiff<D, U1>, SB>
) -> OMatrix<T, D, D>
pub fn append_translation<SB>( &self, shift: &Vector<T, DimNameDiff<D, U1>, SB> ) -> OMatrix<T, D, D>
Computes the transformation equal to self
followed by a translation.
sourcepub fn prepend_translation<SB>(
&self,
shift: &Vector<T, DimNameDiff<D, U1>, SB>
) -> OMatrix<T, D, D>where
D: DimNameSub<U1>,
SB: Storage<T, DimNameDiff<D, U1>>,
DefaultAllocator: Allocator<D, D> + Allocator<DimNameDiff<D, U1>>,
pub fn prepend_translation<SB>(
&self,
shift: &Vector<T, DimNameDiff<D, U1>, SB>
) -> OMatrix<T, D, D>where
D: DimNameSub<U1>,
SB: Storage<T, DimNameDiff<D, U1>>,
DefaultAllocator: Allocator<D, D> + Allocator<DimNameDiff<D, U1>>,
Computes the transformation equal to a translation followed by self
.
sourcepub fn append_scaling_mut(&mut self, scaling: T)
pub fn append_scaling_mut(&mut self, scaling: T)
Computes in-place the transformation equal to self
followed by an uniform scaling factor.
sourcepub fn prepend_scaling_mut(&mut self, scaling: T)
pub fn prepend_scaling_mut(&mut self, scaling: T)
Computes in-place the transformation equal to an uniform scaling factor followed by self
.
sourcepub fn append_nonuniform_scaling_mut<SB>(
&mut self,
scaling: &Vector<T, DimNameDiff<D, U1>, SB>
)
pub fn append_nonuniform_scaling_mut<SB>( &mut self, scaling: &Vector<T, DimNameDiff<D, U1>, SB> )
Computes in-place the transformation equal to self
followed by a non-uniform scaling factor.
sourcepub fn prepend_nonuniform_scaling_mut<SB>(
&mut self,
scaling: &Vector<T, DimNameDiff<D, U1>, SB>
)
pub fn prepend_nonuniform_scaling_mut<SB>( &mut self, scaling: &Vector<T, DimNameDiff<D, U1>, SB> )
Computes in-place the transformation equal to a non-uniform scaling factor followed by self
.
sourcepub fn append_translation_mut<SB>(
&mut self,
shift: &Vector<T, DimNameDiff<D, U1>, SB>
)
pub fn append_translation_mut<SB>( &mut self, shift: &Vector<T, DimNameDiff<D, U1>, SB> )
Computes the transformation equal to self
followed by a translation.
sourcepub fn prepend_translation_mut<SB>(
&mut self,
shift: &Vector<T, DimNameDiff<D, U1>, SB>
)where
D: DimNameSub<U1>,
S: StorageMut<T, D, D>,
SB: Storage<T, DimNameDiff<D, U1>>,
DefaultAllocator: Allocator<DimNameDiff<D, U1>>,
pub fn prepend_translation_mut<SB>(
&mut self,
shift: &Vector<T, DimNameDiff<D, U1>, SB>
)where
D: DimNameSub<U1>,
S: StorageMut<T, D, D>,
SB: Storage<T, DimNameDiff<D, U1>>,
DefaultAllocator: Allocator<DimNameDiff<D, U1>>,
Computes the transformation equal to a translation followed by self
.
source§impl<T: RealField, D: DimNameSub<U1>, S: Storage<T, D, D>> Matrix<T, D, D, S>where
DefaultAllocator: Allocator<D, D> + Allocator<DimNameDiff<D, U1>> + Allocator<DimNameDiff<D, U1>, DimNameDiff<D, U1>>,
impl<T: RealField, D: DimNameSub<U1>, S: Storage<T, D, D>> Matrix<T, D, D, S>where
DefaultAllocator: Allocator<D, D> + Allocator<DimNameDiff<D, U1>> + Allocator<DimNameDiff<D, U1>, DimNameDiff<D, U1>>,
§Transformation of vectors and points
sourcepub fn transform_vector(
&self,
v: &OVector<T, DimNameDiff<D, U1>>
) -> OVector<T, DimNameDiff<D, U1>>
pub fn transform_vector( &self, v: &OVector<T, DimNameDiff<D, U1>> ) -> OVector<T, DimNameDiff<D, U1>>
Transforms the given vector, assuming the matrix self
uses homogeneous coordinates.
source§impl<T: RealField, S: Storage<T, Const<3>, Const<3>>> Matrix<T, Const<3>, Const<3>, S>
impl<T: RealField, S: Storage<T, Const<3>, Const<3>>> Matrix<T, Const<3>, Const<3>, S>
sourcepub fn transform_point(&self, pt: &Point<T, 2>) -> Point<T, 2>
pub fn transform_point(&self, pt: &Point<T, 2>) -> Point<T, 2>
Transforms the given point, assuming the matrix self
uses homogeneous coordinates.
source§impl<T: RealField, S: Storage<T, Const<4>, Const<4>>> Matrix<T, Const<4>, Const<4>, S>
impl<T: RealField, S: Storage<T, Const<4>, Const<4>>> Matrix<T, Const<4>, Const<4>, S>
sourcepub fn transform_point(&self, pt: &Point<T, 3>) -> Point<T, 3>
pub fn transform_point(&self, pt: &Point<T, 3>) -> Point<T, 3>
Transforms the given point, assuming the matrix self
uses homogeneous coordinates.
source§impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
§Componentwise operations
sourcepub fn component_mul<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> MatrixSum<T, R1, C1, R2, C2>where
T: ClosedMulAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
pub fn component_mul<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> MatrixSum<T, R1, C1, R2, C2>where
T: ClosedMulAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Componentwise matrix or vector multiplication.
§Example
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);
assert_eq!(a.component_mul(&b), expected);
sourcepub 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: ClosedMulAssign + Zero + Mul<T, Output = T> + Add<T, Output = 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> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + 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: ClosedMulAssign + Zero + Mul<T, Output = T> + Add<T, Output = 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> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Computes componentwise self[i] = alpha * a[i] * b[i] + beta * self[i]
.
§Example
let mut m = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = (a.component_mul(&b) * 5.0) + m * 10.0;
m.cmpy(5.0, &a, &b, 10.0);
assert_eq!(m, expected);
sourcepub fn component_mul_assign<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)where
T: ClosedMulAssign,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
pub fn component_mul_assign<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)where
T: ClosedMulAssign,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Inplace componentwise matrix or vector multiplication.
§Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);
a.component_mul_assign(&b);
assert_eq!(a, expected);
sourcepub fn component_mul_mut<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)where
T: ClosedMulAssign,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
👎Deprecated: This is renamed using the _assign
suffix instead of the _mut
suffix.
pub fn component_mul_mut<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)where
T: ClosedMulAssign,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
_assign
suffix instead of the _mut
suffix.Inplace componentwise matrix or vector multiplication.
§Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 5.0, 12.0, 21.0);
a.component_mul_assign(&b);
assert_eq!(a, expected);
sourcepub fn component_div<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> MatrixSum<T, R1, C1, R2, C2>where
T: ClosedDivAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
pub fn component_div<R2, C2, SB>(
&self,
rhs: &Matrix<T, R2, C2, SB>
) -> MatrixSum<T, R1, C1, R2, C2>where
T: ClosedDivAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Componentwise matrix or vector division.
§Example
let a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);
assert_eq!(a.component_div(&b), expected);
sourcepub 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: ClosedDivAssign + Zero + Mul<T, Output = T> + Add<T, Output = 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> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + 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: ClosedDivAssign + Zero + Mul<T, Output = T> + Add<T, Output = 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> + SameNumberOfColumns<C1, C2> + SameNumberOfRows<R1, R3> + SameNumberOfColumns<C1, C3>,
Computes componentwise self[i] = alpha * a[i] / b[i] + beta * self[i]
.
§Example
let mut m = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let a = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = (a.component_div(&b) * 5.0) + m * 10.0;
m.cdpy(5.0, &a, &b, 10.0);
assert_eq!(m, expected);
sourcepub fn component_div_assign<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)where
T: ClosedDivAssign,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
pub fn component_div_assign<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)where
T: ClosedDivAssign,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
Inplace componentwise matrix or vector division.
§Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);
a.component_div_assign(&b);
assert_eq!(a, expected);
sourcepub fn component_div_mut<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)where
T: ClosedDivAssign,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
👎Deprecated: This is renamed using the _assign
suffix instead of the _mut
suffix.
pub fn component_div_mut<R2, C2, SB>(&mut self, rhs: &Matrix<T, R2, C2, SB>)where
T: ClosedDivAssign,
R2: Dim,
C2: Dim,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
_assign
suffix instead of the _mut
suffix.Inplace componentwise matrix or vector division.
§Example
let mut a = Matrix2::new(0.0, 1.0, 2.0, 3.0);
let b = Matrix2::new(4.0, 5.0, 6.0, 7.0);
let expected = Matrix2::new(0.0, 1.0 / 5.0, 2.0 / 6.0, 3.0 / 7.0);
a.component_div_assign(&b);
assert_eq!(a, expected);
sourcepub fn inf(&self, other: &Self) -> OMatrix<T, R1, C1>
pub fn inf(&self, other: &Self) -> OMatrix<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)
sourcepub fn sup(&self, other: &Self) -> OMatrix<T, R1, C1>
pub fn sup(&self, other: &Self) -> OMatrix<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)
sourcepub fn inf_sup(&self, other: &Self) -> (OMatrix<T, R1, C1>, OMatrix<T, R1, C1>)
pub fn inf_sup(&self, other: &Self) -> (OMatrix<T, R1, C1>, OMatrix<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)
sourcepub fn add_scalar(&self, rhs: T) -> OMatrix<T, R1, C1>
pub fn add_scalar(&self, rhs: T) -> OMatrix<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)
sourcepub fn add_scalar_mut(&mut self, rhs: T)where
T: ClosedAddAssign,
SA: StorageMut<T, R1, C1>,
pub fn add_scalar_mut(&mut self, rhs: T)where
T: ClosedAddAssign,
SA: StorageMut<T, R1, C1>,
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)
source§impl<T: Scalar, R: Dim, C: Dim> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<R, C>>::BufferUninit<T>>where
DefaultAllocator: Allocator<R, C>,
impl<T: Scalar, R: Dim, C: Dim> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<R, C>>::BufferUninit<T>>where
DefaultAllocator: Allocator<R, C>,
source§impl<T: Scalar, R: Dim, C: Dim> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>where
DefaultAllocator: Allocator<R, C>,
impl<T: Scalar, R: Dim, C: Dim> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>where
DefaultAllocator: Allocator<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.
sourcepub fn from_element_generic(nrows: R, ncols: C, elem: T) -> Self
pub fn from_element_generic(nrows: R, ncols: C, elem: T) -> Self
Creates a matrix with all its elements set to elem
.
sourcepub fn repeat_generic(nrows: R, ncols: C, elem: T) -> Self
pub fn repeat_generic(nrows: R, ncols: C, elem: T) -> Self
Creates a matrix with all its elements set to elem
.
Same as from_element_generic
.
sourcepub fn zeros_generic(nrows: R, ncols: C) -> Selfwhere
T: Zero,
pub fn zeros_generic(nrows: R, ncols: C) -> Selfwhere
T: Zero,
Creates a matrix with all its elements set to 0.
sourcepub fn from_iterator_generic<I>(nrows: R, ncols: C, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
pub fn from_iterator_generic<I>(nrows: R, ncols: C, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
Creates a matrix with all its elements filled by an iterator.
sourcepub fn from_row_iterator_generic<I>(nrows: R, ncols: C, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
pub fn from_row_iterator_generic<I>(nrows: R, ncols: C, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
Creates a matrix with all its elements filled by an row-major order iterator.
sourcepub fn from_row_slice_generic(nrows: R, ncols: C, slice: &[T]) -> Self
pub fn from_row_slice_generic(nrows: R, ncols: C, slice: &[T]) -> Self
Creates a matrix with its elements filled with the components provided by a slice in row-major order.
The order of elements in the slice must follow the usual mathematic writing, i.e., row-by-row.
sourcepub fn from_column_slice_generic(nrows: R, ncols: C, slice: &[T]) -> Self
pub fn from_column_slice_generic(nrows: R, ncols: C, slice: &[T]) -> Self
Creates a matrix with its elements filled with the components provided by a slice. The components must have the same layout as the matrix data storage (i.e. column-major).
sourcepub fn from_fn_generic<F>(nrows: R, ncols: C, f: F) -> Self
pub fn from_fn_generic<F>(nrows: R, ncols: C, f: F) -> Self
Creates a matrix filled with the results of a function applied to each of its component coordinates.
sourcepub fn identity_generic(nrows: R, ncols: C) -> Self
pub fn identity_generic(nrows: R, ncols: C) -> Self
Creates a new identity matrix.
If the matrix is not square, the largest square submatrix starting at index (0, 0)
is set
to the identity matrix. All other entries are set to zero.
sourcepub fn from_diagonal_element_generic(nrows: R, ncols: C, elt: T) -> Self
pub fn from_diagonal_element_generic(nrows: R, ncols: C, elt: T) -> Self
Creates a new matrix with its diagonal filled with copies of elt
.
If the matrix is not square, the largest square submatrix starting at index (0, 0)
is set
to the identity matrix. All other entries are set to zero.
sourcepub fn from_partial_diagonal_generic(nrows: R, ncols: C, elts: &[T]) -> Selfwhere
T: Zero,
pub fn from_partial_diagonal_generic(nrows: R, ncols: C, elts: &[T]) -> Selfwhere
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
.
sourcepub fn from_rows<SB>(rows: &[Matrix<T, Const<1>, C, SB>]) -> Selfwhere
SB: RawStorage<T, Const<1>, C>,
pub fn from_rows<SB>(rows: &[Matrix<T, Const<1>, C, SB>]) -> Selfwhere
SB: RawStorage<T, Const<1>, C>,
Builds a new matrix from its rows.
Panics if not enough rows are provided (for statically-sized matrices), or if all rows do not have the same dimensions.
§Example
let m = Matrix3::from_rows(&[ RowVector3::new(1.0, 2.0, 3.0), RowVector3::new(4.0, 5.0, 6.0), RowVector3::new(7.0, 8.0, 9.0) ]);
assert!(m.m11 == 1.0 && m.m12 == 2.0 && m.m13 == 3.0 &&
m.m21 == 4.0 && m.m22 == 5.0 && m.m23 == 6.0 &&
m.m31 == 7.0 && m.m32 == 8.0 && m.m33 == 9.0);
sourcepub fn from_columns<SB>(columns: &[Vector<T, R, SB>]) -> Selfwhere
SB: RawStorage<T, R>,
pub fn from_columns<SB>(columns: &[Vector<T, R, SB>]) -> Selfwhere
SB: RawStorage<T, R>,
Builds a new matrix from its columns.
Panics if not enough columns are provided (for statically-sized matrices), or if all columns do not have the same dimensions.
§Example
let m = Matrix3::from_columns(&[ Vector3::new(1.0, 2.0, 3.0), Vector3::new(4.0, 5.0, 6.0), Vector3::new(7.0, 8.0, 9.0) ]);
assert!(m.m11 == 1.0 && m.m12 == 4.0 && m.m13 == 7.0 &&
m.m21 == 2.0 && m.m22 == 5.0 && m.m23 == 8.0 &&
m.m31 == 3.0 && m.m32 == 6.0 && m.m33 == 9.0);
sourcepub fn from_vec_generic(nrows: R, ncols: C, data: Vec<T>) -> Self
pub fn from_vec_generic(nrows: R, ncols: C, data: Vec<T>) -> Self
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(Dyn(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);
source§impl<T, D: Dim> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
impl<T, D: Dim> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>
sourcepub fn from_diagonal<SB: RawStorage<T, D>>(diag: &Vector<T, D, SB>) -> Selfwhere
T: Zero,
pub fn from_diagonal<SB: RawStorage<T, D>>(diag: &Vector<T, D, SB>) -> Selfwhere
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);
source§impl<T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>where
DefaultAllocator: Allocator<R, C>,
impl<T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>where
DefaultAllocator: Allocator<R, C>,
§Constructors of statically-sized vectors or statically-sized matrices
sourcepub fn from_element(elem: T) -> Self
pub fn from_element(elem: T) -> Self
Creates a matrix or vector with all its elements set to elem
.
§Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn repeat(elem: T) -> Self
pub fn repeat(elem: T) -> Self
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
§Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn zeros() -> Selfwhere
T: Zero,
pub fn zeros() -> Selfwhere
T: Zero,
Creates a matrix or vector with all its elements set to 0
.
§Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_iterator<I>(iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
pub fn from_iterator<I>(iter: I) -> Selfwhere
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);
sourcepub fn from_row_iterator<I>(iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
pub fn from_row_iterator<I>(iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
Creates a matrix or vector with all its elements filled by a row-major iterator.
The output matrix is filled row-by-row.
§Example
let v = Vector3::from_row_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_row_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_row_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_iterator(2, 3, (0..6).into_iter());
// For Vectors from_row_iterator is identical to from_iterator
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn from_fn<F>(f: F) -> Self
pub fn from_fn<F>(f: F) -> Self
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
§Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn identity() -> Self
pub fn identity() -> Self
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
§Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_diagonal_element(elt: T) -> Self
pub fn from_diagonal_element(elt: T) -> Self
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
§Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_partial_diagonal(elts: &[T]) -> Selfwhere
T: Zero,
pub fn from_partial_diagonal(elts: &[T]) -> Selfwhere
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);
source§impl<T: Scalar, R: DimName> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
impl<T: Scalar, R: DimName> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
§Constructors of matrices with a dynamic number of columns
sourcepub fn from_element(ncols: usize, elem: T) -> Self
pub fn from_element(ncols: usize, elem: T) -> Self
Creates a matrix or vector with all its elements set to elem
.
§Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn repeat(ncols: usize, elem: T) -> Self
pub fn repeat(ncols: usize, elem: T) -> Self
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
§Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn zeros(ncols: usize) -> Selfwhere
T: Zero,
pub fn zeros(ncols: usize) -> Selfwhere
T: Zero,
Creates a matrix or vector with all its elements set to 0
.
§Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_iterator<I>(ncols: usize, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
pub fn from_iterator<I>(ncols: usize, iter: I) -> Selfwhere
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);
sourcepub fn from_row_iterator<I>(ncols: usize, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
pub fn from_row_iterator<I>(ncols: usize, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
Creates a matrix or vector with all its elements filled by a row-major iterator.
The output matrix is filled row-by-row.
§Example
let v = Vector3::from_row_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_row_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_row_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_iterator(2, 3, (0..6).into_iter());
// For Vectors from_row_iterator is identical to from_iterator
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn from_fn<F>(ncols: usize, f: F) -> Self
pub fn from_fn<F>(ncols: usize, f: F) -> Self
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
§Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn identity(ncols: usize) -> Self
pub fn identity(ncols: usize) -> Self
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
§Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_diagonal_element(ncols: usize, elt: T) -> Self
pub fn from_diagonal_element(ncols: usize, elt: T) -> Self
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
§Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_partial_diagonal(ncols: usize, elts: &[T]) -> Selfwhere
T: Zero,
pub fn from_partial_diagonal(ncols: usize, elts: &[T]) -> Selfwhere
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);
source§impl<T: Scalar, C: DimName> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
impl<T: Scalar, C: DimName> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
§Constructors of dynamic vectors and matrices with a dynamic number of rows
sourcepub fn from_element(nrows: usize, elem: T) -> Self
pub fn from_element(nrows: usize, elem: T) -> Self
Creates a matrix or vector with all its elements set to elem
.
§Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn repeat(nrows: usize, elem: T) -> Self
pub fn repeat(nrows: usize, elem: T) -> Self
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
§Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn zeros(nrows: usize) -> Selfwhere
T: Zero,
pub fn zeros(nrows: usize) -> Selfwhere
T: Zero,
Creates a matrix or vector with all its elements set to 0
.
§Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_iterator<I>(nrows: usize, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
pub fn from_iterator<I>(nrows: usize, iter: I) -> Selfwhere
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);
sourcepub fn from_row_iterator<I>(nrows: usize, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
pub fn from_row_iterator<I>(nrows: usize, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
Creates a matrix or vector with all its elements filled by a row-major iterator.
The output matrix is filled row-by-row.
§Example
let v = Vector3::from_row_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_row_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_row_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_iterator(2, 3, (0..6).into_iter());
// For Vectors from_row_iterator is identical to from_iterator
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn from_fn<F>(nrows: usize, f: F) -> Self
pub fn from_fn<F>(nrows: usize, f: F) -> Self
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
§Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn identity(nrows: usize) -> Self
pub fn identity(nrows: usize) -> Self
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
§Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_diagonal_element(nrows: usize, elt: T) -> Self
pub fn from_diagonal_element(nrows: usize, elt: T) -> Self
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
§Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_partial_diagonal(nrows: usize, elts: &[T]) -> Selfwhere
T: Zero,
pub fn from_partial_diagonal(nrows: usize, elts: &[T]) -> Selfwhere
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);
source§impl<T: Scalar> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
impl<T: Scalar> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
§Constructors of fully dynamic matrices
sourcepub fn from_element(nrows: usize, ncols: usize, elem: T) -> Self
pub fn from_element(nrows: usize, ncols: usize, elem: T) -> Self
Creates a matrix or vector with all its elements set to elem
.
§Example
let v = Vector3::from_element(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::from_element(3, 2.0);
let m = Matrix2x3::from_element(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_element(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn repeat(nrows: usize, ncols: usize, elem: T) -> Self
pub fn repeat(nrows: usize, ncols: usize, elem: T) -> Self
Creates a matrix or vector with all its elements set to elem
.
Same as .from_element
.
§Example
let v = Vector3::repeat(2.0);
// The additional argument represents the vector dimension.
let dv = DVector::repeat(3, 2.0);
let m = Matrix2x3::repeat(2.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::repeat(2, 3, 2.0);
assert!(v.x == 2.0 && v.y == 2.0 && v.z == 2.0);
assert!(dv[0] == 2.0 && dv[1] == 2.0 && dv[2] == 2.0);
assert!(m.m11 == 2.0 && m.m12 == 2.0 && m.m13 == 2.0 &&
m.m21 == 2.0 && m.m22 == 2.0 && m.m23 == 2.0);
assert!(dm[(0, 0)] == 2.0 && dm[(0, 1)] == 2.0 && dm[(0, 2)] == 2.0 &&
dm[(1, 0)] == 2.0 && dm[(1, 1)] == 2.0 && dm[(1, 2)] == 2.0);
sourcepub fn zeros(nrows: usize, ncols: usize) -> Selfwhere
T: Zero,
pub fn zeros(nrows: usize, ncols: usize) -> Selfwhere
T: Zero,
Creates a matrix or vector with all its elements set to 0
.
§Example
let v = Vector3::<f32>::zeros();
// The argument represents the vector dimension.
let dv = DVector::<f32>::zeros(3);
let m = Matrix2x3::<f32>::zeros();
// The two arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::zeros(2, 3);
assert!(v.x == 0.0 && v.y == 0.0 && v.z == 0.0);
assert!(dv[0] == 0.0 && dv[1] == 0.0 && dv[2] == 0.0);
assert!(m.m11 == 0.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 0.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 0.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 0.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_iterator<I>(nrows: usize, ncols: usize, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
pub fn from_iterator<I>(nrows: usize, ncols: usize, iter: I) -> Selfwhere
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);
sourcepub fn from_row_iterator<I>(nrows: usize, ncols: usize, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
pub fn from_row_iterator<I>(nrows: usize, ncols: usize, iter: I) -> Selfwhere
I: IntoIterator<Item = T>,
Creates a matrix or vector with all its elements filled by a row-major iterator.
The output matrix is filled row-by-row.
§Example
let v = Vector3::from_row_iterator((0..3).into_iter());
// The additional argument represents the vector dimension.
let dv = DVector::from_row_iterator(3, (0..3).into_iter());
let m = Matrix2x3::from_row_iterator((0..6).into_iter());
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_row_iterator(2, 3, (0..6).into_iter());
// For Vectors from_row_iterator is identical to from_iterator
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn from_fn<F>(nrows: usize, ncols: usize, f: F) -> Self
pub fn from_fn<F>(nrows: usize, ncols: usize, f: F) -> Self
Creates a matrix or vector filled with the results of a function applied to each of its component coordinates.
§Example
let v = Vector3::from_fn(|i, _| i);
// The additional argument represents the vector dimension.
let dv = DVector::from_fn(3, |i, _| i);
let m = Matrix2x3::from_fn(|i, j| i * 3 + j);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_fn(2, 3, |i, j| i * 3 + j);
assert!(v.x == 0 && v.y == 1 && v.z == 2);
assert!(dv[0] == 0 && dv[1] == 1 && dv[2] == 2);
assert!(m.m11 == 0 && m.m12 == 1 && m.m13 == 2 &&
m.m21 == 3 && m.m22 == 4 && m.m23 == 5);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 1 && dm[(0, 2)] == 2 &&
dm[(1, 0)] == 3 && dm[(1, 1)] == 4 && dm[(1, 2)] == 5);
sourcepub fn identity(nrows: usize, ncols: usize) -> Self
pub fn identity(nrows: usize, ncols: usize) -> Self
Creates an identity matrix. If the matrix is not square, the largest square submatrix (starting at the first row and column) is set to the identity while all other entries are set to zero.
§Example
let m = Matrix2x3::<f32>::identity();
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::<f32>::identity(2, 3);
assert!(m.m11 == 1.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 1.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 1.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 1.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_diagonal_element(nrows: usize, ncols: usize, elt: T) -> Self
pub fn from_diagonal_element(nrows: usize, ncols: usize, elt: T) -> Self
Creates a matrix filled with its diagonal filled with elt
and all other
components set to zero.
§Example
let m = Matrix2x3::from_diagonal_element(5.0);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_diagonal_element(2, 3, 5.0);
assert!(m.m11 == 5.0 && m.m12 == 0.0 && m.m13 == 0.0 &&
m.m21 == 0.0 && m.m22 == 5.0 && m.m23 == 0.0);
assert!(dm[(0, 0)] == 5.0 && dm[(0, 1)] == 0.0 && dm[(0, 2)] == 0.0 &&
dm[(1, 0)] == 0.0 && dm[(1, 1)] == 5.0 && dm[(1, 2)] == 0.0);
sourcepub fn from_partial_diagonal(nrows: usize, ncols: usize, elts: &[T]) -> Selfwhere
T: Zero,
pub fn from_partial_diagonal(nrows: usize, ncols: usize, elts: &[T]) -> Selfwhere
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);
source§impl<T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>where
DefaultAllocator: Allocator<R, C>,
impl<T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>where
DefaultAllocator: Allocator<R, C>,
sourcepub fn from_row_slice(data: &[T]) -> Self
pub fn from_row_slice(data: &[T]) -> Self
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);
sourcepub fn from_column_slice(data: &[T]) -> Self
pub fn from_column_slice(data: &[T]) -> Self
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);
sourcepub fn from_vec(data: Vec<T>) -> Self
pub fn from_vec(data: Vec<T>) -> Self
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
§Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
source§impl<T: Scalar, R: DimName> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
impl<T: Scalar, R: DimName> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
sourcepub fn from_row_slice(data: &[T]) -> Self
pub fn from_row_slice(data: &[T]) -> Self
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);
sourcepub fn from_column_slice(data: &[T]) -> Self
pub fn from_column_slice(data: &[T]) -> Self
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);
sourcepub fn from_vec(data: Vec<T>) -> Self
pub fn from_vec(data: Vec<T>) -> Self
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
§Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
source§impl<T: Scalar, C: DimName> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
impl<T: Scalar, C: DimName> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
sourcepub fn from_row_slice(data: &[T]) -> Self
pub fn from_row_slice(data: &[T]) -> Self
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);
sourcepub fn from_column_slice(data: &[T]) -> Self
pub fn from_column_slice(data: &[T]) -> Self
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);
sourcepub fn from_vec(data: Vec<T>) -> Self
pub fn from_vec(data: Vec<T>) -> Self
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
§Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
source§impl<T: Scalar> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
impl<T: Scalar> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
sourcepub fn from_row_slice(nrows: usize, ncols: usize, data: &[T]) -> Self
pub fn from_row_slice(nrows: usize, ncols: usize, data: &[T]) -> Self
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);
sourcepub fn from_column_slice(nrows: usize, ncols: usize, data: &[T]) -> Self
pub fn from_column_slice(nrows: usize, ncols: usize, data: &[T]) -> Self
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);
sourcepub fn from_vec(nrows: usize, ncols: usize, data: Vec<T>) -> Self
pub fn from_vec(nrows: usize, ncols: usize, data: Vec<T>) -> Self
Creates a matrix backed by a given Vec
.
The output matrix is filled column-by-column.
§Example
let m = Matrix2x3::from_vec(vec![0, 1, 2, 3, 4, 5]);
assert!(m.m11 == 0 && m.m12 == 2 && m.m13 == 4 &&
m.m21 == 1 && m.m22 == 3 && m.m23 == 5);
// The two additional arguments represent the matrix dimensions.
let dm = DMatrix::from_vec(2, 3, vec![0, 1, 2, 3, 4, 5]);
assert!(dm[(0, 0)] == 0 && dm[(0, 1)] == 2 && dm[(0, 2)] == 4 &&
dm[(1, 0)] == 1 && dm[(1, 1)] == 3 && dm[(1, 2)] == 5);
source§impl<T> Matrix<T, Const<6>, Const<6>, ArrayStorage<T, 6, 6>>
impl<T> Matrix<T, Const<6>, Const<6>, ArrayStorage<T, 6, 6>>
sourcepub 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
) -> Self
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 ) -> Self
Initializes this matrix from its components.
source§impl<T> Matrix<T, Const<5>, Const<6>, ArrayStorage<T, 5, 6>>
impl<T> Matrix<T, Const<5>, Const<6>, ArrayStorage<T, 5, 6>>
sourcepub 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
) -> Self
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 ) -> Self
Initializes this matrix from its components.
source§impl<T> Matrix<T, Const<6>, Const<5>, ArrayStorage<T, 6, 5>>
impl<T> Matrix<T, Const<6>, Const<5>, ArrayStorage<T, 6, 5>>
sourcepub 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
) -> Self
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 ) -> Self
Initializes this matrix from its components.
source§impl<T, R> Matrix<T, R, Const<1>, <DefaultAllocator as Allocator<R>>::Buffer<T>>
impl<T, R> Matrix<T, R, Const<1>, <DefaultAllocator as Allocator<R>>::Buffer<T>>
sourcepub fn ith_axis(i: usize) -> Unit<Self>
pub fn ith_axis(i: usize) -> Unit<Self>
The column unit vector with T::one()
as its i-th component.
sourcepub fn x_axis() -> Unit<Self>
pub fn x_axis() -> Unit<Self>
The unit column vector with a 1 as its first component, and zero elsewhere.
sourcepub fn y_axis() -> Unit<Self>
pub fn y_axis() -> Unit<Self>
The unit column vector with a 1 as its second component, and zero elsewhere.
sourcepub fn z_axis() -> Unit<Self>
pub fn z_axis() -> Unit<Self>
The unit column vector with a 1 as its third component, and zero elsewhere.
sourcepub fn w_axis() -> Unit<Self>
pub fn w_axis() -> Unit<Self>
The unit column vector with a 1 as its fourth component, and zero elsewhere.
source§impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Matrix<T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>
impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Matrix<T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>
§Creating matrix views from &[T]
sourcepub unsafe fn from_slice_with_strides_generic_unchecked(
data: &'a [T],
start: usize,
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Self
pub unsafe fn from_slice_with_strides_generic_unchecked( data: &'a [T], start: usize, nrows: R, ncols: C, rstride: RStride, cstride: CStride ) -> Self
Creates, without bounds checking, a matrix view 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 Dyn()
.
sourcepub fn from_slice_with_strides_generic(
data: &'a [T],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Self
pub fn from_slice_with_strides_generic( data: &'a [T], nrows: R, ncols: C, rstride: RStride, cstride: CStride ) -> Self
Creates a matrix view 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 Dyn()
.
source§impl<'a, T: Scalar, R: Dim, C: Dim> Matrix<T, R, C, ViewStorage<'a, T, R, C, Const<1>, R>>
impl<'a, T: Scalar, R: Dim, C: Dim> Matrix<T, R, C, ViewStorage<'a, T, R, C, Const<1>, R>>
sourcepub unsafe fn from_slice_generic_unchecked(
data: &'a [T],
start: usize,
nrows: R,
ncols: C
) -> Self
pub unsafe fn from_slice_generic_unchecked( data: &'a [T], start: usize, nrows: R, ncols: C ) -> Self
Creates, without bound-checking, a matrix view 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 Dyn()
.
sourcepub fn from_slice_generic(data: &'a [T], nrows: R, ncols: C) -> Self
pub fn from_slice_generic(data: &'a [T], nrows: R, ncols: C) -> Self
Creates a matrix view 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 Dyn()
.
source§impl<'a, T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, ViewStorage<'a, T, R, C, Const<1>, R>>
impl<'a, T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, ViewStorage<'a, T, R, C, Const<1>, R>>
sourcepub fn from_slice(data: &'a [T]) -> Self
pub fn from_slice(data: &'a [T]) -> Self
Creates a new matrix view from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_unchecked(data: &'a [T], start: usize) -> Self
pub unsafe fn from_slice_unchecked(data: &'a [T], start: usize) -> Self
Creates, without bound checking, a new matrix view from the given data array.
§Safety
data[start..start+rstride * cstride]
must be within bounds.
source§impl<'a, T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, ViewStorage<'a, T, R, C, Dyn, Dyn>>
impl<'a, T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, ViewStorage<'a, T, R, C, Dyn, Dyn>>
sourcepub fn from_slice_with_strides(
data: &'a [T],
rstride: usize,
cstride: usize
) -> Self
pub fn from_slice_with_strides( data: &'a [T], rstride: usize, cstride: usize ) -> Self
Creates a new matrix view with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a [T],
start: usize,
rstride: usize,
cstride: usize
) -> Self
pub unsafe fn from_slice_with_strides_unchecked( data: &'a [T], start: usize, rstride: usize, cstride: usize ) -> Self
Creates, without bound checking, a new matrix view with the specified strides from the given data array.
§Safety
start
, rstride
, and cstride
, with the given matrix size will not index
outside of data
.
source§impl<'a, T: Scalar, R: DimName> Matrix<T, R, Dyn, ViewStorage<'a, T, R, Dyn, Const<1>, R>>
impl<'a, T: Scalar, R: DimName> Matrix<T, R, Dyn, ViewStorage<'a, T, R, Dyn, Const<1>, R>>
sourcepub fn from_slice(data: &'a [T], ncols: usize) -> Self
pub fn from_slice(data: &'a [T], ncols: usize) -> Self
Creates a new matrix view from the given data array.
Panics if data
does not contain enough elements.
source§impl<'a, T: Scalar, R: DimName> Matrix<T, R, Dyn, ViewStorage<'a, T, R, Dyn, Dyn, Dyn>>
impl<'a, T: Scalar, R: DimName> Matrix<T, R, Dyn, ViewStorage<'a, T, R, Dyn, Dyn, Dyn>>
sourcepub fn from_slice_with_strides(
data: &'a [T],
ncols: usize,
rstride: usize,
cstride: usize
) -> Self
pub fn from_slice_with_strides( data: &'a [T], ncols: usize, rstride: usize, cstride: usize ) -> Self
Creates a new matrix view with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a [T],
start: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Self
pub unsafe fn from_slice_with_strides_unchecked( data: &'a [T], start: usize, ncols: usize, rstride: usize, cstride: usize ) -> Self
Creates, without bound checking, a new matrix view with the specified strides from the given data array.
§Safety
start
, rstride
, and cstride
, with the given matrix size will not index
outside of data
.
source§impl<'a, T: Scalar, C: DimName> Matrix<T, Dyn, C, ViewStorage<'a, T, Dyn, C, Const<1>, Dyn>>
impl<'a, T: Scalar, C: DimName> Matrix<T, Dyn, C, ViewStorage<'a, T, Dyn, C, Const<1>, Dyn>>
sourcepub fn from_slice(data: &'a [T], nrows: usize) -> Self
pub fn from_slice(data: &'a [T], nrows: usize) -> Self
Creates a new matrix view from the given data array.
Panics if data
does not contain enough elements.
source§impl<'a, T: Scalar, C: DimName> Matrix<T, Dyn, C, ViewStorage<'a, T, Dyn, C, Dyn, Dyn>>
impl<'a, T: Scalar, C: DimName> Matrix<T, Dyn, C, ViewStorage<'a, T, Dyn, C, Dyn, Dyn>>
sourcepub fn from_slice_with_strides(
data: &'a [T],
nrows: usize,
rstride: usize,
cstride: usize
) -> Self
pub fn from_slice_with_strides( data: &'a [T], nrows: usize, rstride: usize, cstride: usize ) -> Self
Creates a new matrix view with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a [T],
start: usize,
nrows: usize,
rstride: usize,
cstride: usize
) -> Self
pub unsafe fn from_slice_with_strides_unchecked( data: &'a [T], start: usize, nrows: usize, rstride: usize, cstride: usize ) -> Self
Creates, without bound checking, a new matrix view with the specified strides from the given data array.
§Safety
start
, rstride
, and cstride
, with the given matrix size will not index
outside of data
.
source§impl<'a, T: Scalar> Matrix<T, Dyn, Dyn, ViewStorage<'a, T, Dyn, Dyn, Const<1>, Dyn>>
impl<'a, T: Scalar> Matrix<T, Dyn, Dyn, ViewStorage<'a, T, Dyn, Dyn, Const<1>, Dyn>>
sourcepub fn from_slice(data: &'a [T], nrows: usize, ncols: usize) -> Self
pub fn from_slice(data: &'a [T], nrows: usize, ncols: usize) -> Self
Creates a new matrix view from the given data array.
Panics if data
does not contain enough elements.
source§impl<'a, T: Scalar> Matrix<T, Dyn, Dyn, ViewStorage<'a, T, Dyn, Dyn, Dyn, Dyn>>
impl<'a, T: Scalar> Matrix<T, Dyn, Dyn, ViewStorage<'a, T, Dyn, Dyn, Dyn, Dyn>>
sourcepub fn from_slice_with_strides(
data: &'a [T],
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Self
pub fn from_slice_with_strides( data: &'a [T], nrows: usize, ncols: usize, rstride: usize, cstride: usize ) -> Self
Creates a new matrix view with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a [T],
start: usize,
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Self
pub unsafe fn from_slice_with_strides_unchecked( data: &'a [T], start: usize, nrows: usize, ncols: usize, rstride: usize, cstride: usize ) -> Self
Creates, without bound checking, a new matrix view with the specified strides from the given data array.
§Safety
start
, rstride
, and cstride
, with the given matrix size will not index
outside of data
.
source§impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>
impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>
§Creating mutable matrix views from &mut [T]
sourcepub unsafe fn from_slice_with_strides_generic_unchecked(
data: &'a mut [T],
start: usize,
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Self
pub unsafe fn from_slice_with_strides_generic_unchecked( data: &'a mut [T], start: usize, nrows: R, ncols: C, rstride: RStride, cstride: CStride ) -> Self
Creates, without bound-checking, a mutable matrix view 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 Dyn()
.
sourcepub fn from_slice_with_strides_generic(
data: &'a mut [T],
nrows: R,
ncols: C,
rstride: RStride,
cstride: CStride
) -> Self
pub fn from_slice_with_strides_generic( data: &'a mut [T], nrows: R, ncols: C, rstride: RStride, cstride: CStride ) -> Self
Creates a mutable matrix view 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 Dyn()
.
source§impl<'a, T: Scalar, R: Dim, C: Dim> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, Const<1>, R>>
impl<'a, T: Scalar, R: Dim, C: Dim> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, Const<1>, R>>
sourcepub unsafe fn from_slice_generic_unchecked(
data: &'a mut [T],
start: usize,
nrows: R,
ncols: C
) -> Self
pub unsafe fn from_slice_generic_unchecked( data: &'a mut [T], start: usize, nrows: R, ncols: C ) -> Self
Creates, without bound-checking, a mutable matrix view 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 Dyn()
.
sourcepub fn from_slice_generic(data: &'a mut [T], nrows: R, ncols: C) -> Self
pub fn from_slice_generic(data: &'a mut [T], nrows: R, ncols: C) -> Self
Creates a mutable matrix view 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 Dyn()
.
source§impl<'a, T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, Const<1>, R>>
impl<'a, T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, Const<1>, R>>
sourcepub fn from_slice(data: &'a mut [T]) -> Self
pub fn from_slice(data: &'a mut [T]) -> Self
Creates a new mutable matrix view from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_unchecked(data: &'a mut [T], start: usize) -> Self
pub unsafe fn from_slice_unchecked(data: &'a mut [T], start: usize) -> Self
Creates, without bound checking, a new mutable matrix view from the given data array.
§Safety
data[start..start+(R * C)]
must be within bounds.
source§impl<'a, T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, Dyn, Dyn>>
impl<'a, T: Scalar, R: DimName, C: DimName> Matrix<T, R, C, ViewStorageMut<'a, T, R, C, Dyn, Dyn>>
sourcepub fn from_slice_with_strides_mut(
data: &'a mut [T],
rstride: usize,
cstride: usize
) -> Self
pub fn from_slice_with_strides_mut( data: &'a mut [T], rstride: usize, cstride: usize ) -> Self
Creates a new mutable matrix view with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [T],
start: usize,
rstride: usize,
cstride: usize
) -> Self
pub unsafe fn from_slice_with_strides_unchecked( data: &'a mut [T], start: usize, rstride: usize, cstride: usize ) -> Self
Creates, without bound checking, a new mutable matrix view with the specified strides from the given data array.
§Safety
data[start..start+rstride * cstride]
must be within bounds.
source§impl<'a, T: Scalar, R: DimName> Matrix<T, R, Dyn, ViewStorageMut<'a, T, R, Dyn, Const<1>, R>>
impl<'a, T: Scalar, R: DimName> Matrix<T, R, Dyn, ViewStorageMut<'a, T, R, Dyn, Const<1>, R>>
sourcepub fn from_slice(data: &'a mut [T], ncols: usize) -> Self
pub fn from_slice(data: &'a mut [T], ncols: usize) -> Self
Creates a new mutable matrix view from the given data array.
Panics if data
does not contain enough elements.
source§impl<'a, T: Scalar, R: DimName> Matrix<T, R, Dyn, ViewStorageMut<'a, T, R, Dyn, Dyn, Dyn>>
impl<'a, T: Scalar, R: DimName> Matrix<T, R, Dyn, ViewStorageMut<'a, T, R, Dyn, Dyn, Dyn>>
sourcepub fn from_slice_with_strides_mut(
data: &'a mut [T],
ncols: usize,
rstride: usize,
cstride: usize
) -> Self
pub fn from_slice_with_strides_mut( data: &'a mut [T], ncols: usize, rstride: usize, cstride: usize ) -> Self
Creates a new mutable matrix view with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [T],
start: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Self
pub unsafe fn from_slice_with_strides_unchecked( data: &'a mut [T], start: usize, ncols: usize, rstride: usize, cstride: usize ) -> Self
Creates, without bound checking, a new mutable matrix view with the specified strides from the given data array.
§Safety
data[start..start+rstride * cstride]
must be within bounds.
source§impl<'a, T: Scalar, C: DimName> Matrix<T, Dyn, C, ViewStorageMut<'a, T, Dyn, C, Const<1>, Dyn>>
impl<'a, T: Scalar, C: DimName> Matrix<T, Dyn, C, ViewStorageMut<'a, T, Dyn, C, Const<1>, Dyn>>
sourcepub fn from_slice(data: &'a mut [T], nrows: usize) -> Self
pub fn from_slice(data: &'a mut [T], nrows: usize) -> Self
Creates a new mutable matrix view from the given data array.
Panics if data
does not contain enough elements.
source§impl<'a, T: Scalar, C: DimName> Matrix<T, Dyn, C, ViewStorageMut<'a, T, Dyn, C, Dyn, Dyn>>
impl<'a, T: Scalar, C: DimName> Matrix<T, Dyn, C, ViewStorageMut<'a, T, Dyn, C, Dyn, Dyn>>
sourcepub fn from_slice_with_strides_mut(
data: &'a mut [T],
nrows: usize,
rstride: usize,
cstride: usize
) -> Self
pub fn from_slice_with_strides_mut( data: &'a mut [T], nrows: usize, rstride: usize, cstride: usize ) -> Self
Creates a new mutable matrix view with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [T],
start: usize,
nrows: usize,
rstride: usize,
cstride: usize
) -> Self
pub unsafe fn from_slice_with_strides_unchecked( data: &'a mut [T], start: usize, nrows: usize, rstride: usize, cstride: usize ) -> Self
Creates, without bound checking, a new mutable matrix view with the specified strides from the given data array.
§Safety
data[start..start+rstride * cstride]
must be within bounds.
source§impl<'a, T: Scalar> Matrix<T, Dyn, Dyn, ViewStorageMut<'a, T, Dyn, Dyn, Const<1>, Dyn>>
impl<'a, T: Scalar> Matrix<T, Dyn, Dyn, ViewStorageMut<'a, T, Dyn, Dyn, Const<1>, Dyn>>
sourcepub fn from_slice(data: &'a mut [T], nrows: usize, ncols: usize) -> Self
pub fn from_slice(data: &'a mut [T], nrows: usize, ncols: usize) -> Self
Creates a new mutable matrix view from the given data array.
Panics if data
does not contain enough elements.
source§impl<'a, T: Scalar> Matrix<T, Dyn, Dyn, ViewStorageMut<'a, T, Dyn, Dyn, Dyn, Dyn>>
impl<'a, T: Scalar> Matrix<T, Dyn, Dyn, ViewStorageMut<'a, T, Dyn, Dyn, Dyn, Dyn>>
sourcepub fn from_slice_with_strides_mut(
data: &'a mut [T],
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Self
pub fn from_slice_with_strides_mut( data: &'a mut [T], nrows: usize, ncols: usize, rstride: usize, cstride: usize ) -> Self
Creates a new mutable matrix view with the specified strides from the given data array.
Panics if data
does not contain enough elements.
sourcepub unsafe fn from_slice_with_strides_unchecked(
data: &'a mut [T],
start: usize,
nrows: usize,
ncols: usize,
rstride: usize,
cstride: usize
) -> Self
pub unsafe fn from_slice_with_strides_unchecked( data: &'a mut [T], start: usize, nrows: usize, ncols: usize, rstride: usize, cstride: usize ) -> Self
Creates, without bound checking, a new mutable matrix view with the specified strides from the given data array.
§Safety
data[start..start+rstride * cstride]
must be within bounds.
source§impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
§Triangular matrix extraction
sourcepub fn upper_triangle(&self) -> OMatrix<T, R, C>where
DefaultAllocator: Allocator<R, C>,
pub fn upper_triangle(&self) -> OMatrix<T, R, C>where
DefaultAllocator: Allocator<R, C>,
Extracts the upper triangular part of this matrix (including the diagonal).
sourcepub fn lower_triangle(&self) -> OMatrix<T, R, C>where
DefaultAllocator: Allocator<R, C>,
pub fn lower_triangle(&self) -> OMatrix<T, R, C>where
DefaultAllocator: Allocator<R, C>,
Extracts the lower triangular part of this matrix (including the diagonal).
source§impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
§Rows and columns extraction
sourcepub fn select_rows<'a, I>(&self, irows: I) -> OMatrix<T, Dyn, C>where
I: IntoIterator<Item = &'a usize>,
I::IntoIter: ExactSizeIterator + Clone,
DefaultAllocator: Allocator<Dyn, C>,
pub fn select_rows<'a, I>(&self, irows: I) -> OMatrix<T, Dyn, C>where
I: IntoIterator<Item = &'a usize>,
I::IntoIter: ExactSizeIterator + Clone,
DefaultAllocator: Allocator<Dyn, C>,
Creates a new matrix by extracting the given set of rows from self
.
sourcepub fn select_columns<'a, I>(&self, icols: I) -> OMatrix<T, R, Dyn>where
I: IntoIterator<Item = &'a usize>,
I::IntoIter: ExactSizeIterator,
DefaultAllocator: Allocator<R, Dyn>,
pub fn select_columns<'a, I>(&self, icols: I) -> OMatrix<T, R, Dyn>where
I: IntoIterator<Item = &'a usize>,
I::IntoIter: ExactSizeIterator,
DefaultAllocator: Allocator<R, Dyn>,
Creates a new matrix by extracting the given set of columns from self
.
source§impl<T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
§Set rows, columns, and diagonal
sourcepub fn set_diagonal<R2: Dim, S2>(&mut self, diag: &Vector<T, R2, S2>)
pub fn set_diagonal<R2: Dim, S2>(&mut self, diag: &Vector<T, R2, S2>)
Fills the diagonal of this matrix with the content of the given vector.
sourcepub fn set_partial_diagonal(&mut self, diag: impl Iterator<Item = T>)
pub fn set_partial_diagonal(&mut self, diag: impl Iterator<Item = T>)
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).
sourcepub fn set_row<C2: Dim, S2>(&mut self, i: usize, row: &RowVector<T, C2, S2>)
pub fn set_row<C2: Dim, S2>(&mut self, i: usize, row: &RowVector<T, C2, S2>)
Fills the selected row of this matrix with the content of the given vector.
sourcepub fn set_column<R2: Dim, S2>(&mut self, i: usize, column: &Vector<T, R2, S2>)
pub fn set_column<R2: Dim, S2>(&mut self, i: usize, column: &Vector<T, R2, S2>)
Fills the selected column of this matrix with the content of the given vector.
source§impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
§In-place filling
sourcepub fn fill_with(&mut self, val: impl Fn() -> T)
pub fn fill_with(&mut self, val: impl Fn() -> T)
Sets all the elements of this matrix to the value returned by the closure.
sourcepub fn fill_with_identity(&mut self)
pub fn fill_with_identity(&mut self)
Fills self
with the identity matrix.
sourcepub fn fill_diagonal(&mut self, val: T)where
T: Scalar,
pub fn fill_diagonal(&mut self, val: T)where
T: Scalar,
Sets all the diagonal elements of this matrix to val
.
sourcepub fn fill_row(&mut self, i: usize, val: T)where
T: Scalar,
pub fn fill_row(&mut self, i: usize, val: T)where
T: Scalar,
Sets all the elements of the selected row to val
.
sourcepub fn fill_column(&mut self, j: usize, val: T)where
T: Scalar,
pub fn fill_column(&mut self, j: usize, val: T)where
T: Scalar,
Sets all the elements of the selected column to val
.
sourcepub fn fill_lower_triangle(&mut self, val: T, shift: usize)where
T: Scalar,
pub fn fill_lower_triangle(&mut self, val: T, shift: usize)where
T: Scalar,
Sets all the elements of the lower-triangular part of this matrix to val
.
The parameter shift
allows some subdiagonals to be left untouched:
- If
shift = 0
then the diagonal is overwritten as well. - If
shift = 1
then the diagonal is left untouched. - If
shift > 1
, then the diagonal and the firstshift - 1
subdiagonals are left untouched.
sourcepub fn fill_upper_triangle(&mut self, val: T, shift: usize)where
T: Scalar,
pub fn fill_upper_triangle(&mut self, val: T, shift: usize)where
T: Scalar,
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.
source§impl<T: Scalar, D: Dim, S: RawStorageMut<T, D, D>> Matrix<T, D, D, S>
impl<T: Scalar, D: Dim, S: RawStorageMut<T, D, D>> Matrix<T, D, D, S>
sourcepub fn fill_lower_triangle_with_upper_triangle(&mut self)
pub fn fill_lower_triangle_with_upper_triangle(&mut self)
Copies the upper-triangle of this matrix to its lower-triangular part.
This makes the matrix symmetric. Panics if the matrix is not square.
sourcepub fn fill_upper_triangle_with_lower_triangle(&mut self)
pub fn fill_upper_triangle_with_lower_triangle(&mut self)
Copies the upper-triangle of this matrix to its upper-triangular part.
This makes the matrix symmetric. Panics if the matrix is not square.
source§impl<T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
§In-place swapping
source§impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
§Rows and columns removal
sourcepub fn remove_column(self, i: usize) -> OMatrix<T, R, DimDiff<C, U1>>
pub fn remove_column(self, i: usize) -> OMatrix<T, R, DimDiff<C, U1>>
Removes the i
-th column from this matrix.
sourcepub fn remove_columns_at(self, indices: &[usize]) -> OMatrix<T, R, Dyn>
pub fn remove_columns_at(self, indices: &[usize]) -> OMatrix<T, R, Dyn>
Removes all columns in indices
sourcepub fn remove_rows_at(self, indices: &[usize]) -> OMatrix<T, Dyn, C>
pub fn remove_rows_at(self, indices: &[usize]) -> OMatrix<T, Dyn, C>
Removes all rows in indices
sourcepub fn remove_fixed_columns<const D: usize>(
self,
i: usize
) -> OMatrix<T, R, DimDiff<C, Const<D>>>
pub fn remove_fixed_columns<const D: usize>( self, i: usize ) -> OMatrix<T, R, DimDiff<C, Const<D>>>
Removes D::dim()
consecutive columns from this matrix, starting with the i
-th
(included).
sourcepub fn remove_columns(self, i: usize, n: usize) -> OMatrix<T, R, Dyn>
pub fn remove_columns(self, i: usize, n: usize) -> OMatrix<T, R, Dyn>
Removes n
consecutive columns from this matrix, starting with the i
-th (included).
sourcepub fn remove_columns_generic<D>(
self,
i: usize,
nremove: D
) -> OMatrix<T, R, DimDiff<C, D>>
pub fn remove_columns_generic<D>( self, i: usize, nremove: D ) -> OMatrix<T, R, DimDiff<C, D>>
Removes nremove.value()
columns from this matrix, starting with the i
-th (included).
This is the generic implementation of .remove_columns(...)
and
.remove_fixed_columns(...)
which have nicer API interfaces.
sourcepub fn remove_row(self, i: usize) -> OMatrix<T, DimDiff<R, U1>, C>
pub fn remove_row(self, i: usize) -> OMatrix<T, DimDiff<R, U1>, C>
Removes the i
-th row from this matrix.
sourcepub fn remove_fixed_rows<const D: usize>(
self,
i: usize
) -> OMatrix<T, DimDiff<R, Const<D>>, C>
pub fn remove_fixed_rows<const D: usize>( self, i: usize ) -> OMatrix<T, DimDiff<R, Const<D>>, C>
Removes D::dim()
consecutive rows from this matrix, starting with the i
-th (included).
sourcepub fn remove_rows(self, i: usize, n: usize) -> OMatrix<T, Dyn, C>
pub fn remove_rows(self, i: usize, n: usize) -> OMatrix<T, Dyn, C>
Removes n
consecutive rows from this matrix, starting with the i
-th (included).
sourcepub fn remove_rows_generic<D>(
self,
i: usize,
nremove: D
) -> OMatrix<T, DimDiff<R, D>, C>
pub fn remove_rows_generic<D>( self, i: usize, nremove: D ) -> OMatrix<T, DimDiff<R, D>, C>
Removes nremove.value()
rows from this matrix, starting with the i
-th (included).
This is the generic implementation of .remove_rows(...)
and .remove_fixed_rows(...)
which have nicer API interfaces.
source§impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
§Rows and columns insertion
sourcepub fn insert_column(self, i: usize, val: T) -> OMatrix<T, R, DimSum<C, U1>>
pub fn insert_column(self, i: usize, val: T) -> OMatrix<T, R, DimSum<C, U1>>
Inserts a column filled with val
at the i-th
position.
sourcepub fn insert_fixed_columns<const D: usize>(
self,
i: usize,
val: T
) -> OMatrix<T, R, DimSum<C, Const<D>>>
pub fn insert_fixed_columns<const D: usize>( self, i: usize, val: T ) -> OMatrix<T, R, DimSum<C, Const<D>>>
Inserts D
columns filled with val
starting at the i-th
position.
sourcepub fn insert_columns(self, i: usize, n: usize, val: T) -> OMatrix<T, R, Dyn>
pub fn insert_columns(self, i: usize, n: usize, val: T) -> OMatrix<T, R, Dyn>
Inserts n
columns filled with val
starting at the i-th
position.
sourcepub unsafe fn insert_columns_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> UninitMatrix<T, R, DimSum<C, D>>
pub unsafe fn insert_columns_generic_uninitialized<D>( self, i: usize, ninsert: D ) -> UninitMatrix<T, R, DimSum<C, D>>
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.
sourcepub fn insert_row(self, i: usize, val: T) -> OMatrix<T, DimSum<R, U1>, C>
pub fn insert_row(self, i: usize, val: T) -> OMatrix<T, DimSum<R, U1>, C>
Inserts a row filled with val
at the i-th
position.
sourcepub fn insert_fixed_rows<const D: usize>(
self,
i: usize,
val: T
) -> OMatrix<T, DimSum<R, Const<D>>, C>
pub fn insert_fixed_rows<const D: usize>( self, i: usize, val: T ) -> OMatrix<T, DimSum<R, Const<D>>, C>
Inserts D::dim()
rows filled with val
starting at the i-th
position.
sourcepub fn insert_rows(self, i: usize, n: usize, val: T) -> OMatrix<T, Dyn, C>
pub fn insert_rows(self, i: usize, n: usize, val: T) -> OMatrix<T, Dyn, C>
Inserts n
rows filled with val
starting at the i-th
position.
sourcepub unsafe fn insert_rows_generic_uninitialized<D>(
self,
i: usize,
ninsert: D
) -> UninitMatrix<T, DimSum<R, D>, C>
pub unsafe fn insert_rows_generic_uninitialized<D>( self, i: usize, ninsert: D ) -> UninitMatrix<T, DimSum<R, D>, 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.
source§impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
§Resizing and reshaping
sourcepub fn resize(
self,
new_nrows: usize,
new_ncols: usize,
val: T
) -> OMatrix<T, Dyn, Dyn>
pub fn resize( self, new_nrows: usize, new_ncols: usize, val: T ) -> OMatrix<T, Dyn, Dyn>
Resizes this matrix so that it contains new_nrows
rows and new_ncols
columns.
The values are copied such that self[(i, j)] == result[(i, j)]
. If the result has more
rows and/or columns than self
, then the extra rows or columns are filled with val
.
sourcepub fn resize_vertically(self, new_nrows: usize, val: T) -> OMatrix<T, Dyn, C>
pub fn resize_vertically(self, new_nrows: usize, val: T) -> OMatrix<T, Dyn, 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
.
sourcepub fn resize_horizontally(self, new_ncols: usize, val: T) -> OMatrix<T, R, Dyn>
pub fn resize_horizontally(self, new_ncols: usize, val: T) -> OMatrix<T, R, Dyn>
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
.
sourcepub fn fixed_resize<const R2: usize, const C2: usize>(
self,
val: T
) -> OMatrix<T, Const<R2>, Const<C2>>
pub fn fixed_resize<const R2: usize, const C2: usize>( self, val: T ) -> OMatrix<T, 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
.
sourcepub fn resize_generic<R2: Dim, C2: Dim>(
self,
new_nrows: R2,
new_ncols: C2,
val: T
) -> OMatrix<T, R2, C2>where
DefaultAllocator: Reallocator<T, R, C, R2, C2>,
pub fn resize_generic<R2: Dim, C2: Dim>(
self,
new_nrows: R2,
new_ncols: C2,
val: T
) -> OMatrix<T, R2, C2>where
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
.
sourcepub fn reshape_generic<R2, C2>(
self,
new_nrows: R2,
new_ncols: C2
) -> Matrix<T, R2, C2, S::Output>
pub fn reshape_generic<R2, C2>( self, new_nrows: R2, new_ncols: C2 ) -> Matrix<T, R2, C2, S::Output>
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(Dyn(6), Dyn(2));
assert_eq!(reshaped, dm2);
source§impl<T: Scalar> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
impl<T: Scalar> Matrix<T, Dyn, Dyn, <DefaultAllocator as Allocator<Dyn, Dyn>>::Buffer<T>>
§In-place resizing
sourcepub fn resize_mut(&mut self, new_nrows: usize, new_ncols: usize, val: T)
pub fn resize_mut(&mut self, new_nrows: usize, new_ncols: usize, val: T)
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
.
source§impl<T: Scalar, C: Dim> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
impl<T: Scalar, C: Dim> Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>
sourcepub fn resize_vertically_mut(&mut self, new_nrows: usize, val: T)
pub fn resize_vertically_mut(&mut self, new_nrows: usize, val: T)
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
).
source§impl<T: Scalar, R: Dim> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
impl<T: Scalar, R: Dim> Matrix<T, R, Dyn, <DefaultAllocator as Allocator<R, Dyn>>::Buffer<T>>
sourcepub fn resize_horizontally_mut(&mut self, new_ncols: usize, val: T)
pub fn resize_horizontally_mut(&mut self, new_ncols: usize, val: T)
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
).
source§impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
§Views 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)));
sourcepub fn get<'a, I>(&'a self, index: I) -> Option<I::Output>where
I: MatrixIndex<'a, T, R, C, S>,
pub fn get<'a, I>(&'a self, index: I) -> Option<I::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.
sourcepub fn get_mut<'a, I>(&'a mut self, index: I) -> Option<I::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::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.
sourcepub fn index<'a, I>(&'a self, index: I) -> I::Outputwhere
I: MatrixIndex<'a, T, R, C, S>,
pub fn index<'a, I>(&'a self, index: I) -> I::Outputwhere
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.
sourcepub fn index_mut<'a, I>(&'a mut self, index: I) -> I::OutputMutwhere
S: RawStorageMut<T, R, C>,
I: MatrixIndexMut<'a, T, R, C, S>,
pub fn index_mut<'a, I>(&'a mut self, index: I) -> I::OutputMutwhere
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.
sourcepub unsafe fn get_unchecked<'a, I>(&'a self, index: I) -> I::Outputwhere
I: MatrixIndex<'a, T, R, C, S>,
pub unsafe fn get_unchecked<'a, I>(&'a self, index: I) -> I::Outputwhere
I: MatrixIndex<'a, T, R, C, S>,
Produces a view of the data at the given index, without doing any bounds checking.
§Safety
index
must within bounds of the array.
sourcepub unsafe fn get_unchecked_mut<'a, I>(&'a mut self, index: I) -> I::OutputMutwhere
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::OutputMutwhere
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.
§Safety
index
must within bounds of the array.
source§impl<T, R, C, S> Matrix<T, R, C, S>
impl<T, R, C, S> Matrix<T, R, C, S>
sourcepub const unsafe fn from_data_statically_unchecked(
data: S
) -> Matrix<T, R, C, S>
pub const unsafe fn from_data_statically_unchecked( data: S ) -> Matrix<T, R, C, S>
Creates a new matrix with the given data without statically checking that the matrix dimension matches the storage dimension.
§Safety
The storage dimension must match the given dimensions.
source§impl<T, const R: usize, const C: usize> Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
impl<T, const R: usize, const C: usize> Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
sourcepub const fn from_array_storage(storage: ArrayStorage<T, R, C>) -> Self
pub const fn from_array_storage(storage: ArrayStorage<T, R, C>) -> Self
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.
source§impl<T> Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>
impl<T> Matrix<T, Dyn, Dyn, VecStorage<T, Dyn, Dyn>>
sourcepub const fn from_vec_storage(storage: VecStorage<T, Dyn, Dyn>) -> Self
pub const fn from_vec_storage(storage: VecStorage<T, Dyn, Dyn>) -> Self
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.
source§impl<T> Matrix<T, Dyn, Const<1>, VecStorage<T, Dyn, Const<1>>>
impl<T> Matrix<T, Dyn, Const<1>, VecStorage<T, Dyn, Const<1>>>
sourcepub const fn from_vec_storage(storage: VecStorage<T, Dyn, U1>) -> Self
pub const fn from_vec_storage(storage: VecStorage<T, Dyn, U1>) -> Self
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.
source§impl<T> Matrix<T, Const<1>, Dyn, VecStorage<T, Const<1>, Dyn>>
impl<T> Matrix<T, Const<1>, Dyn, VecStorage<T, Const<1>, Dyn>>
sourcepub const fn from_vec_storage(storage: VecStorage<T, U1, Dyn>) -> Self
pub const fn from_vec_storage(storage: VecStorage<T, U1, Dyn>) -> Self
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.
source§impl<T: Scalar, R: Dim, C: Dim> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<R, C>>::BufferUninit<T>>where
DefaultAllocator: Allocator<R, C>,
impl<T: Scalar, R: Dim, C: Dim> Matrix<MaybeUninit<T>, R, C, <DefaultAllocator as Allocator<R, C>>::BufferUninit<T>>where
DefaultAllocator: Allocator<R, C>,
sourcepub unsafe fn assume_init(self) -> OMatrix<T, R, C>
pub unsafe fn assume_init(self) -> OMatrix<T, R, C>
Assumes a matrix’s entries to be initialized. This operation should be near zero-cost.
§Safety
The user must make sure that every single entry of the buffer has been initialized, or Undefined Behavior will immediately occur.
source§impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
sourcepub fn shape(&self) -> (usize, usize)
pub fn shape(&self) -> (usize, usize)
The shape of this matrix returned as the tuple (number of rows, number of columns).
§Example
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.shape(), (3, 4));
sourcepub fn shape_generic(&self) -> (R, C)
pub fn shape_generic(&self) -> (R, C)
The shape of this matrix wrapped into their representative types (Const
or Dyn
).
sourcepub fn nrows(&self) -> usize
pub fn nrows(&self) -> usize
The number of rows of this matrix.
§Example
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.nrows(), 3);
sourcepub fn ncols(&self) -> usize
pub fn ncols(&self) -> usize
The number of columns of this matrix.
§Example
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.ncols(), 4);
sourcepub fn strides(&self) -> (usize, usize)
pub fn strides(&self) -> (usize, usize)
The strides (row stride, column stride) of this matrix.
§Example
let mat = DMatrix::<f32>::zeros(10, 10);
let view = mat.view_with_steps((0, 0), (5, 3), (1, 2));
// The column strides is the number of steps (here 2) multiplied by the corresponding dimension.
assert_eq!(mat.strides(), (1, 10));
sourcepub fn vector_to_matrix_index(&self, i: usize) -> (usize, usize)
pub fn vector_to_matrix_index(&self, i: usize) -> (usize, usize)
Computes the row and column coordinates of the i-th element of this matrix seen as a vector.
§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]);
sourcepub fn as_ptr(&self) -> *const T
pub fn as_ptr(&self) -> *const T
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]);
sourcepub fn relative_eq<R2, C2, SB>(
&self,
other: &Matrix<T, R2, C2, SB>,
eps: T::Epsilon,
max_relative: T::Epsilon
) -> boolwhere
T: RelativeEq + Scalar,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
T::Epsilon: Clone,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn relative_eq<R2, C2, SB>(
&self,
other: &Matrix<T, R2, C2, SB>,
eps: T::Epsilon,
max_relative: T::Epsilon
) -> boolwhere
T: RelativeEq + Scalar,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
T::Epsilon: Clone,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are equal up to a given epsilon.
See relative_eq
from the RelativeEq
trait for more details.
sourcepub fn eq<R2, C2, SB>(&self, other: &Matrix<T, R2, C2, SB>) -> boolwhere
T: PartialEq,
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn eq<R2, C2, SB>(&self, other: &Matrix<T, R2, C2, SB>) -> boolwhere
T: PartialEq,
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Tests whether self
and rhs
are exactly equal.
sourcepub fn into_owned(self) -> OMatrix<T, R, C>
pub fn into_owned(self) -> OMatrix<T, R, C>
Moves this matrix into one that owns its data.
sourcepub fn into_owned_sum<R2, C2>(self) -> MatrixSum<T, R, C, R2, C2>where
T: Scalar,
S: Storage<T, R, C>,
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn into_owned_sum<R2, C2>(self) -> MatrixSum<T, R, C, R2, C2>where
T: Scalar,
S: Storage<T, R, C>,
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Moves this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.
sourcepub fn clone_owned(&self) -> OMatrix<T, R, C>
pub fn clone_owned(&self) -> OMatrix<T, R, C>
Clones this matrix to one that owns its data.
sourcepub fn clone_owned_sum<R2, C2>(&self) -> MatrixSum<T, R, C, R2, C2>where
T: Scalar,
S: Storage<T, R, C>,
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn clone_owned_sum<R2, C2>(&self) -> MatrixSum<T, R, C, R2, C2>where
T: Scalar,
S: Storage<T, R, C>,
R2: Dim,
C2: Dim,
DefaultAllocator: SameShapeAllocator<R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Clones this matrix into one that owns its data. The actual type of the result depends on matrix storage combination rules for addition.
sourcepub fn 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> + 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> + SameNumberOfColumns<C, R2>,
Transposes self
and store the result into out
.
source§impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
§Elementwise mapping and folding
sourcepub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, f: F) -> OMatrix<T2, R, C>
pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, f: F) -> OMatrix<T2, R, C>
Returns a matrix containing the result of f
applied to each of its entries.
sourcepub fn cast<T2: Scalar>(self) -> OMatrix<T2, R, C>
pub fn cast<T2: Scalar>(self) -> OMatrix<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));
sourcepub fn try_cast<T2: Scalar>(self) -> Option<OMatrix<T2, R, C>>
pub fn try_cast<T2: Scalar>(self) -> Option<OMatrix<T2, R, C>>
Attempts to cast the components of self
to another type.
§Example
let q = Vector3::new(1.0f64, 2.0, 3.0);
let q2 = q.try_cast::<i32>();
assert_eq!(q2, Some(Vector3::new(1, 2, 3)));
sourcepub fn fold_with<T2>(
&self,
init_f: impl FnOnce(Option<&T>) -> T2,
f: impl FnMut(T2, &T) -> T2
) -> T2where
T: Scalar,
pub fn fold_with<T2>(
&self,
init_f: impl FnOnce(Option<&T>) -> T2,
f: impl FnMut(T2, &T) -> T2
) -> T2where
T: Scalar,
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.
sourcepub fn map_with_location<T2: Scalar, F: FnMut(usize, usize, T) -> T2>(
&self,
f: F
) -> OMatrix<T2, R, C>
pub fn map_with_location<T2: Scalar, F: FnMut(usize, usize, T) -> T2>( &self, f: F ) -> OMatrix<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)
.
sourcepub fn zip_map<T2, N3, S2, F>(
&self,
rhs: &Matrix<T2, R, C, S2>,
f: F
) -> OMatrix<N3, R, C>where
T: Scalar,
T2: Scalar,
N3: Scalar,
S2: RawStorage<T2, R, C>,
F: FnMut(T, T2) -> N3,
DefaultAllocator: Allocator<R, C>,
pub fn zip_map<T2, N3, S2, F>(
&self,
rhs: &Matrix<T2, R, C, S2>,
f: F
) -> OMatrix<N3, R, C>where
T: Scalar,
T2: Scalar,
N3: Scalar,
S2: RawStorage<T2, R, C>,
F: FnMut(T, T2) -> N3,
DefaultAllocator: Allocator<R, C>,
Returns a matrix containing the result of f
applied to each entries of self
and
rhs
.
sourcepub 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
) -> OMatrix<N4, R, C>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<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
) -> OMatrix<N4, R, C>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<R, C>,
Returns a matrix containing the result of f
applied to each entries of self
and
b
, and c
.
sourcepub fn fold<Acc>(&self, init: Acc, f: impl FnMut(Acc, T) -> Acc) -> Accwhere
T: Scalar,
pub fn fold<Acc>(&self, init: Acc, f: impl FnMut(Acc, T) -> Acc) -> Accwhere
T: Scalar,
Folds a function f
on each entry of self
.
sourcepub fn zip_fold<T2, R2, C2, S2, Acc>(
&self,
rhs: &Matrix<T2, R2, C2, S2>,
init: Acc,
f: impl FnMut(Acc, T, T2) -> Acc
) -> Accwhere
T: Scalar,
T2: Scalar,
R2: Dim,
C2: Dim,
S2: RawStorage<T2, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + 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
) -> Accwhere
T: Scalar,
T2: Scalar,
R2: Dim,
C2: Dim,
S2: RawStorage<T2, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
Folds a function f
on each pairs of entries from self
and rhs
.
sourcepub fn apply<F: FnMut(&mut T)>(&mut self, f: F)where
S: RawStorageMut<T, R, C>,
pub fn apply<F: FnMut(&mut T)>(&mut self, f: F)where
S: RawStorageMut<T, R, C>,
Applies a closure f
to modify each component of self
.
sourcepub 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> + 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> + 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
.
sourcepub 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> + 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> + 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
.
source§impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
§Iteration on components, rows, and columns
sourcepub fn iter(&self) -> MatrixIter<'_, T, R, C, S> ⓘ
pub fn iter(&self) -> MatrixIter<'_, T, R, C, S> ⓘ
Iterates through this matrix coordinates in column-major order.
§Example
let mat = Matrix2x3::new(11, 12, 13,
21, 22, 23);
let mut it = mat.iter();
assert_eq!(*it.next().unwrap(), 11);
assert_eq!(*it.next().unwrap(), 21);
assert_eq!(*it.next().unwrap(), 12);
assert_eq!(*it.next().unwrap(), 22);
assert_eq!(*it.next().unwrap(), 13);
assert_eq!(*it.next().unwrap(), 23);
assert!(it.next().is_none());
sourcepub fn row_iter(&self) -> RowIter<'_, T, R, C, S> ⓘ
pub fn row_iter(&self) -> RowIter<'_, T, R, C, S> ⓘ
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))
}
sourcepub fn column_iter(&self) -> ColumnIter<'_, T, R, C, S> ⓘ
pub fn column_iter(&self) -> ColumnIter<'_, T, R, C, S> ⓘ
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))
}
sourcepub fn iter_mut(&mut self) -> MatrixIterMut<'_, T, R, C, S> ⓘwhere
S: RawStorageMut<T, R, C>,
pub fn iter_mut(&mut self) -> MatrixIterMut<'_, T, R, C, S> ⓘwhere
S: RawStorageMut<T, R, C>,
Mutably iterates through this matrix coordinates.
sourcepub fn row_iter_mut(&mut self) -> RowIterMut<'_, T, R, C, S> ⓘwhere
S: RawStorageMut<T, R, C>,
pub fn row_iter_mut(&mut self) -> RowIterMut<'_, T, R, C, S> ⓘwhere
S: RawStorageMut<T, R, C>,
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);
sourcepub fn column_iter_mut(&mut self) -> ColumnIterMut<'_, T, R, C, S> ⓘwhere
S: RawStorageMut<T, R, C>,
pub fn column_iter_mut(&mut self) -> ColumnIterMut<'_, T, R, C, S> ⓘwhere
S: RawStorageMut<T, R, C>,
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);
source§impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
sourcepub fn as_mut_ptr(&mut self) -> *mut T
pub fn as_mut_ptr(&mut self) -> *mut T
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.
sourcepub unsafe fn swap_unchecked(
&mut self,
row_cols1: (usize, usize),
row_cols2: (usize, usize)
)
pub unsafe fn swap_unchecked( &mut self, row_cols1: (usize, usize), row_cols2: (usize, usize) )
sourcepub fn swap(&mut self, row_cols1: (usize, usize), row_cols2: (usize, usize))
pub fn swap(&mut self, row_cols1: (usize, usize), row_cols2: (usize, usize))
Swaps two entries.
sourcepub fn copy_from_slice(&mut self, slice: &[T])where
T: Scalar,
pub fn copy_from_slice(&mut self, slice: &[T])where
T: Scalar,
Fills this matrix with the content of a slice. Both must hold the same number of elements.
The components of the slice are assumed to be ordered in column-major order.
sourcepub fn copy_from<R2, C2, SB>(&mut self, other: &Matrix<T, R2, C2, SB>)where
T: Scalar,
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + 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> + SameNumberOfColumns<C, C2>,
Fills this matrix with the content of another one. Both must have the same shape.
sourcepub fn tr_copy_from<R2, C2, SB>(&mut self, other: &Matrix<T, R2, C2, SB>)where
T: Scalar,
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: DimEq<R, C2> + 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> + SameNumberOfColumns<C, R2>,
Fills this matrix with the content of the transpose another one.
sourcepub fn apply_into<F: FnMut(&mut T)>(self, f: F) -> Self
pub fn apply_into<F: FnMut(&mut T)>(self, f: F) -> Self
Returns self
with each of its components replaced by the result of a closure f
applied on it.
source§impl<T, D: Dim, S: RawStorage<T, D>> Matrix<T, D, Const<1>, S>
impl<T, D: Dim, S: RawStorage<T, D>> Matrix<T, D, Const<1>, S>
sourcepub unsafe fn vget_unchecked(&self, i: usize) -> &T
pub unsafe fn vget_unchecked(&self, i: usize) -> &T
Gets a reference to the i-th element of this column vector without bound checking.
§Safety
i
must be less than D
.
source§impl<T, D: Dim, S: RawStorageMut<T, D>> Matrix<T, D, Const<1>, S>
impl<T, D: Dim, S: RawStorageMut<T, D>> Matrix<T, D, Const<1>, S>
sourcepub unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut T
pub unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut T
Gets a mutable reference to the i-th element of this column vector without bound checking.
§Safety
i
must be less than D
.
source§impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C> + IsContiguous> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C> + IsContiguous> Matrix<T, R, C, S>
source§impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C> + IsContiguous> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C> + IsContiguous> Matrix<T, R, C, S>
sourcepub fn as_mut_slice(&mut self) -> &mut [T]
pub fn as_mut_slice(&mut self) -> &mut [T]
Extracts a mutable slice containing the entire matrix entries ordered column-by-columns.
source§impl<T: Scalar, D: Dim, S: RawStorageMut<T, D, D>> Matrix<T, D, D, S>
impl<T: Scalar, D: Dim, S: RawStorageMut<T, D, D>> Matrix<T, D, D, S>
sourcepub fn transpose_mut(&mut self)
pub fn transpose_mut(&mut self)
Transposes the square matrix self
in-place.
source§impl<T: SimdComplexField, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T: SimdComplexField, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
sourcepub 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> + 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> + SameNumberOfColumns<C, R2>,
Takes the adjoint (aka. conjugate-transpose) of self
and store the result into out
.
sourcepub fn adjoint(&self) -> OMatrix<T, C, R>where
DefaultAllocator: Allocator<C, R>,
pub fn adjoint(&self) -> OMatrix<T, C, R>where
DefaultAllocator: Allocator<C, R>,
The adjoint (aka. conjugate-transpose) of self
.
sourcepub 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> + 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> + SameNumberOfColumns<C, R2>,
self.adjoint_to(out)
.Takes the conjugate and transposes self
and store the result into out
.
sourcepub fn conjugate_transpose(&self) -> OMatrix<T, C, R>where
DefaultAllocator: Allocator<C, R>,
👎Deprecated: Renamed self.adjoint()
.
pub fn conjugate_transpose(&self) -> OMatrix<T, C, R>where
DefaultAllocator: Allocator<C, R>,
self.adjoint()
.The conjugate transposition of self
.
sourcepub fn conjugate(&self) -> OMatrix<T, R, C>where
DefaultAllocator: Allocator<R, C>,
pub fn conjugate(&self) -> OMatrix<T, R, C>where
DefaultAllocator: Allocator<R, C>,
The conjugate of self
.
sourcepub fn unscale(&self, real: T::SimdRealField) -> OMatrix<T, R, C>where
DefaultAllocator: Allocator<R, C>,
pub fn unscale(&self, real: T::SimdRealField) -> OMatrix<T, R, C>where
DefaultAllocator: Allocator<R, C>,
Divides each component of the complex matrix self
by the given real.
sourcepub fn scale(&self, real: T::SimdRealField) -> OMatrix<T, R, C>where
DefaultAllocator: Allocator<R, C>,
pub fn scale(&self, real: T::SimdRealField) -> OMatrix<T, R, C>where
DefaultAllocator: Allocator<R, C>,
Multiplies each component of the complex matrix self
by the given real.
source§impl<T: SimdComplexField, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
impl<T: SimdComplexField, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
sourcepub fn conjugate_mut(&mut self)
pub fn conjugate_mut(&mut self)
The conjugate of the complex matrix self
computed in-place.
sourcepub fn unscale_mut(&mut self, real: T::SimdRealField)
pub fn unscale_mut(&mut self, real: T::SimdRealField)
Divides each component of the complex matrix self
by the given real.
sourcepub fn scale_mut(&mut self, real: T::SimdRealField)
pub fn scale_mut(&mut self, real: T::SimdRealField)
Multiplies each component of the complex matrix self
by the given real.
source§impl<T: SimdComplexField, D: Dim, S: RawStorageMut<T, D, D>> Matrix<T, D, D, S>
impl<T: SimdComplexField, D: Dim, S: RawStorageMut<T, D, D>> Matrix<T, D, D, S>
sourcepub fn conjugate_transform_mut(&mut self)
👎Deprecated: Renamed to self.adjoint_mut()
.
pub fn conjugate_transform_mut(&mut self)
self.adjoint_mut()
.Sets self
to its adjoint.
sourcepub fn adjoint_mut(&mut self)
pub fn adjoint_mut(&mut self)
Sets self
to its adjoint (aka. conjugate-transpose).
source§impl<T: Scalar, D: Dim, S: RawStorage<T, D, D>> Matrix<T, D, D, S>
impl<T: Scalar, D: Dim, S: RawStorage<T, D, D>> Matrix<T, D, D, S>
sourcepub fn diagonal(&self) -> OVector<T, D>where
DefaultAllocator: Allocator<D>,
pub fn diagonal(&self) -> OVector<T, D>where
DefaultAllocator: Allocator<D>,
The diagonal of this matrix.
sourcepub fn map_diagonal<T2: Scalar>(&self, f: impl FnMut(T) -> T2) -> OVector<T2, D>where
DefaultAllocator: Allocator<D>,
pub fn map_diagonal<T2: Scalar>(&self, f: impl FnMut(T) -> T2) -> OVector<T2, D>where
DefaultAllocator: Allocator<D>,
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.
source§impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>
impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>
sourcepub fn symmetric_part(&self) -> OMatrix<T, D, D>where
DefaultAllocator: Allocator<D, D>,
pub fn symmetric_part(&self) -> OMatrix<T, D, D>where
DefaultAllocator: Allocator<D, D>,
The symmetric part of self
, i.e., 0.5 * (self + self.transpose())
.
sourcepub fn hermitian_part(&self) -> OMatrix<T, D, D>where
DefaultAllocator: Allocator<D, D>,
pub fn hermitian_part(&self) -> OMatrix<T, D, D>where
DefaultAllocator: Allocator<D, D>,
The hermitian part of self
, i.e., 0.5 * (self + self.adjoint())
.
source§impl<T: Scalar + Zero + One, D: DimAdd<U1> + IsNotStaticOne, S: RawStorage<T, D, D>> Matrix<T, D, D, S>
impl<T: Scalar + Zero + One, D: DimAdd<U1> + IsNotStaticOne, S: RawStorage<T, D, D>> Matrix<T, D, D, S>
source§impl<T: Scalar + Zero, D: DimAdd<U1>, S: RawStorage<T, D>> Matrix<T, D, Const<1>, S>
impl<T: Scalar + Zero, D: DimAdd<U1>, S: RawStorage<T, D>> Matrix<T, D, Const<1>, S>
sourcepub fn to_homogeneous(&self) -> OVector<T, DimSum<D, U1>>
pub fn to_homogeneous(&self) -> OVector<T, DimSum<D, U1>>
Computes the coordinates in projective space of this vector, i.e., appends a 0
to its
coordinates.
source§impl<T: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
§Cross product
sourcepub fn perp<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> Twhere
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, U2> + SameNumberOfColumns<C, U1> + SameNumberOfRows<R2, U2> + SameNumberOfColumns<C2, U1>,
pub fn perp<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> Twhere
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, U2> + SameNumberOfColumns<C, U1> + SameNumberOfRows<R2, U2> + SameNumberOfColumns<C2, U1>,
The perpendicular product between two 2D column vectors, i.e. a.x * b.y - a.y * b.x
.
sourcepub fn cross<R2, C2, SB>(
&self,
b: &Matrix<T, R2, C2, SB>
) -> MatrixCross<T, R, C, R2, C2>where
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn cross<R2, C2, SB>(
&self,
b: &Matrix<T, R2, C2, SB>
) -> MatrixCross<T, R, C, R2, C2>where
R2: Dim,
C2: Dim,
SB: RawStorage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R, C, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
The 3D cross product between two vectors.
Panics if the shape is not 3D vector. In the future, this will be implemented only for dynamically-sized matrices and statically-sized 3D matrices.
source§impl<T: Scalar + Field, S: RawStorage<T, U3>> Matrix<T, Const<3>, Const<1>, S>
impl<T: Scalar + Field, S: RawStorage<T, U3>> Matrix<T, Const<3>, Const<1>, S>
sourcepub fn cross_matrix(&self) -> OMatrix<T, U3, U3>
pub fn cross_matrix(&self) -> OMatrix<T, U3, U3>
Computes the matrix M
such that for all vector v
we have M * v == self.cross(&v)
.
source§impl<T: SimdComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
impl<T: SimdComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
source§impl<T, S> Matrix<T, U1, U1, S>
impl<T, S> Matrix<T, U1, U1, S>
sourcepub fn as_scalar(&self) -> &T
pub fn as_scalar(&self) -> &T
Returns a reference to the single element in this matrix.
As opposed to indexing, using this provides type-safety when flattening dimensions.
§Example
let v = Vector3::new(0., 0., 1.);
let inner_product: f32 = *(v.transpose() * v).as_scalar();
let v = Vector3::new(0., 0., 1.);
let inner_product = (v * v.transpose()).item(); // Typo, does not compile.
sourcepub fn as_scalar_mut(&mut self) -> &mut Twhere
S: RawStorageMut<T, U1>,
pub fn as_scalar_mut(&mut self) -> &mut Twhere
S: RawStorageMut<T, U1>,
Get a mutable reference to the single element in this matrix
As opposed to indexing, using this provides type-safety when flattening dimensions.
§Example
let v = Vector3::new(0., 0., 1.);
let mut inner_product = (v.transpose() * v);
*inner_product.as_scalar_mut() = 3.;
let v = Vector3::new(0., 0., 1.);
let mut inner_product = (v * v.transpose());
*inner_product.as_scalar_mut() = 3.;
sourcepub fn to_scalar(&self) -> Twhere
T: Clone,
pub fn to_scalar(&self) -> Twhere
T: Clone,
Convert this 1x1 matrix by reference into a scalar.
As opposed to indexing, using this provides type-safety when flattening dimensions.
§Example
let v = Vector3::new(0., 0., 1.);
let mut inner_product: f32 = (v.transpose() * v).to_scalar();
let v = Vector3::new(0., 0., 1.);
let mut inner_product: f32 = (v * v.transpose()).to_scalar();
source§impl<T> Matrix<T, Const<1>, Const<1>, ArrayStorage<T, 1, 1>>
impl<T> Matrix<T, Const<1>, Const<1>, ArrayStorage<T, 1, 1>>
sourcepub fn into_scalar(self) -> T
pub fn into_scalar(self) -> T
Convert this 1x1 matrix into a scalar.
As opposed to indexing, using this provides type-safety when flattening dimensions.
§Example
let v = Vector3::new(0., 0., 1.);
let inner_product: f32 = (v.transpose() * v).into_scalar();
assert_eq!(inner_product, 1.);
let v = Vector3::new(0., 0., 1.);
let mut inner_product: f32 = (v * v.transpose()).into_scalar();
source§impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
§Views based on index and length
sourcepub fn row(&self, i: usize) -> MatrixView<'_, T, U1, C, S::RStride, S::CStride>
pub fn row(&self, i: usize) -> MatrixView<'_, T, U1, C, S::RStride, S::CStride>
Returns a view containing the i-th row of this matrix.
sourcepub fn row_part(
&self,
i: usize,
n: usize
) -> MatrixView<'_, T, U1, Dyn, S::RStride, S::CStride>
pub fn row_part( &self, i: usize, n: usize ) -> MatrixView<'_, T, U1, Dyn, S::RStride, S::CStride>
Returns a view containing the n
first elements of the i-th row of this matrix.
sourcepub fn rows(
&self,
first_row: usize,
nrows: usize
) -> MatrixView<'_, T, Dyn, C, S::RStride, S::CStride>
pub fn rows( &self, first_row: usize, nrows: usize ) -> MatrixView<'_, T, Dyn, C, S::RStride, S::CStride>
Extracts from this matrix a set of consecutive rows.
sourcepub fn rows_with_step(
&self,
first_row: usize,
nrows: usize,
step: usize
) -> MatrixView<'_, T, Dyn, C, Dyn, S::CStride>
pub fn rows_with_step( &self, first_row: usize, nrows: usize, step: usize ) -> MatrixView<'_, T, Dyn, C, Dyn, S::CStride>
Extracts from this matrix a set of consecutive rows regularly skipping step
rows.
sourcepub fn fixed_rows<const RVIEW: usize>(
&self,
first_row: usize
) -> MatrixView<'_, T, Const<RVIEW>, C, S::RStride, S::CStride>
pub fn fixed_rows<const RVIEW: usize>( &self, first_row: usize ) -> MatrixView<'_, T, Const<RVIEW>, C, S::RStride, S::CStride>
Extracts a compile-time number of consecutive rows from this matrix.
sourcepub fn fixed_rows_with_step<const RVIEW: usize>(
&self,
first_row: usize,
step: usize
) -> MatrixView<'_, T, Const<RVIEW>, C, Dyn, S::CStride>
pub fn fixed_rows_with_step<const RVIEW: usize>( &self, first_row: usize, step: usize ) -> MatrixView<'_, T, Const<RVIEW>, C, Dyn, S::CStride>
Extracts from this matrix a compile-time number of rows regularly skipping step
rows.
sourcepub fn rows_generic<RView: Dim>(
&self,
row_start: usize,
nrows: RView
) -> MatrixView<'_, T, RView, C, S::RStride, S::CStride>
pub fn rows_generic<RView: Dim>( &self, row_start: usize, nrows: RView ) -> MatrixView<'_, T, RView, C, S::RStride, S::CStride>
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
sourcepub fn rows_generic_with_step<RView>(
&self,
row_start: usize,
nrows: RView,
step: usize
) -> MatrixView<'_, T, RView, C, Dyn, S::CStride>where
RView: Dim,
pub fn rows_generic_with_step<RView>(
&self,
row_start: usize,
nrows: RView,
step: usize
) -> MatrixView<'_, T, RView, C, Dyn, S::CStride>where
RView: Dim,
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
sourcepub fn column(
&self,
i: usize
) -> MatrixView<'_, T, R, U1, S::RStride, S::CStride>
pub fn column( &self, i: usize ) -> MatrixView<'_, T, R, U1, S::RStride, S::CStride>
Returns a view containing the i-th column of this matrix.
sourcepub fn column_part(
&self,
i: usize,
n: usize
) -> MatrixView<'_, T, Dyn, U1, S::RStride, S::CStride>
pub fn column_part( &self, i: usize, n: usize ) -> MatrixView<'_, T, Dyn, U1, S::RStride, S::CStride>
Returns a view containing the n
first elements of the i-th column of this matrix.
sourcepub fn columns(
&self,
first_col: usize,
ncols: usize
) -> MatrixView<'_, T, R, Dyn, S::RStride, S::CStride>
pub fn columns( &self, first_col: usize, ncols: usize ) -> MatrixView<'_, T, R, Dyn, S::RStride, S::CStride>
Extracts from this matrix a set of consecutive columns.
sourcepub fn columns_with_step(
&self,
first_col: usize,
ncols: usize,
step: usize
) -> MatrixView<'_, T, R, Dyn, S::RStride, Dyn>
pub fn columns_with_step( &self, first_col: usize, ncols: usize, step: usize ) -> MatrixView<'_, T, R, Dyn, S::RStride, Dyn>
Extracts from this matrix a set of consecutive columns regularly skipping step
columns.
sourcepub fn fixed_columns<const CVIEW: usize>(
&self,
first_col: usize
) -> MatrixView<'_, T, R, Const<CVIEW>, S::RStride, S::CStride>
pub fn fixed_columns<const CVIEW: usize>( &self, first_col: usize ) -> MatrixView<'_, T, R, Const<CVIEW>, S::RStride, S::CStride>
Extracts a compile-time number of consecutive columns from this matrix.
sourcepub fn fixed_columns_with_step<const CVIEW: usize>(
&self,
first_col: usize,
step: usize
) -> MatrixView<'_, T, R, Const<CVIEW>, S::RStride, Dyn>
pub fn fixed_columns_with_step<const CVIEW: usize>( &self, first_col: usize, step: usize ) -> MatrixView<'_, T, R, Const<CVIEW>, S::RStride, Dyn>
Extracts from this matrix a compile-time number of columns regularly skipping
step
columns.
sourcepub fn columns_generic<CView: Dim>(
&self,
first_col: usize,
ncols: CView
) -> MatrixView<'_, T, R, CView, S::RStride, S::CStride>
pub fn columns_generic<CView: Dim>( &self, first_col: usize, ncols: CView ) -> MatrixView<'_, T, R, CView, S::RStride, S::CStride>
Extracts from this matrix ncols
columns. The number of columns may or may not be
known at compile-time.
sourcepub fn columns_generic_with_step<CView: Dim>(
&self,
first_col: usize,
ncols: CView,
step: usize
) -> MatrixView<'_, T, R, CView, S::RStride, Dyn>
pub fn columns_generic_with_step<CView: Dim>( &self, first_col: usize, ncols: CView, step: usize ) -> MatrixView<'_, T, R, CView, S::RStride, Dyn>
Extracts from this matrix ncols
columns skipping step
columns. Both argument may
or may not be values known at compile-time.
sourcepub fn slice(
&self,
start: (usize, usize),
shape: (usize, usize)
) -> MatrixView<'_, T, Dyn, Dyn, S::RStride, S::CStride>
👎Deprecated: Use view instead. See issue #1076 for more information.
pub fn slice( &self, start: (usize, usize), shape: (usize, usize) ) -> MatrixView<'_, T, Dyn, Dyn, S::RStride, S::CStride>
Slices this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
sourcepub fn view(
&self,
start: (usize, usize),
shape: (usize, usize)
) -> MatrixView<'_, T, Dyn, Dyn, S::RStride, S::CStride>
pub fn view( &self, start: (usize, usize), shape: (usize, usize) ) -> MatrixView<'_, T, Dyn, Dyn, S::RStride, S::CStride>
Return a view of this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
sourcepub fn slice_with_steps(
&self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> MatrixView<'_, T, Dyn, Dyn, Dyn, Dyn>
👎Deprecated: Use view_with_steps instead. See issue #1076 for more information.
pub fn slice_with_steps( &self, start: (usize, usize), shape: (usize, usize), steps: (usize, usize) ) -> MatrixView<'_, T, Dyn, Dyn, Dyn, Dyn>
Slices this matrix starting at its component (start.0, start.1)
and with
(shape.0, shape.1)
components. Each row (resp. column) of the sliced matrix is
separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of the
original matrix.
sourcepub fn view_with_steps(
&self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> MatrixView<'_, T, Dyn, Dyn, Dyn, Dyn>
pub fn view_with_steps( &self, start: (usize, usize), shape: (usize, usize), steps: (usize, usize) ) -> MatrixView<'_, T, Dyn, Dyn, Dyn, Dyn>
Return a view of this matrix starting at its component (start.0, start.1)
and with
(shape.0, shape.1)
components. Each row (resp. column) of the matrix view is
separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of the
original matrix.
sourcepub fn fixed_slice<const RVIEW: usize, const CVIEW: usize>(
&self,
irow: usize,
icol: usize
) -> MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride>
👎Deprecated: Use fixed_view instead. See issue #1076 for more information.
pub fn fixed_slice<const RVIEW: usize, const CVIEW: usize>( &self, irow: usize, icol: usize ) -> MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride>
Slices this matrix starting at its component (irow, icol)
and with (RVIEW, CVIEW)
consecutive components.
sourcepub fn fixed_view<const RVIEW: usize, const CVIEW: usize>(
&self,
irow: usize,
icol: usize
) -> MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride>
pub fn fixed_view<const RVIEW: usize, const CVIEW: usize>( &self, irow: usize, icol: usize ) -> MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride>
Return a view of this matrix starting at its component (irow, icol)
and with
(RVIEW, CVIEW)
consecutive components.
sourcepub fn fixed_slice_with_steps<const RVIEW: usize, const CVIEW: usize>(
&self,
start: (usize, usize),
steps: (usize, usize)
) -> MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>
👎Deprecated: Use fixed_view_with_steps instead. See issue #1076 for more information.
pub fn fixed_slice_with_steps<const RVIEW: usize, const CVIEW: usize>( &self, start: (usize, usize), steps: (usize, usize) ) -> MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>
Slices this matrix starting at its component (start.0, start.1)
and with
(RVIEW, CVIEW)
components. Each row (resp. column) of the sliced
matrix is separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of
the original matrix.
sourcepub fn fixed_view_with_steps<const RVIEW: usize, const CVIEW: usize>(
&self,
start: (usize, usize),
steps: (usize, usize)
) -> MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>
pub fn fixed_view_with_steps<const RVIEW: usize, const CVIEW: usize>( &self, start: (usize, usize), steps: (usize, usize) ) -> MatrixView<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>
Returns a view of this matrix starting at its component (start.0, start.1)
and with
(RVIEW, CVIEW)
components. Each row (resp. column) of the matrix view
is separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of
the original matrix.
sourcepub fn generic_slice<RView, CView>(
&self,
start: (usize, usize),
shape: (RView, CView)
) -> MatrixView<'_, T, RView, CView, S::RStride, S::CStride>
👎Deprecated: Use generic_view instead. See issue #1076 for more information.
pub fn generic_slice<RView, CView>( &self, start: (usize, usize), shape: (RView, CView) ) -> MatrixView<'_, T, RView, CView, S::RStride, S::CStride>
Creates a slice that may or may not have a fixed size and stride.
sourcepub fn generic_view<RView, CView>(
&self,
start: (usize, usize),
shape: (RView, CView)
) -> MatrixView<'_, T, RView, CView, S::RStride, S::CStride>
pub fn generic_view<RView, CView>( &self, start: (usize, usize), shape: (RView, CView) ) -> MatrixView<'_, T, RView, CView, S::RStride, S::CStride>
Creates a matrix view that may or may not have a fixed size and stride.
sourcepub fn generic_slice_with_steps<RView, CView>(
&self,
start: (usize, usize),
shape: (RView, CView),
steps: (usize, usize)
) -> MatrixView<'_, T, RView, CView, Dyn, Dyn>
👎Deprecated: Use generic_view_with_steps instead. See issue #1076 for more information.
pub fn generic_slice_with_steps<RView, CView>( &self, start: (usize, usize), shape: (RView, CView), steps: (usize, usize) ) -> MatrixView<'_, T, RView, CView, Dyn, Dyn>
Creates a slice that may or may not have a fixed size and stride.
sourcepub fn generic_view_with_steps<RView, CView>(
&self,
start: (usize, usize),
shape: (RView, CView),
steps: (usize, usize)
) -> MatrixView<'_, T, RView, CView, Dyn, Dyn>
pub fn generic_view_with_steps<RView, CView>( &self, start: (usize, usize), shape: (RView, CView), steps: (usize, usize) ) -> MatrixView<'_, T, RView, CView, Dyn, Dyn>
Creates a matrix view that may or may not have a fixed size and stride.
sourcepub fn rows_range_pair<Range1: DimRange<R>, Range2: DimRange<R>>(
&self,
r1: Range1,
r2: Range2
) -> (MatrixView<'_, T, Range1::Size, C, S::RStride, S::CStride>, MatrixView<'_, T, Range2::Size, C, S::RStride, S::CStride>)
pub fn rows_range_pair<Range1: DimRange<R>, Range2: DimRange<R>>( &self, r1: Range1, r2: Range2 ) -> (MatrixView<'_, T, Range1::Size, C, S::RStride, S::CStride>, MatrixView<'_, T, Range2::Size, C, S::RStride, S::CStride>)
Splits this NxM
matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
sourcepub fn columns_range_pair<Range1: DimRange<C>, Range2: DimRange<C>>(
&self,
r1: Range1,
r2: Range2
) -> (MatrixView<'_, T, R, Range1::Size, S::RStride, S::CStride>, MatrixView<'_, T, R, Range2::Size, S::RStride, S::CStride>)
pub fn columns_range_pair<Range1: DimRange<C>, Range2: DimRange<C>>( &self, r1: Range1, r2: Range2 ) -> (MatrixView<'_, T, R, Range1::Size, S::RStride, S::CStride>, MatrixView<'_, T, R, Range2::Size, S::RStride, S::CStride>)
Splits this NxM
matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
source§impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
§Mutable views based on index and length
sourcepub fn row_mut(
&mut self,
i: usize
) -> MatrixViewMut<'_, T, U1, C, S::RStride, S::CStride>
pub fn row_mut( &mut self, i: usize ) -> MatrixViewMut<'_, T, U1, C, S::RStride, S::CStride>
Returns a view containing the i-th row of this matrix.
sourcepub fn row_part_mut(
&mut self,
i: usize,
n: usize
) -> MatrixViewMut<'_, T, U1, Dyn, S::RStride, S::CStride>
pub fn row_part_mut( &mut self, i: usize, n: usize ) -> MatrixViewMut<'_, T, U1, Dyn, S::RStride, S::CStride>
Returns a view containing the n
first elements of the i-th row of this matrix.
sourcepub fn rows_mut(
&mut self,
first_row: usize,
nrows: usize
) -> MatrixViewMut<'_, T, Dyn, C, S::RStride, S::CStride>
pub fn rows_mut( &mut self, first_row: usize, nrows: usize ) -> MatrixViewMut<'_, T, Dyn, C, S::RStride, S::CStride>
Extracts from this matrix a set of consecutive rows.
sourcepub fn rows_with_step_mut(
&mut self,
first_row: usize,
nrows: usize,
step: usize
) -> MatrixViewMut<'_, T, Dyn, C, Dyn, S::CStride>
pub fn rows_with_step_mut( &mut self, first_row: usize, nrows: usize, step: usize ) -> MatrixViewMut<'_, T, Dyn, C, Dyn, S::CStride>
Extracts from this matrix a set of consecutive rows regularly skipping step
rows.
sourcepub fn fixed_rows_mut<const RVIEW: usize>(
&mut self,
first_row: usize
) -> MatrixViewMut<'_, T, Const<RVIEW>, C, S::RStride, S::CStride>
pub fn fixed_rows_mut<const RVIEW: usize>( &mut self, first_row: usize ) -> MatrixViewMut<'_, T, Const<RVIEW>, C, S::RStride, S::CStride>
Extracts a compile-time number of consecutive rows from this matrix.
sourcepub fn fixed_rows_with_step_mut<const RVIEW: usize>(
&mut self,
first_row: usize,
step: usize
) -> MatrixViewMut<'_, T, Const<RVIEW>, C, Dyn, S::CStride>
pub fn fixed_rows_with_step_mut<const RVIEW: usize>( &mut self, first_row: usize, step: usize ) -> MatrixViewMut<'_, T, Const<RVIEW>, C, Dyn, S::CStride>
Extracts from this matrix a compile-time number of rows regularly skipping step
rows.
sourcepub fn rows_generic_mut<RView: Dim>(
&mut self,
row_start: usize,
nrows: RView
) -> MatrixViewMut<'_, T, RView, C, S::RStride, S::CStride>
pub fn rows_generic_mut<RView: Dim>( &mut self, row_start: usize, nrows: RView ) -> MatrixViewMut<'_, T, RView, C, S::RStride, S::CStride>
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
sourcepub fn rows_generic_with_step_mut<RView>(
&mut self,
row_start: usize,
nrows: RView,
step: usize
) -> MatrixViewMut<'_, T, RView, C, Dyn, S::CStride>where
RView: Dim,
pub fn rows_generic_with_step_mut<RView>(
&mut self,
row_start: usize,
nrows: RView,
step: usize
) -> MatrixViewMut<'_, T, RView, C, Dyn, S::CStride>where
RView: Dim,
Extracts from this matrix nrows
rows regularly skipping step
rows. Both
argument may or may not be values known at compile-time.
sourcepub fn column_mut(
&mut self,
i: usize
) -> MatrixViewMut<'_, T, R, U1, S::RStride, S::CStride>
pub fn column_mut( &mut self, i: usize ) -> MatrixViewMut<'_, T, R, U1, S::RStride, S::CStride>
Returns a view containing the i-th column of this matrix.
sourcepub fn column_part_mut(
&mut self,
i: usize,
n: usize
) -> MatrixViewMut<'_, T, Dyn, U1, S::RStride, S::CStride>
pub fn column_part_mut( &mut self, i: usize, n: usize ) -> MatrixViewMut<'_, T, Dyn, U1, S::RStride, S::CStride>
Returns a view containing the n
first elements of the i-th column of this matrix.
sourcepub fn columns_mut(
&mut self,
first_col: usize,
ncols: usize
) -> MatrixViewMut<'_, T, R, Dyn, S::RStride, S::CStride>
pub fn columns_mut( &mut self, first_col: usize, ncols: usize ) -> MatrixViewMut<'_, T, R, Dyn, S::RStride, S::CStride>
Extracts from this matrix a set of consecutive columns.
sourcepub fn columns_with_step_mut(
&mut self,
first_col: usize,
ncols: usize,
step: usize
) -> MatrixViewMut<'_, T, R, Dyn, S::RStride, Dyn>
pub fn columns_with_step_mut( &mut self, first_col: usize, ncols: usize, step: usize ) -> MatrixViewMut<'_, T, R, Dyn, S::RStride, Dyn>
Extracts from this matrix a set of consecutive columns regularly skipping step
columns.
sourcepub fn fixed_columns_mut<const CVIEW: usize>(
&mut self,
first_col: usize
) -> MatrixViewMut<'_, T, R, Const<CVIEW>, S::RStride, S::CStride>
pub fn fixed_columns_mut<const CVIEW: usize>( &mut self, first_col: usize ) -> MatrixViewMut<'_, T, R, Const<CVIEW>, S::RStride, S::CStride>
Extracts a compile-time number of consecutive columns from this matrix.
sourcepub fn fixed_columns_with_step_mut<const CVIEW: usize>(
&mut self,
first_col: usize,
step: usize
) -> MatrixViewMut<'_, T, R, Const<CVIEW>, S::RStride, Dyn>
pub fn fixed_columns_with_step_mut<const CVIEW: usize>( &mut self, first_col: usize, step: usize ) -> MatrixViewMut<'_, T, R, Const<CVIEW>, S::RStride, Dyn>
Extracts from this matrix a compile-time number of columns regularly skipping
step
columns.
sourcepub fn columns_generic_mut<CView: Dim>(
&mut self,
first_col: usize,
ncols: CView
) -> MatrixViewMut<'_, T, R, CView, S::RStride, S::CStride>
pub fn columns_generic_mut<CView: Dim>( &mut self, first_col: usize, ncols: CView ) -> MatrixViewMut<'_, T, R, CView, S::RStride, S::CStride>
Extracts from this matrix ncols
columns. The number of columns may or may not be
known at compile-time.
sourcepub fn columns_generic_with_step_mut<CView: Dim>(
&mut self,
first_col: usize,
ncols: CView,
step: usize
) -> MatrixViewMut<'_, T, R, CView, S::RStride, Dyn>
pub fn columns_generic_with_step_mut<CView: Dim>( &mut self, first_col: usize, ncols: CView, step: usize ) -> MatrixViewMut<'_, T, R, CView, S::RStride, Dyn>
Extracts from this matrix ncols
columns skipping step
columns. Both argument may
or may not be values known at compile-time.
sourcepub fn slice_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize)
) -> MatrixViewMut<'_, T, Dyn, Dyn, S::RStride, S::CStride>
👎Deprecated: Use view_mut instead. See issue #1076 for more information.
pub fn slice_mut( &mut self, start: (usize, usize), shape: (usize, usize) ) -> MatrixViewMut<'_, T, Dyn, Dyn, S::RStride, S::CStride>
Slices this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
sourcepub fn view_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize)
) -> MatrixViewMut<'_, T, Dyn, Dyn, S::RStride, S::CStride>
pub fn view_mut( &mut self, start: (usize, usize), shape: (usize, usize) ) -> MatrixViewMut<'_, T, Dyn, Dyn, S::RStride, S::CStride>
Return a view of this matrix starting at its component (irow, icol)
and with (nrows, ncols)
consecutive elements.
sourcepub fn slice_with_steps_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> MatrixViewMut<'_, T, Dyn, Dyn, Dyn, Dyn>
👎Deprecated: Use view_with_steps_mut instead. See issue #1076 for more information.
pub fn slice_with_steps_mut( &mut self, start: (usize, usize), shape: (usize, usize), steps: (usize, usize) ) -> MatrixViewMut<'_, T, Dyn, Dyn, Dyn, Dyn>
Slices this matrix starting at its component (start.0, start.1)
and with
(shape.0, shape.1)
components. Each row (resp. column) of the sliced matrix is
separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of the
original matrix.
sourcepub fn view_with_steps_mut(
&mut self,
start: (usize, usize),
shape: (usize, usize),
steps: (usize, usize)
) -> MatrixViewMut<'_, T, Dyn, Dyn, Dyn, Dyn>
pub fn view_with_steps_mut( &mut self, start: (usize, usize), shape: (usize, usize), steps: (usize, usize) ) -> MatrixViewMut<'_, T, Dyn, Dyn, Dyn, Dyn>
Return a view of this matrix starting at its component (start.0, start.1)
and with
(shape.0, shape.1)
components. Each row (resp. column) of the matrix view is
separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of the
original matrix.
sourcepub fn fixed_slice_mut<const RVIEW: usize, const CVIEW: usize>(
&mut self,
irow: usize,
icol: usize
) -> MatrixViewMut<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride>
👎Deprecated: Use fixed_view_mut instead. See issue #1076 for more information.
pub fn fixed_slice_mut<const RVIEW: usize, const CVIEW: usize>( &mut self, irow: usize, icol: usize ) -> MatrixViewMut<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride>
Slices this matrix starting at its component (irow, icol)
and with (RVIEW, CVIEW)
consecutive components.
sourcepub fn fixed_view_mut<const RVIEW: usize, const CVIEW: usize>(
&mut self,
irow: usize,
icol: usize
) -> MatrixViewMut<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride>
pub fn fixed_view_mut<const RVIEW: usize, const CVIEW: usize>( &mut self, irow: usize, icol: usize ) -> MatrixViewMut<'_, T, Const<RVIEW>, Const<CVIEW>, S::RStride, S::CStride>
Return a view of this matrix starting at its component (irow, icol)
and with
(RVIEW, CVIEW)
consecutive components.
sourcepub fn fixed_slice_with_steps_mut<const RVIEW: usize, const CVIEW: usize>(
&mut self,
start: (usize, usize),
steps: (usize, usize)
) -> MatrixViewMut<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>
👎Deprecated: Use fixed_view_with_steps_mut instead. See issue #1076 for more information.
pub fn fixed_slice_with_steps_mut<const RVIEW: usize, const CVIEW: usize>( &mut self, start: (usize, usize), steps: (usize, usize) ) -> MatrixViewMut<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>
Slices this matrix starting at its component (start.0, start.1)
and with
(RVIEW, CVIEW)
components. Each row (resp. column) of the sliced
matrix is separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of
the original matrix.
sourcepub fn fixed_view_with_steps_mut<const RVIEW: usize, const CVIEW: usize>(
&mut self,
start: (usize, usize),
steps: (usize, usize)
) -> MatrixViewMut<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>
pub fn fixed_view_with_steps_mut<const RVIEW: usize, const CVIEW: usize>( &mut self, start: (usize, usize), steps: (usize, usize) ) -> MatrixViewMut<'_, T, Const<RVIEW>, Const<CVIEW>, Dyn, Dyn>
Returns a view of this matrix starting at its component (start.0, start.1)
and with
(RVIEW, CVIEW)
components. Each row (resp. column) of the matrix view
is separated by steps.0
(resp. steps.1
) ignored rows (resp. columns) of
the original matrix.
sourcepub fn generic_slice_mut<RView, CView>(
&mut self,
start: (usize, usize),
shape: (RView, CView)
) -> MatrixViewMut<'_, T, RView, CView, S::RStride, S::CStride>
👎Deprecated: Use generic_view_mut instead. See issue #1076 for more information.
pub fn generic_slice_mut<RView, CView>( &mut self, start: (usize, usize), shape: (RView, CView) ) -> MatrixViewMut<'_, T, RView, CView, S::RStride, S::CStride>
Creates a slice that may or may not have a fixed size and stride.
sourcepub fn generic_view_mut<RView, CView>(
&mut self,
start: (usize, usize),
shape: (RView, CView)
) -> MatrixViewMut<'_, T, RView, CView, S::RStride, S::CStride>
pub fn generic_view_mut<RView, CView>( &mut self, start: (usize, usize), shape: (RView, CView) ) -> MatrixViewMut<'_, T, RView, CView, S::RStride, S::CStride>
Creates a matrix view that may or may not have a fixed size and stride.
sourcepub fn generic_slice_with_steps_mut<RView, CView>(
&mut self,
start: (usize, usize),
shape: (RView, CView),
steps: (usize, usize)
) -> MatrixViewMut<'_, T, RView, CView, Dyn, Dyn>
👎Deprecated: Use generic_view_with_steps_mut instead. See issue #1076 for more information.
pub fn generic_slice_with_steps_mut<RView, CView>( &mut self, start: (usize, usize), shape: (RView, CView), steps: (usize, usize) ) -> MatrixViewMut<'_, T, RView, CView, Dyn, Dyn>
Creates a slice that may or may not have a fixed size and stride.
sourcepub fn generic_view_with_steps_mut<RView, CView>(
&mut self,
start: (usize, usize),
shape: (RView, CView),
steps: (usize, usize)
) -> MatrixViewMut<'_, T, RView, CView, Dyn, Dyn>
pub fn generic_view_with_steps_mut<RView, CView>( &mut self, start: (usize, usize), shape: (RView, CView), steps: (usize, usize) ) -> MatrixViewMut<'_, T, RView, CView, Dyn, Dyn>
Creates a matrix view that may or may not have a fixed size and stride.
sourcepub fn rows_range_pair_mut<Range1: DimRange<R>, Range2: DimRange<R>>(
&mut self,
r1: Range1,
r2: Range2
) -> (MatrixViewMut<'_, T, Range1::Size, C, S::RStride, S::CStride>, MatrixViewMut<'_, T, Range2::Size, C, S::RStride, S::CStride>)
pub fn rows_range_pair_mut<Range1: DimRange<R>, Range2: DimRange<R>>( &mut self, r1: Range1, r2: Range2 ) -> (MatrixViewMut<'_, T, Range1::Size, C, S::RStride, S::CStride>, MatrixViewMut<'_, T, Range2::Size, C, S::RStride, S::CStride>)
Splits this NxM
matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
sourcepub fn columns_range_pair_mut<Range1: DimRange<C>, Range2: DimRange<C>>(
&mut self,
r1: Range1,
r2: Range2
) -> (MatrixViewMut<'_, T, R, Range1::Size, S::RStride, S::CStride>, MatrixViewMut<'_, T, R, Range2::Size, S::RStride, S::CStride>)
pub fn columns_range_pair_mut<Range1: DimRange<C>, Range2: DimRange<C>>( &mut self, r1: Range1, r2: Range2 ) -> (MatrixViewMut<'_, T, R, Range1::Size, S::RStride, S::CStride>, MatrixViewMut<'_, T, R, Range2::Size, S::RStride, S::CStride>)
Splits this NxM
matrix into two parts delimited by two ranges.
Panics if the ranges overlap or if the first range is empty.
source§impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
sourcepub fn slice_range<RowRange, ColRange>(
&self,
rows: RowRange,
cols: ColRange
) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
👎Deprecated: Use view_range instead. See issue #1076 for more information.
pub fn slice_range<RowRange, ColRange>( &self, rows: RowRange, cols: ColRange ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
Slices a sub-matrix containing the rows indexed by the range rows
and the columns indexed
by the range cols
.
sourcepub fn view_range<RowRange, ColRange>(
&self,
rows: RowRange,
cols: ColRange
) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
pub fn view_range<RowRange, ColRange>( &self, rows: RowRange, cols: ColRange ) -> MatrixView<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
Returns a view containing the rows indexed by the range rows
and the columns indexed
by the range cols
.
sourcepub fn rows_range<RowRange: DimRange<R>>(
&self,
rows: RowRange
) -> MatrixView<'_, T, RowRange::Size, C, S::RStride, S::CStride>
pub fn rows_range<RowRange: DimRange<R>>( &self, rows: RowRange ) -> MatrixView<'_, T, RowRange::Size, C, S::RStride, S::CStride>
View containing all the rows indexed by the range rows
.
sourcepub fn columns_range<ColRange: DimRange<C>>(
&self,
cols: ColRange
) -> MatrixView<'_, T, R, ColRange::Size, S::RStride, S::CStride>
pub fn columns_range<ColRange: DimRange<C>>( &self, cols: ColRange ) -> MatrixView<'_, T, R, ColRange::Size, S::RStride, S::CStride>
View containing all the columns indexed by the range rows
.
source§impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> Matrix<T, R, C, S>
sourcepub fn slice_range_mut<RowRange, ColRange>(
&mut self,
rows: RowRange,
cols: ColRange
) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
👎Deprecated: Use view_range_mut instead. See issue #1076 for more information.
pub fn slice_range_mut<RowRange, ColRange>( &mut self, rows: RowRange, cols: ColRange ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
Slices a mutable sub-matrix containing the rows indexed by the range rows
and the columns
indexed by the range cols
.
sourcepub fn view_range_mut<RowRange, ColRange>(
&mut self,
rows: RowRange,
cols: ColRange
) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
pub fn view_range_mut<RowRange, ColRange>( &mut self, rows: RowRange, cols: ColRange ) -> MatrixViewMut<'_, T, RowRange::Size, ColRange::Size, S::RStride, S::CStride>
Return a mutable view containing the rows indexed by the range rows
and the columns
indexed by the range cols
.
sourcepub fn rows_range_mut<RowRange: DimRange<R>>(
&mut self,
rows: RowRange
) -> MatrixViewMut<'_, T, RowRange::Size, C, S::RStride, S::CStride>
pub fn rows_range_mut<RowRange: DimRange<R>>( &mut self, rows: RowRange ) -> MatrixViewMut<'_, T, RowRange::Size, C, S::RStride, S::CStride>
Mutable view containing all the rows indexed by the range rows
.
sourcepub fn columns_range_mut<ColRange: DimRange<C>>(
&mut self,
cols: ColRange
) -> MatrixViewMut<'_, T, R, ColRange::Size, S::RStride, S::CStride>
pub fn columns_range_mut<ColRange: DimRange<C>>( &mut self, cols: ColRange ) -> MatrixViewMut<'_, T, R, ColRange::Size, S::RStride, S::CStride>
Mutable view containing all the columns indexed by the range cols
.
source§impl<T, R, C, S> Matrix<T, R, C, S>
impl<T, R, C, S> Matrix<T, R, C, S>
sourcepub fn as_view<RView, CView, RViewStride, CViewStride>(
&self
) -> MatrixView<'_, T, RView, CView, RViewStride, CViewStride>
pub fn as_view<RView, CView, RViewStride, CViewStride>( &self ) -> MatrixView<'_, T, RView, CView, RViewStride, CViewStride>
Returns this matrix as a view.
The returned view type is generally ambiguous unless specified. This is particularly useful when working with functions or methods that take matrix views as input.
§Panics
Panics if the dimensions of the view and the matrix are not compatible and this cannot be proven at compile-time. This might happen, for example, when constructing a static view of size 3x3 from a dynamically sized matrix of dimension 5x5.
§Examples
use nalgebra::{DMatrixSlice, SMatrixView};
fn consume_view(_: DMatrixSlice<f64>) {}
let matrix = nalgebra::Matrix3::zeros();
consume_view(matrix.as_view());
let dynamic_view: DMatrixSlice<f64> = matrix.as_view();
let static_view_from_dyn: SMatrixView<f64, 3, 3> = dynamic_view.as_view();
source§impl<T, R, C, S> Matrix<T, R, C, S>
impl<T, R, C, S> Matrix<T, R, C, S>
sourcepub fn as_view_mut<RView, CView, RViewStride, CViewStride>(
&mut self
) -> MatrixViewMut<'_, T, RView, CView, RViewStride, CViewStride>
pub fn as_view_mut<RView, CView, RViewStride, CViewStride>( &mut self ) -> MatrixViewMut<'_, T, RView, CView, RViewStride, CViewStride>
Returns this matrix as a mutable view.
The returned view type is generally ambiguous unless specified. This is particularly useful when working with functions or methods that take matrix views as input.
§Panics
Panics if the dimensions of the view and the matrix are not compatible and this cannot be proven at compile-time. This might happen, for example, when constructing a static view of size 3x3 from a dynamically sized matrix of dimension 5x5.
§Examples
use nalgebra::{DMatrixViewMut, SMatrixViewMut};
fn consume_view(_: DMatrixViewMut<f64>) {}
let mut matrix = nalgebra::Matrix3::zeros();
consume_view(matrix.as_view_mut());
let mut dynamic_view: DMatrixViewMut<f64> = matrix.as_view_mut();
let static_view_from_dyn: SMatrixViewMut<f64, 3, 3> = dynamic_view.as_view_mut();
source§impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
§Magnitude and norms
sourcepub fn norm_squared(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
pub fn norm_squared(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
The squared L2 norm of this vector.
sourcepub fn norm(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
pub fn norm(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
The L2 norm of this matrix.
Use .apply_norm
to apply a custom norm.
sourcepub fn metric_distance<R2, C2, S2>(
&self,
rhs: &Matrix<T, R2, C2, S2>
) -> T::SimdRealFieldwhere
T: SimdComplexField,
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn metric_distance<R2, C2, S2>(
&self,
rhs: &Matrix<T, R2, C2, S2>
) -> T::SimdRealFieldwhere
T: SimdComplexField,
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + 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.
sourcepub fn apply_norm(&self, norm: &impl Norm<T>) -> T::SimdRealFieldwhere
T: SimdComplexField,
pub fn apply_norm(&self, norm: &impl Norm<T>) -> T::SimdRealFieldwhere
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());
sourcepub fn apply_metric_distance<R2, C2, S2>(
&self,
rhs: &Matrix<T, R2, C2, S2>,
norm: &impl Norm<T>
) -> T::SimdRealFieldwhere
T: SimdComplexField,
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
pub fn apply_metric_distance<R2, C2, S2>(
&self,
rhs: &Matrix<T, R2, C2, S2>,
norm: &impl Norm<T>
) -> T::SimdRealFieldwhere
T: SimdComplexField,
R2: Dim,
C2: Dim,
S2: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R, R2> + 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());
sourcepub fn magnitude(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
pub fn magnitude(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
A synonym for the norm of this matrix.
Aka the length.
This function is simply implemented as a call to norm()
sourcepub fn magnitude_squared(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
pub fn magnitude_squared(&self) -> T::SimdRealFieldwhere
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()
sourcepub fn set_magnitude(&mut self, magnitude: T::SimdRealField)where
T: SimdComplexField,
S: StorageMut<T, R, C>,
pub fn set_magnitude(&mut self, magnitude: T::SimdRealField)where
T: SimdComplexField,
S: StorageMut<T, R, C>,
Sets the magnitude of this vector.
sourcepub fn lp_norm(&self, p: i32) -> T::SimdRealFieldwhere
T: SimdComplexField,
pub fn lp_norm(&self, p: i32) -> T::SimdRealFieldwhere
T: SimdComplexField,
The Lp norm of this matrix.
sourcepub fn simd_try_normalize(
&self,
min_norm: T::SimdRealField
) -> SimdOption<OMatrix<T, R, C>>
pub fn simd_try_normalize( &self, min_norm: T::SimdRealField ) -> SimdOption<OMatrix<T, R, C>>
Attempts to normalize self
.
The components of this matrix can be SIMD types.
sourcepub fn try_set_magnitude(
&mut self,
magnitude: T::RealField,
min_magnitude: T::RealField
)where
T: ComplexField,
S: StorageMut<T, R, C>,
pub fn try_set_magnitude(
&mut self,
magnitude: T::RealField,
min_magnitude: T::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
.
sourcepub fn cap_magnitude(&self, max: T::RealField) -> OMatrix<T, R, C>
pub fn cap_magnitude(&self, max: T::RealField) -> OMatrix<T, R, C>
Returns a new vector with the same magnitude as self
clamped between 0.0
and max
.
sourcepub fn simd_cap_magnitude(&self, max: T::SimdRealField) -> OMatrix<T, R, C>
pub fn simd_cap_magnitude(&self, max: T::SimdRealField) -> OMatrix<T, R, C>
Returns a new vector with the same magnitude as self
clamped between 0.0
and max
.
sourcepub fn try_normalize(&self, min_norm: T::RealField) -> Option<OMatrix<T, R, C>>
pub fn try_normalize(&self, min_norm: T::RealField) -> Option<OMatrix<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.
source§impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S>
§In-place normalization
sourcepub fn normalize_mut(&mut self) -> T::SimdRealFieldwhere
T: SimdComplexField,
pub fn normalize_mut(&mut self) -> T::SimdRealFieldwhere
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).
sourcepub fn simd_try_normalize_mut(
&mut self,
min_norm: T::SimdRealField
) -> SimdOption<T::SimdRealField>
pub fn simd_try_normalize_mut( &mut self, min_norm: T::SimdRealField ) -> SimdOption<T::SimdRealField>
Normalizes this matrix in-place and return its norm.
The components of the matrix can be SIMD types.
sourcepub fn try_normalize_mut(
&mut self,
min_norm: T::RealField
) -> Option<T::RealField>where
T: ComplexField,
pub fn try_normalize_mut(
&mut self,
min_norm: T::RealField
) -> Option<T::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.
source§impl<T: ComplexField, D: DimName> Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T>>where
DefaultAllocator: Allocator<D>,
impl<T: ComplexField, D: DimName> Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T>>where
DefaultAllocator: Allocator<D>,
§Basis and orthogonalization
sourcepub fn orthonormalize(vs: &mut [Self]) -> usize
pub fn orthonormalize(vs: &mut [Self]) -> 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.
source§impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
The total number of elements of this matrix.
§Examples:
let mat = Matrix3x4::<f32>::zeros();
assert_eq!(mat.len(), 12);
sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true if the matrix contains no elements.
§Examples:
let mat = Matrix3x4::<f32>::zeros();
assert!(!mat.is_empty());
sourcepub fn is_identity(&self, eps: T::Epsilon) -> bool
pub fn is_identity(&self, eps: T::Epsilon) -> bool
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.
source§impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
sourcepub fn is_orthogonal(&self, eps: T::Epsilon) -> boolwhere
T: Zero + One + ClosedAddAssign + ClosedMulAssign + RelativeEq,
S: Storage<T, R, C>,
T::Epsilon: Clone,
DefaultAllocator: Allocator<R, C> + Allocator<C, C>,
pub fn is_orthogonal(&self, eps: T::Epsilon) -> boolwhere
T: Zero + One + ClosedAddAssign + ClosedMulAssign + RelativeEq,
S: Storage<T, R, C>,
T::Epsilon: Clone,
DefaultAllocator: Allocator<R, C> + Allocator<C, C>,
Checks that Mᵀ × M = Id
.
In this definition Id
is approximately equal to the identity matrix with a relative error
equal to eps
.
source§impl<T: RealField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>where
DefaultAllocator: Allocator<D, D>,
impl<T: RealField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>where
DefaultAllocator: Allocator<D, D>,
sourcepub fn is_special_orthogonal(&self, eps: T) -> bool
pub fn is_special_orthogonal(&self, eps: T) -> bool
Checks that this matrix is orthogonal and has a determinant equal to 1.
sourcepub fn is_invertible(&self) -> bool
pub fn is_invertible(&self) -> bool
Returns true
if this matrix is invertible.
source§impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
§Folding on columns and rows
sourcepub fn compress_rows(
&self,
f: impl Fn(VectorView<'_, T, R, S::RStride, S::CStride>) -> T
) -> RowOVector<T, C>
pub fn compress_rows( &self, f: impl Fn(VectorView<'_, T, R, S::RStride, S::CStride>) -> T ) -> RowOVector<T, C>
Returns a row vector where each element is the result of the application of f
on the
corresponding column of the original matrix.
sourcepub fn compress_rows_tr(
&self,
f: impl Fn(VectorView<'_, T, R, S::RStride, S::CStride>) -> T
) -> OVector<T, C>where
DefaultAllocator: Allocator<C>,
pub fn compress_rows_tr(
&self,
f: impl Fn(VectorView<'_, T, R, S::RStride, S::CStride>) -> T
) -> OVector<T, C>where
DefaultAllocator: Allocator<C>,
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()
.
sourcepub fn compress_columns(
&self,
init: OVector<T, R>,
f: impl Fn(&mut OVector<T, R>, VectorView<'_, T, R, S::RStride, S::CStride>)
) -> OVector<T, R>where
DefaultAllocator: Allocator<R>,
pub fn compress_columns(
&self,
init: OVector<T, R>,
f: impl Fn(&mut OVector<T, R>, VectorView<'_, T, R, S::RStride, S::CStride>)
) -> OVector<T, R>where
DefaultAllocator: Allocator<R>,
Returns a column vector resulting from the folding of f
on each column of this matrix.
source§impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
§Common statistics operations
sourcepub fn sum(&self) -> Twhere
T: ClosedAddAssign + Zero,
pub fn sum(&self) -> Twhere
T: ClosedAddAssign + Zero,
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);
sourcepub fn row_sum(&self) -> RowOVector<T, C>
pub fn row_sum(&self) -> RowOVector<T, C>
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));
sourcepub fn row_sum_tr(&self) -> OVector<T, C>
pub fn row_sum_tr(&self) -> OVector<T, C>
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));
sourcepub fn column_sum(&self) -> OVector<T, R>
pub fn column_sum(&self) -> OVector<T, R>
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));
sourcepub fn product(&self) -> Twhere
T: ClosedMulAssign + One,
pub fn product(&self) -> Twhere
T: ClosedMulAssign + One,
The product 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.product(), 720.0);
sourcepub fn row_product(&self) -> RowOVector<T, C>
pub fn row_product(&self) -> RowOVector<T, C>
The product 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_product(), RowVector3::new(4.0, 10.0, 18.0));
let mint = Matrix3x2::new(1, 2,
3, 4,
5, 6);
assert_eq!(mint.row_product(), RowVector2::new(15, 48));
sourcepub fn row_product_tr(&self) -> OVector<T, C>
pub fn row_product_tr(&self) -> OVector<T, C>
The product 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_product_tr(), Vector3::new(4.0, 10.0, 18.0));
let mint = Matrix3x2::new(1, 2,
3, 4,
5, 6);
assert_eq!(mint.row_product_tr(), Vector2::new(15, 48));
sourcepub fn column_product(&self) -> OVector<T, R>
pub fn column_product(&self) -> OVector<T, R>
The product 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_product(), Vector2::new(6.0, 120.0));
let mint = Matrix3x2::new(1, 2,
3, 4,
5, 6);
assert_eq!(mint.column_product(), Vector3::new(2, 12, 30));
sourcepub fn variance(&self) -> T
pub fn variance(&self) -> T
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);
sourcepub fn row_variance(&self) -> RowOVector<T, C>
pub fn row_variance(&self) -> RowOVector<T, 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));
sourcepub fn row_variance_tr(&self) -> OVector<T, C>
pub fn row_variance_tr(&self) -> OVector<T, C>
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));
sourcepub fn column_variance(&self) -> OVector<T, R>
pub fn column_variance(&self) -> OVector<T, R>
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);
sourcepub fn mean(&self) -> T
pub fn mean(&self) -> T
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);
sourcepub fn row_mean(&self) -> RowOVector<T, C>
pub fn row_mean(&self) -> RowOVector<T, 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));
sourcepub fn row_mean_tr(&self) -> OVector<T, C>
pub fn row_mean_tr(&self) -> OVector<T, C>
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));
sourcepub fn column_mean(&self) -> OVector<T, R>
pub fn column_mean(&self) -> OVector<T, R>
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));
source§impl<T: Scalar, D, S: RawStorage<T, D>> Matrix<T, D, Const<1>, S>
impl<T: Scalar, D, S: RawStorage<T, D>> Matrix<T, D, Const<1>, S>
§Swizzling
source§impl<T: Scalar + Zero + One + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign, D: Dim, S: Storage<T, D>> Matrix<T, D, Const<1>, S>
impl<T: Scalar + Zero + One + ClosedAddAssign + ClosedSubAssign + ClosedMulAssign, D: Dim, S: Storage<T, D>> Matrix<T, D, Const<1>, S>
§Interpolation
sourcepub fn lerp<S2: Storage<T, D>>(
&self,
rhs: &Vector<T, D, S2>,
t: T
) -> OVector<T, D>where
DefaultAllocator: Allocator<D>,
pub fn lerp<S2: Storage<T, D>>(
&self,
rhs: &Vector<T, D, S2>,
t: T
) -> OVector<T, D>where
DefaultAllocator: Allocator<D>,
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));
sourcepub fn slerp<S2: Storage<T, D>>(
&self,
rhs: &Vector<T, D, S2>,
t: T
) -> OVector<T, D>
pub fn slerp<S2: Storage<T, D>>( &self, rhs: &Vector<T, D, S2>, t: T ) -> OVector<T, D>
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());
source§impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
§Find the min and max components
sourcepub fn amax(&self) -> T
pub fn amax(&self) -> T
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);
sourcepub fn camax(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
pub fn camax(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
Returns the the 1-norm of the complex component with the largest 1-norm.
§Example
assert_eq!(Vector3::new(
Complex::new(-3.0, -2.0),
Complex::new(1.0, 2.0),
Complex::new(1.0, 3.0)).camax(), 5.0);
sourcepub fn max(&self) -> Twhere
T: SimdPartialOrd + Zero,
pub fn max(&self) -> Twhere
T: SimdPartialOrd + Zero,
Returns the component with the largest value.
§Example
assert_eq!(Vector3::new(-1.0, 2.0, 3.0).max(), 3.0);
assert_eq!(Vector3::new(-1.0, -2.0, -3.0).max(), -1.0);
assert_eq!(Vector3::new(5u32, 2, 3).max(), 5);
sourcepub fn amin(&self) -> T
pub fn amin(&self) -> T
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);
sourcepub fn camin(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
pub fn camin(&self) -> T::SimdRealFieldwhere
T: SimdComplexField,
Returns the the 1-norm of the complex component with the smallest 1-norm.
§Example
assert_eq!(Vector3::new(
Complex::new(-3.0, -2.0),
Complex::new(1.0, 2.0),
Complex::new(1.0, 3.0)).camin(), 3.0);
sourcepub fn min(&self) -> Twhere
T: SimdPartialOrd + Zero,
pub fn min(&self) -> Twhere
T: SimdPartialOrd + Zero,
Returns the component with the smallest value.
§Example
assert_eq!(Vector3::new(-1.0, 2.0, 3.0).min(), -1.0);
assert_eq!(Vector3::new(1.0, 2.0, 3.0).min(), 1.0);
assert_eq!(Vector3::new(5u32, 2, 3).min(), 2);
sourcepub fn icamax_full(&self) -> (usize, usize)where
T: ComplexField,
pub fn icamax_full(&self) -> (usize, usize)where
T: ComplexField,
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));
source§impl<T: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
impl<T: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S>
sourcepub fn iamax_full(&self) -> (usize, usize)
pub fn iamax_full(&self) -> (usize, usize)
Computes the index of the matrix component with the largest absolute value.
§Examples:
let mat = Matrix2x3::new(11, -12, 13,
21, 22, -23);
assert_eq!(mat.iamax_full(), (1, 2));
source§impl<T: Scalar, D: Dim, S: RawStorage<T, D>> Matrix<T, D, Const<1>, S>
impl<T: Scalar, D: Dim, S: RawStorage<T, D>> Matrix<T, D, Const<1>, S>
§Find the min and max components (vector-specific methods)
sourcepub fn icamax(&self) -> usizewhere
T: ComplexField,
pub fn icamax(&self) -> usizewhere
T: ComplexField,
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);
sourcepub fn argmax(&self) -> (usize, T)where
T: PartialOrd,
pub fn argmax(&self) -> (usize, T)where
T: PartialOrd,
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));
sourcepub fn imax(&self) -> usizewhere
T: PartialOrd,
pub fn imax(&self) -> usizewhere
T: PartialOrd,
Computes the index of the vector component with the largest value.
§Examples:
let vec = Vector3::new(11, -15, 13);
assert_eq!(vec.imax(), 2);
sourcepub fn iamax(&self) -> usizewhere
T: PartialOrd + Signed,
pub fn iamax(&self) -> usizewhere
T: PartialOrd + Signed,
Computes the index of the vector component with the largest absolute value.
§Examples:
let vec = Vector3::new(11, -15, 13);
assert_eq!(vec.iamax(), 1);
sourcepub fn argmin(&self) -> (usize, T)where
T: PartialOrd,
pub fn argmin(&self) -> (usize, T)where
T: PartialOrd,
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));
sourcepub fn imin(&self) -> usizewhere
T: PartialOrd,
pub fn imin(&self) -> usizewhere
T: PartialOrd,
Computes the index of the vector component with the smallest value.
§Examples:
let vec = Vector3::new(11, -15, 13);
assert_eq!(vec.imin(), 1);
source§impl<T: RealField, D1: Dim, S1: Storage<T, D1>> Matrix<T, D1, Const<1>, S1>
impl<T: RealField, D1: Dim, S1: Storage<T, D1>> Matrix<T, D1, Const<1>, S1>
sourcepub fn convolve_full<D2, S2>(
&self,
kernel: Vector<T, D2, S2>
) -> OVector<T, DimDiff<DimSum<D1, D2>, U1>>
pub fn convolve_full<D2, S2>( &self, kernel: Vector<T, D2, S2> ) -> OVector<T, DimDiff<DimSum<D1, D2>, U1>>
sourcepub fn convolve_valid<D2, S2>(
&self,
kernel: Vector<T, D2, S2>
) -> OVector<T, DimDiff<DimSum<D1, U1>, D2>>
pub fn convolve_valid<D2, S2>( &self, kernel: Vector<T, D2, S2> ) -> OVector<T, DimDiff<DimSum<D1, U1>, D2>>
sourcepub fn convolve_same<D2, S2>(&self, kernel: Vector<T, D2, S2>) -> OVector<T, D1>
pub fn convolve_same<D2, S2>(&self, kernel: Vector<T, D2, S2>) -> OVector<T, D1>
source§impl<T: ComplexField, D: DimMin<D, Output = D>, S: Storage<T, D, D>> Matrix<T, D, D, S>
impl<T: ComplexField, D: DimMin<D, Output = D>, S: Storage<T, D, D>> Matrix<T, D, D, S>
sourcepub fn determinant(&self) -> T
pub fn determinant(&self) -> T
Computes the matrix determinant.
If the matrix has a dimension larger than 3, an LU decomposition is used.
source§impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>
§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. |
Polar (Left Polar) | P' * U | U is semi-unitary/unitary and P' is a positive semi-definite Hermitian Matrix |
sourcepub fn bidiagonalize(self) -> Bidiagonal<T, R, C>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimMinimum<R, C>> + Allocator<DimDiff<DimMinimum<R, C>, U1>>,
pub fn bidiagonalize(self) -> Bidiagonal<T, R, C>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimMinimum<R, C>> + Allocator<DimDiff<DimMinimum<R, C>, U1>>,
Computes the bidiagonalization using householder reflections.
sourcepub fn full_piv_lu(self) -> FullPivLU<T, R, C>
pub fn full_piv_lu(self) -> FullPivLU<T, R, C>
Computes the LU decomposition with full pivoting of matrix
.
This effectively computes P, L, U, Q
such that P * matrix * Q = LU
.
sourcepub fn lu(self) -> LU<T, R, C>
pub fn lu(self) -> LU<T, R, C>
Computes the LU decomposition with partial (row) pivoting of matrix
.
sourcepub fn col_piv_qr(self) -> ColPivQR<T, R, C>
pub fn col_piv_qr(self) -> ColPivQR<T, R, C>
Computes the QR decomposition (with column pivoting) of this matrix.
sourcepub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<T, R, C>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
pub fn svd(self, compute_u: bool, compute_v: bool) -> SVD<T, R, C>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
Computes the Singular Value Decomposition using implicit shift.
The singular values are guaranteed to be sorted in descending order.
If this order is not required consider using svd_unordered
.
sourcepub fn svd_unordered(self, compute_u: bool, compute_v: bool) -> SVD<T, R, C>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
pub fn svd_unordered(self, compute_u: bool, compute_v: bool) -> SVD<T, R, C>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
Computes the Singular Value Decomposition using implicit shift.
The singular values are not guaranteed to be sorted in any particular order.
If a descending order is required, consider using svd
instead.
sourcepub fn try_svd(
self,
compute_u: bool,
compute_v: bool,
eps: T::RealField,
max_niter: usize
) -> Option<SVD<T, R, C>>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
pub fn try_svd(
self,
compute_u: bool,
compute_v: bool,
eps: T::RealField,
max_niter: usize
) -> Option<SVD<T, R, C>>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
Attempts to compute the Singular Value Decomposition of matrix
using implicit shift.
The singular values are guaranteed to be sorted in descending order.
If this order is not required consider using try_svd_unordered
.
§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.
sourcepub fn try_svd_unordered(
self,
compute_u: bool,
compute_v: bool,
eps: T::RealField,
max_niter: usize
) -> Option<SVD<T, R, C>>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
pub fn try_svd_unordered(
self,
compute_u: bool,
compute_v: bool,
eps: T::RealField,
max_niter: usize
) -> Option<SVD<T, R, C>>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
Attempts to compute the Singular Value Decomposition of matrix
using implicit shift.
The singular values are not guaranteed to be sorted in any particular order.
If a descending order is required, consider using try_svd
instead.
§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.
sourcepub fn polar(self) -> (OMatrix<T, R, R>, OMatrix<T, R, C>)where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>, R> + Allocator<DimMinimum<R, C>> + Allocator<R, R> + Allocator<DimMinimum<R, C>, DimMinimum<R, C>> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>>,
pub fn polar(self) -> (OMatrix<T, R, R>, OMatrix<T, R, C>)where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>, R> + Allocator<DimMinimum<R, C>> + Allocator<R, R> + Allocator<DimMinimum<R, C>, DimMinimum<R, C>> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>>,
Computes the Polar Decomposition of a matrix
(indirectly uses SVD).
sourcepub fn try_polar(
self,
eps: T::RealField,
max_niter: usize
) -> Option<(OMatrix<T, R, R>, OMatrix<T, R, C>)>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>, R> + Allocator<DimMinimum<R, C>> + Allocator<R, R> + Allocator<DimMinimum<R, C>, DimMinimum<R, C>> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>>,
pub fn try_polar(
self,
eps: T::RealField,
max_niter: usize
) -> Option<(OMatrix<T, R, R>, OMatrix<T, R, C>)>where
R: DimMin<C>,
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<DimMinimum<R, C>, R> + Allocator<DimMinimum<R, C>> + Allocator<R, R> + Allocator<DimMinimum<R, C>, DimMinimum<R, C>> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>>,
Attempts to compute the Polar Decomposition of a matrix
(indirectly uses SVD).
§Arguments
eps
− tolerance used to determine when a value converged to 0 when computing the SVD.max_niter
− maximum total number of iterations performed by the SVD computation algorithm.
source§impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>
impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>
§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. |
sourcepub fn cholesky(self) -> Option<Cholesky<T, D>>where
DefaultAllocator: Allocator<D, D>,
pub fn cholesky(self) -> Option<Cholesky<T, D>>where
DefaultAllocator: Allocator<D, D>,
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.
sourcepub fn udu(self) -> Option<UDU<T, D>>
pub fn udu(self) -> Option<UDU<T, 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
.
sourcepub fn hessenberg(self) -> Hessenberg<T, D>
pub fn hessenberg(self) -> Hessenberg<T, D>
Computes the Hessenberg decomposition of this matrix using householder reflections.
sourcepub fn try_schur(
self,
eps: T::RealField,
max_niter: usize
) -> Option<Schur<T, D>>
pub fn try_schur( self, eps: T::RealField, max_niter: usize ) -> Option<Schur<T, D>>
Attempts to compute the Schur decomposition of a square matrix.
If only eigenvalues are needed, it is more efficient to call the matrix method
.eigenvalues()
instead.
§Arguments
eps
− tolerance used to determine when a value converged to 0.max_niter
− maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded,None
is returned. Ifniter == 0
, then the algorithm continues indefinitely until convergence.
sourcepub fn symmetric_eigen(self) -> SymmetricEigen<T, D>
pub fn symmetric_eigen(self) -> SymmetricEigen<T, D>
Computes the eigendecomposition of this symmetric matrix.
Only the lower-triangular part (including the diagonal) of m
is read.
sourcepub fn try_symmetric_eigen(
self,
eps: T::RealField,
max_niter: usize
) -> Option<SymmetricEigen<T, D>>
pub fn try_symmetric_eigen( self, eps: T::RealField, max_niter: usize ) -> Option<SymmetricEigen<T, D>>
Computes the eigendecomposition of the given symmetric matrix with user-specified convergence parameters.
Only the lower-triangular part (including the diagonal) of m
is read.
§Arguments
eps
− tolerance used to determine when a value converged to 0.max_niter
− maximum total number of iterations performed by the algorithm. If this number of iteration is exceeded,None
is returned. Ifniter == 0
, then the algorithm continues indefinitely until convergence.
sourcepub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<T, D>
pub fn symmetric_tridiagonalize(self) -> SymmetricTridiagonal<T, D>
Computes the tridiagonalization of this symmetric matrix.
Only the lower-triangular part (including the diagonal) of m
is read.
source§impl<T: ComplexField, D> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>where
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<D, D> + Allocator<DimMinimum<D, D>> + Allocator<D>,
impl<T: ComplexField, D> Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>where
D: DimMin<D, Output = D>,
DefaultAllocator: Allocator<D, D> + Allocator<DimMinimum<D, D>> + Allocator<D>,
source§impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>
impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>
sourcepub fn try_inverse(self) -> Option<OMatrix<T, D, D>>where
DefaultAllocator: Allocator<D, D>,
pub fn try_inverse(self) -> Option<OMatrix<T, D, D>>where
DefaultAllocator: Allocator<D, D>,
source§impl<T: ComplexField, D: Dim, S: StorageMut<T, D, D>> Matrix<T, D, D, S>
impl<T: ComplexField, D: Dim, S: StorageMut<T, D, D>> Matrix<T, D, D, S>
sourcepub fn try_inverse_mut(&mut self) -> boolwhere
DefaultAllocator: Allocator<D, D>,
pub fn try_inverse_mut(&mut self) -> boolwhere
DefaultAllocator: Allocator<D, D>,
Attempts to invert this square matrix in-place. Returns false
and leaves self
untouched if
inversion fails.
§Panics
Panics if self
isn’t a square matrix.
source§impl<T, D, S> Matrix<T, D, D, S>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
D: DimMin<D, Output = D>,
S: StorageMut<T, D, D>,
DefaultAllocator: Allocator<D, D> + Allocator<D>,
impl<T, D, S> Matrix<T, D, D, S>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
D: DimMin<D, Output = D>,
S: StorageMut<T, D, D>,
DefaultAllocator: Allocator<D, D> + Allocator<D>,
source§impl<T, D, S> Matrix<T, D, D, S>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
D: DimMin<D, Output = D>,
S: StorageMut<T, D, D> + Storage<T, D, D>,
DefaultAllocator: Allocator<D, D> + Allocator<D>,
impl<T, D, S> Matrix<T, D, D, S>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
D: DimMin<D, Output = D>,
S: StorageMut<T, D, D> + Storage<T, D, D>,
DefaultAllocator: Allocator<D, D> + Allocator<D>,
source§impl<T: ComplexField, D, S: Storage<T, D, D>> Matrix<T, D, D, S>
impl<T: ComplexField, D, S: Storage<T, D, D>> Matrix<T, D, D, S>
sourcepub fn eigenvalues(&self) -> Option<OVector<T, D>>
pub fn eigenvalues(&self) -> Option<OVector<T, D>>
Computes the eigenvalues of this matrix.
sourcepub fn complex_eigenvalues(&self) -> OVector<NumComplex<T>, D>
pub fn complex_eigenvalues(&self) -> OVector<NumComplex<T>, D>
Computes the eigenvalues of this matrix.
source§impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>
impl<T: ComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>
sourcepub fn solve_lower_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self . x = b
where x
is the unknown and only
the lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn solve_upper_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_upper_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self . x = b
where x
is the unknown and only
the upper-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool
pub fn solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> ) -> bool
Solves the linear system self . x = b
where x
is the unknown and only the
lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn solve_lower_triangular_with_diag_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>,
diag: T
) -> bool
pub fn solve_lower_triangular_with_diag_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, diag: T ) -> bool
Solves the linear system self . x = b
where x
is the unknown and only the
lower-triangular part of self
is considered not-zero. The diagonal is never read as it is
assumed to be equal to diag
. Returns false
and does not modify its inputs if diag
is zero.
sourcepub fn solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool
pub fn solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> ) -> bool
Solves the linear system self . x = b
where x
is the unknown and only the
upper-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_lower_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_lower_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self.transpose() . x = b
where x
is the unknown and only
the lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_upper_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_upper_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self.transpose() . x = b
where x
is the unknown and only
the upper-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool
pub fn tr_solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> ) -> bool
Solves the linear system self.transpose() . x = b
where x
is the unknown and only the
lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool
pub fn tr_solve_upper_triangular_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> ) -> bool
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.
sourcepub fn ad_solve_lower_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_lower_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<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.
sourcepub fn ad_solve_upper_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_upper_triangular<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> Option<OMatrix<T, R2, C2>>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<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.
sourcepub fn ad_solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
) -> bool
pub fn ad_solve_lower_triangular_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> ) -> bool
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.
source§impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>
impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> Matrix<T, D, D, S>
sourcepub fn solve_lower_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_lower_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self . x = b
where x
is the unknown and only
the lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn solve_upper_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn solve_upper_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self . x = b
where x
is the unknown and only
the upper-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn solve_lower_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
)
pub fn solve_lower_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> )
Solves the linear system self . x = b
where x
is the unknown and only the
lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn solve_lower_triangular_with_diag_unchecked_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>,
diag: T
)
pub fn solve_lower_triangular_with_diag_unchecked_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2>, diag: T )
Solves the linear system self . x = b
where x
is the unknown and only the
lower-triangular part of self
is considered not-zero. The diagonal is never read as it is
assumed to be equal to diag
. Returns false
and does not modify its inputs if diag
is zero.
sourcepub fn solve_upper_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
)
pub fn solve_upper_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> )
Solves the linear system self . x = b
where x
is the unknown and only the
upper-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_lower_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_lower_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self.transpose() . x = b
where x
is the unknown and only
the lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_upper_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn tr_solve_upper_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
Computes the solution of the linear system self.transpose() . x = b
where x
is the unknown and only
the upper-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_lower_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
)
pub fn tr_solve_lower_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> )
Solves the linear system self.transpose() . x = b
where x
is the unknown and only the
lower-triangular part of self
(including the diagonal) is considered not-zero.
sourcepub fn tr_solve_upper_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
)
pub fn tr_solve_upper_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> )
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.
sourcepub fn ad_solve_lower_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_lower_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<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.
sourcepub fn ad_solve_upper_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R2, C2>,
ShapeConstraint: SameNumberOfRows<R2, D>,
pub fn ad_solve_upper_triangular_unchecked<R2: Dim, C2: Dim, S2>(
&self,
b: &Matrix<T, R2, C2, S2>
) -> OMatrix<T, R2, C2>where
S2: Storage<T, R2, C2>,
DefaultAllocator: Allocator<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.
sourcepub fn ad_solve_lower_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
)
pub fn ad_solve_lower_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> )
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.
sourcepub fn ad_solve_upper_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>(
&self,
b: &mut Matrix<T, R2, C2, S2>
)
pub fn ad_solve_upper_triangular_unchecked_mut<R2: Dim, C2: Dim, S2>( &self, b: &mut Matrix<T, R2, C2, S2> )
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.
source§impl<T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>where
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
impl<T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>where
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
sourcepub fn singular_values_unordered(
&self
) -> OVector<T::RealField, DimMinimum<R, C>>
pub fn singular_values_unordered( &self ) -> OVector<T::RealField, DimMinimum<R, C>>
Computes the singular values of this matrix.
The singular values are not guaranteed to be sorted in any particular order.
If a descending order is required, consider using singular_values
instead.
sourcepub fn rank(&self, eps: T::RealField) -> usize
pub fn rank(&self, eps: T::RealField) -> usize
Computes the rank of this matrix.
All singular values below eps
are considered equal to 0.
sourcepub fn pseudo_inverse(
self,
eps: T::RealField
) -> Result<OMatrix<T, C, R>, &'static str>where
DefaultAllocator: Allocator<C, R>,
pub fn pseudo_inverse(
self,
eps: T::RealField
) -> Result<OMatrix<T, C, R>, &'static str>where
DefaultAllocator: Allocator<C, R>,
Computes the pseudo-inverse of this matrix.
All singular values below eps
are considered equal to 0.
source§impl<T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>where
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
impl<T: ComplexField, R: DimMin<C>, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S>where
DimMinimum<R, C>: DimSub<U1>,
DefaultAllocator: Allocator<R, C> + Allocator<C> + Allocator<R> + Allocator<DimDiff<DimMinimum<R, C>, U1>> + Allocator<DimMinimum<R, C>, C> + Allocator<R, DimMinimum<R, C>> + Allocator<DimMinimum<R, C>>,
sourcepub fn singular_values(&self) -> OVector<T::RealField, DimMinimum<R, C>>
pub fn singular_values(&self) -> OVector<T::RealField, DimMinimum<R, C>>
Computes the singular values of this matrix.
The singular values are guaranteed to be sorted in descending order.
If this order is not required consider using singular_values_unordered
.
Trait Implementations§
source§impl<T, R: Dim, C: Dim, S> AbsDiffEq for Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S> AbsDiffEq for Matrix<T, R, C, S>
source§fn default_epsilon() -> Self::Epsilon
fn default_epsilon() -> Self::Epsilon
source§fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool
fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool
source§fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
AbsDiffEq::abs_diff_eq
.source§impl<'a, 'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
impl<'a, 'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
source§impl<'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
impl<'b, T, D1, D2, SB> Add<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
source§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 + ClosedAddAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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 + ClosedAddAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
+
operator.source§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 + ClosedAddAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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 + ClosedAddAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
+
operator.source§impl<'a, T, D1, D2, SB> Add<Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
impl<'a, T, D1, D2, SB> Add<Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
source§impl<T, D1, D2, SB> Add<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
impl<T, D1, D2, SB> Add<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
source§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 + ClosedAddAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + 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 + ClosedAddAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,
§type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer<T>>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer<T>>
+
operator.source§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 + ClosedAddAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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 + ClosedAddAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
+
operator.source§impl<'b, T, D1: DimName, D2: Dim, SB> AddAssign<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
SB: Storage<T, D2>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
DefaultAllocator: Allocator<D1>,
impl<'b, T, D1: DimName, D2: Dim, SB> AddAssign<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
SB: Storage<T, D2>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
DefaultAllocator: Allocator<D1>,
source§fn add_assign(&mut self, right: &'b Vector<T, D2, SB>)
fn add_assign(&mut self, right: &'b Vector<T, D2, SB>)
+=
operation. Read moresource§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 + ClosedAddAssign,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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 + ClosedAddAssign,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
source§fn add_assign(&mut self, rhs: &'b Matrix<T, R2, C2, SB>)
fn add_assign(&mut self, rhs: &'b Matrix<T, R2, C2, SB>)
+=
operation. Read moresource§impl<T, D1: DimName, D2: Dim, SB> AddAssign<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
SB: Storage<T, D2>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
DefaultAllocator: Allocator<D1>,
impl<T, D1: DimName, D2: Dim, SB> AddAssign<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedAddAssign,
SB: Storage<T, D2>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
DefaultAllocator: Allocator<D1>,
source§fn add_assign(&mut self, right: Vector<T, D2, SB>)
fn add_assign(&mut self, right: Vector<T, D2, SB>)
+=
operation. Read moresource§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 + ClosedAddAssign,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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 + ClosedAddAssign,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
source§fn add_assign(&mut self, rhs: Matrix<T, R2, C2, SB>)
fn add_assign(&mut self, rhs: Matrix<T, R2, C2, SB>)
+=
operation. Read moresource§impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C> + IsContiguous> AsRef<[T]> for Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorage<T, R, C> + IsContiguous> AsRef<[T]> for Matrix<T, R, C, S>
source§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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
source§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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
source§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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
source§impl<T, R1, C1, SA, const D2: usize> Div<Rotation<T, D2>> for Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<T, R1, C1, SA, const D2: usize> Div<Rotation<T, D2>> for Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
source§impl<T, R: Dim, C: Dim, S> DivAssign<T> for Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S> DivAssign<T> for Matrix<T, R, C, S>
source§fn div_assign(&mut self, rhs: T)
fn div_assign(&mut self, rhs: T)
/=
operation. Read moresource§impl<T, R, S, RV, SV> Extend<Matrix<T, RV, Const<1>, SV>> for Matrix<T, R, Dyn, S>where
T: Scalar,
R: Dim,
S: Extend<Vector<T, RV, SV>>,
RV: Dim,
SV: RawStorage<T, RV>,
ShapeConstraint: SameNumberOfRows<R, RV>,
impl<T, R, S, RV, SV> Extend<Matrix<T, RV, Const<1>, SV>> for Matrix<T, R, Dyn, S>where
T: Scalar,
R: Dim,
S: Extend<Vector<T, RV, SV>>,
RV: Dim,
SV: RawStorage<T, RV>,
ShapeConstraint: SameNumberOfRows<R, RV>,
source§fn extend<I: IntoIterator<Item = Vector<T, RV, SV>>>(&mut self, iter: I)
fn extend<I: IntoIterator<Item = Vector<T, RV, SV>>>(&mut self, iter: I)
Extends the number of columns of a Matrix
with Vector
s
from a given iterator.
§Example
let data = vec![0, 1, 2, // column 1
3, 4, 5]; // column 2
let mut matrix = DMatrix::from_vec(3, 2, data);
matrix.extend(
vec![Vector3::new(6, 7, 8), // column 3
Vector3::new(9, 10, 11)]); // column 4
assert!(matrix.eq(&Matrix3x4::new(0, 3, 6, 9,
1, 4, 7, 10,
2, 5, 8, 11)));
§Panics
This function panics if the dimension of each Vector
yielded
by the given iterator is not equal to the number of rows of
this Matrix
.
let mut matrix =
DMatrix::from_vec(3, 2,
vec![0, 1, 2, // column 1
3, 4, 5]); // column 2
// The following panics because this matrix can only be extended with 3-dimensional vectors.
matrix.extend(
vec![Vector2::new(6, 7)]); // too few dimensions!
let mut matrix =
DMatrix::from_vec(3, 2,
vec![0, 1, 2, // column 1
3, 4, 5]); // column 2
// The following panics because this matrix can only be extended with 3-dimensional vectors.
matrix.extend(
vec![Vector4::new(6, 7, 8, 9)]); // too few dimensions!
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<T, R, RV, SV> Extend<Matrix<T, RV, Const<1>, SV>> for VecStorage<T, R, Dyn>
impl<T, R, RV, SV> Extend<Matrix<T, RV, Const<1>, SV>> for VecStorage<T, R, Dyn>
source§fn extend<I: IntoIterator<Item = Vector<T, RV, SV>>>(&mut self, iter: I)
fn extend<I: IntoIterator<Item = Vector<T, RV, SV>>>(&mut self, iter: I)
Extends the number of columns of the VecStorage
with vectors
from the given iterator.
§Panics
This function panics if the number of rows of each Vector
yielded by the iterator is not equal to the number of rows
of this VecStorage
.
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<T, S> Extend<T> for Matrix<T, Dyn, U1, S>
impl<T, S> Extend<T> for Matrix<T, Dyn, U1, S>
Extend the number of rows of the Vector
with elements from
a given iterator.
source§fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
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])));
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<T, R, S> Extend<T> for Matrix<T, R, Dyn, S>
impl<T, R, S> Extend<T> for Matrix<T, R, Dyn, S>
Extend the number of columns of the Matrix
with elements from
a given iterator.
source§fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
Extend the number of columns of the Matrix
with elements
from the given iterator.
§Example
let data = vec![0, 1, 2, // column 1
3, 4, 5]; // column 2
let mut matrix = DMatrix::from_vec(3, 2, data);
matrix.extend(vec![6, 7, 8]); // column 3
assert!(matrix.eq(&Matrix3::new(0, 3, 6,
1, 4, 7,
2, 5, 8)));
§Panics
This function panics if the number of elements yielded by the
given iterator is not a multiple of the number of rows of the
Matrix
.
let data = vec![0, 1, 2, // column 1
3, 4, 5]; // column 2
let mut matrix = DMatrix::from_vec(3, 2, data);
// The following panics because the vec length is not a multiple of 3.
matrix.extend(vec![6, 7, 8, 9]);
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
)source§fn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
extend_one
)source§impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: RawStorage<T, R, C> + IsContiguous> From<&'a Matrix<T, R, C, S>> for &'a [T]
impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: RawStorage<T, R, C> + IsContiguous> From<&'a Matrix<T, R, C, S>> for &'a [T]
source§impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a Matrix<T, R, C, S>> for MatrixView<'a, T, RView, CView, RStride, CStride>
impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a Matrix<T, R, C, S>> for MatrixView<'a, T, RView, CView, RStride, CStride>
source§impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: RawStorageMut<T, R, C> + IsContiguous> From<&'a mut Matrix<T, R, C, S>> for &'a mut [T]
impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: RawStorageMut<T, R, C> + IsContiguous> From<&'a mut Matrix<T, R, C, S>> for &'a mut [T]
source§impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>> for MatrixView<'a, T, RView, CView, RStride, CStride>
impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>> for MatrixView<'a, T, RView, CView, RStride, CStride>
source§impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>> for MatrixViewMut<'a, T, RView, CView, RStride, CStride>
impl<'a, T, R, C, RView, CView, RStride, CStride, S> From<&'a mut Matrix<T, R, C, S>> for MatrixViewMut<'a, T, RView, CView, RStride, CStride>
source§impl<T: Scalar, const D: usize> From<Matrix<T, Const<1>, Const<D>, ArrayStorage<T, 1, D>>> for [T; D]where
Const<D>: IsNotStaticOne,
impl<T: Scalar, const D: usize> From<Matrix<T, Const<1>, Const<D>, ArrayStorage<T, 1, D>>> for [T; D]where
Const<D>: IsNotStaticOne,
source§fn from(vec: RowSVector<T, D>) -> [T; D]
fn from(vec: RowSVector<T, D>) -> [T; D]
source§impl<T: Scalar> From<Matrix<T, Const<4>, Const<1>, ArrayStorage<T, 4, 1>>> for Quaternion<T>
impl<T: Scalar> From<Matrix<T, Const<4>, Const<1>, ArrayStorage<T, 4, 1>>> for Quaternion<T>
source§impl<T: Scalar, const D: usize> From<Matrix<T, Const<D>, Const<1>, <DefaultAllocator as Allocator<Const<D>>>::Buffer<T>>> for Scale<T, D>
impl<T: Scalar, const D: usize> From<Matrix<T, Const<D>, Const<1>, <DefaultAllocator as Allocator<Const<D>>>::Buffer<T>>> for Scale<T, D>
source§impl<T: Scalar, const D: usize> From<Matrix<T, Const<D>, Const<1>, <DefaultAllocator as Allocator<Const<D>>>::Buffer<T>>> for Translation<T, D>
impl<T: Scalar, const D: usize> From<Matrix<T, Const<D>, Const<1>, <DefaultAllocator as Allocator<Const<D>>>::Buffer<T>>> for Translation<T, D>
source§impl<T: Scalar, const D: usize> From<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for [T; D]
impl<T: Scalar, const D: usize> From<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for [T; D]
source§impl<T: SimdRealField, R, const D: usize> From<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Isometry<T, R, D>where
R: AbstractRotation<T, D>,
impl<T: SimdRealField, R, const D: usize> From<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Isometry<T, R, D>where
R: AbstractRotation<T, D>,
source§impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize> From<Matrix<T, Const<D>, Const<1>, ViewStorage<'a, T, Const<D>, Const<1>, RStride, CStride>>> for [T; D]
impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize> From<Matrix<T, Const<D>, Const<1>, ViewStorage<'a, T, Const<D>, Const<1>, RStride, CStride>>> for [T; D]
source§fn from(vec: VectorView<'a, T, Const<D>, RStride, CStride>) -> Self
fn from(vec: VectorView<'a, T, Const<D>, RStride, CStride>) -> Self
source§impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize> From<Matrix<T, Const<D>, Const<1>, ViewStorageMut<'a, T, Const<D>, Const<1>, RStride, CStride>>> for [T; D]
impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const D: usize> From<Matrix<T, Const<D>, Const<1>, ViewStorageMut<'a, T, Const<D>, Const<1>, RStride, CStride>>> for [T; D]
source§fn from(vec: VectorViewMut<'a, T, Const<D>, RStride, CStride>) -> Self
fn from(vec: VectorViewMut<'a, T, Const<D>, RStride, CStride>) -> Self
source§impl<T: Scalar, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>> for [[T; R]; C]
impl<T: Scalar, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>> for [[T; R]; C]
source§impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, ViewStorage<'a, T, Const<R>, Const<C>, RStride, CStride>>> for [[T; R]; C]
impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, ViewStorage<'a, T, Const<R>, Const<C>, RStride, CStride>>> for [[T; R]; C]
source§impl<'a, T, RStride, CStride, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, ViewStorage<'a, T, Const<R>, Const<C>, RStride, CStride>>> for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
impl<'a, T, RStride, CStride, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, ViewStorage<'a, T, Const<R>, Const<C>, RStride, CStride>>> for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
source§impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, ViewStorageMut<'a, T, Const<R>, Const<C>, RStride, CStride>>> for [[T; R]; C]
impl<'a, T: Scalar, RStride: Dim, CStride: Dim, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, ViewStorageMut<'a, T, Const<R>, Const<C>, RStride, CStride>>> for [[T; R]; C]
source§impl<'a, T, RStride, CStride, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, ViewStorageMut<'a, T, Const<R>, Const<C>, RStride, CStride>>> for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
impl<'a, T, RStride, CStride, const R: usize, const C: usize> From<Matrix<T, Const<R>, Const<C>, ViewStorageMut<'a, T, Const<R>, Const<C>, RStride, CStride>>> for Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>
source§impl<T: Scalar, D: DimName> From<Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T>>> for OPoint<T, D>where
DefaultAllocator: Allocator<D>,
impl<T: Scalar, D: DimName> From<Matrix<T, D, Const<1>, <DefaultAllocator as Allocator<D>>::Buffer<T>>> for OPoint<T, D>where
DefaultAllocator: Allocator<D>,
source§impl<'a, T, C, RStride, CStride> From<Matrix<T, Dyn, C, ViewStorage<'a, T, Dyn, C, RStride, CStride>>> for Matrix<T, Dyn, C, VecStorage<T, Dyn, C>>
impl<'a, T, C, RStride, CStride> From<Matrix<T, Dyn, C, ViewStorage<'a, T, Dyn, C, RStride, CStride>>> for Matrix<T, Dyn, C, VecStorage<T, Dyn, C>>
source§fn from(matrix_view: MatrixView<'a, T, Dyn, C, RStride, CStride>) -> Self
fn from(matrix_view: MatrixView<'a, T, Dyn, C, RStride, CStride>) -> Self
source§impl<'a, T, C, RStride, CStride> From<Matrix<T, Dyn, C, ViewStorageMut<'a, T, Dyn, C, RStride, CStride>>> for Matrix<T, Dyn, C, VecStorage<T, Dyn, C>>
impl<'a, T, C, RStride, CStride> From<Matrix<T, Dyn, C, ViewStorageMut<'a, T, Dyn, C, RStride, CStride>>> for Matrix<T, Dyn, C, VecStorage<T, Dyn, C>>
source§fn from(matrix_view: MatrixViewMut<'a, T, Dyn, C, RStride, CStride>) -> Self
fn from(matrix_view: MatrixViewMut<'a, T, Dyn, C, RStride, CStride>) -> Self
source§impl<'a, T: Scalar> From<Matrix<T, Dyn, Const<1>, ViewStorage<'a, T, Dyn, Const<1>, Const<1>, Dyn>>> for &'a [T]
impl<'a, T: Scalar> From<Matrix<T, Dyn, Const<1>, ViewStorage<'a, T, Dyn, Const<1>, Const<1>, Dyn>>> for &'a [T]
source§fn from(vec: DVectorView<'a, T>) -> &'a [T]
fn from(vec: DVectorView<'a, T>) -> &'a [T]
source§impl<'a, T: Scalar> From<Matrix<T, Dyn, Const<1>, ViewStorageMut<'a, T, Dyn, Const<1>, Const<1>, Dyn>>> for &'a mut [T]
impl<'a, T: Scalar> From<Matrix<T, Dyn, Const<1>, ViewStorageMut<'a, T, Dyn, Const<1>, Const<1>, Dyn>>> for &'a mut [T]
source§fn from(vec: DVectorViewMut<'a, T>) -> &'a mut [T]
fn from(vec: DVectorViewMut<'a, T>) -> &'a mut [T]
source§impl<'a, T, R, C, RStride, CStride> From<Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>> for MatrixView<'a, T, R, C, RStride, CStride>
impl<'a, T, R, C, RStride, CStride> From<Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>> for MatrixView<'a, T, R, C, RStride, CStride>
source§fn from(view_mut: MatrixViewMut<'a, T, R, C, RStride, CStride>) -> Self
fn from(view_mut: MatrixViewMut<'a, T, R, C, RStride, CStride>) -> Self
source§impl<'a, T, R, RStride, CStride> From<Matrix<T, R, Dyn, ViewStorage<'a, T, R, Dyn, RStride, CStride>>> for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
impl<'a, T, R, RStride, CStride> From<Matrix<T, R, Dyn, ViewStorage<'a, T, R, Dyn, RStride, CStride>>> for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
source§fn from(matrix_view: MatrixView<'a, T, R, Dyn, RStride, CStride>) -> Self
fn from(matrix_view: MatrixView<'a, T, R, Dyn, RStride, CStride>) -> Self
source§impl<'a, T, R, RStride, CStride> From<Matrix<T, R, Dyn, ViewStorageMut<'a, T, R, Dyn, RStride, CStride>>> for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
impl<'a, T, R, RStride, CStride> From<Matrix<T, R, Dyn, ViewStorageMut<'a, T, R, Dyn, RStride, CStride>>> for Matrix<T, R, Dyn, VecStorage<T, R, Dyn>>
source§fn from(matrix_view: MatrixViewMut<'a, T, R, Dyn, RStride, CStride>) -> Self
fn from(matrix_view: MatrixViewMut<'a, T, R, Dyn, RStride, CStride>) -> Self
source§impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> IndexMut<(usize, usize)> for Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> IndexMut<(usize, usize)> for Matrix<T, R, C, S>
source§impl<'a, T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> IntoIterator for &'a Matrix<T, R, C, S>
impl<'a, T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> IntoIterator for &'a Matrix<T, R, C, S>
source§impl<'a, T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> IntoIterator for &'a mut Matrix<T, R, C, S>
impl<'a, T: Scalar, R: Dim, C: Dim, S: RawStorageMut<T, R, C>> IntoIterator for &'a mut Matrix<T, R, C, S>
source§impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> IntoIterator for Matrix<T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>
impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> IntoIterator for Matrix<T, R, C, ViewStorage<'a, T, R, C, RStride, CStride>>
source§impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> IntoIterator for Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>
impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> IntoIterator for Matrix<T, R, C, ViewStorageMut<'a, T, R, C, RStride, CStride>>
source§impl<'a, 'b, T: SimdRealField, S: Storage<T, Const<2>>> Mul<&'b Matrix<T, Const<2>, Const<1>, S>> for &'a UnitComplex<T>where
T::Element: SimdRealField,
impl<'a, 'b, T: SimdRealField, S: Storage<T, Const<2>>> Mul<&'b Matrix<T, Const<2>, Const<1>, S>> for &'a UnitComplex<T>where
T::Element: SimdRealField,
source§impl<'b, T: SimdRealField, S: Storage<T, Const<2>>> Mul<&'b Matrix<T, Const<2>, Const<1>, S>> for UnitComplex<T>where
T::Element: SimdRealField,
impl<'b, T: SimdRealField, S: Storage<T, Const<2>>> Mul<&'b Matrix<T, Const<2>, Const<1>, S>> for UnitComplex<T>where
T::Element: SimdRealField,
source§impl<'a, 'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,
impl<'a, 'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,
source§impl<'a, 'b, T: SimdRealField, SB: Storage<T, Const<3>>> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for &'a UnitQuaternion<T>where
T::Element: SimdRealField,
impl<'a, 'b, T: SimdRealField, SB: Storage<T, Const<3>>> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for &'a UnitQuaternion<T>where
T::Element: SimdRealField,
source§impl<'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,
impl<'b, T: SimdRealField, SB: Storage<T, U3>> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,
source§impl<'b, T: SimdRealField, SB: Storage<T, Const<3>>> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for UnitQuaternion<T>where
T::Element: SimdRealField,
impl<'b, T: SimdRealField, SB: Storage<T, Const<3>>> Mul<&'b Matrix<T, Const<3>, Const<1>, SB>> for UnitQuaternion<T>where
T::Element: SimdRealField,
source§impl<'a, 'b, T: SimdRealField, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Isometry<T, R, D>
impl<'a, 'b, T: SimdRealField, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Isometry<T, R, D>
source§impl<'a, 'b, T, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Scale<T, D>where
T: Scalar + ClosedMulAssign,
ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,
impl<'a, 'b, T, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Scale<T, D>where
T: Scalar + ClosedMulAssign,
ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,
source§impl<'a, 'b, T: SimdRealField, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Similarity<T, R, D>
impl<'a, 'b, T: SimdRealField, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Similarity<T, R, D>
source§impl<'a, 'b, T, C, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Transform<T, C, D>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign + RealField,
Const<D>: DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
impl<'a, 'b, T, C, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Transform<T, C, D>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign + RealField,
Const<D>: DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
source§impl<'b, T: SimdRealField, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Isometry<T, R, D>
impl<'b, T: SimdRealField, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Isometry<T, R, D>
source§impl<'b, T, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Scale<T, D>where
T: Scalar + ClosedMulAssign,
ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,
impl<'b, T, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Scale<T, D>where
T: Scalar + ClosedMulAssign,
ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,
source§impl<'b, T: SimdRealField, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Similarity<T, R, D>
impl<'b, T: SimdRealField, R, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Similarity<T, R, D>
source§impl<'b, T, C, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Transform<T, C, D>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign + RealField,
Const<D>: DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
impl<'b, T, C, const D: usize> Mul<&'b Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Transform<T, C, D>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign + RealField,
Const<D>: DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
source§impl<'a, 'b, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'a, 'b, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
source§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 + ClosedAddAssign + ClosedMulAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<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 + ClosedAddAssign + ClosedMulAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
source§impl<'b, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'b, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<&'b Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
source§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 + ClosedAddAssign + ClosedMulAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<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 + ClosedAddAssign + ClosedMulAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
source§impl<'b, R: Dim, C: Dim, S: Storage<f32, R, C>> Mul<&'b Matrix<f32, R, C, S>> for f32where
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<f32, R, C>> Mul<&'b Matrix<f32, R, C, S>> for f32where
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<f64, R, C>> Mul<&'b Matrix<f64, R, C, S>> for f64where
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<f64, R, C>> Mul<&'b Matrix<f64, R, C, S>> for f64where
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<i16, R, C>> Mul<&'b Matrix<i16, R, C, S>> for i16where
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<i16, R, C>> Mul<&'b Matrix<i16, R, C, S>> for i16where
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<i32, R, C>> Mul<&'b Matrix<i32, R, C, S>> for i32where
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<i32, R, C>> Mul<&'b Matrix<i32, R, C, S>> for i32where
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<i64, R, C>> Mul<&'b Matrix<i64, R, C, S>> for i64where
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<i64, R, C>> Mul<&'b Matrix<i64, R, C, S>> for i64where
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<i8, R, C>> Mul<&'b Matrix<i8, R, C, S>> for i8where
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<i8, R, C>> Mul<&'b Matrix<i8, R, C, S>> for i8where
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<isize, R, C>> Mul<&'b Matrix<isize, R, C, S>> for isizewhere
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<isize, R, C>> Mul<&'b Matrix<isize, R, C, S>> for isizewhere
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<u16, R, C>> Mul<&'b Matrix<u16, R, C, S>> for u16where
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<u16, R, C>> Mul<&'b Matrix<u16, R, C, S>> for u16where
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<u32, R, C>> Mul<&'b Matrix<u32, R, C, S>> for u32where
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<u32, R, C>> Mul<&'b Matrix<u32, R, C, S>> for u32where
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<u64, R, C>> Mul<&'b Matrix<u64, R, C, S>> for u64where
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<u64, R, C>> Mul<&'b Matrix<u64, R, C, S>> for u64where
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<u8, R, C>> Mul<&'b Matrix<u8, R, C, S>> for u8where
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<u8, R, C>> Mul<&'b Matrix<u8, R, C, S>> for u8where
DefaultAllocator: Allocator<R, C>,
source§impl<'b, R: Dim, C: Dim, S: Storage<usize, R, C>> Mul<&'b Matrix<usize, R, C, S>> for usizewhere
DefaultAllocator: Allocator<R, C>,
impl<'b, R: Dim, C: Dim, S: Storage<usize, R, C>> Mul<&'b Matrix<usize, R, C, S>> for usizewhere
DefaultAllocator: Allocator<R, C>,
source§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 + ClosedAddAssign + ClosedMulAssign,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,
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 + ClosedAddAssign + ClosedMulAssign,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,
source§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 + ClosedAddAssign + ClosedMulAssign,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,
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 + ClosedAddAssign + ClosedMulAssign,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,
source§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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
source§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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
source§impl<'a, T: SimdRealField, S: Storage<T, Const<2>>> Mul<Matrix<T, Const<2>, Const<1>, S>> for &'a UnitComplex<T>where
T::Element: SimdRealField,
impl<'a, T: SimdRealField, S: Storage<T, Const<2>>> Mul<Matrix<T, Const<2>, Const<1>, S>> for &'a UnitComplex<T>where
T::Element: SimdRealField,
source§impl<T: SimdRealField, S: Storage<T, Const<2>>> Mul<Matrix<T, Const<2>, Const<1>, S>> for UnitComplex<T>where
T::Element: SimdRealField,
impl<T: SimdRealField, S: Storage<T, Const<2>>> Mul<Matrix<T, Const<2>, Const<1>, S>> for UnitComplex<T>where
T::Element: SimdRealField,
source§impl<'a, T: SimdRealField, SB: Storage<T, U3>> Mul<Matrix<T, Const<3>, Const<1>, SB>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,
impl<'a, T: SimdRealField, SB: Storage<T, U3>> Mul<Matrix<T, Const<3>, Const<1>, SB>> for &'a UnitDualQuaternion<T>where
T::Element: SimdRealField,
source§impl<'a, T: SimdRealField, SB: Storage<T, Const<3>>> Mul<Matrix<T, Const<3>, Const<1>, SB>> for &'a UnitQuaternion<T>where
T::Element: SimdRealField,
impl<'a, T: SimdRealField, SB: Storage<T, Const<3>>> Mul<Matrix<T, Const<3>, Const<1>, SB>> for &'a UnitQuaternion<T>where
T::Element: SimdRealField,
source§impl<T: SimdRealField, SB: Storage<T, U3>> Mul<Matrix<T, Const<3>, Const<1>, SB>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,
impl<T: SimdRealField, SB: Storage<T, U3>> Mul<Matrix<T, Const<3>, Const<1>, SB>> for UnitDualQuaternion<T>where
T::Element: SimdRealField,
source§impl<T: SimdRealField, SB: Storage<T, Const<3>>> Mul<Matrix<T, Const<3>, Const<1>, SB>> for UnitQuaternion<T>where
T::Element: SimdRealField,
impl<T: SimdRealField, SB: Storage<T, Const<3>>> Mul<Matrix<T, Const<3>, Const<1>, SB>> for UnitQuaternion<T>where
T::Element: SimdRealField,
source§impl<'a, T: SimdRealField, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Isometry<T, R, D>
impl<'a, T: SimdRealField, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Isometry<T, R, D>
source§impl<'a, T, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Scale<T, D>where
T: Scalar + ClosedMulAssign,
ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,
impl<'a, T, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Scale<T, D>where
T: Scalar + ClosedMulAssign,
ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,
source§impl<'a, T: SimdRealField, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Similarity<T, R, D>
impl<'a, T: SimdRealField, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Similarity<T, R, D>
source§impl<'a, T, C, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Transform<T, C, D>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign + RealField,
Const<D>: DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
impl<'a, T, C, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for &'a Transform<T, C, D>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign + RealField,
Const<D>: DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
source§impl<T: SimdRealField, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Isometry<T, R, D>
impl<T: SimdRealField, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Isometry<T, R, D>
source§impl<T, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Scale<T, D>where
T: Scalar + ClosedMulAssign,
ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,
impl<T, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Scale<T, D>where
T: Scalar + ClosedMulAssign,
ShapeConstraint: SameNumberOfRows<Const<D>, Const<D>, Representative = Const<D>> + SameNumberOfColumns<U1, U1, Representative = U1>,
source§impl<T: SimdRealField, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Similarity<T, R, D>
impl<T: SimdRealField, R, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Similarity<T, R, D>
source§impl<T, C, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Transform<T, C, D>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign + RealField,
Const<D>: DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
impl<T, C, const D: usize> Mul<Matrix<T, Const<D>, Const<1>, ArrayStorage<T, D, 1>>> for Transform<T, C, D>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign + RealField,
Const<D>: DimNameAdd<U1>,
C: TCategory,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
source§impl<'a, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<'a, T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<T, R2, C2, SB>> for &'a Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
source§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 + ClosedAddAssign + ClosedMulAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<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 + ClosedAddAssign + ClosedMulAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
source§impl<T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
impl<T, R1: Dim, C1: Dim, R2: Dim, C2: Dim, SA, SB> Mul<Matrix<T, R2, C2, SB>> for Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
SB: Storage<T, R2, C2>,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, C2>,
ShapeConstraint: AreMultipliable<R1, C1, R2, C2>,
source§impl<T, R2, C2, SB, const D1: usize> Mul<Matrix<T, R2, C2, SB>> for Rotation<T, D1>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
impl<T, R2, C2, SB, const D1: usize> Mul<Matrix<T, R2, C2, SB>> for Rotation<T, D1>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
R2: Dim,
C2: Dim,
SB: Storage<T, R2, C2>,
DefaultAllocator: Allocator<Const<D1>, C2>,
ShapeConstraint: AreMultipliable<Const<D1>, Const<D1>, R2, C2>,
source§impl<R: Dim, C: Dim, S: Storage<f32, R, C>> Mul<Matrix<f32, R, C, S>> for f32where
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<f32, R, C>> Mul<Matrix<f32, R, C, S>> for f32where
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<f64, R, C>> Mul<Matrix<f64, R, C, S>> for f64where
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<f64, R, C>> Mul<Matrix<f64, R, C, S>> for f64where
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<i16, R, C>> Mul<Matrix<i16, R, C, S>> for i16where
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<i16, R, C>> Mul<Matrix<i16, R, C, S>> for i16where
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<i32, R, C>> Mul<Matrix<i32, R, C, S>> for i32where
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<i32, R, C>> Mul<Matrix<i32, R, C, S>> for i32where
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<i64, R, C>> Mul<Matrix<i64, R, C, S>> for i64where
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<i64, R, C>> Mul<Matrix<i64, R, C, S>> for i64where
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<i8, R, C>> Mul<Matrix<i8, R, C, S>> for i8where
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<i8, R, C>> Mul<Matrix<i8, R, C, S>> for i8where
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<isize, R, C>> Mul<Matrix<isize, R, C, S>> for isizewhere
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<isize, R, C>> Mul<Matrix<isize, R, C, S>> for isizewhere
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<u16, R, C>> Mul<Matrix<u16, R, C, S>> for u16where
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<u16, R, C>> Mul<Matrix<u16, R, C, S>> for u16where
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<u32, R, C>> Mul<Matrix<u32, R, C, S>> for u32where
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<u32, R, C>> Mul<Matrix<u32, R, C, S>> for u32where
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<u64, R, C>> Mul<Matrix<u64, R, C, S>> for u64where
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<u64, R, C>> Mul<Matrix<u64, R, C, S>> for u64where
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<u8, R, C>> Mul<Matrix<u8, R, C, S>> for u8where
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<u8, R, C>> Mul<Matrix<u8, R, C, S>> for u8where
DefaultAllocator: Allocator<R, C>,
source§impl<R: Dim, C: Dim, S: Storage<usize, R, C>> Mul<Matrix<usize, R, C, S>> for usizewhere
DefaultAllocator: Allocator<R, C>,
impl<R: Dim, C: Dim, S: Storage<usize, R, C>> Mul<Matrix<usize, R, C, S>> for usizewhere
DefaultAllocator: Allocator<R, C>,
source§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 + ClosedAddAssign + ClosedMulAssign,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,
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 + ClosedAddAssign + ClosedMulAssign,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,
source§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 + ClosedAddAssign + ClosedMulAssign,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,
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 + ClosedAddAssign + ClosedMulAssign,
SA: Storage<T, Const<R1>, Const<C1>>,
ShapeConstraint: AreMultipliable<Const<R1>, Const<C1>, Const<D2>, U1>,
source§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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<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 + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
source§impl<T, R1, C1, SA, const D2: usize> Mul<Rotation<T, D2>> for Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
impl<T, R1, C1, SA, const D2: usize> Mul<Rotation<T, D2>> for Matrix<T, R1, C1, SA>where
T: Scalar + Zero + One + ClosedAddAssign + ClosedMulAssign,
R1: Dim,
C1: Dim,
SA: Storage<T, R1, C1>,
DefaultAllocator: Allocator<R1, Const<D2>>,
ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,
source§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 + ClosedAddAssign + ClosedMulAssign,
SB: Storage<T, R2, C1>,
SA: StorageMut<T, R1, C1> + IsContiguous + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<R1, C1, Buffer<T> = 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 + ClosedAddAssign + ClosedMulAssign,
SB: Storage<T, R2, C1>,
SA: StorageMut<T, R1, C1> + IsContiguous + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<R1, C1, Buffer<T> = SA>,
source§fn mul_assign(&mut self, rhs: &'b Matrix<T, R2, C1, SB>)
fn mul_assign(&mut self, rhs: &'b Matrix<T, R2, C1, SB>)
*=
operation. Read moresource§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 + ClosedAddAssign + ClosedMulAssign,
SB: Storage<T, R2, C1>,
SA: StorageMut<T, R1, C1> + IsContiguous + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<R1, C1, Buffer<T> = 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 + ClosedAddAssign + ClosedMulAssign,
SB: Storage<T, R2, C1>,
SA: StorageMut<T, R1, C1> + IsContiguous + Clone,
ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
DefaultAllocator: Allocator<R1, C1, Buffer<T> = SA>,
source§fn mul_assign(&mut self, rhs: Matrix<T, R2, C1, SB>)
fn mul_assign(&mut self, rhs: Matrix<T, R2, C1, SB>)
*=
operation. Read moresource§impl<T, R: Dim, C: Dim, S> MulAssign<T> for Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S> MulAssign<T> for Matrix<T, R, C, S>
source§fn mul_assign(&mut self, rhs: T)
fn mul_assign(&mut self, rhs: T)
*=
operation. Read moresource§impl<T, R, R2, C, C2, S, S2> PartialEq<Matrix<T, R2, C2, S2>> for Matrix<T, R, C, S>where
T: PartialEq,
C: Dim,
C2: Dim,
R: Dim,
R2: Dim,
S: RawStorage<T, R, C>,
S2: RawStorage<T, R2, C2>,
impl<T, R, R2, C, C2, S, S2> PartialEq<Matrix<T, R2, C2, S2>> for Matrix<T, R, C, S>where
T: PartialEq,
C: Dim,
C2: Dim,
R: Dim,
R2: Dim,
S: RawStorage<T, R, C>,
S2: RawStorage<T, R2, C2>,
source§impl<T, R: Dim, C: Dim, S> PartialOrd for Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S> PartialOrd for Matrix<T, R, C, S>
source§impl<'a, T, D: DimName> Product<&'a Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>> for OMatrix<T, D, D>where
T: Scalar + Zero + One + ClosedMulAssign + ClosedAddAssign,
DefaultAllocator: Allocator<D, D>,
impl<'a, T, D: DimName> Product<&'a Matrix<T, D, D, <DefaultAllocator as Allocator<D, D>>::Buffer<T>>> for OMatrix<T, D, D>where
T: Scalar + Zero + One + ClosedMulAssign + ClosedAddAssign,
DefaultAllocator: Allocator<D, D>,
source§impl<T, R: Dim, C: Dim, S> RelativeEq for Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S> RelativeEq for Matrix<T, R, C, S>
source§fn default_max_relative() -> Self::Epsilon
fn default_max_relative() -> Self::Epsilon
source§fn relative_eq(
&self,
other: &Self,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon ) -> bool
source§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
RelativeEq::relative_eq
.source§impl<'a, 'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
impl<'a, 'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
source§impl<'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
impl<'b, T, D1, D2, SB> Sub<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
source§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 + ClosedSubAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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 + ClosedSubAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
-
operator.source§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 + ClosedSubAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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 + ClosedSubAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
-
operator.source§impl<'a, T, D1, D2, SB> Sub<Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
impl<'a, T, D1, D2, SB> Sub<Matrix<T, D2, Const<1>, SB>> for &'a OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
source§impl<T, D1, D2, SB> Sub<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
impl<T, D1, D2, SB> Sub<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
ShapeConstraint: SameNumberOfRows<D1, D2, Representative = D1> + SameNumberOfColumns<U1, U1, Representative = U1>,
D1: DimName,
D2: Dim,
SB: Storage<T, D2>,
DefaultAllocator: Allocator<D1>,
source§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 + ClosedSubAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + 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 + ClosedSubAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R2, C2, R1, C1>,
ShapeConstraint: SameNumberOfRows<R2, R1> + SameNumberOfColumns<C2, C1>,
§type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer<T>>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R2, R1>>::Representative, <ShapeConstraint as SameNumberOfColumns<C2, C1>>::Representative>>::Buffer<T>>
-
operator.source§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 + ClosedSubAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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 + ClosedSubAssign,
SA: Storage<T, R1, C1>,
SB: Storage<T, R2, C2>,
DefaultAllocator: SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
§type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
type Output = Matrix<T, <ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative, <DefaultAllocator as Allocator<<ShapeConstraint as SameNumberOfRows<R1, R2>>::Representative, <ShapeConstraint as SameNumberOfColumns<C1, C2>>::Representative>>::Buffer<T>>
-
operator.source§impl<'b, T, D1: DimName, D2: Dim, SB> SubAssign<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
SB: Storage<T, D2>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
DefaultAllocator: Allocator<D1>,
impl<'b, T, D1: DimName, D2: Dim, SB> SubAssign<&'b Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
SB: Storage<T, D2>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
DefaultAllocator: Allocator<D1>,
source§fn sub_assign(&mut self, right: &'b Vector<T, D2, SB>)
fn sub_assign(&mut self, right: &'b Vector<T, D2, SB>)
-=
operation. Read moresource§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 + ClosedSubAssign,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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 + ClosedSubAssign,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
source§fn sub_assign(&mut self, rhs: &'b Matrix<T, R2, C2, SB>)
fn sub_assign(&mut self, rhs: &'b Matrix<T, R2, C2, SB>)
-=
operation. Read moresource§impl<T, D1: DimName, D2: Dim, SB> SubAssign<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
SB: Storage<T, D2>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
DefaultAllocator: Allocator<D1>,
impl<T, D1: DimName, D2: Dim, SB> SubAssign<Matrix<T, D2, Const<1>, SB>> for OPoint<T, D1>where
T: Scalar + ClosedSubAssign,
SB: Storage<T, D2>,
ShapeConstraint: SameNumberOfRows<D1, D2>,
DefaultAllocator: Allocator<D1>,
source§fn sub_assign(&mut self, right: Vector<T, D2, SB>)
fn sub_assign(&mut self, right: Vector<T, D2, SB>)
-=
operation. Read moresource§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 + ClosedSubAssign,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + 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 + ClosedSubAssign,
SA: StorageMut<T, R1, C1>,
SB: Storage<T, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
source§fn sub_assign(&mut self, rhs: Matrix<T, R2, C2, SB>)
fn sub_assign(&mut self, rhs: Matrix<T, R2, C2, SB>)
-=
operation. Read moresource§impl<T1, T2, R, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Isometry<T1, R, D>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
R: AbstractRotation<T1, D> + SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>> + SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>,
DefaultAllocator: Allocator<Const<D>, Const<1>, Buffer<T1> = ArrayStorage<T1, D, 1>> + Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
impl<T1, T2, R, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Isometry<T1, R, D>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
R: AbstractRotation<T1, D> + SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>> + SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>,
DefaultAllocator: Allocator<Const<D>, Const<1>, Buffer<T1> = ArrayStorage<T1, D, 1>> + Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
source§fn to_superset(
&self
) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
fn to_superset( &self ) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
self
to the equivalent element of its superset.source§fn is_in_subset(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> bool
fn is_in_subset( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> Self
fn from_superset_unchecked( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Rotation<T1, D>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>,
DefaultAllocator: Allocator<Const<D>, Const<D>, Buffer<T1> = ArrayStorage<T1, D, D>> + Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Rotation<T1, D>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>,
DefaultAllocator: Allocator<Const<D>, Const<D>, Buffer<T1> = ArrayStorage<T1, D, D>> + Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
source§fn to_superset(
&self
) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
fn to_superset( &self ) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
self
to the equivalent element of its superset.source§fn is_in_subset(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> bool
fn is_in_subset( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> Self
fn from_superset_unchecked( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Scale<T1, D>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<DimNameSum<Const<D>, U1>, U1>,
impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Scale<T1, D>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<DimNameSum<Const<D>, U1>, U1>,
source§fn to_superset(
&self
) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
fn to_superset( &self ) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
self
to the equivalent element of its superset.source§fn is_in_subset(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> bool
fn is_in_subset( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> Self
fn from_superset_unchecked( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<T1, T2, R, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Similarity<T1, R, D>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
R: AbstractRotation<T1, D> + SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>> + SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>,
DefaultAllocator: Allocator<Const<D>, Const<1>, Buffer<T1> = ArrayStorage<T1, D, 1>> + Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
impl<T1, T2, R, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Similarity<T1, R, D>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
R: AbstractRotation<T1, D> + SubsetOf<OMatrix<T1, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>> + SubsetOf<OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>>,
Const<D>: DimNameAdd<U1> + DimMin<Const<D>, Output = Const<D>>,
DefaultAllocator: Allocator<Const<D>, Const<1>, Buffer<T1> = ArrayStorage<T1, D, 1>> + Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
source§fn to_superset(
&self
) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
fn to_superset( &self ) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
self
to the equivalent element of its superset.source§fn is_in_subset(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> bool
fn is_in_subset( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> Self
fn from_superset_unchecked( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<T1, T2, C, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Transform<T1, C, D>where
T1: RealField + SubsetOf<T2>,
T2: RealField,
C: TCategory,
Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
T1::Epsilon: Copy,
T2::Epsilon: Copy,
impl<T1, T2, C, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Transform<T1, C, D>where
T1: RealField + SubsetOf<T2>,
T2: RealField,
C: TCategory,
Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
T1::Epsilon: Copy,
T2::Epsilon: Copy,
source§fn to_superset(
&self
) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
fn to_superset( &self ) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
self
to the equivalent element of its superset.source§fn is_in_subset(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> bool
fn is_in_subset( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> Self
fn from_superset_unchecked( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Translation<T1, D>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<Const<D>, Buffer<T1> = ArrayStorage<T1, D, 1>> + Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
impl<T1, T2, const D: usize> SubsetOf<Matrix<T2, <Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output, <DefaultAllocator as Allocator<<Const<D> as DimNameAdd<Const<1>>>::Output, <Const<D> as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for Translation<T1, D>where
T1: RealField,
T2: RealField + SupersetOf<T1>,
Const<D>: DimNameAdd<U1>,
DefaultAllocator: Allocator<Const<D>, Buffer<T1> = ArrayStorage<T1, D, 1>> + Allocator<DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
source§fn to_superset(
&self
) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
fn to_superset( &self ) -> OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
self
to the equivalent element of its superset.source§fn is_in_subset(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> bool
fn is_in_subset( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(
m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
) -> Self
fn from_superset_unchecked( m: &OMatrix<T2, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> ) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<T1, T2, D> SubsetOf<Matrix<T2, <D as DimNameAdd<Const<1>>>::Output, Const<1>, <DefaultAllocator as Allocator<<D as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for OPoint<T1, D>where
D: DimNameAdd<U1>,
T1: Scalar,
T2: Scalar + Zero + One + ClosedDivAssign + SupersetOf<T1>,
DefaultAllocator: Allocator<D> + Allocator<DimNameSum<D, U1>>,
impl<T1, T2, D> SubsetOf<Matrix<T2, <D as DimNameAdd<Const<1>>>::Output, Const<1>, <DefaultAllocator as Allocator<<D as DimNameAdd<Const<1>>>::Output>>::Buffer<T2>>> for OPoint<T1, D>where
D: DimNameAdd<U1>,
T1: Scalar,
T2: Scalar + Zero + One + ClosedDivAssign + SupersetOf<T1>,
DefaultAllocator: Allocator<D> + Allocator<DimNameSum<D, U1>>,
source§fn to_superset(&self) -> OVector<T2, DimNameSum<D, U1>>
fn to_superset(&self) -> OVector<T2, DimNameSum<D, U1>>
self
to the equivalent element of its superset.source§fn is_in_subset(v: &OVector<T2, DimNameSum<D, U1>>) -> bool
fn is_in_subset(v: &OVector<T2, DimNameSum<D, U1>>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(v: &OVector<T2, DimNameSum<D, U1>>) -> Self
fn from_superset_unchecked(v: &OVector<T2, DimNameSum<D, U1>>) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<T1: RealField, T2: RealField + SupersetOf<T1>> SubsetOf<Matrix<T2, Const<3>, Const<3>, ArrayStorage<T2, 3, 3>>> for UnitComplex<T1>
impl<T1: RealField, T2: RealField + SupersetOf<T1>> SubsetOf<Matrix<T2, Const<3>, Const<3>, ArrayStorage<T2, 3, 3>>> for UnitComplex<T1>
source§fn to_superset(&self) -> Matrix3<T2>
fn to_superset(&self) -> Matrix3<T2>
self
to the equivalent element of its superset.source§fn is_in_subset(m: &Matrix3<T2>) -> bool
fn is_in_subset(m: &Matrix3<T2>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(m: &Matrix3<T2>) -> Self
fn from_superset_unchecked(m: &Matrix3<T2>) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<T1: RealField, T2: RealField + SupersetOf<T1>> SubsetOf<Matrix<T2, Const<4>, Const<4>, ArrayStorage<T2, 4, 4>>> for UnitDualQuaternion<T1>
impl<T1: RealField, T2: RealField + SupersetOf<T1>> SubsetOf<Matrix<T2, Const<4>, Const<4>, ArrayStorage<T2, 4, 4>>> for UnitDualQuaternion<T1>
source§fn to_superset(&self) -> Matrix4<T2>
fn to_superset(&self) -> Matrix4<T2>
self
to the equivalent element of its superset.source§fn is_in_subset(m: &Matrix4<T2>) -> bool
fn is_in_subset(m: &Matrix4<T2>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(m: &Matrix4<T2>) -> Self
fn from_superset_unchecked(m: &Matrix4<T2>) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<T1: RealField, T2: RealField + SupersetOf<T1>> SubsetOf<Matrix<T2, Const<4>, Const<4>, ArrayStorage<T2, 4, 4>>> for UnitQuaternion<T1>
impl<T1: RealField, T2: RealField + SupersetOf<T1>> SubsetOf<Matrix<T2, Const<4>, Const<4>, ArrayStorage<T2, 4, 4>>> for UnitQuaternion<T1>
source§fn to_superset(&self) -> Matrix4<T2>
fn to_superset(&self) -> Matrix4<T2>
self
to the equivalent element of its superset.source§fn is_in_subset(m: &Matrix4<T2>) -> bool
fn is_in_subset(m: &Matrix4<T2>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(m: &Matrix4<T2>) -> Self
fn from_superset_unchecked(m: &Matrix4<T2>) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<T1, T2, R1, C1, R2, C2> SubsetOf<Matrix<T2, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T2>>> for OMatrix<T1, R1, C1>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T1: Scalar,
T2: Scalar + SupersetOf<T1>,
DefaultAllocator: Allocator<R2, C2> + Allocator<R1, C1> + SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
impl<T1, T2, R1, C1, R2, C2> SubsetOf<Matrix<T2, R2, C2, <DefaultAllocator as Allocator<R2, C2>>::Buffer<T2>>> for OMatrix<T1, R1, C1>where
R1: Dim,
C1: Dim,
R2: Dim,
C2: Dim,
T1: Scalar,
T2: Scalar + SupersetOf<T1>,
DefaultAllocator: Allocator<R2, C2> + Allocator<R1, C1> + SameShapeAllocator<R1, C1, R2, C2>,
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>,
source§fn to_superset(&self) -> OMatrix<T2, R2, C2>
fn to_superset(&self) -> OMatrix<T2, R2, C2>
self
to the equivalent element of its superset.source§fn is_in_subset(m: &OMatrix<T2, R2, C2>) -> bool
fn is_in_subset(m: &OMatrix<T2, R2, C2>) -> bool
element
is actually part of the subset Self
(and can be converted to it).source§fn from_superset_unchecked(m: &OMatrix<T2, R2, C2>) -> Self
fn from_superset_unchecked(m: &OMatrix<T2, R2, C2>) -> Self
self.to_superset
but without any property checks. Always succeeds.source§impl<'a, T, C: Dim> Sum<&'a Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>> for OMatrix<T, Dyn, C>
impl<'a, T, C: Dim> Sum<&'a Matrix<T, Dyn, C, <DefaultAllocator as Allocator<Dyn, C>>::Buffer<T>>> for OMatrix<T, Dyn, C>
source§impl<'a, T, R: DimName, C: DimName> Sum<&'a Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>> for OMatrix<T, R, C>
impl<'a, T, R: DimName, C: DimName> Sum<&'a Matrix<T, R, C, <DefaultAllocator as Allocator<R, C>>::Buffer<T>>> for OMatrix<T, R, C>
source§impl<T, R: Dim, C: Dim, S> UlpsEq for Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S> UlpsEq for Matrix<T, R, C, S>
impl<T: Copy, R: Copy, C: Copy, S: Copy> Copy for Matrix<T, R, C, S>
impl<T, R: Dim, C: Dim, S> Eq for Matrix<T, R, C, S>where
T: Eq,
S: RawStorage<T, R, C>,
Auto Trait Implementations§
impl<T, R, C, S> Freeze for Matrix<T, R, C, S>where
S: Freeze,
impl<T, R, C, S> RefUnwindSafe for Matrix<T, R, C, S>
impl<T, R, C, S> Send for Matrix<T, R, C, S>
impl<T, R, C, S> Sync for Matrix<T, R, C, S>
impl<T, R, C, S> Unpin for Matrix<T, R, C, S>
impl<T, R, C, S> UnwindSafe for Matrix<T, R, C, S>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> LowerBounded for Twhere
T: Bounded,
impl<T> LowerBounded for Twhere
T: Bounded,
source§impl<T> SimdPartialOrd for T
impl<T> SimdPartialOrd for T
source§fn simd_ge(self, other: T) -> <T as SimdValue>::SimdBool
fn simd_ge(self, other: T) -> <T as SimdValue>::SimdBool
>=
comparison.source§fn simd_le(self, other: T) -> <T as SimdValue>::SimdBool
fn simd_le(self, other: T) -> <T as SimdValue>::SimdBool
<=
comparison.source§fn simd_clamp(self, min: T, max: T) -> T
fn simd_clamp(self, min: T, max: T) -> T
self
between the corresponding lane of min
and max
.source§fn simd_horizontal_min(self) -> <T as SimdValue>::Element
fn simd_horizontal_min(self) -> <T as SimdValue>::Element
self
.source§fn simd_horizontal_max(self) -> <T as SimdValue>::Element
fn simd_horizontal_max(self) -> <T as SimdValue>::Element
self
.source§impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
impl<SS, SP> SupersetOf<SS> for SPwhere
SS: SubsetOf<SP>,
source§fn to_subset(&self) -> Option<SS>
fn to_subset(&self) -> Option<SS>
self
from the equivalent element of its
superset. Read moresource§fn is_in_subset(&self) -> bool
fn is_in_subset(&self) -> bool
self
is actually part of its subset T
(and can be converted to it).source§fn to_subset_unchecked(&self) -> SS
fn to_subset_unchecked(&self) -> SS
self.to_subset
but without any property checks. Always succeeds.source§fn from_subset(element: &SS) -> SP
fn from_subset(element: &SS) -> SP
self
to the equivalent element of its superset.