Sébastien Crozet
parent
830c19aeba
commit
df872f407d
|
|
@ -4,6 +4,15 @@ documented here.
|
|||
|
||||
This project adheres to [Semantic Versioning](http://semver.org/).
|
||||
|
||||
## [0.9.0]
|
||||
## Modified
|
||||
* Renamed:
|
||||
- `::from_col_vector` -> `::from_column_vector`
|
||||
- `::from_col_iter` -> `::from_column_iter`
|
||||
- `.col_slice` -> `.column_slice`
|
||||
- `.set_col` -> `.set_column`
|
||||
- `::canonical_basis_with_dim` -> `::canonical_basis_with_dimension`
|
||||
|
||||
## [0.8.0]
|
||||
## Modified
|
||||
* Almost everything (types, methods, and traits) now use full names instead
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ an optimized set of tools for computer graphics and physics. Those features incl
|
|||
* Square matrices with static sizes: `Matrix1`, `Matrix2`, `Matrix3`, `Matrix4`, `Matrix5`, `Matrix6 `.
|
||||
* Rotation matrices: `Rotation2`, `Rotation3`
|
||||
* Quaternions: `Quaternion`, `UnitQuaternion`.
|
||||
* Isometrymetries (translation ⨯ rotation): `Isometry2`, `Isometry3`
|
||||
* Isometries (translation ⨯ rotation): `Isometry2`, `Isometry3`
|
||||
* Similarity transformations (translation ⨯ rotation ⨯ uniform scale): `Similarity2`, `Similarity3`.
|
||||
* 3D projections for computer graphics: `Persp3`, `PerspMatrix3`, `Ortho3`, `OrthoMatrix3`.
|
||||
* Dynamically sized heap-allocated vector: `DVector`.
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ an optimized set of tools for computer graphics and physics. Those features incl
|
|||
* Square matrices with static sizes: `Matrix1`, `Matrix2`, `Matrix3`, `Matrix4`, `Matrix5`, `Matrix6 `.
|
||||
* Rotation matrices: `Rotation2`, `Rotation3`
|
||||
* Quaternions: `Quaternion`, `UnitQuaternion`.
|
||||
* Isometrymetries (translation ⨯ rotation): `Isometry2`, `Isometry3`
|
||||
* Isometries (translation ⨯ rotation): `Isometry2`, `Isometry3`
|
||||
* Similarity transformations (translation ⨯ rotation ⨯ uniform scale): `Similarity2`, `Similarity3`.
|
||||
* 3D projections for computer graphics: `Perspective3`, `PerspectiveMatrix3`, `Orthographic3`, `OrthographicMatrix3`.
|
||||
* Dynamically sized heap-allocated vector: `DVector`.
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ pub fn qr<N, V, M>(m: &M) -> (M, M)
|
|||
let mut r = *m;
|
||||
|
||||
for ite in 0 .. cmp::min(rows - 1, cols) {
|
||||
let mut v = r.col_slice(ite, ite, rows);
|
||||
let mut v = r.column_slice(ite, ite, rows);
|
||||
let alpha =
|
||||
if unsafe { v.unsafe_at(ite) } >= ::zero() {
|
||||
-Norm::norm(&v)
|
||||
|
|
@ -330,7 +330,7 @@ pub fn hessenberg<N, V, M>(m: &M) -> (M, M)
|
|||
}
|
||||
|
||||
for ite in 0 .. (cols - 2) {
|
||||
let mut v = h.col_slice(ite, ite + 1, rows);
|
||||
let mut v = h.column_slice(ite, ite + 1, rows);
|
||||
|
||||
let alpha = Norm::norm(&v);
|
||||
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ impl<N> DMatrix<N> {
|
|||
impl<N: Clone + Copy> DMatrix<N> {
|
||||
/// Builds a matrix filled with a given constant.
|
||||
#[inline]
|
||||
pub fn from_elem(nrows: usize, ncols: usize, val: N) -> DMatrix<N> {
|
||||
pub fn from_element(nrows: usize, ncols: usize, val: N) -> DMatrix<N> {
|
||||
DMatrix {
|
||||
nrows: nrows,
|
||||
ncols: ncols,
|
||||
|
|
@ -50,7 +50,7 @@ impl<N: Clone + Copy> DMatrix<N> {
|
|||
|
||||
/// Builds a matrix filled with the components provided by a vector.
|
||||
/// The vector contains the matrix data in row-major order.
|
||||
/// Note that `from_col_vector` is much faster than `from_row_vector` since a `DMatrix` stores its data
|
||||
/// Note that `from_column_vector` is much faster than `from_row_vector` since a `DMatrix` stores its data
|
||||
/// in column-major order.
|
||||
///
|
||||
/// The vector must have exactly `nrows * ncols` elements.
|
||||
|
|
@ -61,24 +61,24 @@ impl<N: Clone + Copy> DMatrix<N> {
|
|||
|
||||
/// Builds a matrix filled with the components provided by a vector.
|
||||
/// The vector contains the matrix data in column-major order.
|
||||
/// Note that `from_col_vector` is much faster than `from_row_vector` since a `DMatrix` stores its data
|
||||
/// Note that `from_column_vector` is much faster than `from_row_vector` since a `DMatrix` stores its data
|
||||
/// in column-major order.
|
||||
///
|
||||
/// The vector must have exactly `nrows * ncols` elements.
|
||||
#[inline]
|
||||
pub fn from_col_vector(nrows: usize, ncols: usize, vector: &[N]) -> DMatrix<N> {
|
||||
DMatrix::from_col_iter(nrows, ncols, vector.to_vec())
|
||||
pub fn from_column_vector(nrows: usize, ncols: usize, vector: &[N]) -> DMatrix<N> {
|
||||
DMatrix::from_column_iter(nrows, ncols, vector.to_vec())
|
||||
}
|
||||
|
||||
/// Builds a matrix filled with the components provided by a source that may be moved into an iterator.
|
||||
/// The source contains the matrix data in row-major order.
|
||||
/// Note that `from_col_iter` is much faster than `from_row_iter` since a `DMatrix` stores its data
|
||||
/// Note that `from_column_iter` is much faster than `from_row_iter` since a `DMatrix` stores its data
|
||||
/// in column-major order.
|
||||
///
|
||||
/// The source must have exactly `nrows * ncols` elements.
|
||||
#[inline]
|
||||
pub fn from_row_iter<I: IntoIterator<Item = N>>(nrows: usize, ncols: usize, param: I) -> DMatrix<N> {
|
||||
let mut res = DMatrix::from_col_iter(ncols, nrows, param);
|
||||
let mut res = DMatrix::from_column_iter(ncols, nrows, param);
|
||||
|
||||
// we transpose because the buffer is row_major
|
||||
res.transpose_mut();
|
||||
|
|
@ -89,12 +89,12 @@ impl<N: Clone + Copy> DMatrix<N> {
|
|||
|
||||
/// Builds a matrix filled with the components provided by a source that may be moved into an iterator.
|
||||
/// The source contains the matrix data in column-major order.
|
||||
/// Note that `from_col_iter` is much faster than `from_row_iter` since a `DMatrix` stores its data
|
||||
/// Note that `from_column_iter` is much faster than `from_row_iter` since a `DMatrix` stores its data
|
||||
/// in column-major order.
|
||||
///
|
||||
/// The source must have exactly `nrows * ncols` elements.
|
||||
#[inline]
|
||||
pub fn from_col_iter<I: IntoIterator<Item = N>>(nrows: usize, ncols: usize, param: I) -> DMatrix<N> {
|
||||
pub fn from_column_iter<I: IntoIterator<Item = N>>(nrows: usize, ncols: usize, param: I) -> DMatrix<N> {
|
||||
let mij: Vec<N> = param.into_iter().collect();
|
||||
|
||||
assert!(nrows * ncols == mij.len(), "The ammount of data provided does not matches the matrix size.");
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ macro_rules! dmat_impl(
|
|||
/// components.
|
||||
#[inline]
|
||||
pub fn new_zeros(nrows: usize, ncols: usize) -> $dmatrix<N> {
|
||||
$dmatrix::from_elem(nrows, ncols, ::zero())
|
||||
$dmatrix::from_element(nrows, ncols, ::zero())
|
||||
}
|
||||
|
||||
/// Tests if all components of the matrix are zeroes.
|
||||
|
|
@ -40,7 +40,7 @@ macro_rules! dmat_impl(
|
|||
/// Builds a matrix filled with a given constant.
|
||||
#[inline]
|
||||
pub fn new_ones(nrows: usize, ncols: usize) -> $dmatrix<N> {
|
||||
$dmatrix::from_elem(nrows, ncols, ::one())
|
||||
$dmatrix::from_element(nrows, ncols, ::one())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -745,35 +745,35 @@ macro_rules! dmat_impl(
|
|||
}
|
||||
|
||||
#[inline]
|
||||
fn set_col(&mut self, col_id: usize, column: $dvector<N>) {
|
||||
assert!(col_id < self.ncols);
|
||||
fn set_column(&mut self, column_id: usize, column: $dvector<N>) {
|
||||
assert!(column_id < self.ncols);
|
||||
assert!(column.len() == self.nrows);
|
||||
|
||||
for row_id in 0 .. self.nrows {
|
||||
unsafe {
|
||||
self.unsafe_set((row_id, col_id), column.unsafe_at(row_id));
|
||||
self.unsafe_set((row_id, column_id), column.unsafe_at(row_id));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn column(&self, col_id: usize) -> $dvector<N> {
|
||||
assert!(col_id < self.ncols);
|
||||
fn column(&self, column_id: usize) -> $dvector<N> {
|
||||
assert!(column_id < self.ncols);
|
||||
|
||||
let start = self.offset(0, col_id);
|
||||
let stop = self.offset(self.nrows, col_id);
|
||||
let start = self.offset(0, column_id);
|
||||
let stop = self.offset(self.nrows, column_id);
|
||||
$dvector::from_slice(self.nrows, &self.mij[start .. stop])
|
||||
}
|
||||
}
|
||||
|
||||
impl<N: Copy + Clone + Zero> ColumnSlice<$dvector<N>> for $dmatrix<N> {
|
||||
fn col_slice(&self, col_id :usize, row_start: usize, row_end: usize) -> $dvector<N> {
|
||||
assert!(col_id < self.ncols);
|
||||
fn column_slice(&self, column_id :usize, row_start: usize, row_end: usize) -> $dvector<N> {
|
||||
assert!(column_id < self.ncols);
|
||||
assert!(row_start < row_end);
|
||||
assert!(row_end <= self.nrows);
|
||||
|
||||
// We can init from slice thanks to the matrix being column-major.
|
||||
let start = self.offset(row_start, col_id);
|
||||
let stop = self.offset(row_end, col_id);
|
||||
let start = self.offset(row_start, column_id);
|
||||
let stop = self.offset(row_end, column_id);
|
||||
let slice = $dvector::from_slice(row_end - row_start, &self.mij[start .. stop]);
|
||||
|
||||
slice
|
||||
|
|
@ -791,9 +791,9 @@ macro_rules! dmat_impl(
|
|||
assert!(row_id < self.nrows);
|
||||
assert!(row.len() == self.ncols);
|
||||
|
||||
for col_id in 0 .. self.ncols {
|
||||
for column_id in 0 .. self.ncols {
|
||||
unsafe {
|
||||
self.unsafe_set((row_id, col_id), row.unsafe_at(col_id));
|
||||
self.unsafe_set((row_id, column_id), row.unsafe_at(column_id));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -806,9 +806,9 @@ macro_rules! dmat_impl(
|
|||
$dvector::new_uninitialized(self.ncols)
|
||||
};
|
||||
|
||||
for col_id in 0 .. self.ncols {
|
||||
for column_id in 0 .. self.ncols {
|
||||
unsafe {
|
||||
slice.unsafe_set(col_id, self.unsafe_at((row_id, col_id)));
|
||||
slice.unsafe_set(column_id, self.unsafe_at((row_id, column_id)));
|
||||
}
|
||||
}
|
||||
slice
|
||||
|
|
@ -816,18 +816,18 @@ macro_rules! dmat_impl(
|
|||
}
|
||||
|
||||
impl<N: Copy> RowSlice<$dvector<N>> for $dmatrix<N> {
|
||||
fn row_slice(&self, row_id :usize, col_start: usize, col_end: usize) -> $dvector<N> {
|
||||
fn row_slice(&self, row_id :usize, column_start: usize, column_end: usize) -> $dvector<N> {
|
||||
assert!(row_id < self.nrows);
|
||||
assert!(col_start < col_end);
|
||||
assert!(col_end <= self.ncols);
|
||||
assert!(column_start < column_end);
|
||||
assert!(column_end <= self.ncols);
|
||||
|
||||
let mut slice : $dvector<N> = unsafe {
|
||||
$dvector::new_uninitialized(col_end - col_start)
|
||||
$dvector::new_uninitialized(column_end - column_start)
|
||||
};
|
||||
let mut slice_idx = 0;
|
||||
for col_id in col_start .. col_end {
|
||||
for column_id in column_start .. column_end {
|
||||
unsafe {
|
||||
slice.unsafe_set(slice_idx, self.unsafe_at((row_id, col_id)));
|
||||
slice.unsafe_set(slice_idx, self.unsafe_at((row_id, column_id)));
|
||||
}
|
||||
slice_idx += 1;
|
||||
}
|
||||
|
|
@ -1083,7 +1083,7 @@ macro_rules! small_dmat_from_impl(
|
|||
impl<N: Zero + Clone + Copy> $dmatrix<N> {
|
||||
/// Builds a matrix filled with a given constant.
|
||||
#[inline]
|
||||
pub fn from_elem(nrows: usize, ncols: usize, elem: N) -> $dmatrix<N> {
|
||||
pub fn from_element(nrows: usize, ncols: usize, elem: N) -> $dmatrix<N> {
|
||||
assert!(nrows <= $dimension);
|
||||
assert!(ncols <= $dimension);
|
||||
|
||||
|
|
@ -1102,13 +1102,13 @@ macro_rules! small_dmat_from_impl(
|
|||
|
||||
/// Builds a matrix filled with the components provided by a vector.
|
||||
/// The vector contains the matrix data in row-major order.
|
||||
/// Note that `from_col_vector` is a lot faster than `from_row_vector` since a `$dmatrix` stores its data
|
||||
/// Note that `from_column_vector` is a lot faster than `from_row_vector` since a `$dmatrix` stores its data
|
||||
/// in column-major order.
|
||||
///
|
||||
/// The vector must have at least `nrows * ncols` elements.
|
||||
#[inline]
|
||||
pub fn from_row_vector(nrows: usize, ncols: usize, vector: &[N]) -> $dmatrix<N> {
|
||||
let mut res = $dmatrix::from_col_vector(ncols, nrows, vector);
|
||||
let mut res = $dmatrix::from_column_vector(ncols, nrows, vector);
|
||||
|
||||
// we transpose because the buffer is row_major
|
||||
res.transpose_mut();
|
||||
|
|
@ -1118,12 +1118,12 @@ macro_rules! small_dmat_from_impl(
|
|||
|
||||
/// Builds a matrix filled with the components provided by a vector.
|
||||
/// The vector contains the matrix data in column-major order.
|
||||
/// Note that `from_col_vector` is a lot faster than `from_row_vector` since a `$dmatrix` stores its data
|
||||
/// Note that `from_column_vector` is a lot faster than `from_row_vector` since a `$dmatrix` stores its data
|
||||
/// in column-major order.
|
||||
///
|
||||
/// The vector must have at least `nrows * ncols` elements.
|
||||
#[inline]
|
||||
pub fn from_col_vector(nrows: usize, ncols: usize, vector: &[N]) -> $dmatrix<N> {
|
||||
pub fn from_column_vector(nrows: usize, ncols: usize, vector: &[N]) -> $dmatrix<N> {
|
||||
assert!(nrows * ncols == vector.len());
|
||||
|
||||
let mut mij: [N; $dimension * $dimension] = [ $( $zeros, )* ];
|
||||
|
|
|
|||
|
|
@ -37,7 +37,7 @@ impl<N> DVector<N> {
|
|||
impl<N: Clone> DVector<N> {
|
||||
/// Builds a vector filled with a constant.
|
||||
#[inline]
|
||||
pub fn from_elem(dimension: usize, elem: N) -> DVector<N> {
|
||||
pub fn from_element(dimension: usize, elem: N) -> DVector<N> {
|
||||
DVector { at: repeat(elem).take(dimension).collect() }
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ macro_rules! dvec_impl(
|
|||
/// * `dimension` - The dimension of the vector.
|
||||
#[inline]
|
||||
pub fn new_zeros(dimension: usize) -> $dvector<N> {
|
||||
$dvector::from_elem(dimension, ::zero())
|
||||
$dvector::from_element(dimension, ::zero())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -22,7 +22,7 @@ macro_rules! dvec_impl(
|
|||
/// * `dimension` - The dimension of the vector.
|
||||
#[inline]
|
||||
pub fn new_ones(dimension: usize) -> $dvector<N> {
|
||||
$dvector::from_elem(dimension, ::one())
|
||||
$dvector::from_element(dimension, ::one())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -38,7 +38,7 @@ macro_rules! dvec_impl(
|
|||
/// Computes the canonical basis for the given dimension. A canonical basis is a set of
|
||||
/// vectors, mutually orthogonal, with all its component equal to 0.0 except one which is equal
|
||||
/// to 1.0.
|
||||
pub fn canonical_basis_with_dim(dimension: usize) -> Vec<$dvector<N>> {
|
||||
pub fn canonical_basis_with_dimension(dimension: usize) -> Vec<$dvector<N>> {
|
||||
let mut res : Vec<$dvector<N>> = Vec::new();
|
||||
|
||||
for i in 0 .. dimension {
|
||||
|
|
@ -151,7 +151,7 @@ macro_rules! small_dvec_from_impl (
|
|||
impl<N: Copy + Zero> $dvector<N> {
|
||||
/// Builds a vector filled with a constant.
|
||||
#[inline]
|
||||
pub fn from_elem(dimension: usize, elem: N) -> $dvector<N> {
|
||||
pub fn from_element(dimension: usize, elem: N) -> $dvector<N> {
|
||||
assert!(dimension <= $dimension);
|
||||
|
||||
let mut at: [N; $dimension] = [ $( $zeros, )* ];
|
||||
|
|
|
|||
|
|
@ -20,7 +20,7 @@ use quickcheck::{Arbitrary, Gen};
|
|||
///
|
||||
/// This is the composition of a rotation followed by a translation. Vectors `Vector2` are not
|
||||
/// affected by the translational component of this transformation while points `Point2` are.
|
||||
/// Isometrymetries conserve angles and distances, hence do not allow shearing nor scaling.
|
||||
/// Isometries conserve angles and distances, hence do not allow shearing nor scaling.
|
||||
#[repr(C)]
|
||||
#[derive(Eq, PartialEq, RustcEncodable, RustcDecodable, Clone, Debug, Copy)]
|
||||
pub struct Isometry2<N> {
|
||||
|
|
@ -34,7 +34,7 @@ pub struct Isometry2<N> {
|
|||
///
|
||||
/// This is the composition of a rotation followed by a translation. Vectors `Vector3` are not
|
||||
/// affected by the translational component of this transformation while points `Point3` are.
|
||||
/// Isometrymetries conserve angles and distances, hence do not allow shearing nor scaling.
|
||||
/// Isometries conserve angles and distances, hence do not allow shearing nor scaling.
|
||||
#[repr(C)]
|
||||
#[derive(Eq, PartialEq, RustcEncodable, RustcDecodable, Clone, Debug, Copy)]
|
||||
pub struct Isometry3<N> {
|
||||
|
|
|
|||
|
|
@ -347,7 +347,7 @@ macro_rules! to_homogeneous_impl(
|
|||
// copy the translation
|
||||
let dimension = Dimension::dimension(None::<$th<N>>);
|
||||
|
||||
res.set_col(dimension - 1, self.translation.as_point().to_homogeneous().to_vector());
|
||||
res.set_column(dimension - 1, self.translation.as_point().to_homogeneous().to_vector());
|
||||
|
||||
res
|
||||
}
|
||||
|
|
|
|||
|
|
@ -72,8 +72,8 @@ point_mul_mat_impl!(Matrix1, Point1, 1, Origin::origin);
|
|||
transpose_impl!(Matrix1, 1);
|
||||
approx_eq_impl!(Matrix1);
|
||||
row_impl!(Matrix1, Vector1, 1);
|
||||
col_impl!(Matrix1, Vector1, 1);
|
||||
col_slice_impl!(Matrix1, Vector1, DVector1, 1);
|
||||
column_impl!(Matrix1, Vector1, 1);
|
||||
column_slice_impl!(Matrix1, Vector1, DVector1, 1);
|
||||
row_slice_impl!(Matrix1, Vector1, DVector1, 1);
|
||||
diag_impl!(Matrix1, Vector1, 1);
|
||||
to_homogeneous_impl!(Matrix1, Matrix2, 1, 2);
|
||||
|
|
@ -127,8 +127,8 @@ at_fast_impl!(Matrix2, 2);
|
|||
transpose_impl!(Matrix2, 2);
|
||||
approx_eq_impl!(Matrix2);
|
||||
row_impl!(Matrix2, Vector2, 2);
|
||||
col_impl!(Matrix2, Vector2, 2);
|
||||
col_slice_impl!(Matrix2, Vector2, DVector2, 2);
|
||||
column_impl!(Matrix2, Vector2, 2);
|
||||
column_slice_impl!(Matrix2, Vector2, DVector2, 2);
|
||||
row_slice_impl!(Matrix2, Vector2, DVector2, 2);
|
||||
diag_impl!(Matrix2, Vector2, 2);
|
||||
to_homogeneous_impl!(Matrix2, Matrix3, 2, 3);
|
||||
|
|
@ -217,8 +217,8 @@ at_fast_impl!(Matrix3, 3);
|
|||
transpose_impl!(Matrix3, 3);
|
||||
approx_eq_impl!(Matrix3);
|
||||
// (specialized); row_impl!(Matrix3, Vector3, 3);
|
||||
// (specialized); col_impl!(Matrix3, Vector3, 3);
|
||||
col_slice_impl!(Matrix3, Vector3, DVector3, 3);
|
||||
// (specialized); column_impl!(Matrix3, Vector3, 3);
|
||||
column_slice_impl!(Matrix3, Vector3, DVector3, 3);
|
||||
row_slice_impl!(Matrix3, Vector3, DVector3, 3);
|
||||
diag_impl!(Matrix3, Vector3, 3);
|
||||
to_homogeneous_impl!(Matrix3, Matrix4, 3, 4);
|
||||
|
|
@ -336,8 +336,8 @@ inverse_impl!(Matrix4, 4);
|
|||
transpose_impl!(Matrix4, 4);
|
||||
approx_eq_impl!(Matrix4);
|
||||
row_impl!(Matrix4, Vector4, 4);
|
||||
col_impl!(Matrix4, Vector4, 4);
|
||||
col_slice_impl!(Matrix4, Vector4, DVector4, 4);
|
||||
column_impl!(Matrix4, Vector4, 4);
|
||||
column_slice_impl!(Matrix4, Vector4, DVector4, 4);
|
||||
row_slice_impl!(Matrix4, Vector4, DVector4, 4);
|
||||
diag_impl!(Matrix4, Vector4, 4);
|
||||
to_homogeneous_impl!(Matrix4, Matrix5, 4, 5);
|
||||
|
|
@ -472,8 +472,8 @@ inverse_impl!(Matrix5, 5);
|
|||
transpose_impl!(Matrix5, 5);
|
||||
approx_eq_impl!(Matrix5);
|
||||
row_impl!(Matrix5, Vector5, 5);
|
||||
col_impl!(Matrix5, Vector5, 5);
|
||||
col_slice_impl!(Matrix5, Vector5, DVector5, 5);
|
||||
column_impl!(Matrix5, Vector5, 5);
|
||||
column_slice_impl!(Matrix5, Vector5, DVector5, 5);
|
||||
row_slice_impl!(Matrix5, Vector5, DVector5, 5);
|
||||
diag_impl!(Matrix5, Vector5, 5);
|
||||
to_homogeneous_impl!(Matrix5, Matrix6, 5, 6);
|
||||
|
|
@ -615,8 +615,8 @@ inverse_impl!(Matrix6, 6);
|
|||
transpose_impl!(Matrix6, 6);
|
||||
approx_eq_impl!(Matrix6);
|
||||
row_impl!(Matrix6, Vector6, 6);
|
||||
col_impl!(Matrix6, Vector6, 6);
|
||||
col_slice_impl!(Matrix6, Vector6, DVector6, 6);
|
||||
column_impl!(Matrix6, Vector6, 6);
|
||||
column_slice_impl!(Matrix6, Vector6, DVector6, 6);
|
||||
row_slice_impl!(Matrix6, Vector6, DVector6, 6);
|
||||
diag_impl!(Matrix6, Vector6, 6);
|
||||
outer_impl!(Vector6, Matrix6);
|
||||
|
|
|
|||
|
|
@ -413,10 +413,10 @@ macro_rules! index_impl(
|
|||
)
|
||||
);
|
||||
|
||||
macro_rules! col_slice_impl(
|
||||
macro_rules! column_slice_impl(
|
||||
($t: ident, $tv: ident, $slice: ident, $dimension: expr) => (
|
||||
impl<N: Clone + Copy + Zero> ColumnSlice<$slice<N>> for $t<N> {
|
||||
fn col_slice(&self, cid: usize, rstart: usize, rend: usize) -> $slice<N> {
|
||||
fn column_slice(&self, cid: usize, rstart: usize, rend: usize) -> $slice<N> {
|
||||
let column = self.column(cid);
|
||||
|
||||
$slice::from_slice(rend - rstart, &column.as_ref()[rstart .. rend])
|
||||
|
|
@ -466,7 +466,7 @@ macro_rules! row_slice_impl(
|
|||
)
|
||||
);
|
||||
|
||||
macro_rules! col_impl(
|
||||
macro_rules! column_impl(
|
||||
($t: ident, $tv: ident, $dimension: expr) => (
|
||||
impl<N: Copy + Zero> Column<$tv<N>> for $t<N> {
|
||||
#[inline]
|
||||
|
|
@ -475,7 +475,7 @@ macro_rules! col_impl(
|
|||
}
|
||||
|
||||
#[inline]
|
||||
fn set_col(&mut self, column: usize, v: $tv<N>) {
|
||||
fn set_column(&mut self, column: usize, v: $tv<N>) {
|
||||
for (i, e) in v.iter().enumerate() {
|
||||
self[(i, column)] = *e;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -372,7 +372,7 @@ point_mul_rotation_impl!(Rotation2, Point2);
|
|||
one_impl!(Rotation2);
|
||||
eye_impl!(Rotation2);
|
||||
rotation_matrix_impl!(Rotation2, Vector2, Vector1);
|
||||
col_impl!(Rotation2, Vector2);
|
||||
column_impl!(Rotation2, Vector2);
|
||||
row_impl!(Rotation2, Vector2);
|
||||
index_impl!(Rotation2);
|
||||
absolute_impl!(Rotation2, Matrix2);
|
||||
|
|
@ -395,7 +395,7 @@ point_mul_rotation_impl!(Rotation3, Point3);
|
|||
one_impl!(Rotation3);
|
||||
eye_impl!(Rotation3);
|
||||
rotation_matrix_impl!(Rotation3, Vector3, Vector3);
|
||||
col_impl!(Rotation3, Vector3);
|
||||
column_impl!(Rotation3, Vector3);
|
||||
row_impl!(Rotation3, Vector3);
|
||||
index_impl!(Rotation3);
|
||||
absolute_impl!(Rotation3, Matrix3);
|
||||
|
|
|
|||
|
|
@ -256,7 +256,7 @@ macro_rules! row_impl(
|
|||
)
|
||||
);
|
||||
|
||||
macro_rules! col_impl(
|
||||
macro_rules! column_impl(
|
||||
($t: ident, $tv: ident) => (
|
||||
impl<N: Copy + Zero> Column<$tv<N>> for $t<N> {
|
||||
#[inline]
|
||||
|
|
@ -269,8 +269,8 @@ macro_rules! col_impl(
|
|||
}
|
||||
|
||||
#[inline]
|
||||
fn set_col(&mut self, i: usize, column: $tv<N>) {
|
||||
self.submatrix.set_col(i, column);
|
||||
fn set_column(&mut self, i: usize, column: $tv<N>) {
|
||||
self.submatrix.set_column(i, column);
|
||||
}
|
||||
}
|
||||
)
|
||||
|
|
|
|||
|
|
@ -275,7 +275,7 @@ macro_rules! sim_to_homogeneous_impl(
|
|||
// copy the translation
|
||||
let dimension = Dimension::dimension(None::<$th<N>>);
|
||||
|
||||
res.set_col(dimension - 1, self.isometry.translation.as_point().to_homogeneous().to_vector());
|
||||
res.set_column(dimension - 1, self.isometry.translation.as_point().to_homogeneous().to_vector());
|
||||
|
||||
res
|
||||
}
|
||||
|
|
|
|||
|
|
@ -187,7 +187,7 @@ impl<N: Copy> Column<Vector3<N>> for Matrix3<N> {
|
|||
}
|
||||
|
||||
#[inline]
|
||||
fn set_col(&mut self, i: usize, r: Vector3<N>) {
|
||||
fn set_column(&mut self, i: usize, r: Vector3<N>) {
|
||||
match i {
|
||||
0 => {
|
||||
self.m11 = r.x;
|
||||
|
|
|
|||
|
|
@ -142,7 +142,7 @@ pub trait Column<C> {
|
|||
fn column(&self, i: usize) -> C;
|
||||
|
||||
/// Writes the `i`-th column of `self`.
|
||||
fn set_col(&mut self, i: usize, C);
|
||||
fn set_column(&mut self, i: usize, C);
|
||||
|
||||
// FIXME: add iterators on columns: this could be a very good way to generalize _and_ optimize
|
||||
// a lot of operations.
|
||||
|
|
@ -151,13 +151,13 @@ pub trait Column<C> {
|
|||
/// Trait to access part of a column of a matrix
|
||||
pub trait ColumnSlice<C> {
|
||||
/// Returns a view to a slice of a column of a matrix.
|
||||
fn col_slice(&self, col_id: usize, row_start: usize, row_end: usize) -> C;
|
||||
fn column_slice(&self, column_id: usize, row_start: usize, row_end: usize) -> C;
|
||||
}
|
||||
|
||||
/// Trait to access part of a row of a matrix
|
||||
pub trait RowSlice<R> {
|
||||
/// Returns a view to a slice of a row of a matrix.
|
||||
fn row_slice(&self, row_id: usize, col_start: usize, col_end: usize) -> R;
|
||||
fn row_slice(&self, row_id: usize, column_start: usize, column_end: usize) -> R;
|
||||
}
|
||||
|
||||
/// Trait of objects having a spacial dimension known at compile time.
|
||||
|
|
|
|||
24
tests/mat.rs
24
tests/mat.rs
|
|
@ -332,7 +332,7 @@ fn test_row_slice_dmatrix() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn test_col_dmatrix() {
|
||||
fn test_column_dmatrix() {
|
||||
let matrix = DMatrix::from_row_vector(
|
||||
8,
|
||||
4,
|
||||
|
|
@ -355,7 +355,7 @@ fn test_col_dmatrix() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn test_col_slice_dmatrix() {
|
||||
fn test_column_slice_dmatrix() {
|
||||
let matrix = DMatrix::from_row_vector(
|
||||
8,
|
||||
4,
|
||||
|
|
@ -371,10 +371,10 @@ fn test_col_slice_dmatrix() {
|
|||
]
|
||||
);
|
||||
|
||||
assert_eq!(&DVector::from_slice(8, &[1u32, 5, 9, 13, 17, 21, 25, 29]), &matrix.col_slice(0, 0, 8));
|
||||
assert_eq!(&DVector::from_slice(3, &[1u32, 5, 9]), &matrix.col_slice(0, 0, 3));
|
||||
assert_eq!(&DVector::from_slice(5, &[11u32, 15, 19, 23, 27]), &matrix.col_slice(2, 2, 7));
|
||||
assert_eq!(&DVector::from_slice(2, &[28u32, 32]), &matrix.col_slice(3, 6, 8));
|
||||
assert_eq!(&DVector::from_slice(8, &[1u32, 5, 9, 13, 17, 21, 25, 29]), &matrix.column_slice(0, 0, 8));
|
||||
assert_eq!(&DVector::from_slice(3, &[1u32, 5, 9]), &matrix.column_slice(0, 0, 3));
|
||||
assert_eq!(&DVector::from_slice(5, &[11u32, 15, 19, 23, 27]), &matrix.column_slice(2, 2, 7));
|
||||
assert_eq!(&DVector::from_slice(2, &[28u32, 32]), &matrix.column_slice(3, 6, 8));
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
@ -394,7 +394,7 @@ fn test_dmat_from_vector() {
|
|||
]
|
||||
);
|
||||
|
||||
let mat2 = DMatrix::from_col_vector(
|
||||
let mat2 = DMatrix::from_column_vector(
|
||||
8,
|
||||
4,
|
||||
&[
|
||||
|
|
@ -541,7 +541,7 @@ fn test_dmat_subtraction() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn test_dmat_col() {
|
||||
fn test_dmat_column() {
|
||||
let matrix = DMatrix::from_row_vector(
|
||||
3,
|
||||
3,
|
||||
|
|
@ -556,7 +556,7 @@ fn test_dmat_col() {
|
|||
}
|
||||
|
||||
#[test]
|
||||
fn test_dmat_set_col() {
|
||||
fn test_dmat_set_column() {
|
||||
let mut matrix = DMatrix::from_row_vector(
|
||||
3,
|
||||
3,
|
||||
|
|
@ -567,7 +567,7 @@ fn test_dmat_set_col() {
|
|||
]
|
||||
);
|
||||
|
||||
matrix.set_col(1, DVector::from_slice(3, &[12.0, 15.0, 18.0]));
|
||||
matrix.set_column(1, DVector::from_slice(3, &[12.0, 15.0, 18.0]));
|
||||
|
||||
let expected = DMatrix::from_row_vector(
|
||||
3,
|
||||
|
|
@ -823,13 +823,13 @@ fn test_hessenberg_mat6() {
|
|||
|
||||
#[test]
|
||||
fn test_transpose_square_matrix() {
|
||||
let col_major_matrix = &[0, 1, 2, 3,
|
||||
let column_major_matrix = &[0, 1, 2, 3,
|
||||
0, 1, 2, 3,
|
||||
0, 1, 2, 3,
|
||||
0, 1, 2, 3];
|
||||
let num_rows = 4;
|
||||
let num_cols = 4;
|
||||
let mut matrix = DMatrix::from_col_vector(num_rows, num_cols, col_major_matrix);
|
||||
let mut matrix = DMatrix::from_column_vector(num_rows, num_cols, column_major_matrix);
|
||||
matrix.transpose_mut();
|
||||
for i in 0..num_rows {
|
||||
assert_eq!(&[0, 1, 2, 3], &matrix.row_slice(i, 0, num_cols)[..]);
|
||||
|
|
|
|||
Loading…
Reference in New Issue