diff --git a/CHANGELOG.md b/CHANGELOG.md index 82fc953a..cfc0e080 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,10 +4,25 @@ documented here. This project adheres to [Semantic Versioning](https://semver.org/). +## [0.24.0] + +### Added +* The `DualQuaternion` type. It is still work-in-progress but the basics are here: + creation from its real and dual part, multiplication of two dual quaternions, + and normalization. + +### Removed +* There is no blanket `impl PartialEq for Unit` any more. Instead, it is + implemented specifically for `UnitComplex`, `UnitQuaternion` and `Unit`. + ## [0.23.2] In this release, we improved the documentation of some of the geometric types by applying changes similar to what we did in the version 0.23.1 for matrices. +### Added +* The `Isometry::inv_mul` method which is a more efficient way of doing + `isometry1.inverse() * isometry2`. + ## [0.23.1] In this release we improved the documentation of the matrix and vector types by: - Grouping `impl` bocks logically, adding a title comment to these impl blocks. diff --git a/Cargo.toml b/Cargo.toml index ae3b3378..615942a8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "nalgebra" -version = "0.23.2" +version = "0.24.0" authors = [ "Sébastien Crozet " ] description = "Linear algebra library with transformations and statically-sized or dynamically-sized matrices." diff --git a/nalgebra-glm/Cargo.toml b/nalgebra-glm/Cargo.toml index f4e12f8e..6cbf7ab7 100644 --- a/nalgebra-glm/Cargo.toml +++ b/nalgebra-glm/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "nalgebra-glm" -version = "0.9.0" +version = "0.10.0" authors = ["sebcrozet "] description = "A computer-graphics oriented API for nalgebra, inspired by the C++ GLM library." @@ -25,4 +25,4 @@ abomonation-serialize = [ "nalgebra/abomonation-serialize" ] num-traits = { version = "0.2", default-features = false } approx = { version = "0.4", default-features = false } simba = { version = "0.3", default-features = false } -nalgebra = { path = "..", version = "0.23", default-features = false } +nalgebra = { path = "..", version = "0.24", default-features = false } diff --git a/nalgebra-lapack/Cargo.toml b/nalgebra-lapack/Cargo.toml index e70359cc..1ea68287 100644 --- a/nalgebra-lapack/Cargo.toml +++ b/nalgebra-lapack/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "nalgebra-lapack" -version = "0.14.0" +version = "0.15.0" authors = [ "Sébastien Crozet ", "Andrew Straw " ] description = "Linear algebra library with transformations and satically-sized or dynamically-sized matrices." @@ -23,7 +23,7 @@ accelerate = ["lapack-src/accelerate"] intel-mkl = ["lapack-src/intel-mkl"] [dependencies] -nalgebra = { version = "0.22" } # , path = ".." } +nalgebra = { version = "0.24", path = ".." } num-traits = "0.2" num-complex = { version = "0.2", default-features = false } simba = "0.2" @@ -34,7 +34,7 @@ lapack-src = { version = "0.5", default-features = false } # clippy = "*" [dev-dependencies] -nalgebra = { version = "0.22", features = [ "arbitrary" ] } # path = ".." } +nalgebra = { version = "0.24", features = [ "arbitrary" ], path = ".." } quickcheck = "0.9" approx = "0.3" rand = "0.7" diff --git a/src/base/unit.rs b/src/base/unit.rs index 20ca4603..2483307a 100644 --- a/src/base/unit.rs +++ b/src/base/unit.rs @@ -11,7 +11,8 @@ use abomonation::Abomonation; use crate::allocator::Allocator; use crate::base::DefaultAllocator; -use crate::{Dim, MatrixMN, RealField, Scalar, SimdComplexField, SimdRealField}; +use crate::storage::Storage; +use crate::{Dim, Matrix, MatrixMN, RealField, Scalar, SimdComplexField, SimdRealField}; /// A wrapper that ensures the underlying algebraic entity has a unit norm. /// @@ -24,7 +25,7 @@ use crate::{Dim, MatrixMN, RealField, Scalar, SimdComplexField, SimdRealField}; /// and [`UnitQuaternion`](crate::UnitQuaternion); both built on top of `Unit`. If you are interested /// in their documentation, read their dedicated pages directly. #[repr(transparent)] -#[derive(Eq, PartialEq, Clone, Hash, Debug, Copy)] +#[derive(Clone, Hash, Debug, Copy)] pub struct Unit { pub(crate) value: T, } @@ -64,6 +65,28 @@ impl Abomonation for Unit { } } +impl PartialEq for Unit> +where + N: Scalar + PartialEq, + R: Dim, + C: Dim, + S: Storage, +{ + #[inline] + fn eq(&self, rhs: &Self) -> bool { + self.value.eq(&rhs.value) + } +} + +impl Eq for Unit> +where + N: Scalar + Eq, + R: Dim, + C: Dim, + S: Storage, +{ +} + /// Trait implemented by entities scan be be normalized and put in an `Unit` struct. pub trait Normed { /// The type of the norm. diff --git a/src/geometry/dual_quaternion.rs b/src/geometry/dual_quaternion.rs new file mode 100644 index 00000000..ce9f7284 --- /dev/null +++ b/src/geometry/dual_quaternion.rs @@ -0,0 +1,116 @@ +use crate::{Quaternion, SimdRealField}; +#[cfg(feature = "serde-serialize")] +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +/// A dual quaternion. +/// +/// # Indexing +/// +/// DualQuaternions are stored as \[..real, ..dual\]. +/// Both of the quaternion components are laid out in `i, j, k, w` order. +/// +/// ``` +/// # use nalgebra::{DualQuaternion, Quaternion}; +/// +/// let real = Quaternion::new(1.0, 2.0, 3.0, 4.0); +/// let dual = Quaternion::new(5.0, 6.0, 7.0, 8.0); +/// +/// let dq = DualQuaternion::from_real_and_dual(real, dual); +/// assert_eq!(dq[0], 2.0); +/// assert_eq!(dq[1], 3.0); +/// +/// assert_eq!(dq[4], 6.0); +/// assert_eq!(dq[7], 5.0); +/// ``` +/// +/// NOTE: +/// As of December 2020, dual quaternion support is a work in progress. +/// If a feature that you need is missing, feel free to open an issue or a PR. +/// See https://github.com/dimforge/nalgebra/issues/487 +#[repr(C)] +#[derive(Debug, Default, Eq, PartialEq, Copy, Clone)] +pub struct DualQuaternion { + /// The real component of the quaternion + pub real: Quaternion, + /// The dual component of the quaternion + pub dual: Quaternion, +} + +impl DualQuaternion +where + N::Element: SimdRealField, +{ + /// Normalizes this quaternion. + /// + /// # Example + /// ``` + /// # #[macro_use] extern crate approx; + /// # use nalgebra::{DualQuaternion, Quaternion}; + /// let real = Quaternion::new(1.0, 2.0, 3.0, 4.0); + /// let dual = Quaternion::new(5.0, 6.0, 7.0, 8.0); + /// let dq = DualQuaternion::from_real_and_dual(real, dual); + /// + /// let dq_normalized = dq.normalize(); + /// + /// relative_eq!(dq_normalized.real.norm(), 1.0); + /// ``` + #[inline] + #[must_use = "Did you mean to use normalize_mut()?"] + pub fn normalize(&self) -> Self { + let real_norm = self.real.norm(); + + Self::from_real_and_dual(self.real / real_norm, self.dual / real_norm) + } + + /// Normalizes this quaternion. + /// + /// # Example + /// ``` + /// # #[macro_use] extern crate approx; + /// # use nalgebra::{DualQuaternion, Quaternion}; + /// let real = Quaternion::new(1.0, 2.0, 3.0, 4.0); + /// let dual = Quaternion::new(5.0, 6.0, 7.0, 8.0); + /// let mut dq = DualQuaternion::from_real_and_dual(real, dual); + /// + /// dq.normalize_mut(); + /// + /// relative_eq!(dq.real.norm(), 1.0); + /// ``` + #[inline] + pub fn normalize_mut(&mut self) { + *self = self.normalize(); + } +} + +#[cfg(feature = "serde-serialize")] +impl Serialize for DualQuaternion +where + N: Serialize, +{ + fn serialize(&self, serializer: S) -> Result<::Ok, ::Error> + where + S: Serializer, + { + self.as_ref().serialize(serializer) + } +} + +#[cfg(feature = "serde-serialize")] +impl<'a, N: SimdRealField> Deserialize<'a> for DualQuaternion +where + N: Deserialize<'a>, +{ + fn deserialize(deserializer: Des) -> Result + where + Des: Deserializer<'a>, + { + type Dq = [N; 8]; + + let dq: Dq = Dq::::deserialize(deserializer)?; + + Ok(Self { + real: Quaternion::new(dq[3], dq[0], dq[1], dq[2]), + dual: Quaternion::new(dq[7], dq[4], dq[5], dq[6]), + }) + } +} diff --git a/src/geometry/dual_quaternion_construction.rs b/src/geometry/dual_quaternion_construction.rs new file mode 100644 index 00000000..25a979f7 --- /dev/null +++ b/src/geometry/dual_quaternion_construction.rs @@ -0,0 +1,42 @@ +use crate::{DualQuaternion, Quaternion, SimdRealField}; + +impl DualQuaternion { + /// Creates a dual quaternion from its rotation and translation components. + /// + /// # Example + /// ``` + /// # use nalgebra::{DualQuaternion, Quaternion}; + /// let rot = Quaternion::new(1.0, 2.0, 3.0, 4.0); + /// let trans = Quaternion::new(5.0, 6.0, 7.0, 8.0); + /// + /// let dq = DualQuaternion::from_real_and_dual(rot, trans); + /// assert_eq!(dq.real.w, 1.0); + /// ``` + #[inline] + pub fn from_real_and_dual(real: Quaternion, dual: Quaternion) -> Self { + Self { real, dual } + } + /// The dual quaternion multiplicative identity + /// + /// # Example + /// + /// ``` + /// # use nalgebra::{DualQuaternion, Quaternion}; + /// + /// let dq1 = DualQuaternion::identity(); + /// let dq2 = DualQuaternion::from_real_and_dual( + /// Quaternion::new(1.,2.,3.,4.), + /// Quaternion::new(5.,6.,7.,8.) + /// ); + /// + /// assert_eq!(dq1 * dq2, dq2); + /// assert_eq!(dq2 * dq1, dq2); + /// ``` + #[inline] + pub fn identity() -> Self { + Self::from_real_and_dual( + Quaternion::from_real(N::one()), + Quaternion::from_real(N::zero()), + ) + } +} diff --git a/src/geometry/dual_quaternion_ops.rs b/src/geometry/dual_quaternion_ops.rs new file mode 100644 index 00000000..0c9f78f4 --- /dev/null +++ b/src/geometry/dual_quaternion_ops.rs @@ -0,0 +1,104 @@ +/* + * This file provides: + * + * NOTE: Work in progress https://github.com/dimforge/nalgebra/issues/487 + * + * (Dual Quaternion) + * + * Index + * IndexMut + * + * (Assignment Operators) + * + * DualQuaternion × Scalar + * DualQuaternion × DualQuaternion + * DualQuaternion + DualQuaternion + * DualQuaternion - DualQuaternion + * + * --- + * + * References: + * Multiplication: + * - https://cs.gmu.edu/~jmlien/teaching/cs451/uploads/Main/dual-quaternion.pdf + */ + +use crate::{DualQuaternion, SimdRealField}; +use std::mem; +use std::ops::{Add, Index, IndexMut, Mul, Sub}; + +impl AsRef<[N; 8]> for DualQuaternion { + #[inline] + fn as_ref(&self) -> &[N; 8] { + unsafe { mem::transmute(self) } + } +} + +impl AsMut<[N; 8]> for DualQuaternion { + #[inline] + fn as_mut(&mut self) -> &mut [N; 8] { + unsafe { mem::transmute(self) } + } +} + +impl Index for DualQuaternion { + type Output = N; + + #[inline] + fn index(&self, i: usize) -> &Self::Output { + &self.as_ref()[i] + } +} + +impl IndexMut for DualQuaternion { + #[inline] + fn index_mut(&mut self, i: usize) -> &mut N { + &mut self.as_mut()[i] + } +} + +impl Mul> for DualQuaternion +where + N::Element: SimdRealField, +{ + type Output = DualQuaternion; + + fn mul(self, rhs: Self) -> Self::Output { + Self::from_real_and_dual( + self.real * rhs.real, + self.real * rhs.dual + self.dual * rhs.real, + ) + } +} + +impl Mul for DualQuaternion +where + N::Element: SimdRealField, +{ + type Output = DualQuaternion; + + fn mul(self, rhs: N) -> Self::Output { + Self::from_real_and_dual(self.real * rhs, self.dual * rhs) + } +} + +impl Add> for DualQuaternion +where + N::Element: SimdRealField, +{ + type Output = DualQuaternion; + + fn add(self, rhs: DualQuaternion) -> Self::Output { + Self::from_real_and_dual(self.real + rhs.real, self.dual + rhs.dual) + } +} + +impl Sub> for DualQuaternion +where + N::Element: SimdRealField, +{ + type Output = DualQuaternion; + + fn sub(self, rhs: DualQuaternion) -> Self::Output { + Self::from_real_and_dual(self.real - rhs.real, self.dual - rhs.dual) + } +} diff --git a/src/geometry/mod.rs b/src/geometry/mod.rs index d3e2236a..19313b65 100644 --- a/src/geometry/mod.rs +++ b/src/geometry/mod.rs @@ -35,6 +35,10 @@ mod quaternion_coordinates; mod quaternion_ops; mod quaternion_simba; +mod dual_quaternion; +mod dual_quaternion_construction; +mod dual_quaternion_ops; + mod unit_complex; #[cfg(feature = "alga")] mod unit_complex_alga; @@ -98,6 +102,8 @@ pub use self::rotation_alias::*; pub use self::quaternion::*; +pub use self::dual_quaternion::*; + pub use self::unit_complex::*; pub use self::translation::*; diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs index e860a8b8..a5db1c69 100755 --- a/src/geometry/quaternion.rs +++ b/src/geometry/quaternion.rs @@ -1,7 +1,6 @@ use approx::{AbsDiffEq, RelativeEq, UlpsEq}; use num::Zero; use std::fmt; -use std::hash; #[cfg(feature = "abomonation-serialize")] use std::io::{Result as IOResult, Write}; @@ -13,8 +12,8 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer}; #[cfg(feature = "abomonation-serialize")] use abomonation::Abomonation; -use simba::scalar::RealField; -use simba::simd::{SimdBool, SimdOption, SimdRealField, SimdValue}; +use simba::scalar::{ClosedNeg, RealField}; +use simba::simd::{SimdBool, SimdOption, SimdRealField}; use crate::base::dimension::{U1, U3, U4}; use crate::base::storage::{CStride, RStride}; @@ -27,13 +26,13 @@ use crate::geometry::{Point3, Rotation}; /// A quaternion. See the type alias `UnitQuaternion = Unit` for a quaternion /// that may be used as a rotation. #[repr(C)] -#[derive(Debug)] -pub struct Quaternion { +#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)] +pub struct Quaternion { /// This quaternion as a 4D vector of coordinates in the `[ x, y, z, w ]` storage order. pub coords: Vector4, } -impl Default for Quaternion { +impl Default for Quaternion { fn default() -> Self { Quaternion { coords: Vector4::zeros(), @@ -42,7 +41,7 @@ impl Default for Quaternion { } #[cfg(feature = "abomonation-serialize")] -impl Abomonation for Quaternion +impl Abomonation for Quaternion where Vector4: Abomonation, { @@ -59,36 +58,8 @@ where } } -impl Eq for Quaternion where N::Element: SimdRealField {} - -impl PartialEq for Quaternion -where - N::Element: SimdRealField, -{ - fn eq(&self, rhs: &Self) -> bool { - self.coords == rhs.coords || - // Account for the double-covering of S², i.e. q = -q - self.as_vector().iter().zip(rhs.as_vector().iter()).all(|(a, b)| *a == -*b) - } -} - -impl hash::Hash for Quaternion { - fn hash(&self, state: &mut H) { - self.coords.hash(state) - } -} - -impl Copy for Quaternion {} - -impl Clone for Quaternion { - #[inline] - fn clone(&self) -> Self { - Self::from(self.coords.clone()) - } -} - #[cfg(feature = "serde-serialize")] -impl Serialize for Quaternion +impl Serialize for Quaternion where Owned: Serialize, { @@ -101,7 +72,7 @@ where } #[cfg(feature = "serde-serialize")] -impl<'a, N: SimdRealField> Deserialize<'a> for Quaternion +impl<'a, N: Scalar> Deserialize<'a> for Quaternion where Owned: Deserialize<'a>, { @@ -980,6 +951,17 @@ impl fmt::Display for Quaternion { /// A unit quaternions. May be used to represent a rotation. pub type UnitQuaternion = Unit>; +impl PartialEq for UnitQuaternion { + #[inline] + fn eq(&self, rhs: &Self) -> bool { + self.coords == rhs.coords || + // Account for the double-covering of S², i.e. q = -q + self.coords.iter().zip(rhs.coords.iter()).all(|(a, b)| *a == -b.inlined_clone()) + } +} + +impl Eq for UnitQuaternion {} + impl Normed for Quaternion { type Norm = N::SimdRealField; diff --git a/src/geometry/quaternion_construction.rs b/src/geometry/quaternion_construction.rs index 63f00636..03d87d39 100644 --- a/src/geometry/quaternion_construction.rs +++ b/src/geometry/quaternion_construction.rs @@ -10,7 +10,7 @@ use rand::distributions::{Distribution, OpenClosed01, Standard}; use rand::Rng; use simba::scalar::RealField; -use simba::simd::{SimdBool, SimdValue}; +use simba::simd::SimdBool; use crate::base::dimension::U3; use crate::base::storage::Storage; @@ -19,7 +19,7 @@ use crate::{Scalar, SimdRealField}; use crate::geometry::{Quaternion, Rotation3, UnitQuaternion}; -impl Quaternion { +impl Quaternion { /// Creates a quaternion from a 4D vector. The quaternion scalar part corresponds to the `w` /// vector component. #[inline] diff --git a/src/geometry/quaternion_conversion.rs b/src/geometry/quaternion_conversion.rs index 330c97e4..b57cc52b 100644 --- a/src/geometry/quaternion_conversion.rs +++ b/src/geometry/quaternion_conversion.rs @@ -184,36 +184,36 @@ impl> SubsetOf> for Un } #[cfg(feature = "mint")] -impl From> for Quaternion { +impl From> for Quaternion { fn from(q: mint::Quaternion) -> Self { Self::new(q.s, q.v.x, q.v.y, q.v.z) } } #[cfg(feature = "mint")] -impl Into> for Quaternion { +impl Into> for Quaternion { fn into(self) -> mint::Quaternion { mint::Quaternion { v: mint::Vector3 { - x: self[0], - y: self[1], - z: self[2], + x: self[0].inlined_clone(), + y: self[1].inlined_clone(), + z: self[2].inlined_clone(), }, - s: self[3], + s: self[3].inlined_clone(), } } } #[cfg(feature = "mint")] -impl Into> for UnitQuaternion { +impl Into> for UnitQuaternion { fn into(self) -> mint::Quaternion { mint::Quaternion { v: mint::Vector3 { - x: self[0], - y: self[1], - z: self[2], + x: self[0].inlined_clone(), + y: self[1].inlined_clone(), + z: self[2].inlined_clone(), }, - s: self[3], + s: self[3].inlined_clone(), } } } @@ -258,14 +258,14 @@ where } } -impl From> for Quaternion { +impl From> for Quaternion { #[inline] fn from(coords: Vector4) -> Self { Self { coords } } } -impl From<[N; 4]> for Quaternion { +impl From<[N; 4]> for Quaternion { #[inline] fn from(coords: [N; 4]) -> Self { Self { diff --git a/src/geometry/quaternion_ops.rs b/src/geometry/quaternion_ops.rs index 2961362e..f9205874 100644 --- a/src/geometry/quaternion_ops.rs +++ b/src/geometry/quaternion_ops.rs @@ -57,12 +57,12 @@ use std::ops::{ use crate::base::allocator::Allocator; use crate::base::dimension::{U1, U3, U4}; use crate::base::storage::Storage; -use crate::base::{DefaultAllocator, Unit, Vector, Vector3}; +use crate::base::{DefaultAllocator, Scalar, Unit, Vector, Vector3}; use crate::SimdRealField; use crate::geometry::{Point3, Quaternion, Rotation, UnitQuaternion}; -impl Index for Quaternion { +impl Index for Quaternion { type Output = N; #[inline] @@ -71,7 +71,7 @@ impl Index for Quaternion { } } -impl IndexMut for Quaternion { +impl IndexMut for Quaternion { #[inline] fn index_mut(&mut self, i: usize) -> &mut N { &mut self.coords[i] diff --git a/src/geometry/unit_complex.rs b/src/geometry/unit_complex.rs index 40148454..43ef7324 100755 --- a/src/geometry/unit_complex.rs +++ b/src/geometry/unit_complex.rs @@ -4,8 +4,10 @@ use std::fmt; use crate::base::{Matrix2, Matrix3, Normed, Unit, Vector1, Vector2}; use crate::geometry::{Point2, Rotation2}; +use crate::Scalar; use simba::scalar::RealField; use simba::simd::SimdRealField; +use std::cmp::{Eq, PartialEq}; /// A 2D rotation represented as a complex number with magnitude 1. /// @@ -29,6 +31,15 @@ use simba::simd::SimdRealField; /// * [Conversion to a matrix `to_rotation_matrix`, `to_homogeneous`…](#conversion-to-a-matrix) pub type UnitComplex = Unit>; +impl PartialEq for UnitComplex { + #[inline] + fn eq(&self, rhs: &Self) -> bool { + (**self).eq(&**rhs) + } +} + +impl Eq for UnitComplex {} + impl Normed for Complex { type Norm = N::SimdRealField; diff --git a/tests/core/matrixcompare.rs b/tests/core/matrixcompare.rs index df112173..cdd93ea3 100644 --- a/tests/core/matrixcompare.rs +++ b/tests/core/matrixcompare.rs @@ -4,9 +4,15 @@ //! The tests here only check that the necessary trait implementations are correctly implemented, //! in addition to some sanity checks with example input. -use nalgebra::{DMatrix, MatrixMN, U4, U5}; +use nalgebra::{MatrixMN, U4, U5}; -use matrixcompare::{assert_matrix_eq, DenseAccess}; +#[cfg(feature = "arbitrary")] +use nalgebra::DMatrix; + +use matrixcompare::assert_matrix_eq; + +#[cfg(feature = "arbitrary")] +use matrixcompare::DenseAccess; #[cfg(feature = "arbitrary")] quickcheck! { diff --git a/tests/geometry/quaternion.rs b/tests/geometry/quaternion.rs index 77456ca0..5ff20a0e 100644 --- a/tests/geometry/quaternion.rs +++ b/tests/geometry/quaternion.rs @@ -114,7 +114,6 @@ quickcheck!( */ fn unit_quaternion_double_covering(q: UnitQuaternion) -> bool { let mq = UnitQuaternion::new_unchecked(-q.into_inner()); - mq == q && mq.angle() == q.angle() && mq.axis() == q.axis() }