Merge pull request #499 from rustsim/rusty_machine
Add features required by rusty-machine.
This commit is contained in:
Sébastien Crozet
GitHub
commit
21c163db3a
|
|
@ -175,24 +175,24 @@ pub type MatrixSliceXx6<'a, N, RStride = U1, CStride = Dynamic> =
|
||||||
MatrixSliceMN<'a, N, Dynamic, U6, RStride, CStride>;
|
MatrixSliceMN<'a, N, Dynamic, U6, RStride, CStride>;
|
||||||
|
|
||||||
/// A column vector slice with `D` rows.
|
/// A column vector slice with `D` rows.
|
||||||
pub type VectorSliceN<'a, N, D, Stride = U1> =
|
pub type VectorSliceN<'a, N, D, RStride = U1, CStride = D> =
|
||||||
Matrix<N, D, U1, SliceStorage<'a, N, D, U1, Stride, D>>;
|
Matrix<N, D, U1, SliceStorage<'a, N, D, U1, RStride, CStride>>;
|
||||||
|
|
||||||
/// A column vector slice dynamic numbers of rows and columns.
|
/// A column vector slice dynamic numbers of rows and columns.
|
||||||
pub type DVectorSlice<'a, N, Stride = U1> = VectorSliceN<'a, N, Dynamic, Stride>;
|
pub type DVectorSlice<'a, N, RStride = U1, CStride = Dynamic> = VectorSliceN<'a, N, Dynamic, RStride, CStride>;
|
||||||
|
|
||||||
/// A 1D column vector slice.
|
/// A 1D column vector slice.
|
||||||
pub type VectorSlice1<'a, N, Stride = U1> = VectorSliceN<'a, N, U1, Stride>;
|
pub type VectorSlice1<'a, N, RStride = U1, CStride = U1> = VectorSliceN<'a, N, U1, RStride, CStride>;
|
||||||
/// A 2D column vector slice.
|
/// A 2D column vector slice.
|
||||||
pub type VectorSlice2<'a, N, Stride = U1> = VectorSliceN<'a, N, U2, Stride>;
|
pub type VectorSlice2<'a, N, RStride = U1, CStride = U2> = VectorSliceN<'a, N, U2, RStride, CStride>;
|
||||||
/// A 3D column vector slice.
|
/// A 3D column vector slice.
|
||||||
pub type VectorSlice3<'a, N, Stride = U1> = VectorSliceN<'a, N, U3, Stride>;
|
pub type VectorSlice3<'a, N, RStride = U1, CStride = U3> = VectorSliceN<'a, N, U3, RStride, CStride>;
|
||||||
/// A 4D column vector slice.
|
/// A 4D column vector slice.
|
||||||
pub type VectorSlice4<'a, N, Stride = U1> = VectorSliceN<'a, N, U4, Stride>;
|
pub type VectorSlice4<'a, N, RStride = U1, CStride = U4> = VectorSliceN<'a, N, U4, RStride, CStride>;
|
||||||
/// A 5D column vector slice.
|
/// A 5D column vector slice.
|
||||||
pub type VectorSlice5<'a, N, Stride = U1> = VectorSliceN<'a, N, U5, Stride>;
|
pub type VectorSlice5<'a, N, RStride = U1, CStride = U5> = VectorSliceN<'a, N, U5, RStride, CStride>;
|
||||||
/// A 6D column vector slice.
|
/// A 6D column vector slice.
|
||||||
pub type VectorSlice6<'a, N, Stride = U1> = VectorSliceN<'a, N, U6, Stride>;
|
pub type VectorSlice6<'a, N, RStride = U1, CStride = U6> = VectorSliceN<'a, N, U6, RStride, CStride>;
|
||||||
|
|
||||||
/*
|
/*
|
||||||
*
|
*
|
||||||
|
|
@ -367,21 +367,21 @@ pub type MatrixSliceMutXx6<'a, N, RStride = U1, CStride = Dynamic> =
|
||||||
MatrixSliceMutMN<'a, N, Dynamic, U6, RStride, CStride>;
|
MatrixSliceMutMN<'a, N, Dynamic, U6, RStride, CStride>;
|
||||||
|
|
||||||
/// A mutable column vector slice with `D` rows.
|
/// A mutable column vector slice with `D` rows.
|
||||||
pub type VectorSliceMutN<'a, N, D, Stride = U1> =
|
pub type VectorSliceMutN<'a, N, D, RStride = U1, CStride = D> =
|
||||||
Matrix<N, D, U1, SliceStorageMut<'a, N, D, U1, Stride, D>>;
|
Matrix<N, D, U1, SliceStorageMut<'a, N, D, U1, RStride, CStride>>;
|
||||||
|
|
||||||
/// A mutable column vector slice dynamic numbers of rows and columns.
|
/// A mutable column vector slice dynamic numbers of rows and columns.
|
||||||
pub type DVectorSliceMut<'a, N, Stride = U1> = VectorSliceMutN<'a, N, Dynamic, Stride>;
|
pub type DVectorSliceMut<'a, N, RStride = U1, CStride = Dynamic> = VectorSliceMutN<'a, N, Dynamic, RStride, CStride>;
|
||||||
|
|
||||||
/// A 1D mutable column vector slice.
|
/// A 1D mutable column vector slice.
|
||||||
pub type VectorSliceMut1<'a, N, Stride = U1> = VectorSliceMutN<'a, N, U1, Stride>;
|
pub type VectorSliceMut1<'a, N, RStride = U1, CStride = U1> = VectorSliceMutN<'a, N, U1, RStride, CStride>;
|
||||||
/// A 2D mutable column vector slice.
|
/// A 2D mutable column vector slice.
|
||||||
pub type VectorSliceMut2<'a, N, Stride = U1> = VectorSliceMutN<'a, N, U2, Stride>;
|
pub type VectorSliceMut2<'a, N, RStride = U1, CStride = U2> = VectorSliceMutN<'a, N, U2, RStride, CStride>;
|
||||||
/// A 3D mutable column vector slice.
|
/// A 3D mutable column vector slice.
|
||||||
pub type VectorSliceMut3<'a, N, Stride = U1> = VectorSliceMutN<'a, N, U3, Stride>;
|
pub type VectorSliceMut3<'a, N, RStride = U1, CStride = U3> = VectorSliceMutN<'a, N, U3, RStride, CStride>;
|
||||||
/// A 4D mutable column vector slice.
|
/// A 4D mutable column vector slice.
|
||||||
pub type VectorSliceMut4<'a, N, Stride = U1> = VectorSliceMutN<'a, N, U4, Stride>;
|
pub type VectorSliceMut4<'a, N, RStride = U1, CStride = U4> = VectorSliceMutN<'a, N, U4, RStride, CStride>;
|
||||||
/// A 5D mutable column vector slice.
|
/// A 5D mutable column vector slice.
|
||||||
pub type VectorSliceMut5<'a, N, Stride = U1> = VectorSliceMutN<'a, N, U5, Stride>;
|
pub type VectorSliceMut5<'a, N, RStride = U1, CStride = U5> = VectorSliceMutN<'a, N, U5, RStride, CStride>;
|
||||||
/// A 6D mutable column vector slice.
|
/// A 6D mutable column vector slice.
|
||||||
pub type VectorSliceMut6<'a, N, Stride = U1> = VectorSliceMutN<'a, N, U6, Stride>;
|
pub type VectorSliceMut6<'a, N, RStride = U1, CStride = U6> = VectorSliceMutN<'a, N, U6, RStride, CStride>;
|
||||||
|
|
|
||||||
|
|
@ -13,18 +13,18 @@ use base::dimension::{Dim, Dynamic, U1, U2, U3, U4};
|
||||||
use base::storage::{Storage, StorageMut};
|
use base::storage::{Storage, StorageMut};
|
||||||
use base::{DefaultAllocator, Matrix, Scalar, SquareMatrix, Vector};
|
use base::{DefaultAllocator, Matrix, Scalar, SquareMatrix, Vector};
|
||||||
|
|
||||||
impl<N: Scalar + PartialOrd + Signed, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
|
impl<N: Scalar + PartialOrd, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
|
||||||
/// Computes the index of the vector component with the largest value.
|
/// Computes the index and value of the vector component with the largest value.
|
||||||
///
|
///
|
||||||
/// # Examples:
|
/// # Examples:
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # use nalgebra::Vector3;
|
/// # use nalgebra::Vector3;
|
||||||
/// let vec = Vector3::new(11, -15, 13);
|
/// let vec = Vector3::new(11, -15, 13);
|
||||||
/// assert_eq!(vec.imax(), 2);
|
/// assert_eq!(vec.argmax(), (2, 13));
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn imax(&self) -> usize {
|
pub fn argmax(&self) -> (usize, N) {
|
||||||
assert!(!self.is_empty(), "The input vector must not be empty.");
|
assert!(!self.is_empty(), "The input vector must not be empty.");
|
||||||
|
|
||||||
let mut the_max = unsafe { self.vget_unchecked(0) };
|
let mut the_max = unsafe { self.vget_unchecked(0) };
|
||||||
|
|
@ -39,7 +39,21 @@ impl<N: Scalar + PartialOrd + Signed, D: Dim, S: Storage<N, D>> Vector<N, D, S>
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
the_i
|
(the_i, *the_max)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Computes the index of the vector component with the largest value.
|
||||||
|
///
|
||||||
|
/// # Examples:
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::Vector3;
|
||||||
|
/// let vec = Vector3::new(11, -15, 13);
|
||||||
|
/// assert_eq!(vec.imax(), 2);
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn imax(&self) -> usize {
|
||||||
|
self.argmax().0
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Computes the index of the vector component with the largest absolute value.
|
/// Computes the index of the vector component with the largest absolute value.
|
||||||
|
|
@ -52,7 +66,8 @@ impl<N: Scalar + PartialOrd + Signed, D: Dim, S: Storage<N, D>> Vector<N, D, S>
|
||||||
/// assert_eq!(vec.iamax(), 1);
|
/// assert_eq!(vec.iamax(), 1);
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn iamax(&self) -> usize {
|
pub fn iamax(&self) -> usize
|
||||||
|
where N: Signed {
|
||||||
assert!(!self.is_empty(), "The input vector must not be empty.");
|
assert!(!self.is_empty(), "The input vector must not be empty.");
|
||||||
|
|
||||||
let mut the_max = unsafe { self.vget_unchecked(0).abs() };
|
let mut the_max = unsafe { self.vget_unchecked(0).abs() };
|
||||||
|
|
@ -70,6 +85,34 @@ impl<N: Scalar + PartialOrd + Signed, D: Dim, S: Storage<N, D>> Vector<N, D, S>
|
||||||
the_i
|
the_i
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Computes the index and value of the vector component with the smallest value.
|
||||||
|
///
|
||||||
|
/// # Examples:
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::Vector3;
|
||||||
|
/// let vec = Vector3::new(11, -15, 13);
|
||||||
|
/// assert_eq!(vec.argmin(), (1, -15));
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn argmin(&self) -> (usize, N) {
|
||||||
|
assert!(!self.is_empty(), "The input vector must not be empty.");
|
||||||
|
|
||||||
|
let mut the_min = unsafe { self.vget_unchecked(0) };
|
||||||
|
let mut the_i = 0;
|
||||||
|
|
||||||
|
for i in 1..self.nrows() {
|
||||||
|
let val = unsafe { self.vget_unchecked(i) };
|
||||||
|
|
||||||
|
if val < the_min {
|
||||||
|
the_min = val;
|
||||||
|
the_i = i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
(the_i, *the_min)
|
||||||
|
}
|
||||||
|
|
||||||
/// Computes the index of the vector component with the smallest value.
|
/// Computes the index of the vector component with the smallest value.
|
||||||
///
|
///
|
||||||
/// # Examples:
|
/// # Examples:
|
||||||
|
|
@ -81,21 +124,7 @@ impl<N: Scalar + PartialOrd + Signed, D: Dim, S: Storage<N, D>> Vector<N, D, S>
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn imin(&self) -> usize {
|
pub fn imin(&self) -> usize {
|
||||||
assert!(!self.is_empty(), "The input vector must not be empty.");
|
self.argmin().0
|
||||||
|
|
||||||
let mut the_max = unsafe { self.vget_unchecked(0) };
|
|
||||||
let mut the_i = 0;
|
|
||||||
|
|
||||||
for i in 1..self.nrows() {
|
|
||||||
let val = unsafe { self.vget_unchecked(i) };
|
|
||||||
|
|
||||||
if val < the_max {
|
|
||||||
the_max = val;
|
|
||||||
the_i = i;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
the_i
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Computes the index of the vector component with the smallest absolute value.
|
/// Computes the index of the vector component with the smallest absolute value.
|
||||||
|
|
@ -108,17 +137,18 @@ impl<N: Scalar + PartialOrd + Signed, D: Dim, S: Storage<N, D>> Vector<N, D, S>
|
||||||
/// assert_eq!(vec.iamin(), 0);
|
/// assert_eq!(vec.iamin(), 0);
|
||||||
/// ```
|
/// ```
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn iamin(&self) -> usize {
|
pub fn iamin(&self) -> usize
|
||||||
|
where N: Signed {
|
||||||
assert!(!self.is_empty(), "The input vector must not be empty.");
|
assert!(!self.is_empty(), "The input vector must not be empty.");
|
||||||
|
|
||||||
let mut the_max = unsafe { self.vget_unchecked(0).abs() };
|
let mut the_min = unsafe { self.vget_unchecked(0).abs() };
|
||||||
let mut the_i = 0;
|
let mut the_i = 0;
|
||||||
|
|
||||||
for i in 1..self.nrows() {
|
for i in 1..self.nrows() {
|
||||||
let val = unsafe { self.vget_unchecked(i).abs() };
|
let val = unsafe { self.vget_unchecked(i).abs() };
|
||||||
|
|
||||||
if val < the_max {
|
if val < the_min {
|
||||||
the_max = val;
|
the_min = val;
|
||||||
the_i = i;
|
the_i = i;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -627,7 +657,6 @@ where N: Scalar + Zero + ClosedAdd + ClosedMul
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Matrix2x3, Matrix3x4, Matrix2x4};
|
/// # use nalgebra::{Matrix2x3, Matrix3x4, Matrix2x4};
|
||||||
/// let mut mat1 = Matrix2x4::identity();
|
/// let mut mat1 = Matrix2x4::identity();
|
||||||
/// let mat2 = Matrix2x3::new(1.0, 2.0, 3.0,
|
/// let mat2 = Matrix2x3::new(1.0, 2.0, 3.0,
|
||||||
|
|
@ -760,7 +789,6 @@ where N: Scalar + Zero + ClosedAdd + ClosedMul
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Matrix3x2, Matrix3x4, Matrix2x4};
|
/// # use nalgebra::{Matrix3x2, Matrix3x4, Matrix2x4};
|
||||||
/// let mut mat1 = Matrix2x4::identity();
|
/// let mut mat1 = Matrix2x4::identity();
|
||||||
/// let mat2 = Matrix3x2::new(1.0, 4.0,
|
/// let mat2 = Matrix3x2::new(1.0, 4.0,
|
||||||
|
|
@ -879,7 +907,6 @@ where N: Scalar + Zero + One + ClosedAdd + ClosedMul
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{DMatrix, DVector};
|
/// # use nalgebra::{DMatrix, DVector};
|
||||||
/// // Note that all those would also work with statically-sized matrices.
|
/// // 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
|
/// // We use DMatrix/DVector since that's the only case where pre-allocating the
|
||||||
|
|
@ -934,7 +961,6 @@ where N: Scalar + Zero + One + ClosedAdd + ClosedMul
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Matrix2, Matrix3, Matrix2x3, Vector2};
|
/// # use nalgebra::{Matrix2, Matrix3, Matrix2x3, Vector2};
|
||||||
/// let mut mat = Matrix2::identity();
|
/// let mut mat = Matrix2::identity();
|
||||||
/// let lhs = Matrix2x3::new(1.0, 2.0, 3.0,
|
/// let lhs = Matrix2x3::new(1.0, 2.0, 3.0,
|
||||||
|
|
@ -971,7 +997,6 @@ where N: Scalar + Zero + One + ClosedAdd + ClosedMul
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{DMatrix, DVector};
|
/// # use nalgebra::{DMatrix, DVector};
|
||||||
/// // Note that all those would also work with statically-sized matrices.
|
/// // 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
|
/// // We use DMatrix/DVector since that's the only case where pre-allocating the
|
||||||
|
|
@ -1026,7 +1051,6 @@ where N: Scalar + Zero + One + ClosedAdd + ClosedMul
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Matrix2, Matrix3x2, Matrix3};
|
/// # use nalgebra::{Matrix2, Matrix3x2, Matrix3};
|
||||||
/// let mut mat = Matrix2::identity();
|
/// let mut mat = Matrix2::identity();
|
||||||
/// let rhs = Matrix3x2::new(1.0, 2.0,
|
/// let rhs = Matrix3x2::new(1.0, 2.0,
|
||||||
|
|
|
||||||
|
|
@ -296,7 +296,7 @@ where
|
||||||
///
|
///
|
||||||
/// let m = Matrix3::from_diagonal(&Vector3::new(1.0, 2.0, 3.0));
|
/// let m = Matrix3::from_diagonal(&Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// // The two additional arguments represent the matrix dimensions.
|
/// // The two additional arguments represent the matrix dimensions.
|
||||||
/// let dm = DMatrix::from_diagonal(&DVector::from_row_slice(3, &[1.0, 2.0, 3.0]));
|
/// 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 &&
|
/// 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.m21 == 0.0 && m.m22 == 2.0 && m.m23 == 0.0 &&
|
||||||
|
|
@ -444,63 +444,6 @@ macro_rules! impl_constructors(
|
||||||
Self::from_iterator_generic($($gargs, )* iter)
|
Self::from_iterator_generic($($gargs, )* iter)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// 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
|
|
||||||
/// ```
|
|
||||||
/// # use nalgebra::{Matrix2x3, Vector3, DVector, DMatrix};
|
|
||||||
/// # use std::iter;
|
|
||||||
///
|
|
||||||
/// let v = Vector3::from_row_slice(&[0, 1, 2]);
|
|
||||||
/// // The additional argument represents the vector dimension.
|
|
||||||
/// let dv = DVector::from_row_slice(3, &[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);
|
|
||||||
/// ```
|
|
||||||
#[inline]
|
|
||||||
pub fn from_row_slice($($args: usize,)* slice: &[N]) -> Self {
|
|
||||||
Self::from_row_slice_generic($($gargs, )* slice)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a matrix with its elements filled with the components provided by a slice
|
|
||||||
/// in column-major order.
|
|
||||||
///
|
|
||||||
/// # Example
|
|
||||||
/// ```
|
|
||||||
/// # use nalgebra::{Matrix2x3, Vector3, DVector, DMatrix};
|
|
||||||
/// # use std::iter;
|
|
||||||
///
|
|
||||||
/// let v = Vector3::from_column_slice(&[0, 1, 2]);
|
|
||||||
/// // The additional argument represents the vector dimension.
|
|
||||||
/// let dv = DVector::from_column_slice(3, &[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);
|
|
||||||
/// ```
|
|
||||||
#[inline]
|
|
||||||
pub fn from_column_slice($($args: usize,)* slice: &[N]) -> Self {
|
|
||||||
Self::from_column_slice_generic($($gargs, )* slice)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a matrix or vector filled with the results of a function applied to each of its
|
/// Creates a matrix or vector filled with the results of a function applied to each of its
|
||||||
/// component coordinates.
|
/// component coordinates.
|
||||||
///
|
///
|
||||||
|
|
@ -612,32 +555,6 @@ macro_rules! impl_constructors(
|
||||||
) -> Self {
|
) -> Self {
|
||||||
Self::from_distribution_generic($($gargs, )* distribution, rng)
|
Self::from_distribution_generic($($gargs, )* distribution, rng)
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Creates a matrix backed by a given `Vec`.
|
|
||||||
///
|
|
||||||
/// The output matrix is filled column-by-column.
|
|
||||||
///
|
|
||||||
/// # Example
|
|
||||||
/// ```
|
|
||||||
/// # use nalgebra::{DMatrix, Matrix2x3};
|
|
||||||
///
|
|
||||||
/// 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);
|
|
||||||
/// ```
|
|
||||||
#[inline]
|
|
||||||
#[cfg(feature = "std")]
|
|
||||||
pub fn from_vec($($args: usize,)* data: Vec<N>) -> Self {
|
|
||||||
Self::from_vec_generic($($gargs, )* data)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: Scalar, $($DimIdent: $DimBound, )*> MatrixMN<N $(, $Dims)*>
|
impl<N: Scalar, $($DimIdent: $DimBound, )*> MatrixMN<N $(, $Dims)*>
|
||||||
|
|
@ -676,6 +593,125 @@ impl_constructors!(Dynamic, Dynamic;
|
||||||
Dynamic::new(nrows), Dynamic::new(ncols);
|
Dynamic::new(nrows), Dynamic::new(ncols);
|
||||||
nrows, ncols);
|
nrows, ncols);
|
||||||
|
|
||||||
|
/*
|
||||||
|
*
|
||||||
|
* Constructors that don't necessarily require all dimensions
|
||||||
|
* to be specified whon one dimension is already known.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
macro_rules! impl_constructors_from_data(
|
||||||
|
($data: ident; $($Dims: ty),*; $(=> $DimIdent: ident: $DimBound: ident),*; $($gargs: expr),*; $($args: ident),*) => {
|
||||||
|
impl<N: Scalar, $($DimIdent: $DimBound, )*> MatrixMN<N $(, $Dims)*>
|
||||||
|
where DefaultAllocator: Allocator<N $(, $Dims)*> {
|
||||||
|
/// 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
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Matrix2x3, Vector3, DVector, DMatrix};
|
||||||
|
/// # use std::iter;
|
||||||
|
///
|
||||||
|
/// 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);
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn from_row_slice($($args: usize,)* $data: &[N]) -> Self {
|
||||||
|
Self::from_row_slice_generic($($gargs, )* $data)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Creates a matrix with its elements filled with the components provided by a slice
|
||||||
|
/// in column-major order.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Matrix2x3, Vector3, DVector, DMatrix};
|
||||||
|
/// # use std::iter;
|
||||||
|
///
|
||||||
|
/// 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);
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn from_column_slice($($args: usize,)* $data: &[N]) -> Self {
|
||||||
|
Self::from_column_slice_generic($($gargs, )* $data)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Creates a matrix backed by a given `Vec`.
|
||||||
|
///
|
||||||
|
/// The output matrix is filled column-by-column.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{DMatrix, Matrix2x3};
|
||||||
|
///
|
||||||
|
/// 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);
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
#[cfg(feature = "std")]
|
||||||
|
pub fn from_vec($($args: usize,)* $data: Vec<N>) -> Self {
|
||||||
|
Self::from_vec_generic($($gargs, )* $data)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
);
|
||||||
|
|
||||||
|
// FIXME: this is not very pretty. We could find a better call syntax.
|
||||||
|
impl_constructors_from_data!(data; R, C; // Arguments for Matrix<N, ..., S>
|
||||||
|
=> R: DimName, => C: DimName; // Type parameters for impl<N, ..., S>
|
||||||
|
R::name(), C::name(); // Arguments for `_generic` constructors.
|
||||||
|
); // Arguments for non-generic constructors.
|
||||||
|
|
||||||
|
impl_constructors_from_data!(data; R, Dynamic;
|
||||||
|
=> R: DimName;
|
||||||
|
R::name(), Dynamic::new(data.len() / R::dim());
|
||||||
|
);
|
||||||
|
|
||||||
|
impl_constructors_from_data!(data; Dynamic, C;
|
||||||
|
=> C: DimName;
|
||||||
|
Dynamic::new(data.len() / C::dim()), C::name();
|
||||||
|
);
|
||||||
|
|
||||||
|
impl_constructors_from_data!(data; Dynamic, Dynamic;
|
||||||
|
;
|
||||||
|
Dynamic::new(nrows), Dynamic::new(ncols);
|
||||||
|
nrows, ncols);
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
/*
|
||||||
*
|
*
|
||||||
* Zero, One, Rand traits.
|
* Zero, One, Rand traits.
|
||||||
|
|
|
||||||
|
|
@ -1,6 +1,7 @@
|
||||||
use num::{One, Zero};
|
use num::{One, Zero};
|
||||||
use std::cmp;
|
use std::cmp;
|
||||||
use std::ptr;
|
use std::ptr;
|
||||||
|
use std::iter::ExactSizeIterator;
|
||||||
|
|
||||||
use base::allocator::{Allocator, Reallocator};
|
use base::allocator::{Allocator, Reallocator};
|
||||||
use base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
|
use base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
|
||||||
|
|
@ -32,6 +33,52 @@ impl<N: Scalar + Zero, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
|
||||||
|
|
||||||
res
|
res
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Creates a new matrix by extracting the given set of rows from `self`.
|
||||||
|
pub fn select_rows<'a, I>(&self, irows: I) -> MatrixMN<N, Dynamic, C>
|
||||||
|
where I: IntoIterator<Item = &'a usize>,
|
||||||
|
I::IntoIter: ExactSizeIterator + Clone,
|
||||||
|
DefaultAllocator: Allocator<N, Dynamic, C> {
|
||||||
|
let irows = irows.into_iter();
|
||||||
|
let ncols = self.data.shape().1;
|
||||||
|
let mut res = unsafe { MatrixMN::new_uninitialized_generic(Dynamic::new(irows.len()), ncols) };
|
||||||
|
|
||||||
|
// First, check that all the indices from irows are valid.
|
||||||
|
// This will allow us to use unchecked access in the inner loop.
|
||||||
|
for i in irows.clone() {
|
||||||
|
assert!(*i < self.nrows(), "Row index out of bounds.")
|
||||||
|
}
|
||||||
|
|
||||||
|
for j in 0..ncols.value() {
|
||||||
|
// FIXME: use unchecked column indexing
|
||||||
|
let mut res = res.column_mut(j);
|
||||||
|
let mut src = self.column(j);
|
||||||
|
|
||||||
|
for (destination, source) in irows.clone().enumerate() {
|
||||||
|
unsafe {
|
||||||
|
*res.vget_unchecked_mut(destination) = *src.vget_unchecked(*source)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
res
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Creates a new matrix by extracting the given set of columns from `self`.
|
||||||
|
pub fn select_columns<'a, I>(&self, icols: I) -> MatrixMN<N, R, Dynamic>
|
||||||
|
where I: IntoIterator<Item = &'a usize>,
|
||||||
|
I::IntoIter: ExactSizeIterator,
|
||||||
|
DefaultAllocator: Allocator<N, R, Dynamic> {
|
||||||
|
let icols = icols.into_iter();
|
||||||
|
let nrows = self.data.shape().0;
|
||||||
|
let mut res = unsafe { MatrixMN::new_uninitialized_generic(nrows, Dynamic::new(icols.len())) };
|
||||||
|
|
||||||
|
for (destination, source) in icols.enumerate() {
|
||||||
|
res.column_mut(destination).copy_from(&self.column(*source))
|
||||||
|
}
|
||||||
|
|
||||||
|
res
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
|
impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
|
||||||
|
|
@ -764,9 +811,9 @@ where
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # use nalgebra::DVector;
|
/// # use nalgebra::DVector;
|
||||||
/// let mut vector = DVector::from_vec(3, vec![0, 1, 2]);
|
/// let mut vector = DVector::from_vec(vec![0, 1, 2]);
|
||||||
/// vector.extend(vec![3, 4, 5]);
|
/// vector.extend(vec![3, 4, 5]);
|
||||||
/// assert!(vector.eq(&DVector::from_vec(6, vec![0, 1, 2, 3, 4, 5])));
|
/// assert!(vector.eq(&DVector::from_vec(vec![0, 1, 2, 3, 4, 5])));
|
||||||
/// ```
|
/// ```
|
||||||
fn extend<I: IntoIterator<Item=N>>(&mut self, iter: I) {
|
fn extend<I: IntoIterator<Item=N>>(&mut self, iter: I) {
|
||||||
self.data.extend(iter);
|
self.data.extend(iter);
|
||||||
|
|
|
||||||
227
src/base/iter.rs
227
src/base/iter.rs
|
|
@ -3,9 +3,9 @@
|
||||||
use std::marker::PhantomData;
|
use std::marker::PhantomData;
|
||||||
use std::mem;
|
use std::mem;
|
||||||
|
|
||||||
use base::dimension::Dim;
|
use base::dimension::{Dim, U1};
|
||||||
use base::storage::{Storage, StorageMut};
|
use base::storage::{Storage, StorageMut};
|
||||||
use base::Scalar;
|
use base::{Scalar, Matrix, MatrixSlice, MatrixSliceMut};
|
||||||
|
|
||||||
macro_rules! iterator {
|
macro_rules! iterator {
|
||||||
(struct $Name:ident for $Storage:ident.$ptr: ident -> $Ptr:ty, $Ref:ty, $SRef: ty) => {
|
(struct $Name:ident for $Storage:ident.$ptr: ident -> $Ptr:ty, $Ref:ty, $SRef: ty) => {
|
||||||
|
|
@ -96,3 +96,226 @@ macro_rules! iterator {
|
||||||
|
|
||||||
iterator!(struct MatrixIter for Storage.ptr -> *const N, &'a N, &'a S);
|
iterator!(struct MatrixIter for Storage.ptr -> *const N, &'a N, &'a S);
|
||||||
iterator!(struct MatrixIterMut for StorageMut.ptr_mut -> *mut N, &'a mut N, &'a mut S);
|
iterator!(struct MatrixIterMut for StorageMut.ptr_mut -> *mut N, &'a mut N, &'a mut S);
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
*
|
||||||
|
* Row iterators.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
#[derive(Clone)]
|
||||||
|
/// An iterator through the rows of a matrix.
|
||||||
|
pub struct RowIter<'a, N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> {
|
||||||
|
mat: &'a Matrix<N, R, C, S>,
|
||||||
|
curr: usize
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> RowIter<'a, N, R, C, S> {
|
||||||
|
pub(crate) fn new(mat: &'a Matrix<N, R, C, S>) -> Self {
|
||||||
|
RowIter {
|
||||||
|
mat, curr: 0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> Iterator for RowIter<'a, N, R, C, S> {
|
||||||
|
type Item = MatrixSlice<'a, N, U1, C, S::RStride, S::CStride>;
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
|
if self.curr < self.mat.nrows() {
|
||||||
|
let res = self.mat.row(self.curr);
|
||||||
|
self.curr += 1;
|
||||||
|
Some(res)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||||
|
(self.mat.nrows() - self.curr, Some(self.mat.nrows() - self.curr))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn count(self) -> usize {
|
||||||
|
self.mat.nrows() - self.curr
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> ExactSizeIterator for RowIter<'a, N, R, C, S> {
|
||||||
|
#[inline]
|
||||||
|
fn len(&self) -> usize {
|
||||||
|
self.mat.nrows() - self.curr
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/// An iterator through the mutable rows of a matrix.
|
||||||
|
pub struct RowIterMut<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> {
|
||||||
|
mat: *mut Matrix<N, R, C, S>,
|
||||||
|
curr: usize,
|
||||||
|
phantom: PhantomData<&'a mut Matrix<N, R, C, S>>
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> RowIterMut<'a, N, R, C, S> {
|
||||||
|
pub(crate) fn new(mat: &'a mut Matrix<N, R, C, S>) -> Self {
|
||||||
|
RowIterMut {
|
||||||
|
mat,
|
||||||
|
curr: 0,
|
||||||
|
phantom: PhantomData
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn nrows(&self) -> usize {
|
||||||
|
unsafe {
|
||||||
|
(*self.mat).nrows()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> Iterator for RowIterMut<'a, N, R, C, S> {
|
||||||
|
type Item = MatrixSliceMut<'a, N, U1, C, S::RStride, S::CStride>;
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
|
if self.curr < self.nrows() {
|
||||||
|
let res = unsafe { (*self.mat).row_mut(self.curr) };
|
||||||
|
self.curr += 1;
|
||||||
|
Some(res)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||||
|
(self.nrows() - self.curr, Some(self.nrows() - self.curr))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn count(self) -> usize {
|
||||||
|
self.nrows() - self.curr
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> ExactSizeIterator for RowIterMut<'a, N, R, C, S> {
|
||||||
|
#[inline]
|
||||||
|
fn len(&self) -> usize {
|
||||||
|
self.nrows() - self.curr
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
*
|
||||||
|
* Column iterators.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
#[derive(Clone)]
|
||||||
|
/// An iterator through the columns of a matrix.
|
||||||
|
pub struct ColumnIter<'a, N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> {
|
||||||
|
mat: &'a Matrix<N, R, C, S>,
|
||||||
|
curr: usize
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> ColumnIter<'a, N, R, C, S> {
|
||||||
|
pub(crate) fn new(mat: &'a Matrix<N, R, C, S>) -> Self {
|
||||||
|
ColumnIter {
|
||||||
|
mat, curr: 0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> Iterator for ColumnIter<'a, N, R, C, S> {
|
||||||
|
type Item = MatrixSlice<'a, N, R, U1, S::RStride, S::CStride>;
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
|
if self.curr < self.mat.ncols() {
|
||||||
|
let res = self.mat.column(self.curr);
|
||||||
|
self.curr += 1;
|
||||||
|
Some(res)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||||
|
(self.mat.ncols() - self.curr, Some(self.mat.ncols() - self.curr))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn count(self) -> usize {
|
||||||
|
self.mat.ncols() - self.curr
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + Storage<N, R, C>> ExactSizeIterator for ColumnIter<'a, N, R, C, S> {
|
||||||
|
#[inline]
|
||||||
|
fn len(&self) -> usize {
|
||||||
|
self.mat.ncols() - self.curr
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/// An iterator through the mutable columns of a matrix.
|
||||||
|
pub struct ColumnIterMut<'a, N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> {
|
||||||
|
mat: *mut Matrix<N, R, C, S>,
|
||||||
|
curr: usize,
|
||||||
|
phantom: PhantomData<&'a mut Matrix<N, R, C, S>>
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> ColumnIterMut<'a, N, R, C, S> {
|
||||||
|
pub(crate) fn new(mat: &'a mut Matrix<N, R, C, S>) -> Self {
|
||||||
|
ColumnIterMut {
|
||||||
|
mat,
|
||||||
|
curr: 0,
|
||||||
|
phantom: PhantomData
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn ncols(&self) -> usize {
|
||||||
|
unsafe {
|
||||||
|
(*self.mat).ncols()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> Iterator for ColumnIterMut<'a, N, R, C, S> {
|
||||||
|
type Item = MatrixSliceMut<'a, N, R, U1, S::RStride, S::CStride>;
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn next(&mut self) -> Option<Self::Item> {
|
||||||
|
if self.curr < self.ncols() {
|
||||||
|
let res = unsafe { (*self.mat).column_mut(self.curr) };
|
||||||
|
self.curr += 1;
|
||||||
|
Some(res)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||||
|
(self.ncols() - self.curr, Some(self.ncols() - self.curr))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn count(self) -> usize {
|
||||||
|
self.ncols() - self.curr
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a, N: Scalar, R: Dim, C: Dim, S: 'a + StorageMut<N, R, C>> ExactSizeIterator for ColumnIterMut<'a, N, R, C, S> {
|
||||||
|
#[inline]
|
||||||
|
fn len(&self) -> usize {
|
||||||
|
self.ncols() - self.curr
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -22,7 +22,7 @@ use alga::general::{ClosedAdd, ClosedMul, ClosedSub, Real, Ring};
|
||||||
use base::allocator::{Allocator, SameShapeAllocator, SameShapeC, SameShapeR};
|
use base::allocator::{Allocator, SameShapeAllocator, SameShapeC, SameShapeR};
|
||||||
use base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
|
use base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint};
|
||||||
use base::dimension::{Dim, DimAdd, DimSum, IsNotStaticOne, U1, U2, U3};
|
use base::dimension::{Dim, DimAdd, DimSum, IsNotStaticOne, U1, U2, U3};
|
||||||
use base::iter::{MatrixIter, MatrixIterMut};
|
use base::iter::{MatrixIter, MatrixIterMut, RowIter, RowIterMut, ColumnIter, ColumnIterMut};
|
||||||
use base::storage::{
|
use base::storage::{
|
||||||
ContiguousStorage, ContiguousStorageMut, Owned, SameShapeStorage, Storage, StorageMut,
|
ContiguousStorage, ContiguousStorageMut, Owned, SameShapeStorage, Storage, StorageMut,
|
||||||
};
|
};
|
||||||
|
|
@ -247,6 +247,37 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
|
||||||
MatrixIter::new(&self.data)
|
MatrixIter::new(&self.data)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Iterate through the rows of this matrix.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::Matrix2x3;
|
||||||
|
/// 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))
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn row_iter(&self) -> RowIter<N, R, C, S> {
|
||||||
|
RowIter::new(self)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Iterate through the columns of this matrix.
|
||||||
|
/// # Example
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::Matrix2x3;
|
||||||
|
/// 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))
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn column_iter(&self) -> ColumnIter<N, R, C, S> {
|
||||||
|
ColumnIter::new(self)
|
||||||
|
}
|
||||||
|
|
||||||
/// Computes the row and column coordinates of the i-th element of this matrix seen as a
|
/// Computes the row and column coordinates of the i-th element of this matrix seen as a
|
||||||
/// vector.
|
/// vector.
|
||||||
#[inline]
|
#[inline]
|
||||||
|
|
@ -493,6 +524,57 @@ impl<N: Scalar, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
|
||||||
res
|
res
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Folds a function `f` on each entry of `self`.
|
||||||
|
#[inline]
|
||||||
|
pub fn fold<Acc>(&self, init: Acc, mut f: impl FnMut(Acc, N) -> Acc) -> Acc {
|
||||||
|
let (nrows, ncols) = self.data.shape();
|
||||||
|
|
||||||
|
let mut res = init;
|
||||||
|
|
||||||
|
for j in 0..ncols.value() {
|
||||||
|
for i in 0..nrows.value() {
|
||||||
|
unsafe {
|
||||||
|
let a = *self.data.get_unchecked(i, j);
|
||||||
|
res = f(res, a)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
res
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Folds a function `f` on each pairs of entries from `self` and `rhs`.
|
||||||
|
#[inline]
|
||||||
|
pub fn zip_fold<N2, R2, C2, S2, Acc>(&self, rhs: &Matrix<N2, R2, C2, S2>, init: Acc, mut f: impl FnMut(Acc, N, N2) -> Acc) -> Acc
|
||||||
|
where
|
||||||
|
N2: Scalar,
|
||||||
|
R2: Dim,
|
||||||
|
C2: Dim,
|
||||||
|
S2: Storage<N2, R2, C2>,
|
||||||
|
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>
|
||||||
|
{
|
||||||
|
let (nrows, ncols) = self.data.shape();
|
||||||
|
|
||||||
|
let mut res = init;
|
||||||
|
|
||||||
|
assert!(
|
||||||
|
(nrows.value(), ncols.value()) == rhs.shape(),
|
||||||
|
"Matrix simultaneous traversal error: dimension mismatch."
|
||||||
|
);
|
||||||
|
|
||||||
|
for j in 0..ncols.value() {
|
||||||
|
for i in 0..nrows.value() {
|
||||||
|
unsafe {
|
||||||
|
let a = *self.data.get_unchecked(i, j);
|
||||||
|
let b = *rhs.data.get_unchecked(i, j);
|
||||||
|
res = f(res, a, b)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
res
|
||||||
|
}
|
||||||
|
|
||||||
/// Transposes `self` and store the result into `out`.
|
/// Transposes `self` and store the result into `out`.
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>)
|
pub fn transpose_to<R2, C2, SB>(&self, out: &mut Matrix<N, R2, C2, SB>)
|
||||||
|
|
@ -540,6 +622,46 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
|
||||||
MatrixIterMut::new(&mut self.data)
|
MatrixIterMut::new(&mut self.data)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Mutably iterates through this matrix rows.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::Matrix2x3;
|
||||||
|
/// 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);
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn row_iter_mut(&mut self) -> RowIterMut<N, R, C, S> {
|
||||||
|
RowIterMut::new(self)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Mutably iterates through this matrix columns.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::Matrix2x3;
|
||||||
|
/// 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);
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn column_iter_mut(&mut self) -> ColumnIterMut<N, R, C, S> {
|
||||||
|
ColumnIterMut::new(self)
|
||||||
|
}
|
||||||
|
|
||||||
/// Swaps two entries without bound-checking.
|
/// Swaps two entries without bound-checking.
|
||||||
#[inline]
|
#[inline]
|
||||||
pub 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)) {
|
||||||
|
|
@ -633,8 +755,7 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
|
||||||
|
|
||||||
/// Replaces each component of `self` by the result of a closure `f` applied on it.
|
/// Replaces each component of `self` by the result of a closure `f` applied on it.
|
||||||
#[inline]
|
#[inline]
|
||||||
pub fn apply<F: FnMut(N) -> N>(&mut self, mut f: F)
|
pub fn apply<F: FnMut(N) -> N>(&mut self, mut f: F) {
|
||||||
where DefaultAllocator: Allocator<N, R, C> {
|
|
||||||
let (nrows, ncols) = self.shape();
|
let (nrows, ncols) = self.shape();
|
||||||
|
|
||||||
for j in 0..ncols {
|
for j in 0..ncols {
|
||||||
|
|
@ -646,6 +767,71 @@ impl<N: Scalar, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Replaces each component of `self` by the result of a closure `f` applied on its components
|
||||||
|
/// joined with the components from `rhs`.
|
||||||
|
#[inline]
|
||||||
|
pub fn zip_apply<N2, R2, C2, S2>(&mut self, rhs: &Matrix<N2, R2, C2, S2>, mut f: impl FnMut(N, N2) -> N)
|
||||||
|
where N2: Scalar,
|
||||||
|
R2: Dim,
|
||||||
|
C2: Dim,
|
||||||
|
S2: Storage<N2, R2, C2>,
|
||||||
|
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2> {
|
||||||
|
let (nrows, ncols) = self.shape();
|
||||||
|
|
||||||
|
assert!(
|
||||||
|
(nrows, ncols) == rhs.shape(),
|
||||||
|
"Matrix simultaneous traversal error: dimension mismatch."
|
||||||
|
);
|
||||||
|
|
||||||
|
for j in 0..ncols {
|
||||||
|
for i in 0..nrows {
|
||||||
|
unsafe {
|
||||||
|
let e = self.data.get_unchecked_mut(i, j);
|
||||||
|
let rhs = rhs.get_unchecked((i, j));
|
||||||
|
*e = f(*e, *rhs)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/// Replaces each component of `self` by the result of a closure `f` applied on its components
|
||||||
|
/// joined with the components from `b` and `c`.
|
||||||
|
#[inline]
|
||||||
|
pub fn zip_zip_apply<N2, R2, C2, S2, N3, R3, C3, S3>(&mut self, b: &Matrix<N2, R2, C2, S2>, c: &Matrix<N3, R3, C3, S3>, mut f: impl FnMut(N, N2, N3) -> N)
|
||||||
|
where N2: Scalar,
|
||||||
|
R2: Dim,
|
||||||
|
C2: Dim,
|
||||||
|
S2: Storage<N2, R2, C2>,
|
||||||
|
N3: Scalar,
|
||||||
|
R3: Dim,
|
||||||
|
C3: Dim,
|
||||||
|
S3: Storage<N3, R3, C3>,
|
||||||
|
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2>,
|
||||||
|
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2> {
|
||||||
|
let (nrows, ncols) = self.shape();
|
||||||
|
|
||||||
|
assert!(
|
||||||
|
(nrows, ncols) == b.shape(),
|
||||||
|
"Matrix simultaneous traversal error: dimension mismatch."
|
||||||
|
);
|
||||||
|
assert!(
|
||||||
|
(nrows, ncols) == c.shape(),
|
||||||
|
"Matrix simultaneous traversal error: dimension mismatch."
|
||||||
|
);
|
||||||
|
|
||||||
|
for j in 0..ncols {
|
||||||
|
for i in 0..nrows {
|
||||||
|
unsafe {
|
||||||
|
let e = self.data.get_unchecked_mut(i, j);
|
||||||
|
let b = b.get_unchecked((i, j));
|
||||||
|
let c = c.get_unchecked((i, j));
|
||||||
|
*e = f(*e, *b, *c)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
|
impl<N: Scalar, D: Dim, S: Storage<N, D>> Vector<N, D, S> {
|
||||||
|
|
@ -1251,67 +1437,6 @@ impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
|
|
||||||
/// The squared L2 norm of this vector.
|
|
||||||
#[inline]
|
|
||||||
pub fn norm_squared(&self) -> N {
|
|
||||||
let mut res = N::zero();
|
|
||||||
|
|
||||||
for i in 0..self.ncols() {
|
|
||||||
let col = self.column(i);
|
|
||||||
res += col.dot(&col)
|
|
||||||
}
|
|
||||||
|
|
||||||
res
|
|
||||||
}
|
|
||||||
|
|
||||||
/// The L2 norm of this matrix.
|
|
||||||
#[inline]
|
|
||||||
pub fn norm(&self) -> N {
|
|
||||||
self.norm_squared().sqrt()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A synonym for the norm of this matrix.
|
|
||||||
///
|
|
||||||
/// Aka the length.
|
|
||||||
///
|
|
||||||
/// This function is simply implemented as a call to `norm()`
|
|
||||||
#[inline]
|
|
||||||
pub fn magnitude(&self) -> N {
|
|
||||||
self.norm()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A synonym for the squared norm of this matrix.
|
|
||||||
///
|
|
||||||
/// Aka the squared length.
|
|
||||||
///
|
|
||||||
/// This function is simply implemented as a call to `norm_squared()`
|
|
||||||
#[inline]
|
|
||||||
pub fn magnitude_squared(&self) -> N {
|
|
||||||
self.norm_squared()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns a normalized version of this matrix.
|
|
||||||
#[inline]
|
|
||||||
pub fn normalize(&self) -> MatrixMN<N, R, C>
|
|
||||||
where DefaultAllocator: Allocator<N, R, C> {
|
|
||||||
self / self.norm()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns a normalized version of this matrix unless its norm as smaller or equal to `eps`.
|
|
||||||
#[inline]
|
|
||||||
pub fn try_normalize(&self, min_norm: N) -> Option<MatrixMN<N, R, C>>
|
|
||||||
where DefaultAllocator: Allocator<N, R, C> {
|
|
||||||
let n = self.norm();
|
|
||||||
|
|
||||||
if n <= min_norm {
|
|
||||||
None
|
|
||||||
} else {
|
|
||||||
Some(self / n)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<N: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Storage<N, D>>
|
impl<N: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Storage<N, D>>
|
||||||
Vector<N, D, S>
|
Vector<N, D, S>
|
||||||
{
|
{
|
||||||
|
|
@ -1386,32 +1511,6 @@ impl<N: Real, D: Dim, S: Storage<N, D>> Unit<Vector<N, D, S>> {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl<N: Real, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
|
|
||||||
/// Normalizes this matrix in-place and returns its norm.
|
|
||||||
#[inline]
|
|
||||||
pub fn normalize_mut(&mut self) -> N {
|
|
||||||
let n = self.norm();
|
|
||||||
*self /= n;
|
|
||||||
|
|
||||||
n
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Normalizes this matrix in-place or does nothing if its norm is smaller or equal to `eps`.
|
|
||||||
///
|
|
||||||
/// If the normalization succeeded, returns the old normal of this matrix.
|
|
||||||
#[inline]
|
|
||||||
pub fn try_normalize_mut(&mut self, min_norm: N) -> Option<N> {
|
|
||||||
let n = self.norm();
|
|
||||||
|
|
||||||
if n <= min_norm {
|
|
||||||
None
|
|
||||||
} else {
|
|
||||||
*self /= n;
|
|
||||||
Some(n)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<N, R: Dim, C: Dim, S> AbsDiffEq for Unit<Matrix<N, R, C, S>>
|
impl<N, R: Dim, C: Dim, S> AbsDiffEq for Unit<Matrix<N, R, C, S>>
|
||||||
where
|
where
|
||||||
N: Scalar + AbsDiffEq,
|
N: Scalar + AbsDiffEq,
|
||||||
|
|
|
||||||
|
|
@ -29,6 +29,8 @@ mod properties;
|
||||||
mod scalar;
|
mod scalar;
|
||||||
mod swizzle;
|
mod swizzle;
|
||||||
mod unit;
|
mod unit;
|
||||||
|
mod statistics;
|
||||||
|
mod norm;
|
||||||
|
|
||||||
#[doc(hidden)]
|
#[doc(hidden)]
|
||||||
pub mod helper;
|
pub mod helper;
|
||||||
|
|
@ -36,6 +38,7 @@ pub mod helper;
|
||||||
pub use self::matrix::*;
|
pub use self::matrix::*;
|
||||||
pub use self::scalar::*;
|
pub use self::scalar::*;
|
||||||
pub use self::unit::*;
|
pub use self::unit::*;
|
||||||
|
pub use self::norm::*;
|
||||||
|
|
||||||
pub use self::default_allocator::*;
|
pub use self::default_allocator::*;
|
||||||
pub use self::dimension::*;
|
pub use self::dimension::*;
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,238 @@
|
||||||
|
use num::Signed;
|
||||||
|
use std::cmp::PartialOrd;
|
||||||
|
|
||||||
|
use allocator::Allocator;
|
||||||
|
use ::{Real, Scalar};
|
||||||
|
use storage::{Storage, StorageMut};
|
||||||
|
use base::{DefaultAllocator, Matrix, Dim, MatrixMN};
|
||||||
|
use constraint::{SameNumberOfRows, SameNumberOfColumns, ShapeConstraint};
|
||||||
|
|
||||||
|
|
||||||
|
// FIXME: this should be be a trait on alga?
|
||||||
|
/// A trait for abstract matrix norms.
|
||||||
|
///
|
||||||
|
/// This may be moved to the alga crate in the future.
|
||||||
|
pub trait Norm<N: Scalar> {
|
||||||
|
/// Apply this norm to the given matrix.
|
||||||
|
fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N
|
||||||
|
where R: Dim, C: Dim, S: Storage<N, R, C>;
|
||||||
|
/// Use the metric induced by this norm to compute the metric distance between the two given matrices.
|
||||||
|
fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N
|
||||||
|
where R1: Dim, C1: Dim, S1: Storage<N, R1, C1>,
|
||||||
|
R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
|
||||||
|
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2>;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Euclidean norm.
|
||||||
|
pub struct EuclideanNorm;
|
||||||
|
/// Lp norm.
|
||||||
|
pub struct LpNorm(pub i32);
|
||||||
|
/// L-infinite norm aka. Chebytchev norm aka. uniform norm aka. suppremum norm.
|
||||||
|
pub struct UniformNorm;
|
||||||
|
|
||||||
|
impl<N: Real> Norm<N> for EuclideanNorm {
|
||||||
|
#[inline]
|
||||||
|
fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N
|
||||||
|
where R: Dim, C: Dim, S: Storage<N, R, C> {
|
||||||
|
m.norm_squared().sqrt()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N
|
||||||
|
where R1: Dim, C1: Dim, S1: Storage<N, R1, C1>,
|
||||||
|
R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
|
||||||
|
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
||||||
|
m1.zip_fold(m2, N::zero(), |acc, a, b| {
|
||||||
|
let diff = a - b;
|
||||||
|
acc + diff * diff
|
||||||
|
}).sqrt()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<N: Real> Norm<N> for LpNorm {
|
||||||
|
#[inline]
|
||||||
|
fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N
|
||||||
|
where R: Dim, C: Dim, S: Storage<N, R, C> {
|
||||||
|
m.fold(N::zero(), |a, b| {
|
||||||
|
a + b.abs().powi(self.0)
|
||||||
|
}).powf(::convert(1.0 / (self.0 as f64)))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N
|
||||||
|
where R1: Dim, C1: Dim, S1: Storage<N, R1, C1>,
|
||||||
|
R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
|
||||||
|
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
||||||
|
m1.zip_fold(m2, N::zero(), |acc, a, b| {
|
||||||
|
let diff = a - b;
|
||||||
|
acc + diff.abs().powi(self.0)
|
||||||
|
}).powf(::convert(1.0 / (self.0 as f64)))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<N: Scalar + PartialOrd + Signed> Norm<N> for UniformNorm {
|
||||||
|
#[inline]
|
||||||
|
fn norm<R, C, S>(&self, m: &Matrix<N, R, C, S>) -> N
|
||||||
|
where R: Dim, C: Dim, S: Storage<N, R, C> {
|
||||||
|
m.amax()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn metric_distance<R1, C1, S1, R2, C2, S2>(&self, m1: &Matrix<N, R1, C1, S1>, m2: &Matrix<N, R2, C2, S2>) -> N
|
||||||
|
where R1: Dim, C1: Dim, S1: Storage<N, R1, C1>,
|
||||||
|
R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
|
||||||
|
ShapeConstraint: SameNumberOfRows<R1, R2> + SameNumberOfColumns<C1, C2> {
|
||||||
|
m1.zip_fold(m2, N::zero(), |acc, a, b| {
|
||||||
|
let val = (a - b).abs();
|
||||||
|
if val > acc {
|
||||||
|
val
|
||||||
|
} else {
|
||||||
|
acc
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
|
||||||
|
/// The squared L2 norm of this vector.
|
||||||
|
#[inline]
|
||||||
|
pub fn norm_squared(&self) -> N {
|
||||||
|
let mut res = N::zero();
|
||||||
|
|
||||||
|
for i in 0..self.ncols() {
|
||||||
|
let col = self.column(i);
|
||||||
|
res += col.dot(&col)
|
||||||
|
}
|
||||||
|
|
||||||
|
res
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The L2 norm of this matrix.
|
||||||
|
///
|
||||||
|
/// Use `.apply_norm` to apply a custom norm.
|
||||||
|
#[inline]
|
||||||
|
pub fn norm(&self) -> N {
|
||||||
|
self.norm_squared().sqrt()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Compute the distance between `self` and `rhs` using the metric induced by the euclidean norm.
|
||||||
|
///
|
||||||
|
/// Use `.apply_metric_distance` to apply a custom norm.
|
||||||
|
#[inline]
|
||||||
|
pub fn metric_distance<R2, C2, S2>(&self, rhs: &Matrix<N, R2, C2, S2>) -> N
|
||||||
|
where R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
|
||||||
|
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2> {
|
||||||
|
self.apply_metric_distance(rhs, &EuclideanNorm)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Uses the given `norm` to compute the norm of `self`.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Vector3, UniformNorm, LpNorm, EuclideanNorm};
|
||||||
|
///
|
||||||
|
/// 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());
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn apply_norm(&self, norm: &impl Norm<N>) -> N {
|
||||||
|
norm.norm(self)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Uses the metric induced by the given `norm` to compute the metric distance between `self` and `rhs`.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Vector3, UniformNorm, LpNorm, EuclideanNorm};
|
||||||
|
///
|
||||||
|
/// 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());
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn apply_metric_distance<R2, C2, S2>(&self, rhs: &Matrix<N, R2, C2, S2>, norm: &impl Norm<N>) -> N
|
||||||
|
where R2: Dim, C2: Dim, S2: Storage<N, R2, C2>,
|
||||||
|
ShapeConstraint: SameNumberOfRows<R, R2> + SameNumberOfColumns<C, C2> {
|
||||||
|
norm.metric_distance(self,rhs)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The Lp norm of this matrix.
|
||||||
|
#[inline]
|
||||||
|
pub fn lp_norm(&self, p: i32) -> N {
|
||||||
|
self.apply_norm(&LpNorm(p))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A synonym for the norm of this matrix.
|
||||||
|
///
|
||||||
|
/// Aka the length.
|
||||||
|
///
|
||||||
|
/// This function is simply implemented as a call to `norm()`
|
||||||
|
#[inline]
|
||||||
|
pub fn magnitude(&self) -> N {
|
||||||
|
self.norm()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A synonym for the squared norm of this matrix.
|
||||||
|
///
|
||||||
|
/// Aka the squared length.
|
||||||
|
///
|
||||||
|
/// This function is simply implemented as a call to `norm_squared()`
|
||||||
|
#[inline]
|
||||||
|
pub fn magnitude_squared(&self) -> N {
|
||||||
|
self.norm_squared()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns a normalized version of this matrix.
|
||||||
|
#[inline]
|
||||||
|
pub fn normalize(&self) -> MatrixMN<N, R, C>
|
||||||
|
where DefaultAllocator: Allocator<N, R, C> {
|
||||||
|
self / self.norm()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns a normalized version of this matrix unless its norm as smaller or equal to `eps`.
|
||||||
|
#[inline]
|
||||||
|
pub fn try_normalize(&self, min_norm: N) -> Option<MatrixMN<N, R, C>>
|
||||||
|
where DefaultAllocator: Allocator<N, R, C> {
|
||||||
|
let n = self.norm();
|
||||||
|
|
||||||
|
if n <= min_norm {
|
||||||
|
None
|
||||||
|
} else {
|
||||||
|
Some(self / n)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<N: Real, R: Dim, C: Dim, S: StorageMut<N, R, C>> Matrix<N, R, C, S> {
|
||||||
|
/// Normalizes this matrix in-place and returns its norm.
|
||||||
|
#[inline]
|
||||||
|
pub fn normalize_mut(&mut self) -> N {
|
||||||
|
let n = self.norm();
|
||||||
|
*self /= n;
|
||||||
|
|
||||||
|
n
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Normalizes this matrix in-place or does nothing if its norm is smaller or equal to `eps`.
|
||||||
|
///
|
||||||
|
/// If the normalization succeeded, returns the old normal of this matrix.
|
||||||
|
#[inline]
|
||||||
|
pub fn try_normalize_mut(&mut self, min_norm: N) -> Option<N> {
|
||||||
|
let n = self.norm();
|
||||||
|
|
||||||
|
if n <= min_norm {
|
||||||
|
None
|
||||||
|
} else {
|
||||||
|
*self /= n;
|
||||||
|
Some(n)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,309 @@
|
||||||
|
use ::{Real, Dim, Matrix, VectorN, RowVectorN, DefaultAllocator, U1, VectorSliceN};
|
||||||
|
use storage::Storage;
|
||||||
|
use allocator::Allocator;
|
||||||
|
|
||||||
|
impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
|
||||||
|
/// Returns a row vector where each element is the result of the application of `f` on the
|
||||||
|
/// corresponding column of the original matrix.
|
||||||
|
#[inline]
|
||||||
|
pub fn compress_rows(&self, f: impl Fn(VectorSliceN<N, R, S::RStride, S::CStride>) -> N) -> RowVectorN<N, C>
|
||||||
|
where DefaultAllocator: Allocator<N, U1, C> {
|
||||||
|
|
||||||
|
let ncols = self.data.shape().1;
|
||||||
|
let mut res = unsafe { RowVectorN::new_uninitialized_generic(U1, ncols) };
|
||||||
|
|
||||||
|
for i in 0..ncols.value() {
|
||||||
|
// FIXME: avoid bound checking of column.
|
||||||
|
unsafe { *res.get_unchecked_mut((0, i)) = f(self.column(i)); }
|
||||||
|
}
|
||||||
|
|
||||||
|
res
|
||||||
|
}
|
||||||
|
|
||||||
|
/// 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()`.
|
||||||
|
#[inline]
|
||||||
|
pub fn compress_rows_tr(&self, f: impl Fn(VectorSliceN<N, R, S::RStride, S::CStride>) -> N) -> VectorN<N, C>
|
||||||
|
where DefaultAllocator: Allocator<N, C> {
|
||||||
|
|
||||||
|
let ncols = self.data.shape().1;
|
||||||
|
let mut res = unsafe { VectorN::new_uninitialized_generic(ncols, U1) };
|
||||||
|
|
||||||
|
for i in 0..ncols.value() {
|
||||||
|
// FIXME: avoid bound checking of column.
|
||||||
|
unsafe { *res.vget_unchecked_mut(i) = f(self.column(i)); }
|
||||||
|
}
|
||||||
|
|
||||||
|
res
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns a column vector resulting from the folding of `f` on each column of this matrix.
|
||||||
|
#[inline]
|
||||||
|
pub fn compress_columns(&self, init: VectorN<N, R>, f: impl Fn(&mut VectorN<N, R>, VectorSliceN<N, R, S::RStride, S::CStride>)) -> VectorN<N, R>
|
||||||
|
where DefaultAllocator: Allocator<N, R> {
|
||||||
|
let mut res = init;
|
||||||
|
|
||||||
|
for i in 0..self.ncols() {
|
||||||
|
f(&mut res, self.column(i))
|
||||||
|
}
|
||||||
|
|
||||||
|
res
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<N: Real, R: Dim, C: Dim, S: Storage<N, R, C>> Matrix<N, R, C, S> {
|
||||||
|
/*
|
||||||
|
*
|
||||||
|
* Sum computation.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
/// The sum of all the elements of this matrix.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::Matrix2x3;
|
||||||
|
///
|
||||||
|
/// let m = Matrix2x3::new(1.0, 2.0, 3.0,
|
||||||
|
/// 4.0, 5.0, 6.0);
|
||||||
|
/// assert_eq!(m.sum(), 21.0);
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn sum(&self) -> N {
|
||||||
|
self.iter().cloned().fold(N::zero(), |a, b| a + b)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The sum of all the rows of this matrix.
|
||||||
|
///
|
||||||
|
/// Use `.row_variance_tr` if you need the result in a column vector instead.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Matrix2x3, RowVector3};
|
||||||
|
///
|
||||||
|
/// 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));
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn row_sum(&self) -> RowVectorN<N, C>
|
||||||
|
where DefaultAllocator: Allocator<N, U1, C> {
|
||||||
|
self.compress_rows(|col| col.sum())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The sum of all the rows of this matrix. The result is transposed and returned as a column vector.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Matrix2x3, Vector3};
|
||||||
|
///
|
||||||
|
/// 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));
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn row_sum_tr(&self) -> VectorN<N, C>
|
||||||
|
where DefaultAllocator: Allocator<N, C> {
|
||||||
|
self.compress_rows_tr(|col| col.sum())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The sum of all the columns of this matrix.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Matrix2x3, Vector2};
|
||||||
|
///
|
||||||
|
/// 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));
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn column_sum(&self) -> VectorN<N, R>
|
||||||
|
where DefaultAllocator: Allocator<N, R> {
|
||||||
|
let nrows = self.data.shape().0;
|
||||||
|
self.compress_columns(VectorN::zeros_generic(nrows, U1), |out, col| {
|
||||||
|
out.axpy(N::one(), &col, N::one())
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
*
|
||||||
|
* Variance computation.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
/// The variance of all the elements of this matrix.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # #[macro_use] extern crate approx;
|
||||||
|
/// # use nalgebra::Matrix2x3;
|
||||||
|
///
|
||||||
|
/// 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);
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn variance(&self) -> N {
|
||||||
|
if self.len() == 0 {
|
||||||
|
N::zero()
|
||||||
|
} else {
|
||||||
|
let val = self.iter().cloned().fold((N::zero(), N::zero()), |a, b| (a.0 + b * b, a.1 + b));
|
||||||
|
let denom = N::one() / ::convert::<_, N>(self.len() as f64);
|
||||||
|
val.0 * denom - (val.1 * denom) * (val.1 * denom)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The variance of all the rows of this matrix.
|
||||||
|
///
|
||||||
|
/// Use `.row_variance_tr` if you need the result in a column vector instead.
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Matrix2x3, RowVector3};
|
||||||
|
///
|
||||||
|
/// 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));
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn row_variance(&self) -> RowVectorN<N, C>
|
||||||
|
where DefaultAllocator: Allocator<N, U1, C> {
|
||||||
|
self.compress_rows(|col| col.variance())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The variance of all the rows of this matrix. The result is transposed and returned as a column vector.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Matrix2x3, Vector3};
|
||||||
|
///
|
||||||
|
/// 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));
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn row_variance_tr(&self) -> VectorN<N, C>
|
||||||
|
where DefaultAllocator: Allocator<N, C> {
|
||||||
|
self.compress_rows_tr(|col| col.variance())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The variance of all the columns of this matrix.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # #[macro_use] extern crate approx;
|
||||||
|
/// # use nalgebra::{Matrix2x3, Vector2};
|
||||||
|
///
|
||||||
|
/// 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);
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn column_variance(&self) -> VectorN<N, R>
|
||||||
|
where DefaultAllocator: Allocator<N, R> {
|
||||||
|
let (nrows, ncols) = self.data.shape();
|
||||||
|
|
||||||
|
let mut mean = self.column_mean();
|
||||||
|
mean.apply(|e| -(e * e));
|
||||||
|
|
||||||
|
let denom = N::one() / ::convert::<_, N>(ncols.value() as f64);
|
||||||
|
self.compress_columns(mean, |out, col| {
|
||||||
|
for i in 0..nrows.value() {
|
||||||
|
unsafe {
|
||||||
|
let val = col.vget_unchecked(i);
|
||||||
|
*out.vget_unchecked_mut(i) += denom * *val * *val
|
||||||
|
}
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
*
|
||||||
|
* Mean computation.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
/// The mean of all the elements of this matrix.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::Matrix2x3;
|
||||||
|
///
|
||||||
|
/// let m = Matrix2x3::new(1.0, 2.0, 3.0,
|
||||||
|
/// 4.0, 5.0, 6.0);
|
||||||
|
/// assert_eq!(m.mean(), 3.5);
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn mean(&self) -> N {
|
||||||
|
if self.len() == 0 {
|
||||||
|
N::zero()
|
||||||
|
} else {
|
||||||
|
self.sum() / ::convert(self.len() as f64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The mean of all the rows of this matrix.
|
||||||
|
///
|
||||||
|
/// Use `.row_mean_tr` if you need the result in a column vector instead.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Matrix2x3, RowVector3};
|
||||||
|
///
|
||||||
|
/// 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));
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn row_mean(&self) -> RowVectorN<N, C>
|
||||||
|
where DefaultAllocator: Allocator<N, U1, C> {
|
||||||
|
self.compress_rows(|col| col.mean())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The mean of all the rows of this matrix. The result is transposed and returned as a column vector.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Matrix2x3, Vector3};
|
||||||
|
///
|
||||||
|
/// 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));
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn row_mean_tr(&self) -> VectorN<N, C>
|
||||||
|
where DefaultAllocator: Allocator<N, C> {
|
||||||
|
self.compress_rows_tr(|col| col.mean())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The mean of all the columns of this matrix.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # use nalgebra::{Matrix2x3, Vector2};
|
||||||
|
///
|
||||||
|
/// 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));
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn column_mean(&self) -> VectorN<N, R>
|
||||||
|
where DefaultAllocator: Allocator<N, R> {
|
||||||
|
let (nrows, ncols) = self.data.shape();
|
||||||
|
let denom = N::one() / ::convert::<_, N>(ncols.value() as f64);
|
||||||
|
self.compress_columns(VectorN::zeros_generic(nrows, U1), |out, col| {
|
||||||
|
out.axpy(denom, &col, N::one())
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -113,7 +113,6 @@ where DefaultAllocator: Allocator<N, D>
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Isometry3, Translation3, UnitQuaternion, Vector3, Point3};
|
/// # use nalgebra::{Isometry3, Translation3, UnitQuaternion, Vector3, Point3};
|
||||||
/// let tra = Translation3::new(0.0, 0.0, 3.0);
|
/// let tra = Translation3::new(0.0, 0.0, 3.0);
|
||||||
|
|
@ -197,7 +196,6 @@ where DefaultAllocator: Allocator<N, D>
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Isometry2, Translation2, UnitComplex, Vector2};
|
/// # use nalgebra::{Isometry2, Translation2, UnitComplex, Vector2};
|
||||||
/// let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::PI / 6.0);
|
/// let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::PI / 6.0);
|
||||||
|
|
@ -220,7 +218,6 @@ where DefaultAllocator: Allocator<N, D>
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Isometry2, Translation2, UnitComplex, Vector2, Point2};
|
/// # use nalgebra::{Isometry2, Translation2, UnitComplex, Vector2, Point2};
|
||||||
/// let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
|
/// let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
|
||||||
|
|
@ -272,7 +269,6 @@ where DefaultAllocator: Allocator<N, D>
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Isometry2, Vector2, Matrix3};
|
/// # use nalgebra::{Isometry2, Vector2, Matrix3};
|
||||||
/// let iso = Isometry2::new(Vector2::new(10.0, 20.0), f32::consts::FRAC_PI_6);
|
/// let iso = Isometry2::new(Vector2::new(10.0, 20.0), f32::consts::FRAC_PI_6);
|
||||||
|
|
|
||||||
|
|
@ -49,7 +49,6 @@ where DefaultAllocator: Allocator<N, D>
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Isometry2, Point2, UnitComplex};
|
/// # use nalgebra::{Isometry2, Point2, UnitComplex};
|
||||||
/// let rot = UnitComplex::new(f32::consts::PI);
|
/// let rot = UnitComplex::new(f32::consts::PI);
|
||||||
|
|
@ -165,7 +164,6 @@ macro_rules! isometry_construction_impl(
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Isometry3, IsometryMatrix3, Point3, Vector3};
|
/// # use nalgebra::{Isometry3, IsometryMatrix3, Point3, Vector3};
|
||||||
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
||||||
|
|
@ -206,7 +204,6 @@ macro_rules! isometry_construction_impl(
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Isometry3, IsometryMatrix3, Point3, Vector3};
|
/// # use nalgebra::{Isometry3, IsometryMatrix3, Point3, Vector3};
|
||||||
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
||||||
|
|
@ -258,7 +255,6 @@ macro_rules! isometry_construction_impl(
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Isometry3, IsometryMatrix3, Point3, Vector3};
|
/// # use nalgebra::{Isometry3, IsometryMatrix3, Point3, Vector3};
|
||||||
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
||||||
|
|
@ -302,7 +298,6 @@ macro_rules! isometry_construction_impl(
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Isometry3, IsometryMatrix3, Point3, Vector3};
|
/// # use nalgebra::{Isometry3, IsometryMatrix3, Point3, Vector3};
|
||||||
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
||||||
|
|
|
||||||
|
|
@ -69,7 +69,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Orthographic3, Point3};
|
/// # use nalgebra::{Orthographic3, Point3};
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// // Check this projection actually transforms the view cuboid into the double-unit cube.
|
/// // Check this projection actually transforms the view cuboid into the double-unit cube.
|
||||||
|
|
@ -170,7 +169,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Orthographic3, Point3, Matrix4};
|
/// # use nalgebra::{Orthographic3, Point3, Matrix4};
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// let inv = proj.inverse();
|
/// let inv = proj.inverse();
|
||||||
|
|
@ -271,7 +269,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Orthographic3, Point3, Matrix4};
|
/// # use nalgebra::{Orthographic3, Point3, Matrix4};
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// let expected = Matrix4::new(
|
/// let expected = Matrix4::new(
|
||||||
|
|
@ -299,7 +296,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// assert_relative_eq!(proj.left(), 1.0, epsilon = 1.0e-6);
|
/// assert_relative_eq!(proj.left(), 1.0, epsilon = 1.0e-6);
|
||||||
|
|
@ -316,7 +312,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// assert_relative_eq!(proj.right(), 10.0, epsilon = 1.0e-6);
|
/// assert_relative_eq!(proj.right(), 10.0, epsilon = 1.0e-6);
|
||||||
|
|
@ -333,7 +328,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// assert_relative_eq!(proj.bottom(), 2.0, epsilon = 1.0e-6);
|
/// assert_relative_eq!(proj.bottom(), 2.0, epsilon = 1.0e-6);
|
||||||
|
|
@ -350,7 +344,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// assert_relative_eq!(proj.top(), 20.0, epsilon = 1.0e-6);
|
/// assert_relative_eq!(proj.top(), 20.0, epsilon = 1.0e-6);
|
||||||
|
|
@ -367,7 +360,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// assert_relative_eq!(proj.znear(), 0.1, epsilon = 1.0e-6);
|
/// assert_relative_eq!(proj.znear(), 0.1, epsilon = 1.0e-6);
|
||||||
|
|
@ -384,7 +376,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// assert_relative_eq!(proj.zfar(), 1000.0, epsilon = 1.0e-6);
|
/// assert_relative_eq!(proj.zfar(), 1000.0, epsilon = 1.0e-6);
|
||||||
|
|
@ -403,7 +394,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Orthographic3, Point3};
|
/// # use nalgebra::{Orthographic3, Point3};
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
///
|
///
|
||||||
|
|
@ -439,7 +429,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Orthographic3, Point3};
|
/// # use nalgebra::{Orthographic3, Point3};
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
///
|
///
|
||||||
|
|
@ -478,7 +467,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Orthographic3, Vector3};
|
/// # use nalgebra::{Orthographic3, Vector3};
|
||||||
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
///
|
///
|
||||||
|
|
@ -504,7 +492,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// proj.set_left(2.0);
|
/// proj.set_left(2.0);
|
||||||
|
|
@ -524,7 +511,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// proj.set_right(15.0);
|
/// proj.set_right(15.0);
|
||||||
|
|
@ -544,7 +530,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// proj.set_bottom(8.0);
|
/// proj.set_bottom(8.0);
|
||||||
|
|
@ -564,7 +549,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// proj.set_top(15.0);
|
/// proj.set_top(15.0);
|
||||||
|
|
@ -584,7 +568,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// proj.set_znear(8.0);
|
/// proj.set_znear(8.0);
|
||||||
|
|
@ -604,7 +587,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// proj.set_zfar(15.0);
|
/// proj.set_zfar(15.0);
|
||||||
|
|
@ -624,7 +606,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// proj.set_left_and_right(7.0, 70.0);
|
/// proj.set_left_and_right(7.0, 70.0);
|
||||||
|
|
@ -650,7 +631,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// proj.set_bottom_and_top(7.0, 70.0);
|
/// proj.set_bottom_and_top(7.0, 70.0);
|
||||||
|
|
@ -676,7 +656,6 @@ impl<N: Real> Orthographic3<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Orthographic3;
|
/// # use nalgebra::Orthographic3;
|
||||||
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
/// let mut proj = Orthographic3::new(1.0, 10.0, 2.0, 20.0, 0.1, 1000.0);
|
||||||
/// proj.set_znear_and_zfar(50.0, 5000.0);
|
/// proj.set_znear_and_zfar(50.0, 5000.0);
|
||||||
|
|
|
||||||
|
|
@ -114,7 +114,6 @@ impl<N: Real> Quaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Quaternion;
|
/// # use nalgebra::Quaternion;
|
||||||
/// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
/// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
||||||
/// let q_normalized = q.normalize();
|
/// let q_normalized = q.normalize();
|
||||||
|
|
@ -150,7 +149,6 @@ impl<N: Real> Quaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Quaternion;
|
/// # use nalgebra::Quaternion;
|
||||||
/// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
/// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
||||||
/// let inv_q = q.try_inverse();
|
/// let inv_q = q.try_inverse();
|
||||||
|
|
@ -240,7 +238,6 @@ impl<N: Real> Quaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Quaternion;
|
/// # use nalgebra::Quaternion;
|
||||||
/// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
/// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
||||||
/// assert_relative_eq!(q.norm(), 5.47722557, epsilon = 1.0e-6);
|
/// assert_relative_eq!(q.norm(), 5.47722557, epsilon = 1.0e-6);
|
||||||
|
|
@ -258,7 +255,6 @@ impl<N: Real> Quaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Quaternion;
|
/// # use nalgebra::Quaternion;
|
||||||
/// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
/// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
||||||
/// assert_relative_eq!(q.magnitude(), 5.47722557, epsilon = 1.0e-6);
|
/// assert_relative_eq!(q.magnitude(), 5.47722557, epsilon = 1.0e-6);
|
||||||
|
|
@ -345,7 +341,6 @@ impl<N: Real> Quaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Quaternion;
|
/// # use nalgebra::Quaternion;
|
||||||
/// let q = Quaternion::new(2.0, 5.0, 0.0, 0.0);
|
/// let q = Quaternion::new(2.0, 5.0, 0.0, 0.0);
|
||||||
/// assert_relative_eq!(q.ln(), Quaternion::new(1.683647, 1.190289, 0.0, 0.0), epsilon = 1.0e-6)
|
/// assert_relative_eq!(q.ln(), Quaternion::new(1.683647, 1.190289, 0.0, 0.0), epsilon = 1.0e-6)
|
||||||
|
|
@ -364,7 +359,6 @@ impl<N: Real> Quaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Quaternion;
|
/// # use nalgebra::Quaternion;
|
||||||
/// let q = Quaternion::new(1.683647, 1.190289, 0.0, 0.0);
|
/// let q = Quaternion::new(1.683647, 1.190289, 0.0, 0.0);
|
||||||
/// assert_relative_eq!(q.exp(), Quaternion::new(2.0, 5.0, 0.0, 0.0), epsilon = 1.0e-5)
|
/// assert_relative_eq!(q.exp(), Quaternion::new(2.0, 5.0, 0.0, 0.0), epsilon = 1.0e-5)
|
||||||
|
|
@ -380,7 +374,6 @@ impl<N: Real> Quaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Quaternion;
|
/// # use nalgebra::Quaternion;
|
||||||
/// let q = Quaternion::new(1.683647, 1.190289, 0.0, 0.0);
|
/// let q = Quaternion::new(1.683647, 1.190289, 0.0, 0.0);
|
||||||
/// assert_relative_eq!(q.exp_eps(1.0e-6), Quaternion::new(2.0, 5.0, 0.0, 0.0), epsilon = 1.0e-5);
|
/// assert_relative_eq!(q.exp_eps(1.0e-6), Quaternion::new(2.0, 5.0, 0.0, 0.0), epsilon = 1.0e-5);
|
||||||
|
|
@ -410,7 +403,6 @@ impl<N: Real> Quaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Quaternion;
|
/// # use nalgebra::Quaternion;
|
||||||
/// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
/// let q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
||||||
/// assert_relative_eq!(q.powf(1.5), Quaternion::new( -6.2576659, 4.1549037, 6.2323556, 8.3098075), epsilon = 1.0e-6);
|
/// assert_relative_eq!(q.powf(1.5), Quaternion::new( -6.2576659, 4.1549037, 6.2323556, 8.3098075), epsilon = 1.0e-6);
|
||||||
|
|
@ -476,7 +468,6 @@ impl<N: Real> Quaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Quaternion;
|
/// # use nalgebra::Quaternion;
|
||||||
/// let mut q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
/// let mut q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
||||||
///
|
///
|
||||||
|
|
@ -506,7 +497,6 @@ impl<N: Real> Quaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Quaternion;
|
/// # use nalgebra::Quaternion;
|
||||||
/// let mut q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
/// let mut q = Quaternion::new(1.0, 2.0, 3.0, 4.0);
|
||||||
/// q.normalize_mut();
|
/// q.normalize_mut();
|
||||||
|
|
@ -672,7 +662,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{UnitQuaternion, Vector3};
|
/// # use nalgebra::{UnitQuaternion, Vector3};
|
||||||
/// let rot1 = UnitQuaternion::from_axis_angle(&Vector3::y_axis(), 1.0);
|
/// let rot1 = UnitQuaternion::from_axis_angle(&Vector3::y_axis(), 1.0);
|
||||||
/// let rot2 = UnitQuaternion::from_axis_angle(&Vector3::x_axis(), 0.1);
|
/// let rot2 = UnitQuaternion::from_axis_angle(&Vector3::x_axis(), 0.1);
|
||||||
|
|
@ -691,7 +680,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{UnitQuaternion, Vector3};
|
/// # use nalgebra::{UnitQuaternion, Vector3};
|
||||||
/// let rot1 = UnitQuaternion::from_axis_angle(&Vector3::y_axis(), 1.0);
|
/// let rot1 = UnitQuaternion::from_axis_angle(&Vector3::y_axis(), 1.0);
|
||||||
/// let rot2 = UnitQuaternion::from_axis_angle(&Vector3::x_axis(), 0.1);
|
/// let rot2 = UnitQuaternion::from_axis_angle(&Vector3::x_axis(), 0.1);
|
||||||
|
|
@ -785,7 +773,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{UnitQuaternion, Vector3, Unit};
|
/// # use nalgebra::{UnitQuaternion, Vector3, Unit};
|
||||||
/// let axisangle = Vector3::new(0.1, 0.2, 0.3);
|
/// let axisangle = Vector3::new(0.1, 0.2, 0.3);
|
||||||
/// let mut rot = UnitQuaternion::new(axisangle);
|
/// let mut rot = UnitQuaternion::new(axisangle);
|
||||||
|
|
@ -828,7 +815,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{UnitQuaternion, Vector3, Unit};
|
/// # use nalgebra::{UnitQuaternion, Vector3, Unit};
|
||||||
/// let axisangle = Vector3::new(0.1, 0.2, 0.3);
|
/// let axisangle = Vector3::new(0.1, 0.2, 0.3);
|
||||||
/// let rot = UnitQuaternion::new(axisangle);
|
/// let rot = UnitQuaternion::new(axisangle);
|
||||||
|
|
@ -885,7 +871,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Vector3, UnitQuaternion};
|
/// # use nalgebra::{Vector3, UnitQuaternion};
|
||||||
/// let axisangle = Vector3::new(0.1, 0.2, 0.3);
|
/// let axisangle = Vector3::new(0.1, 0.2, 0.3);
|
||||||
/// let q = UnitQuaternion::new(axisangle);
|
/// let q = UnitQuaternion::new(axisangle);
|
||||||
|
|
@ -908,7 +893,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{UnitQuaternion, Vector3, Unit};
|
/// # use nalgebra::{UnitQuaternion, Vector3, Unit};
|
||||||
/// let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
/// let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let angle = 1.2;
|
/// let angle = 1.2;
|
||||||
|
|
@ -932,7 +916,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitQuaternion, Vector3, Matrix3};
|
/// # use nalgebra::{UnitQuaternion, Vector3, Matrix3};
|
||||||
/// let q = UnitQuaternion::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
|
/// let q = UnitQuaternion::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
|
||||||
|
|
@ -990,7 +973,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::UnitQuaternion;
|
/// # use nalgebra::UnitQuaternion;
|
||||||
/// let rot = UnitQuaternion::from_euler_angles(0.1, 0.2, 0.3);
|
/// let rot = UnitQuaternion::from_euler_angles(0.1, 0.2, 0.3);
|
||||||
/// let euler = rot.euler_angles();
|
/// let euler = rot.euler_angles();
|
||||||
|
|
@ -1009,7 +991,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitQuaternion, Vector3, Matrix4};
|
/// # use nalgebra::{UnitQuaternion, Vector3, Matrix4};
|
||||||
/// let rot = UnitQuaternion::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
|
/// let rot = UnitQuaternion::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
|
||||||
|
|
|
||||||
|
|
@ -166,7 +166,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitQuaternion, Point3, Vector3};
|
/// # use nalgebra::{UnitQuaternion, Point3, Vector3};
|
||||||
/// let axis = Vector3::y_axis();
|
/// let axis = Vector3::y_axis();
|
||||||
|
|
@ -208,7 +207,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::UnitQuaternion;
|
/// # use nalgebra::UnitQuaternion;
|
||||||
/// let rot = UnitQuaternion::from_euler_angles(0.1, 0.2, 0.3);
|
/// let rot = UnitQuaternion::from_euler_angles(0.1, 0.2, 0.3);
|
||||||
/// let euler = rot.euler_angles();
|
/// let euler = rot.euler_angles();
|
||||||
|
|
@ -237,7 +235,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation3, UnitQuaternion, Vector3};
|
/// # use nalgebra::{Rotation3, UnitQuaternion, Vector3};
|
||||||
/// let axis = Vector3::y_axis();
|
/// let axis = Vector3::y_axis();
|
||||||
/// let angle = 0.1;
|
/// let angle = 0.1;
|
||||||
|
|
@ -302,7 +299,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Vector3, UnitQuaternion};
|
/// # use nalgebra::{Vector3, UnitQuaternion};
|
||||||
/// let a = Vector3::new(1.0, 2.0, 3.0);
|
/// let a = Vector3::new(1.0, 2.0, 3.0);
|
||||||
/// let b = Vector3::new(3.0, 1.0, 2.0);
|
/// let b = Vector3::new(3.0, 1.0, 2.0);
|
||||||
|
|
@ -325,7 +321,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Vector3, UnitQuaternion};
|
/// # use nalgebra::{Vector3, UnitQuaternion};
|
||||||
/// let a = Vector3::new(1.0, 2.0, 3.0);
|
/// let a = Vector3::new(1.0, 2.0, 3.0);
|
||||||
/// let b = Vector3::new(3.0, 1.0, 2.0);
|
/// let b = Vector3::new(3.0, 1.0, 2.0);
|
||||||
|
|
@ -361,7 +356,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Unit, Vector3, UnitQuaternion};
|
/// # use nalgebra::{Unit, Vector3, UnitQuaternion};
|
||||||
/// let a = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
/// let a = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let b = Unit::new_normalize(Vector3::new(3.0, 1.0, 2.0));
|
/// let b = Unit::new_normalize(Vector3::new(3.0, 1.0, 2.0));
|
||||||
|
|
@ -387,7 +381,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Unit, Vector3, UnitQuaternion};
|
/// # use nalgebra::{Unit, Vector3, UnitQuaternion};
|
||||||
/// let a = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
/// let a = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let b = Unit::new_normalize(Vector3::new(3.0, 1.0, 2.0));
|
/// let b = Unit::new_normalize(Vector3::new(3.0, 1.0, 2.0));
|
||||||
|
|
@ -446,7 +439,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitQuaternion, Vector3};
|
/// # use nalgebra::{UnitQuaternion, Vector3};
|
||||||
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
||||||
|
|
@ -488,7 +480,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitQuaternion, Vector3};
|
/// # use nalgebra::{UnitQuaternion, Vector3};
|
||||||
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
||||||
|
|
@ -520,7 +511,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitQuaternion, Vector3};
|
/// # use nalgebra::{UnitQuaternion, Vector3};
|
||||||
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
||||||
|
|
@ -545,7 +535,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitQuaternion, Point3, Vector3};
|
/// # use nalgebra::{UnitQuaternion, Point3, Vector3};
|
||||||
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
||||||
|
|
@ -575,7 +564,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitQuaternion, Point3, Vector3};
|
/// # use nalgebra::{UnitQuaternion, Point3, Vector3};
|
||||||
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
||||||
|
|
@ -606,7 +594,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitQuaternion, Point3, Vector3};
|
/// # use nalgebra::{UnitQuaternion, Point3, Vector3};
|
||||||
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
||||||
|
|
@ -635,7 +622,6 @@ impl<N: Real> UnitQuaternion<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitQuaternion, Point3, Vector3};
|
/// # use nalgebra::{UnitQuaternion, Point3, Vector3};
|
||||||
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
||||||
|
|
|
||||||
|
|
@ -257,7 +257,6 @@ where DefaultAllocator: Allocator<N, D, D>
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation2, Rotation3, Vector3};
|
/// # use nalgebra::{Rotation2, Rotation3, Vector3};
|
||||||
/// let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
/// let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let tr_rot = rot.transpose();
|
/// let tr_rot = rot.transpose();
|
||||||
|
|
@ -281,7 +280,6 @@ where DefaultAllocator: Allocator<N, D, D>
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation2, Rotation3, Vector3};
|
/// # use nalgebra::{Rotation2, Rotation3, Vector3};
|
||||||
/// let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
/// let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let inv = rot.inverse();
|
/// let inv = rot.inverse();
|
||||||
|
|
@ -305,7 +303,6 @@ where DefaultAllocator: Allocator<N, D, D>
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation2, Rotation3, Vector3};
|
/// # use nalgebra::{Rotation2, Rotation3, Vector3};
|
||||||
/// let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
/// let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let mut tr_rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
/// let mut tr_rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
||||||
|
|
@ -333,7 +330,6 @@ where DefaultAllocator: Allocator<N, D, D>
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation2, Rotation3, Vector3};
|
/// # use nalgebra::{Rotation2, Rotation3, Vector3};
|
||||||
/// let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
/// let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let mut inv = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
/// let mut inv = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
|
||||||
|
|
|
||||||
|
|
@ -27,7 +27,6 @@ impl<N: Real> Rotation2<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Rotation2, Point2};
|
/// # use nalgebra::{Rotation2, Point2};
|
||||||
/// let rot = Rotation2::new(f32::consts::FRAC_PI_2);
|
/// let rot = Rotation2::new(f32::consts::FRAC_PI_2);
|
||||||
|
|
@ -56,7 +55,6 @@ impl<N: Real> Rotation2<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Vector2, Rotation2};
|
/// # use nalgebra::{Vector2, Rotation2};
|
||||||
/// let a = Vector2::new(1.0, 2.0);
|
/// let a = Vector2::new(1.0, 2.0);
|
||||||
/// let b = Vector2::new(2.0, 1.0);
|
/// let b = Vector2::new(2.0, 1.0);
|
||||||
|
|
@ -79,7 +77,6 @@ impl<N: Real> Rotation2<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Vector2, Rotation2};
|
/// # use nalgebra::{Vector2, Rotation2};
|
||||||
/// let a = Vector2::new(1.0, 2.0);
|
/// let a = Vector2::new(1.0, 2.0);
|
||||||
/// let b = Vector2::new(2.0, 1.0);
|
/// let b = Vector2::new(2.0, 1.0);
|
||||||
|
|
@ -108,7 +105,6 @@ impl<N: Real> Rotation2<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Rotation2;
|
/// # use nalgebra::Rotation2;
|
||||||
/// let rot = Rotation2::new(1.78);
|
/// let rot = Rotation2::new(1.78);
|
||||||
/// assert_relative_eq!(rot.angle(), 1.78);
|
/// assert_relative_eq!(rot.angle(), 1.78);
|
||||||
|
|
@ -123,7 +119,6 @@ impl<N: Real> Rotation2<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Rotation2;
|
/// # use nalgebra::Rotation2;
|
||||||
/// let rot1 = Rotation2::new(0.1);
|
/// let rot1 = Rotation2::new(0.1);
|
||||||
/// let rot2 = Rotation2::new(1.7);
|
/// let rot2 = Rotation2::new(1.7);
|
||||||
|
|
@ -141,7 +136,6 @@ impl<N: Real> Rotation2<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Rotation2;
|
/// # use nalgebra::Rotation2;
|
||||||
/// let rot1 = Rotation2::new(0.1);
|
/// let rot1 = Rotation2::new(0.1);
|
||||||
/// let rot2 = Rotation2::new(1.7);
|
/// let rot2 = Rotation2::new(1.7);
|
||||||
|
|
@ -161,7 +155,6 @@ impl<N: Real> Rotation2<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Rotation2;
|
/// # use nalgebra::Rotation2;
|
||||||
/// let rot = Rotation2::new(0.78);
|
/// let rot = Rotation2::new(0.78);
|
||||||
/// let pow = rot.powf(2.0);
|
/// let pow = rot.powf(2.0);
|
||||||
|
|
@ -217,7 +210,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Rotation3, Point3, Vector3};
|
/// # use nalgebra::{Rotation3, Point3, Vector3};
|
||||||
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
||||||
|
|
@ -245,7 +237,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Rotation3, Point3, Vector3};
|
/// # use nalgebra::{Rotation3, Point3, Vector3};
|
||||||
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
||||||
|
|
@ -269,7 +260,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Rotation3, Point3, Vector3};
|
/// # use nalgebra::{Rotation3, Point3, Vector3};
|
||||||
/// let axis = Vector3::y_axis();
|
/// let axis = Vector3::y_axis();
|
||||||
|
|
@ -322,7 +312,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Rotation3;
|
/// # use nalgebra::Rotation3;
|
||||||
/// let rot = Rotation3::from_euler_angles(0.1, 0.2, 0.3);
|
/// let rot = Rotation3::from_euler_angles(0.1, 0.2, 0.3);
|
||||||
/// let euler = rot.euler_angles();
|
/// let euler = rot.euler_angles();
|
||||||
|
|
@ -363,7 +352,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::Rotation3;
|
/// # use nalgebra::Rotation3;
|
||||||
/// let rot = Rotation3::from_euler_angles(0.1, 0.2, 0.3);
|
/// let rot = Rotation3::from_euler_angles(0.1, 0.2, 0.3);
|
||||||
/// let euler = rot.euler_angles();
|
/// let euler = rot.euler_angles();
|
||||||
|
|
@ -403,7 +391,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Rotation3, Vector3};
|
/// # use nalgebra::{Rotation3, Vector3};
|
||||||
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
||||||
|
|
@ -451,7 +438,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Rotation3, Vector3};
|
/// # use nalgebra::{Rotation3, Vector3};
|
||||||
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
||||||
|
|
@ -483,7 +469,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Rotation3, Vector3};
|
/// # use nalgebra::{Rotation3, Vector3};
|
||||||
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
/// let dir = Vector3::new(1.0, 2.0, 3.0);
|
||||||
|
|
@ -508,7 +493,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Vector3, Rotation3};
|
/// # use nalgebra::{Vector3, Rotation3};
|
||||||
/// let a = Vector3::new(1.0, 2.0, 3.0);
|
/// let a = Vector3::new(1.0, 2.0, 3.0);
|
||||||
/// let b = Vector3::new(3.0, 1.0, 2.0);
|
/// let b = Vector3::new(3.0, 1.0, 2.0);
|
||||||
|
|
@ -531,7 +515,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Vector3, Rotation3};
|
/// # use nalgebra::{Vector3, Rotation3};
|
||||||
/// let a = Vector3::new(1.0, 2.0, 3.0);
|
/// let a = Vector3::new(1.0, 2.0, 3.0);
|
||||||
/// let b = Vector3::new(3.0, 1.0, 2.0);
|
/// let b = Vector3::new(3.0, 1.0, 2.0);
|
||||||
|
|
@ -576,7 +559,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Unit, Rotation3, Vector3};
|
/// # use nalgebra::{Unit, Rotation3, Vector3};
|
||||||
/// let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
/// let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let rot = Rotation3::from_axis_angle(&axis, 1.78);
|
/// let rot = Rotation3::from_axis_angle(&axis, 1.78);
|
||||||
|
|
@ -594,7 +576,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation3, Vector3, Unit};
|
/// # use nalgebra::{Rotation3, Vector3, Unit};
|
||||||
/// let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
/// let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let angle = 1.2;
|
/// let angle = 1.2;
|
||||||
|
|
@ -621,7 +602,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation3, Vector3, Unit};
|
/// # use nalgebra::{Rotation3, Vector3, Unit};
|
||||||
/// let axisangle = Vector3::new(0.1, 0.2, 0.3);
|
/// let axisangle = Vector3::new(0.1, 0.2, 0.3);
|
||||||
/// let rot = Rotation3::new(axisangle);
|
/// let rot = Rotation3::new(axisangle);
|
||||||
|
|
@ -643,7 +623,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation3, Vector3, Unit};
|
/// # use nalgebra::{Rotation3, Vector3, Unit};
|
||||||
/// let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
/// let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let angle = 1.2;
|
/// let angle = 1.2;
|
||||||
|
|
@ -670,7 +649,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation3, Vector3};
|
/// # use nalgebra::{Rotation3, Vector3};
|
||||||
/// let rot1 = Rotation3::from_axis_angle(&Vector3::y_axis(), 1.0);
|
/// let rot1 = Rotation3::from_axis_angle(&Vector3::y_axis(), 1.0);
|
||||||
/// let rot2 = Rotation3::from_axis_angle(&Vector3::x_axis(), 0.1);
|
/// let rot2 = Rotation3::from_axis_angle(&Vector3::x_axis(), 0.1);
|
||||||
|
|
@ -688,7 +666,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation3, Vector3};
|
/// # use nalgebra::{Rotation3, Vector3};
|
||||||
/// let rot1 = Rotation3::from_axis_angle(&Vector3::y_axis(), 1.0);
|
/// let rot1 = Rotation3::from_axis_angle(&Vector3::y_axis(), 1.0);
|
||||||
/// let rot2 = Rotation3::from_axis_angle(&Vector3::x_axis(), 0.1);
|
/// let rot2 = Rotation3::from_axis_angle(&Vector3::x_axis(), 0.1);
|
||||||
|
|
@ -706,7 +683,6 @@ impl<N: Real> Rotation3<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Rotation3, Vector3, Unit};
|
/// # use nalgebra::{Rotation3, Vector3, Unit};
|
||||||
/// let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
/// let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
|
||||||
/// let angle = 1.2;
|
/// let angle = 1.2;
|
||||||
|
|
|
||||||
|
|
@ -86,7 +86,6 @@ where
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Similarity2, Point2, UnitComplex};
|
/// # use nalgebra::{Similarity2, Point2, UnitComplex};
|
||||||
/// let rot = UnitComplex::new(f32::consts::FRAC_PI_2);
|
/// let rot = UnitComplex::new(f32::consts::FRAC_PI_2);
|
||||||
|
|
@ -135,7 +134,6 @@ impl<N: Real> Similarity<N, U2, Rotation2<N>> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{SimilarityMatrix2, Vector2, Point2};
|
/// # use nalgebra::{SimilarityMatrix2, Vector2, Point2};
|
||||||
/// let sim = SimilarityMatrix2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2, 3.0);
|
/// let sim = SimilarityMatrix2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2, 3.0);
|
||||||
|
|
@ -159,7 +157,6 @@ impl<N: Real> Similarity<N, U2, UnitComplex<N>> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Similarity2, Vector2, Point2};
|
/// # use nalgebra::{Similarity2, Vector2, Point2};
|
||||||
/// let sim = Similarity2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2, 3.0);
|
/// let sim = Similarity2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2, 3.0);
|
||||||
|
|
@ -187,7 +184,6 @@ macro_rules! similarity_construction_impl(
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Similarity3, SimilarityMatrix3, Point3, Vector3};
|
/// # use nalgebra::{Similarity3, SimilarityMatrix3, Point3, Vector3};
|
||||||
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
/// let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
|
||||||
|
|
@ -227,7 +223,6 @@ macro_rules! similarity_construction_impl(
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Similarity3, SimilarityMatrix3, Point3, Vector3};
|
/// # use nalgebra::{Similarity3, SimilarityMatrix3, Point3, Vector3};
|
||||||
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
||||||
|
|
@ -278,7 +273,6 @@ macro_rules! similarity_construction_impl(
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Similarity3, SimilarityMatrix3, Point3, Vector3};
|
/// # use nalgebra::{Similarity3, SimilarityMatrix3, Point3, Vector3};
|
||||||
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
||||||
|
|
@ -317,7 +311,6 @@ macro_rules! similarity_construction_impl(
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{Similarity3, SimilarityMatrix3, Point3, Vector3};
|
/// # use nalgebra::{Similarity3, SimilarityMatrix3, Point3, Vector3};
|
||||||
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
/// let eye = Point3::new(1.0, 2.0, 3.0);
|
||||||
|
|
|
||||||
|
|
@ -350,7 +350,6 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
|
||||||
/// # Examples
|
/// # Examples
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Matrix3, Transform2};
|
/// # use nalgebra::{Matrix3, Transform2};
|
||||||
///
|
///
|
||||||
/// let m = Matrix3::new(2.0, 2.0, -0.3,
|
/// let m = Matrix3::new(2.0, 2.0, -0.3,
|
||||||
|
|
@ -383,7 +382,6 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
|
||||||
/// # Examples
|
/// # Examples
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Matrix3, Projective2};
|
/// # use nalgebra::{Matrix3, Projective2};
|
||||||
///
|
///
|
||||||
/// let m = Matrix3::new(2.0, 2.0, -0.3,
|
/// let m = Matrix3::new(2.0, 2.0, -0.3,
|
||||||
|
|
@ -407,7 +405,6 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
|
||||||
/// # Examples
|
/// # Examples
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Matrix3, Transform2};
|
/// # use nalgebra::{Matrix3, Transform2};
|
||||||
///
|
///
|
||||||
/// let m = Matrix3::new(2.0, 2.0, -0.3,
|
/// let m = Matrix3::new(2.0, 2.0, -0.3,
|
||||||
|
|
@ -437,7 +434,6 @@ where DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>
|
||||||
/// # Examples
|
/// # Examples
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Matrix3, Projective2};
|
/// # use nalgebra::{Matrix3, Projective2};
|
||||||
///
|
///
|
||||||
/// let m = Matrix3::new(2.0, 2.0, -0.3,
|
/// let m = Matrix3::new(2.0, 2.0, -0.3,
|
||||||
|
|
|
||||||
|
|
@ -85,7 +85,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # extern crate num_complex;
|
/// # extern crate num_complex;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use num_complex::Complex;
|
/// # use num_complex::Complex;
|
||||||
/// # use nalgebra::UnitComplex;
|
/// # use nalgebra::UnitComplex;
|
||||||
/// let angle = 1.78f32;
|
/// let angle = 1.78f32;
|
||||||
|
|
@ -117,7 +116,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::UnitComplex;
|
/// # use nalgebra::UnitComplex;
|
||||||
/// let rot = UnitComplex::new(1.2);
|
/// let rot = UnitComplex::new(1.2);
|
||||||
/// let inv = rot.inverse();
|
/// let inv = rot.inverse();
|
||||||
|
|
@ -134,7 +132,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::UnitComplex;
|
/// # use nalgebra::UnitComplex;
|
||||||
/// let rot1 = UnitComplex::new(0.1);
|
/// let rot1 = UnitComplex::new(0.1);
|
||||||
/// let rot2 = UnitComplex::new(1.7);
|
/// let rot2 = UnitComplex::new(1.7);
|
||||||
|
|
@ -153,7 +150,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::UnitComplex;
|
/// # use nalgebra::UnitComplex;
|
||||||
/// let rot1 = UnitComplex::new(0.1);
|
/// let rot1 = UnitComplex::new(0.1);
|
||||||
/// let rot2 = UnitComplex::new(1.7);
|
/// let rot2 = UnitComplex::new(1.7);
|
||||||
|
|
@ -172,7 +168,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::UnitComplex;
|
/// # use nalgebra::UnitComplex;
|
||||||
/// let angle = 1.7;
|
/// let angle = 1.7;
|
||||||
/// let rot = UnitComplex::new(angle);
|
/// let rot = UnitComplex::new(angle);
|
||||||
|
|
@ -192,7 +187,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::UnitComplex;
|
/// # use nalgebra::UnitComplex;
|
||||||
/// let angle = 1.7;
|
/// let angle = 1.7;
|
||||||
/// let mut rot = UnitComplex::new(angle);
|
/// let mut rot = UnitComplex::new(angle);
|
||||||
|
|
@ -213,7 +207,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::UnitComplex;
|
/// # use nalgebra::UnitComplex;
|
||||||
/// let rot = UnitComplex::new(0.78);
|
/// let rot = UnitComplex::new(0.78);
|
||||||
/// let pow = rot.powf(2.0);
|
/// let pow = rot.powf(2.0);
|
||||||
|
|
|
||||||
|
|
@ -35,7 +35,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitComplex, Point2};
|
/// # use nalgebra::{UnitComplex, Point2};
|
||||||
/// let rot = UnitComplex::new(f32::consts::FRAC_PI_2);
|
/// let rot = UnitComplex::new(f32::consts::FRAC_PI_2);
|
||||||
|
|
@ -56,7 +55,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitComplex, Point2};
|
/// # use nalgebra::{UnitComplex, Point2};
|
||||||
/// let rot = UnitComplex::from_angle(f32::consts::FRAC_PI_2);
|
/// let rot = UnitComplex::from_angle(f32::consts::FRAC_PI_2);
|
||||||
|
|
@ -78,7 +76,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
///
|
///
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use std::f32;
|
/// # use std::f32;
|
||||||
/// # use nalgebra::{UnitComplex, Vector2, Point2};
|
/// # use nalgebra::{UnitComplex, Vector2, Point2};
|
||||||
/// let angle = f32::consts::FRAC_PI_2;
|
/// let angle = f32::consts::FRAC_PI_2;
|
||||||
|
|
@ -138,7 +135,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Vector2, UnitComplex};
|
/// # use nalgebra::{Vector2, UnitComplex};
|
||||||
/// let a = Vector2::new(1.0, 2.0);
|
/// let a = Vector2::new(1.0, 2.0);
|
||||||
/// let b = Vector2::new(2.0, 1.0);
|
/// let b = Vector2::new(2.0, 1.0);
|
||||||
|
|
@ -161,7 +157,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Vector2, UnitComplex};
|
/// # use nalgebra::{Vector2, UnitComplex};
|
||||||
/// let a = Vector2::new(1.0, 2.0);
|
/// let a = Vector2::new(1.0, 2.0);
|
||||||
/// let b = Vector2::new(2.0, 1.0);
|
/// let b = Vector2::new(2.0, 1.0);
|
||||||
|
|
@ -197,7 +192,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Unit, Vector2, UnitComplex};
|
/// # use nalgebra::{Unit, Vector2, UnitComplex};
|
||||||
/// let a = Unit::new_normalize(Vector2::new(1.0, 2.0));
|
/// let a = Unit::new_normalize(Vector2::new(1.0, 2.0));
|
||||||
/// let b = Unit::new_normalize(Vector2::new(2.0, 1.0));
|
/// let b = Unit::new_normalize(Vector2::new(2.0, 1.0));
|
||||||
|
|
@ -223,7 +217,6 @@ impl<N: Real> UnitComplex<N> {
|
||||||
/// # Example
|
/// # Example
|
||||||
/// ```
|
/// ```
|
||||||
/// # #[macro_use] extern crate approx;
|
/// # #[macro_use] extern crate approx;
|
||||||
/// # extern crate nalgebra;
|
|
||||||
/// # use nalgebra::{Unit, Vector2, UnitComplex};
|
/// # use nalgebra::{Unit, Vector2, UnitComplex};
|
||||||
/// let a = Unit::new_normalize(Vector2::new(1.0, 2.0));
|
/// let a = Unit::new_normalize(Vector2::new(1.0, 2.0));
|
||||||
/// let b = Unit::new_normalize(Vector2::new(2.0, 1.0));
|
/// let b = Unit::new_normalize(Vector2::new(2.0, 1.0));
|
||||||
|
|
|
||||||
|
|
@ -195,10 +195,10 @@ fn from_columns() {
|
||||||
#[test]
|
#[test]
|
||||||
fn from_columns_dynamic() {
|
fn from_columns_dynamic() {
|
||||||
let columns = &[
|
let columns = &[
|
||||||
DVector::from_row_slice(3, &[11, 21, 31]),
|
DVector::from_row_slice(&[11, 21, 31]),
|
||||||
DVector::from_row_slice(3, &[12, 22, 32]),
|
DVector::from_row_slice(&[12, 22, 32]),
|
||||||
DVector::from_row_slice(3, &[13, 23, 33]),
|
DVector::from_row_slice(&[13, 23, 33]),
|
||||||
DVector::from_row_slice(3, &[14, 24, 34]),
|
DVector::from_row_slice(&[14, 24, 34]),
|
||||||
];
|
];
|
||||||
|
|
||||||
let expected = DMatrix::from_row_slice(3, 4, &[11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34]);
|
let expected = DMatrix::from_row_slice(3, 4, &[11, 12, 13, 14, 21, 22, 23, 24, 31, 32, 33, 34]);
|
||||||
|
|
@ -233,8 +233,8 @@ fn from_not_enough_columns() {
|
||||||
#[should_panic]
|
#[should_panic]
|
||||||
fn from_rows_with_different_dimensions() {
|
fn from_rows_with_different_dimensions() {
|
||||||
let columns = &[
|
let columns = &[
|
||||||
DVector::from_row_slice(3, &[11, 21, 31]),
|
DVector::from_row_slice(&[11, 21, 31]),
|
||||||
DVector::from_row_slice(3, &[12, 22, 32, 33]),
|
DVector::from_row_slice(&[12, 22, 32, 33]),
|
||||||
];
|
];
|
||||||
|
|
||||||
let _ = DMatrix::from_columns(columns);
|
let _ = DMatrix::from_columns(columns);
|
||||||
|
|
@ -272,8 +272,8 @@ fn to_homogeneous() {
|
||||||
let a = Vector3::new(1.0, 2.0, 3.0);
|
let a = Vector3::new(1.0, 2.0, 3.0);
|
||||||
let expected_a = Vector4::new(1.0, 2.0, 3.0, 0.0);
|
let expected_a = Vector4::new(1.0, 2.0, 3.0, 0.0);
|
||||||
|
|
||||||
let b = DVector::from_row_slice(3, &[1.0, 2.0, 3.0]);
|
let b = DVector::from_row_slice(&[1.0, 2.0, 3.0]);
|
||||||
let expected_b = DVector::from_row_slice(4, &[1.0, 2.0, 3.0, 0.0]);
|
let expected_b = DVector::from_row_slice(&[1.0, 2.0, 3.0, 0.0]);
|
||||||
|
|
||||||
let c = Matrix2::new(1.0, 2.0, 3.0, 4.0);
|
let c = Matrix2::new(1.0, 2.0, 3.0, 4.0);
|
||||||
let expected_c = Matrix3::new(1.0, 2.0, 0.0, 3.0, 4.0, 0.0, 0.0, 0.0, 1.0);
|
let expected_c = Matrix3::new(1.0, 2.0, 0.0, 3.0, 4.0, 0.0, 0.0, 0.0, 1.0);
|
||||||
|
|
@ -292,8 +292,8 @@ fn push() {
|
||||||
let a = Vector3::new(1.0, 2.0, 3.0);
|
let a = Vector3::new(1.0, 2.0, 3.0);
|
||||||
let expected_a = Vector4::new(1.0, 2.0, 3.0, 4.0);
|
let expected_a = Vector4::new(1.0, 2.0, 3.0, 4.0);
|
||||||
|
|
||||||
let b = DVector::from_row_slice(3, &[1.0, 2.0, 3.0]);
|
let b = DVector::from_row_slice(&[1.0, 2.0, 3.0]);
|
||||||
let expected_b = DVector::from_row_slice(4, &[1.0, 2.0, 3.0, 4.0]);
|
let expected_b = DVector::from_row_slice(&[1.0, 2.0, 3.0, 4.0]);
|
||||||
|
|
||||||
assert_eq!(a.push(4.0), expected_a);
|
assert_eq!(a.push(4.0), expected_a);
|
||||||
assert_eq!(b.push(4.0), expected_b);
|
assert_eq!(b.push(4.0), expected_b);
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue