Merge branch 'dimforge:dev' into dev

This commit is contained in:
Matteo Carnelos 2023-06-10 00:54:26 +02:00 committed by GitHub
commit 331925e170
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 135 additions and 12 deletions

View File

@ -4,6 +4,10 @@ documented here.
This project adheres to [Semantic Versioning](https://semver.org/).
## Unreleased
### Fixed
- Fixed severe catastrophic cancellation issue in variance calculation.
## [0.32.2] (07 March 2023)

View File

@ -111,6 +111,7 @@ serde_json = "1.0"
rand_xorshift = "0.3"
rand_isaac = "0.3"
criterion = { version = "0.4", features = ["html_reports"] }
nalgebra = { path = ".", features = ["debug", "compare", "rand", "macros"]}
# For matrix comparison macro
matrixcompare = "0.3.0"

View File

@ -81,32 +81,32 @@ pub type MatrixXx5<T> = Matrix<T, Dyn, U5, VecStorage<T, Dyn, U5>>;
#[cfg(any(feature = "std", feature = "alloc"))]
pub type MatrixXx6<T> = Matrix<T, Dyn, U6, VecStorage<T, Dyn, U6>>;
/// A heap-allocated, row-major, matrix with 1 rows and a dynamic number of columns.
/// A heap-allocated, column-major, matrix with 1 rows and a dynamic number of columns.
///
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
#[cfg(any(feature = "std", feature = "alloc"))]
pub type Matrix1xX<T> = Matrix<T, U1, Dyn, VecStorage<T, U1, Dyn>>;
/// A heap-allocated, row-major, matrix with 2 rows and a dynamic number of columns.
/// A heap-allocated, column-major, matrix with 2 rows and a dynamic number of columns.
///
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
#[cfg(any(feature = "std", feature = "alloc"))]
pub type Matrix2xX<T> = Matrix<T, U2, Dyn, VecStorage<T, U2, Dyn>>;
/// A heap-allocated, row-major, matrix with 3 rows and a dynamic number of columns.
/// A heap-allocated, column-major, matrix with 3 rows and a dynamic number of columns.
///
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
#[cfg(any(feature = "std", feature = "alloc"))]
pub type Matrix3xX<T> = Matrix<T, U3, Dyn, VecStorage<T, U3, Dyn>>;
/// A heap-allocated, row-major, matrix with 4 rows and a dynamic number of columns.
/// A heap-allocated, column-major, matrix with 4 rows and a dynamic number of columns.
///
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
#[cfg(any(feature = "std", feature = "alloc"))]
pub type Matrix4xX<T> = Matrix<T, U4, Dyn, VecStorage<T, U4, Dyn>>;
/// A heap-allocated, row-major, matrix with 5 rows and a dynamic number of columns.
/// A heap-allocated, column-major, matrix with 5 rows and a dynamic number of columns.
///
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
#[cfg(any(feature = "std", feature = "alloc"))]
pub type Matrix5xX<T> = Matrix<T, U5, Dyn, VecStorage<T, U5, Dyn>>;
/// A heap-allocated, row-major, matrix with 6 rows and a dynamic number of columns.
/// A heap-allocated, column-major, matrix with 6 rows and a dynamic number of columns.
///
/// **Because this is an alias, not all its methods are listed here. See the [`Matrix`](crate::base::Matrix) type too.**
#[cfg(any(feature = "std", feature = "alloc"))]

View File

@ -2255,3 +2255,102 @@ where
Unit::new_unchecked(crate::convert_ref(self.as_ref()))
}
}
impl<T, S> Matrix<T, U1, U1, S>
where
S: RawStorage<T, U1, U1>,
{
/// Returns a reference to the single element in this matrix.
///
/// As opposed to indexing, using this provides type-safety
/// when flattening dimensions.
///
/// # Example
/// ```
/// # use nalgebra::Vector3;
/// let v = Vector3::new(0., 0., 1.);
/// let inner_product: f32 = *(v.transpose() * v).as_scalar();
/// ```
///
///```compile_fail
/// # use nalgebra::Vector3;
/// let v = Vector3::new(0., 0., 1.);
/// let inner_product = (v * v.transpose()).item(); // Typo, does not compile.
///```
pub fn as_scalar(&self) -> &T {
&self[(0, 0)]
}
/// Get a mutable reference to the single element in this matrix
///
/// As opposed to indexing, using this provides type-safety
/// when flattening dimensions.
///
/// # Example
/// ```
/// # use nalgebra::Vector3;
/// let v = Vector3::new(0., 0., 1.);
/// let mut inner_product = (v.transpose() * v);
/// *inner_product.as_scalar_mut() = 3.;
/// ```
///
///```compile_fail
/// # use nalgebra::Vector3;
/// let v = Vector3::new(0., 0., 1.);
/// let mut inner_product = (v * v.transpose());
/// *inner_product.as_scalar_mut() = 3.;
///```
pub fn as_scalar_mut(&mut self) -> &mut T
where
S: RawStorageMut<T, U1>,
{
&mut self[(0, 0)]
}
/// Convert this 1x1 matrix by reference into a scalar.
///
/// As opposed to indexing, using this provides type-safety
/// when flattening dimensions.
///
/// # Example
/// ```
/// # use nalgebra::Vector3;
/// let v = Vector3::new(0., 0., 1.);
/// let mut inner_product: f32 = (v.transpose() * v).to_scalar();
/// ```
///
///```compile_fail
/// # use nalgebra::Vector3;
/// let v = Vector3::new(0., 0., 1.);
/// let mut inner_product: f32 = (v * v.transpose()).to_scalar();
///```
pub fn to_scalar(&self) -> T
where
T: Clone,
{
self.as_scalar().clone()
}
}
impl<T> super::alias::Matrix1<T> {
/// Convert this 1x1 matrix into a scalar.
///
/// As opposed to indexing, using this provides type-safety
/// when flattening dimensions.
///
/// # Example
/// ```
/// # use nalgebra::{Vector3, Matrix2, U1};
/// let v = Vector3::new(0., 0., 1.);
/// let inner_product: f32 = (v.transpose() * v).into_scalar();
/// assert_eq!(inner_product, 1.);
/// ```
///
///```compile_fail
/// # use nalgebra::Vector3;
/// let v = Vector3::new(0., 0., 1.);
/// let mut inner_product: f32 = (v * v.transpose()).into_scalar();
///```
pub fn into_scalar(self) -> T {
let [[scalar]] = self.data.0;
scalar
}
}

View File

@ -335,12 +335,12 @@ impl<T: Scalar, R: Dim, C: Dim, S: RawStorage<T, R, C>> Matrix<T, R, C, S> {
if self.is_empty() {
T::zero()
} else {
let val = self.iter().cloned().fold((T::zero(), T::zero()), |a, b| {
(a.0 + b.clone() * b.clone(), a.1 + b)
});
let denom = T::one() / crate::convert::<_, T>(self.len() as f64);
let vd = val.1 * denom.clone();
val.0 * denom - vd.clone() * vd
let n_elements: T = crate::convert(self.len() as f64);
let mean = self.mean();
self.iter().cloned().fold(T::zero(), |acc, x| {
acc + (x.clone() - mean.clone()) * (x.clone() - mean.clone())
}) / n_elements
}
}

View File

@ -11,6 +11,7 @@ mod reshape;
#[cfg(feature = "rkyv-serialize-no-std")]
mod rkyv;
mod serde;
mod variance;
#[cfg(feature = "compare")]
mod matrixcompare;

18
tests/core/variance.rs Normal file
View File

@ -0,0 +1,18 @@
use nalgebra::DVector;
#[test]
fn test_variance_catastrophic_cancellation() {
let long_repeating_vector = DVector::repeat(10_000, 100000000.0);
assert_eq!(long_repeating_vector.variance(), 0.0);
let short_vec = DVector::from_vec(vec![1., 2., 3.]);
assert_eq!(short_vec.variance(), 2.0 / 3.0);
let short_vec =
DVector::<f64>::from_vec(vec![1.0e8 + 4.0, 1.0e8 + 7.0, 1.0e8 + 13.0, 1.0e8 + 16.0]);
assert_eq!(short_vec.variance(), 22.5);
let short_vec =
DVector::<f64>::from_vec(vec![1.0e9 + 4.0, 1.0e9 + 7.0, 1.0e9 + 13.0, 1.0e9 + 16.0]);
assert_eq!(short_vec.variance(), 22.5);
}