Use explicit storage names in matrix aliases.
This commit is contained in:
Crozet Sébastien
parent
bc7db9d139
commit
5a1dbfe37d
|
|
@ -4,7 +4,7 @@ use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
|
|||
use crate::base::storage::Owned;
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
use crate::base::vec_storage::VecStorage;
|
||||
use crate::base::{Const, Matrix, Unit};
|
||||
use crate::base::{ArrayStorage, Const, Matrix, Unit};
|
||||
|
||||
/*
|
||||
*
|
||||
|
|
@ -31,230 +31,230 @@ pub type MatrixMN<T, R, C> = Matrix<T, R, C, Owned<T, R, C>>;
|
|||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type SMatrix<T, const R: usize, const C: usize> =
|
||||
Matrix<T, Const<R>, Const<C>, Owned<T, Const<R>, Const<C>>>;
|
||||
Matrix<T, Const<R>, Const<C>, ArrayStorage<T, R, C>>;
|
||||
|
||||
/// A dynamically sized column-major matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type DMatrix<T> = Matrix<T, Dynamic, Dynamic, Owned<T, Dynamic, Dynamic>>;
|
||||
pub type DMatrix<T> = Matrix<T, Dynamic, Dynamic, VecStorage<T, Dynamic, Dynamic>>;
|
||||
|
||||
/// A heap-allocated, column-major, matrix with a dynamic number of rows and 1 columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type MatrixXx1<T> = Matrix<T, Dynamic, U1, Owned<T, Dynamic, U1>>;
|
||||
pub type MatrixXx1<T> = Matrix<T, Dynamic, U1, VecStorage<T, Dynamic, U1>>;
|
||||
/// A heap-allocated, column-major, matrix with a dynamic number of rows and 2 columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type MatrixXx2<T> = Matrix<T, Dynamic, U2, Owned<T, Dynamic, U2>>;
|
||||
pub type MatrixXx2<T> = Matrix<T, Dynamic, U2, VecStorage<T, Dynamic, U2>>;
|
||||
/// A heap-allocated, column-major, matrix with a dynamic number of rows and 3 columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type MatrixXx3<T> = Matrix<T, Dynamic, U3, Owned<T, Dynamic, U3>>;
|
||||
pub type MatrixXx3<T> = Matrix<T, Dynamic, U3, VecStorage<T, Dynamic, U3>>;
|
||||
/// A heap-allocated, column-major, matrix with a dynamic number of rows and 4 columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type MatrixXx4<T> = Matrix<T, Dynamic, U4, Owned<T, Dynamic, U4>>;
|
||||
pub type MatrixXx4<T> = Matrix<T, Dynamic, U4, VecStorage<T, Dynamic, U4>>;
|
||||
/// A heap-allocated, column-major, matrix with a dynamic number of rows and 5 columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type MatrixXx5<T> = Matrix<T, Dynamic, U5, Owned<T, Dynamic, U5>>;
|
||||
pub type MatrixXx5<T> = Matrix<T, Dynamic, U5, VecStorage<T, Dynamic, U5>>;
|
||||
/// A heap-allocated, column-major, matrix with a dynamic number of rows and 6 columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type MatrixXx6<T> = Matrix<T, Dynamic, U6, Owned<T, Dynamic, U6>>;
|
||||
pub type MatrixXx6<T> = Matrix<T, Dynamic, U6, VecStorage<T, Dynamic, U6>>;
|
||||
|
||||
/// A heap-allocated, row-major, matrix with 1 rows and a dynamic number of columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type Matrix1xX<T> = Matrix<T, U1, Dynamic, Owned<T, U1, Dynamic>>;
|
||||
pub type Matrix1xX<T> = Matrix<T, U1, Dynamic, VecStorage<T, U1, Dynamic>>;
|
||||
/// A heap-allocated, row-major, matrix with 2 rows and a dynamic number of columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type Matrix2xX<T> = Matrix<T, U2, Dynamic, Owned<T, U2, Dynamic>>;
|
||||
pub type Matrix2xX<T> = Matrix<T, U2, Dynamic, VecStorage<T, U2, Dynamic>>;
|
||||
/// A heap-allocated, row-major, matrix with 3 rows and a dynamic number of columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type Matrix3xX<T> = Matrix<T, U3, Dynamic, Owned<T, U3, Dynamic>>;
|
||||
pub type Matrix3xX<T> = Matrix<T, U3, Dynamic, VecStorage<T, U3, Dynamic>>;
|
||||
/// A heap-allocated, row-major, matrix with 4 rows and a dynamic number of columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type Matrix4xX<T> = Matrix<T, U4, Dynamic, Owned<T, U4, Dynamic>>;
|
||||
pub type Matrix4xX<T> = Matrix<T, U4, Dynamic, VecStorage<T, U4, Dynamic>>;
|
||||
/// A heap-allocated, row-major, matrix with 5 rows and a dynamic number of columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type Matrix5xX<T> = Matrix<T, U5, Dynamic, Owned<T, U5, Dynamic>>;
|
||||
pub type Matrix5xX<T> = Matrix<T, U5, Dynamic, VecStorage<T, U5, Dynamic>>;
|
||||
/// A heap-allocated, row-major, matrix with 6 rows and a dynamic number of columns.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub type Matrix6xX<T> = Matrix<T, U6, Dynamic, Owned<T, U6, Dynamic>>;
|
||||
pub type Matrix6xX<T> = Matrix<T, U6, Dynamic, VecStorage<T, U6, Dynamic>>;
|
||||
|
||||
/// A stack-allocated, column-major, 1x1 square matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix1<T> = Matrix<T, U1, U1, Owned<T, U1, U1>>;
|
||||
pub type Matrix1<T> = Matrix<T, U1, U1, ArrayStorage<T, 1, 1>>;
|
||||
/// A stack-allocated, column-major, 2x2 square matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix2<T> = Matrix<T, U2, U2, Owned<T, U2, U2>>;
|
||||
pub type Matrix2<T> = Matrix<T, U2, U2, ArrayStorage<T, 2, 2>>;
|
||||
/// A stack-allocated, column-major, 3x3 square matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix3<T> = Matrix<T, U3, U3, Owned<T, U3, U3>>;
|
||||
pub type Matrix3<T> = Matrix<T, U3, U3, ArrayStorage<T, 3, 3>>;
|
||||
/// A stack-allocated, column-major, 4x4 square matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix4<T> = Matrix<T, U4, U4, Owned<T, U4, U4>>;
|
||||
pub type Matrix4<T> = Matrix<T, U4, U4, ArrayStorage<T, 4, 4>>;
|
||||
/// A stack-allocated, column-major, 5x5 square matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix5<T> = Matrix<T, U5, U5, Owned<T, U5, U5>>;
|
||||
pub type Matrix5<T> = Matrix<T, U5, U5, ArrayStorage<T, 5, 5>>;
|
||||
/// A stack-allocated, column-major, 6x6 square matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix6<T> = Matrix<T, U6, U6, Owned<T, U6, U6>>;
|
||||
pub type Matrix6<T> = Matrix<T, U6, U6, ArrayStorage<T, 6, 6>>;
|
||||
|
||||
/// A stack-allocated, column-major, 1x2 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix1x2<T> = Matrix<T, U1, U2, Owned<T, U1, U2>>;
|
||||
pub type Matrix1x2<T> = Matrix<T, U1, U2, ArrayStorage<T, 1, 2>>;
|
||||
/// A stack-allocated, column-major, 1x3 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix1x3<T> = Matrix<T, U1, U3, Owned<T, U1, U3>>;
|
||||
pub type Matrix1x3<T> = Matrix<T, U1, U3, ArrayStorage<T, 1, 3>>;
|
||||
/// A stack-allocated, column-major, 1x4 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix1x4<T> = Matrix<T, U1, U4, Owned<T, U1, U4>>;
|
||||
pub type Matrix1x4<T> = Matrix<T, U1, U4, ArrayStorage<T, 1, 4>>;
|
||||
/// A stack-allocated, column-major, 1x5 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix1x5<T> = Matrix<T, U1, U5, Owned<T, U1, U5>>;
|
||||
pub type Matrix1x5<T> = Matrix<T, U1, U5, ArrayStorage<T, 1, 5>>;
|
||||
/// A stack-allocated, column-major, 1x6 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix1x6<T> = Matrix<T, U1, U6, Owned<T, U1, U6>>;
|
||||
pub type Matrix1x6<T> = Matrix<T, U1, U6, ArrayStorage<T, 1, 6>>;
|
||||
|
||||
/// A stack-allocated, column-major, 2x3 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix2x3<T> = Matrix<T, U2, U3, Owned<T, U2, U3>>;
|
||||
pub type Matrix2x3<T> = Matrix<T, U2, U3, ArrayStorage<T, 2, 3>>;
|
||||
/// A stack-allocated, column-major, 2x4 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix2x4<T> = Matrix<T, U2, U4, Owned<T, U2, U4>>;
|
||||
pub type Matrix2x4<T> = Matrix<T, U2, U4, ArrayStorage<T, 2, 4>>;
|
||||
/// A stack-allocated, column-major, 2x5 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix2x5<T> = Matrix<T, U2, U5, Owned<T, U2, U5>>;
|
||||
pub type Matrix2x5<T> = Matrix<T, U2, U5, ArrayStorage<T, 2, 5>>;
|
||||
/// A stack-allocated, column-major, 2x6 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix2x6<T> = Matrix<T, U2, U6, Owned<T, U2, U6>>;
|
||||
pub type Matrix2x6<T> = Matrix<T, U2, U6, ArrayStorage<T, 2, 6>>;
|
||||
|
||||
/// A stack-allocated, column-major, 3x4 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix3x4<T> = Matrix<T, U3, U4, Owned<T, U3, U4>>;
|
||||
pub type Matrix3x4<T> = Matrix<T, U3, U4, ArrayStorage<T, 3, 4>>;
|
||||
/// A stack-allocated, column-major, 3x5 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix3x5<T> = Matrix<T, U3, U5, Owned<T, U3, U5>>;
|
||||
pub type Matrix3x5<T> = Matrix<T, U3, U5, ArrayStorage<T, 3, 5>>;
|
||||
/// A stack-allocated, column-major, 3x6 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix3x6<T> = Matrix<T, U3, U6, Owned<T, U3, U6>>;
|
||||
pub type Matrix3x6<T> = Matrix<T, U3, U6, ArrayStorage<T, 3, 6>>;
|
||||
|
||||
/// A stack-allocated, column-major, 4x5 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix4x5<T> = Matrix<T, U4, U5, Owned<T, U4, U5>>;
|
||||
pub type Matrix4x5<T> = Matrix<T, U4, U5, ArrayStorage<T, 4, 5>>;
|
||||
/// A stack-allocated, column-major, 4x6 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix4x6<T> = Matrix<T, U4, U6, Owned<T, U4, U6>>;
|
||||
pub type Matrix4x6<T> = Matrix<T, U4, U6, ArrayStorage<T, 4, 6>>;
|
||||
|
||||
/// A stack-allocated, column-major, 5x6 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix5x6<T> = Matrix<T, U5, U6, Owned<T, U5, U6>>;
|
||||
pub type Matrix5x6<T> = Matrix<T, U5, U6, ArrayStorage<T, 5, 6>>;
|
||||
|
||||
/// A stack-allocated, column-major, 2x1 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix2x1<T> = Matrix<T, U2, U1, Owned<T, U2, U1>>;
|
||||
pub type Matrix2x1<T> = Matrix<T, U2, U1, ArrayStorage<T, 2, 1>>;
|
||||
/// A stack-allocated, column-major, 3x1 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix3x1<T> = Matrix<T, U3, U1, Owned<T, U3, U1>>;
|
||||
pub type Matrix3x1<T> = Matrix<T, U3, U1, ArrayStorage<T, 3, 1>>;
|
||||
/// A stack-allocated, column-major, 4x1 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix4x1<T> = Matrix<T, U4, U1, Owned<T, U4, U1>>;
|
||||
pub type Matrix4x1<T> = Matrix<T, U4, U1, ArrayStorage<T, 4, 1>>;
|
||||
/// A stack-allocated, column-major, 5x1 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix5x1<T> = Matrix<T, U5, U1, Owned<T, U5, U1>>;
|
||||
pub type Matrix5x1<T> = Matrix<T, U5, U1, ArrayStorage<T, 5, 1>>;
|
||||
/// A stack-allocated, column-major, 6x1 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix6x1<T> = Matrix<T, U6, U1, Owned<T, U6, U1>>;
|
||||
pub type Matrix6x1<T> = Matrix<T, U6, U1, ArrayStorage<T, 6, 1>>;
|
||||
|
||||
/// A stack-allocated, column-major, 3x2 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix3x2<T> = Matrix<T, U3, U2, Owned<T, U3, U2>>;
|
||||
pub type Matrix3x2<T> = Matrix<T, U3, U2, ArrayStorage<T, 3, 2>>;
|
||||
/// A stack-allocated, column-major, 4x2 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix4x2<T> = Matrix<T, U4, U2, Owned<T, U4, U2>>;
|
||||
pub type Matrix4x2<T> = Matrix<T, U4, U2, ArrayStorage<T, 4, 2>>;
|
||||
/// A stack-allocated, column-major, 5x2 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix5x2<T> = Matrix<T, U5, U2, Owned<T, U5, U2>>;
|
||||
pub type Matrix5x2<T> = Matrix<T, U5, U2, ArrayStorage<T, 5, 2>>;
|
||||
/// A stack-allocated, column-major, 6x2 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix6x2<T> = Matrix<T, U6, U2, Owned<T, U6, U2>>;
|
||||
pub type Matrix6x2<T> = Matrix<T, U6, U2, ArrayStorage<T, 6, 2>>;
|
||||
|
||||
/// A stack-allocated, column-major, 4x3 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix4x3<T> = Matrix<T, U4, U3, Owned<T, U4, U3>>;
|
||||
pub type Matrix4x3<T> = Matrix<T, U4, U3, ArrayStorage<T, 4, 3>>;
|
||||
/// A stack-allocated, column-major, 5x3 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix5x3<T> = Matrix<T, U5, U3, Owned<T, U5, U3>>;
|
||||
pub type Matrix5x3<T> = Matrix<T, U5, U3, ArrayStorage<T, 5, 3>>;
|
||||
/// A stack-allocated, column-major, 6x3 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix6x3<T> = Matrix<T, U6, U3, Owned<T, U6, U3>>;
|
||||
pub type Matrix6x3<T> = Matrix<T, U6, U3, ArrayStorage<T, 6, 3>>;
|
||||
|
||||
/// A stack-allocated, column-major, 5x4 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix5x4<T> = Matrix<T, U5, U4, Owned<T, U5, U4>>;
|
||||
pub type Matrix5x4<T> = Matrix<T, U5, U4, ArrayStorage<T, 5, 4>>;
|
||||
/// A stack-allocated, column-major, 6x4 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix6x4<T> = Matrix<T, U6, U4, Owned<T, U6, U4>>;
|
||||
pub type Matrix6x4<T> = Matrix<T, U6, U4, ArrayStorage<T, 6, 4>>;
|
||||
|
||||
/// A stack-allocated, column-major, 6x5 matrix.
|
||||
///
|
||||
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
|
||||
pub type Matrix6x5<T> = Matrix<T, U6, U5, Owned<T, U6, U5>>;
|
||||
pub type Matrix6x5<T> = Matrix<T, U6, U5, ArrayStorage<T, 6, 5>>;
|
||||
|
||||
/*
|
||||
*
|
||||
|
|
@ -270,7 +270,7 @@ pub type DVector<T> = Matrix<T, Dynamic, U1, VecStorage<T, Dynamic, U1>>;
|
|||
/// An owned D-dimensional column vector.
|
||||
pub type OVector<T, D> = Matrix<T, D, U1, Owned<T, D, U1>>;
|
||||
/// A statically sized D-dimensional column vector.
|
||||
pub type SVector<T, const D: usize> = Matrix<T, Const<D>, U1, Owned<T, Const<D>, U1>>;
|
||||
pub type SVector<T, const D: usize> = Matrix<T, Const<D>, U1, ArrayStorage<T, D, 1>>; // Owned<T, Const<D>, U1>>;
|
||||
|
||||
/// An owned matrix column-major matrix with `R` rows and `C` columns.
|
||||
///
|
||||
|
|
@ -278,20 +278,20 @@ pub type SVector<T, const D: usize> = Matrix<T, Const<D>, U1, Owned<T, Const<D>,
|
|||
#[deprecated(
|
||||
note = "use SVector for a statically-sized matrix using integer dimensions, or OVector for an owned matrix using types as dimensions."
|
||||
)]
|
||||
pub type VectorN<T, D> = Matrix<T, D, U1, Owned<T, D, U1>>;
|
||||
pub type VectorN<T, D> = Matrix<T, D, U1, VecStorage<T, D, U1>>;
|
||||
|
||||
/// A stack-allocated, 1-dimensional column vector.
|
||||
pub type Vector1<T> = Matrix<T, U1, U1, Owned<T, U1, U1>>;
|
||||
pub type Vector1<T> = Matrix<T, U1, U1, ArrayStorage<T, 1, 1>>;
|
||||
/// A stack-allocated, 2-dimensional column vector.
|
||||
pub type Vector2<T> = Matrix<T, U2, U1, Owned<T, U2, U1>>;
|
||||
pub type Vector2<T> = Matrix<T, U2, U1, ArrayStorage<T, 2, 1>>;
|
||||
/// A stack-allocated, 3-dimensional column vector.
|
||||
pub type Vector3<T> = Matrix<T, U3, U1, Owned<T, U3, U1>>;
|
||||
pub type Vector3<T> = Matrix<T, U3, U1, ArrayStorage<T, 3, 1>>;
|
||||
/// A stack-allocated, 4-dimensional column vector.
|
||||
pub type Vector4<T> = Matrix<T, U4, U1, Owned<T, U4, U1>>;
|
||||
pub type Vector4<T> = Matrix<T, U4, U1, ArrayStorage<T, 4, 1>>;
|
||||
/// A stack-allocated, 5-dimensional column vector.
|
||||
pub type Vector5<T> = Matrix<T, U5, U1, Owned<T, U5, U1>>;
|
||||
pub type Vector5<T> = Matrix<T, U5, U1, ArrayStorage<T, 5, 1>>;
|
||||
/// A stack-allocated, 6-dimensional column vector.
|
||||
pub type Vector6<T> = Matrix<T, U6, U1, Owned<T, U6, U1>>;
|
||||
pub type Vector6<T> = Matrix<T, U6, U1, ArrayStorage<T, 6, 1>>;
|
||||
|
||||
/*
|
||||
*
|
||||
|
|
@ -308,20 +308,20 @@ pub type RowDVector<T> = Matrix<T, U1, Dynamic, VecStorage<T, U1, Dynamic>>;
|
|||
pub type RowOVector<T, D> = Matrix<T, U1, D, Owned<T, U1, D>>;
|
||||
|
||||
/// A statically sized D-dimensional row vector.
|
||||
pub type RowSVector<T, const D: usize> = Matrix<T, U1, Const<D>, Owned<T, U1, Const<D>>>;
|
||||
pub type RowSVector<T, const D: usize> = Matrix<T, U1, Const<D>, ArrayStorage<T, 1, D>>;
|
||||
|
||||
/// A stack-allocated, 1-dimensional row vector.
|
||||
pub type RowVector1<T> = Matrix<T, U1, U1, Owned<T, U1, U1>>;
|
||||
pub type RowVector1<T> = Matrix<T, U1, U1, ArrayStorage<T, 1, 1>>;
|
||||
/// A stack-allocated, 2-dimensional row vector.
|
||||
pub type RowVector2<T> = Matrix<T, U1, U2, Owned<T, U1, U2>>;
|
||||
pub type RowVector2<T> = Matrix<T, U1, U2, ArrayStorage<T, 1, 2>>;
|
||||
/// A stack-allocated, 3-dimensional row vector.
|
||||
pub type RowVector3<T> = Matrix<T, U1, U3, Owned<T, U1, U3>>;
|
||||
pub type RowVector3<T> = Matrix<T, U1, U3, ArrayStorage<T, 1, 3>>;
|
||||
/// A stack-allocated, 4-dimensional row vector.
|
||||
pub type RowVector4<T> = Matrix<T, U1, U4, Owned<T, U1, U4>>;
|
||||
pub type RowVector4<T> = Matrix<T, U1, U4, ArrayStorage<T, 1, 4>>;
|
||||
/// A stack-allocated, 5-dimensional row vector.
|
||||
pub type RowVector5<T> = Matrix<T, U1, U5, Owned<T, U1, U5>>;
|
||||
pub type RowVector5<T> = Matrix<T, U1, U5, ArrayStorage<T, 1, 5>>;
|
||||
/// A stack-allocated, 6-dimensional row vector.
|
||||
pub type RowVector6<T> = Matrix<T, U1, U6, Owned<T, U1, U6>>;
|
||||
pub type RowVector6<T> = Matrix<T, U1, U6, ArrayStorage<T, 1, 6>>;
|
||||
|
||||
/*
|
||||
*
|
||||
|
|
@ -331,14 +331,14 @@ pub type RowVector6<T> = Matrix<T, U1, U6, Owned<T, U1, U6>>;
|
|||
*
|
||||
*/
|
||||
/// A stack-allocated, 1-dimensional unit vector.
|
||||
pub type UnitVector1<T> = Unit<Matrix<T, U1, U1, Owned<T, U1, U1>>>;
|
||||
pub type UnitVector1<T> = Unit<Matrix<T, U1, U1, ArrayStorage<T, 1, 1>>>;
|
||||
/// A stack-allocated, 2-dimensional unit vector.
|
||||
pub type UnitVector2<T> = Unit<Matrix<T, U2, U1, Owned<T, U2, U1>>>;
|
||||
pub type UnitVector2<T> = Unit<Matrix<T, U2, U1, ArrayStorage<T, 2, 1>>>;
|
||||
/// A stack-allocated, 3-dimensional unit vector.
|
||||
pub type UnitVector3<T> = Unit<Matrix<T, U3, U1, Owned<T, U3, U1>>>;
|
||||
pub type UnitVector3<T> = Unit<Matrix<T, U3, U1, ArrayStorage<T, 3, 1>>>;
|
||||
/// A stack-allocated, 4-dimensional unit vector.
|
||||
pub type UnitVector4<T> = Unit<Matrix<T, U4, U1, Owned<T, U4, U1>>>;
|
||||
pub type UnitVector4<T> = Unit<Matrix<T, U4, U1, ArrayStorage<T, 4, 1>>>;
|
||||
/// A stack-allocated, 5-dimensional unit vector.
|
||||
pub type UnitVector5<T> = Unit<Matrix<T, U5, U1, Owned<T, U5, U1>>>;
|
||||
pub type UnitVector5<T> = Unit<Matrix<T, U5, U1, ArrayStorage<T, 5, 1>>>;
|
||||
/// A stack-allocated, 6-dimensional unit vector.
|
||||
pub type UnitVector6<T> = Unit<Matrix<T, U6, U1, Owned<T, U6, U1>>>;
|
||||
pub type UnitVector6<T> = Unit<Matrix<T, U6, U1, ArrayStorage<T, 6, 1>>>;
|
||||
|
|
|
|||
|
|
@ -12,9 +12,7 @@ use crate::base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, Shap
|
|||
use crate::base::dimension::Dynamic;
|
||||
use crate::base::dimension::{Const, Dim, DimAdd, DimDiff, DimMin, DimMinimum, DimSub, DimSum, U1};
|
||||
use crate::base::storage::{ReshapableStorage, Storage, StorageMut};
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
use crate::base::DMatrix;
|
||||
use crate::base::{DefaultAllocator, Matrix, OMatrix, RowVector, SMatrix, Scalar, Vector};
|
||||
use crate::base::{DefaultAllocator, Matrix, OMatrix, RowVector, Scalar, Vector};
|
||||
|
||||
/// # Rows and columns extraction
|
||||
impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
||||
|
|
@ -711,7 +709,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
|||
/// 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`.
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
pub fn resize(self, new_nrows: usize, new_ncols: usize, val: T) -> DMatrix<T>
|
||||
pub fn resize(self, new_nrows: usize, new_ncols: usize, val: T) -> OMatrix<T, Dynamic, Dynamic>
|
||||
where
|
||||
DefaultAllocator: Reallocator<T, R, C, Dynamic, Dynamic>,
|
||||
{
|
||||
|
|
@ -748,7 +746,10 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
|||
///
|
||||
/// The values are copied such that `self[(i, j)] == result[(i, j)]`. If the result has more
|
||||
/// rows and/or columns than `self`, then the extra rows or columns are filled with `val`.
|
||||
pub fn fixed_resize<const R2: usize, const C2: usize>(self, val: T) -> SMatrix<T, R2, C2>
|
||||
pub fn fixed_resize<const R2: usize, const C2: usize>(
|
||||
self,
|
||||
val: T,
|
||||
) -> OMatrix<T, Const<R2>, Const<C2>>
|
||||
where
|
||||
DefaultAllocator: Reallocator<T, R, C, Const<R2>, Const<C2>>,
|
||||
{
|
||||
|
|
@ -892,7 +893,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
|
|||
|
||||
/// # In-place resizing
|
||||
#[cfg(any(feature = "std", feature = "alloc"))]
|
||||
impl<T: Scalar> DMatrix<T> {
|
||||
impl<T: Scalar> OMatrix<T, Dynamic, Dynamic> {
|
||||
/// Resizes this matrix in-place.
|
||||
///
|
||||
/// The values are copied such that `self[(i, j)] == result[(i, j)]`. If the result has more
|
||||
|
|
|
|||
Loading…
Reference in New Issue