M-Labs
/
nalgebra
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #945 from dimforge/dev 

Release v0.28.0
This commit is contained in:
Sébastien Crozet 2021-07-11 18:11:45 +02:00 committed by GitHub
parent c04b087388 7eb5fd3ba6
commit 944afe24e8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
129 changed files with 1732 additions and 804 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
CHANGELOG.md
View File

@ -4,6 +4,30 @@ documented here.
This project adheres to [Semantic Versioning](https://semver.org/). This project adheres to [Semantic Versioning](https://semver.org/).
## [0.28.0]
### Added
- Implement `Hash` for `Transform`.
- Implement `Borrow` and `BorrowMut` for contiguous slices.
### Modified
- The `OPoint<T, D>` type has been added. It takes the dimension number as a type-level integer (e.g. `Const<3>`) instead
of a const-generic. The type `Point<T, const D: usize>` is now an alias for `OPoint`. This changes doesn't affect any
of the existing code using `Point`. However, it will allow the use `OPoint` in a generic context where the dimension
cannot be easily expressed as a const-generic (because of the current limitation of const-generics in Rust).
- Several clippy warnings were fixed. This results in some method signature changes (e.g. taking `self` instead of `&self`)
but this should not have any practical infulances on existing codebase.
- The `Point::new` constructors are no longer const-fn. This is due to some limitations in const-fn
not allowing custom trait-bounds. Use the `point!` macro instead to build points in const environments.
- `Dynamic::new` and `Unit::new_unchecked` are now const-fn.
- Methods returning `Result<(), ()>` now return `bool` instead.
### Fixed
- Fixed a potential unsoundess issue when converting a mutable slice to a `&mut[T]`.
## [0.27.1]
### Fixed
- Fixed a bug in the conversion from `glam::Vec2` or `glam::DVec2` to `Isometry2`.
## [0.27.0] ## [0.27.0]
This removes the `convert-glam` and `convert-glam-unchecked` optional features. This removes the `convert-glam` and `convert-glam-unchecked` optional features.
Instead, this adds the `convert-glam013`, `convert-glam014`, and `convert-glam015` optional features for Instead, this adds the `convert-glam013`, `convert-glam014`, and `convert-glam015` optional features for
@ -34,7 +58,7 @@ conversions targeting the versions 0.13, 0.14, and 0.15 of `glam`.
Fix a regression introduced in 0.26.0 preventing `DVector` from being serialized with `serde`. Fix a regression introduced in 0.26.0 preventing `DVector` from being serialized with `serde`.
## [0.26.0] ## [0.26.0]
This releases integrates `min-const-generics` to nalgebra. See This release integrates `min-const-generics` to nalgebra. See
[our blog post](https://www.dimforge.com/blog/2021/04/12/integrating-const-generics-to-nalgebra) [our blog post](https://www.dimforge.com/blog/2021/04/12/integrating-const-generics-to-nalgebra)
for details about this release. for details about this release.
@ -74,7 +98,7 @@ for details about this release.
## [0.25.3] ## [0.25.3]
### Added ### Added
- The `Vector::simd_cap_magnitude` method to cap the magnitude of the a vector with - The `Vector::simd_cap_magnitude` method to cap the magnitude of the vector with
SIMD components. SIMD components.
## [0.25.2] ## [0.25.2]
@ -105,7 +129,7 @@ This updates all the dependencies of nalgebra to their latest version, including
### New crate: nalgebra-sparse ### New crate: nalgebra-sparse
Alongside this release of `nalgebra`, we are releasing `nalgebra-sparse`: a crate dedicated to sparse matrix Alongside this release of `nalgebra`, we are releasing `nalgebra-sparse`: a crate dedicated to sparse matrix
computation with `nalgebra`. The `sparse` module of `nalgebra`itself still exists for backward compatibility computation with `nalgebra`. The `sparse` module of `nalgebra`itself still exists for backward compatibility,
but it will be deprecated soon in favor of the `nalgebra-sparse` crate. but it will be deprecated soon in favor of the `nalgebra-sparse` crate.
### Added ### Added
@ -121,12 +145,12 @@ but it will be deprecated soon in favor of the `nalgebra-sparse` crate.
## [0.24.0] ## [0.24.0]
### Added ### Added
* The `DualQuaternion` type. It is still work-in-progress but the basics are here: * 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, creation from its real and dual part, multiplication of two dual quaternions,
and normalization. and normalization.
### Removed ### Removed
* There is no blanket `impl<T> PartialEq for Unit<T>` any more. Instead, it is * There is no blanket `impl<T> PartialEq for Unit<T>` anymore. Instead, it is
implemented specifically for `UnitComplex`, `UnitQuaternion` and `Unit<Vector>`. implemented specifically for `UnitComplex`, `UnitQuaternion` and `Unit<Vector>`.
## [0.23.2] ## [0.23.2]
@ -153,7 +177,7 @@ In this release we improved the documentation of the matrix and vector types by:
and `Vector.apply(f)`. and `Vector.apply(f)`.
* The `Quaternion::from([N; 4])` conversion to build a quaternion from an array of four elements. * The `Quaternion::from([N; 4])` conversion to build a quaternion from an array of four elements.
* The `Isometry::from(Translation)` conversion to build an isometry from a translation. * The `Isometry::from(Translation)` conversion to build an isometry from a translation.
* The `Vector::ith_axis(i)` which build a unit vector, e.g., `Unit<Vector3<f32>>` with its i-th component set to 1.0 and the * The `Vector::ith_axis(i)` which build a unit vector, e.g., `Unit<Vector3<f32>>` with its i-th component set to 1.0, and the
others set to zero. others set to zero.
* The `Isometry.lerp_slerp` and `Isometry.try_lerp_slerp` methods to interpolate between two isometries using linear * The `Isometry.lerp_slerp` and `Isometry.try_lerp_slerp` methods to interpolate between two isometries using linear
interpolation for the translational part, and spherical interpolation for the rotational part. interpolation for the translational part, and spherical interpolation for the rotational part.
@ -162,7 +186,7 @@ In this release we improved the documentation of the matrix and vector types by:
## [0.22.0] ## [0.22.0]
In this release, we are using the new version 0.2 of simba. One major change of that version is that the In this release, we are using the new version 0.2 of simba. One major change of that version is that the
use of `libm` is now opt-in when building targetting `no-std` environment. If you are using floating-point use of `libm` is now opt-in when building targeting `no-std` environment. If you are using floating-point
operations with nalgebra in a `no-std` environment, you will need to enable the new `libm` feature operations with nalgebra in a `no-std` environment, you will need to enable the new `libm` feature
of nalgebra for your code to compile again. of nalgebra for your code to compile again.
@ -170,7 +194,7 @@ of nalgebra for your code to compile again.
* The `libm` feature that enables `libm` when building for `no-std` environment. * The `libm` feature that enables `libm` when building for `no-std` environment.
* The `libm-force` feature that enables `libm` even when building for a not `no-std` environment. * The `libm-force` feature that enables `libm` even when building for a not `no-std` environment.
* `Cholesky::new_unchecked` which build a Cholesky decomposition without checking that its input is * `Cholesky::new_unchecked` which build a Cholesky decomposition without checking that its input is
positive-definite. It can be use with SIMD types. positive-definite. It can be used with SIMD types.
* The `Default` trait is now implemented for matrices, and quaternions. They are all filled with zeros, * The `Default` trait is now implemented for matrices, and quaternions. They are all filled with zeros,
except for `UnitQuaternion` which is initialized with the identity. except for `UnitQuaternion` which is initialized with the identity.
* Matrix exponential `matrix.exp()`. * Matrix exponential `matrix.exp()`.
@ -341,7 +365,7 @@ library (i.e. it supports `#![no_std]`). See the corresponding [documentation](h
* Add methods `.rotation_between_axis(...)` and `.scaled_rotation_between_axis(...)` to `UnitComplex` * Add methods `.rotation_between_axis(...)` and `.scaled_rotation_between_axis(...)` to `UnitComplex`
to compute the rotation matrix between two 2D **unit** vectors. to compute the rotation matrix between two 2D **unit** vectors.
* Add methods `.axis_angle()` to `UnitComplex` and `UnitQuaternion` in order to retrieve both the * Add methods `.axis_angle()` to `UnitComplex` and `UnitQuaternion` in order to retrieve both the
unit rotation axis and the rotation angle simultaneously. unit rotation axis, and the rotation angle simultaneously.
* Add functions to construct a random matrix with a user-defined distribution: `::from_distribution(...)`. * Add functions to construct a random matrix with a user-defined distribution: `::from_distribution(...)`.
## [0.14.0] ## [0.14.0]
@ -362,7 +386,7 @@ library (i.e. it supports `#![no_std]`). See the corresponding [documentation](h
the matrix `M` such that for all vector `v` we have the matrix `M` such that for all vector `v` we have
`M * v == self.cross(&v)`. `M * v == self.cross(&v)`.
* `.iamin()` that returns the index of the vector entry with * `.iamin()` that returns the index of the vector entry with
smallest absolute value. the smallest absolute value.
* The `mint` feature that can be enabled in order to allow conversions from * The `mint` feature that can be enabled in order to allow conversions from
and to types of the [mint](https://crates.io/crates/mint) crate. and to types of the [mint](https://crates.io/crates/mint) crate.
* Aliases for matrix and vector slices. Their are named by adding `Slice` * Aliases for matrix and vector slices. Their are named by adding `Slice`
@ -400,7 +424,7 @@ This adds support for serialization using the
* The alias `MatrixNM` is now deprecated. Use `MatrixMN` instead (we * The alias `MatrixNM` is now deprecated. Use `MatrixMN` instead (we
reordered M and N to be in alphabetical order). reordered M and N to be in alphabetical order).
* In-place componentwise multiplication and division * In-place componentwise multiplication and division
`.component_mul_mut(...)` and `.component_div_mut(...)` have bee deprecated `.component_mul_mut(...)` and `.component_div_mut(...)` have been deprecated
for a future renaming. Use `.component_mul_assign(...)` and for a future renaming. Use `.component_mul_assign(...)` and
`.component_div_assign(...)` instead. `.component_div_assign(...)` instead.
@ -502,7 +526,7 @@ This version is a major rewrite of the library. Major changes are:
All other mathematical traits, except `Axpy` have been removed from All other mathematical traits, except `Axpy` have been removed from
**nalgebra**. **nalgebra**.
* Methods are now preferred to free functions because they do not require any * Methods are now preferred to free functions because they do not require any
trait to be used any more. trait to be used anymore.
* Most algebraic entities can be parametrized by type-level integers * Most algebraic entities can be parametrized by type-level integers
to specify their dimensions. Using `Dynamic` instead of a type-level to specify their dimensions. Using `Dynamic` instead of a type-level
integer indicates that the dimension known at run-time only. integer indicates that the dimension known at run-time only.
@ -578,7 +602,7 @@ only:
* The free functions `::prepend_rotation`, `::append_rotation`, * The free functions `::prepend_rotation`, `::append_rotation`,
`::append_rotation_wrt_center`, `::append_rotation_wrt_point`, `::append_rotation_wrt_center`, `::append_rotation_wrt_point`,
`::append_transformation`, and `::append_translation ` have been removed. `::append_transformation`, and `::append_translation ` have been removed.
Instead create the rotation or translation object explicitly and use Instead, create the rotation or translation object explicitly and use
multiplication to compose it with anything else. multiplication to compose it with anything else.
* The free function `::outer` has been removed. Use column-vector × * The free function `::outer` has been removed. Use column-vector ×
@ -604,7 +628,7 @@ Binary operations are now allowed between references as well. For example
### Modified ### Modified
Removed unused parameters to methods from the `ApproxEq` trait. Those were Removed unused parameters to methods from the `ApproxEq` trait. Those were
required before rust 1.0 to help type inference. The are not needed any more required before rust 1.0 to help type inference. They are not needed any more
since it now allowed to write for a type `T` that implements `ApproxEq`: since it now allowed to write for a type `T` that implements `ApproxEq`:
`<T as ApproxEq>::approx_epsilon()`. This replaces the old form: `<T as ApproxEq>::approx_epsilon()`. This replaces the old form:
`ApproxEq::approx_epsilon(None::<T>)`. `ApproxEq::approx_epsilon(None::<T>)`.
@ -623,7 +647,7 @@ since it now allowed to write for a type `T` that implements `ApproxEq`:
`UnitQuaternion::from_axisangle`. The new `::new` method now requires a `UnitQuaternion::from_axisangle`. The new `::new` method now requires a
not-normalized quaternion. not-normalized quaternion.
Methods names starting with `new_with_` now start with `from_`. This is more Method names starting with `new_with_` now start with `from_`. This is more
idiomatic in Rust. idiomatic in Rust.
The `Norm` trait now uses an associated type instead of a type parameter. The `Norm` trait now uses an associated type instead of a type parameter.
@ -654,8 +678,8 @@ crate for vectors, rotations and points. To enable them, activate the
## [0.8.0] ## [0.8.0]
### Modified ### Modified
* Almost everything (types, methods, and traits) now use full names instead * Almost everything (types, methods, and traits) now use fulls names instead
of abbreviations (e.g. `Vec3` becomes `Vector3`). Most changes are abvious. of abbreviations (e.g. `Vec3` becomes `Vector3`). Most changes are obvious.
Note however that: Note however that:
- `::sqnorm` becomes `::norm_squared`. - `::sqnorm` becomes `::norm_squared`.
- `::sqdist` becomes `::distance_squared`. - `::sqdist` becomes `::distance_squared`.
@ -689,11 +713,11 @@ you [there](https://users.nphysics.org)!
### Removed ### Removed
* Removed zero-sized elements `Vector0`, `Point0`. * Removed zero-sized elements `Vector0`, `Point0`.
* Removed 4-dimensional transformations `Rotation4` and `Isometry4` (which had an implementation to incomplete to be useful). * Removed 4-dimensional transformations `Rotation4` and `Isometry4` (which had an implementation too incomplete to be useful).
### Modified ### Modified
* Vectors are now multipliable with isometries. This will result into a pure rotation (this is how * Vectors are now multipliable with isometries. This will result into a pure rotation (this is how
vectors differ from point semantically: they design directions so they are not translatable). vectors differ from point semantically: they design directions, so they are not translatable).
* `{Isometry3, Rotation3}::look_at` reimplemented and renamed to `::look_at_rh` and `::look_at_lh` to agree * `{Isometry3, Rotation3}::look_at` reimplemented and renamed to `::look_at_rh` and `::look_at_lh` to agree
with the computer graphics community (in particular, the GLM library). Use the `::look_at_rh` with the computer graphics community (in particular, the GLM library). Use the `::look_at_rh`
variant to build a view matrix that variant to build a view matrix that

2
Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "nalgebra" name = "nalgebra"
version = "0.27.0" version = "0.28.0"
authors = [ "Sébastien Crozet <developer@crozet.re>" ] authors = [ "Sébastien Crozet <developer@crozet.re>" ]
description = "General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices." description = "General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices."

2
examples/cargo/Cargo.toml
View File

@ -4,7 +4,7 @@ version = "0.0.0"
authors = [ "You" ] authors = [ "You" ]
[dependencies] [dependencies]
nalgebra = "0.27.0" nalgebra = "0.28.0"
[[bin]] [[bin]]
name = "example" name = "example"

4
nalgebra-glm/Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "nalgebra-glm" name = "nalgebra-glm"
version = "0.13.0" version = "0.14.0"
authors = ["sebcrozet <developer@crozet.re>"] authors = ["sebcrozet <developer@crozet.re>"]
description = "A computer-graphics oriented API for nalgebra, inspired by the C++ GLM library." description = "A computer-graphics oriented API for nalgebra, inspired by the C++ GLM library."
@ -27,4 +27,4 @@ abomonation-serialize = [ "nalgebra/abomonation-serialize" ]
num-traits = { version = "0.2", default-features = false } num-traits = { version = "0.2", default-features = false }
approx = { version = "0.5", default-features = false } approx = { version = "0.5", default-features = false }
simba = { version = "0.5", default-features = false } simba = { version = "0.5", default-features = false }
nalgebra = { path = "..", version = "0.27", default-features = false } nalgebra = { path = "..", version = "0.28", default-features = false }

2
nalgebra-glm/src/lib.rs
View File

@ -21,7 +21,7 @@
**nalgebra-glm** using the module prefix `glm::`. For example you will write `glm::rotate(...)` instead **nalgebra-glm** using the module prefix `glm::`. For example you will write `glm::rotate(...)` instead
of the more verbose `nalgebra_glm::rotate(...)`: of the more verbose `nalgebra_glm::rotate(...)`:
```rust ```
extern crate nalgebra_glm as glm; extern crate nalgebra_glm as glm;
``` ```

6
nalgebra-lapack/Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "nalgebra-lapack" name = "nalgebra-lapack"
version = "0.18.0" version = "0.19.0"
authors = [ "Sébastien Crozet <developer@crozet.re>", "Andrew Straw <strawman@astraw.com>" ] authors = [ "Sébastien Crozet <developer@crozet.re>", "Andrew Straw <strawman@astraw.com>" ]
description = "Matrix decompositions using nalgebra matrices and Lapack bindings." description = "Matrix decompositions using nalgebra matrices and Lapack bindings."
@ -29,7 +29,7 @@ accelerate = ["lapack-src/accelerate"]
intel-mkl = ["lapack-src/intel-mkl"] intel-mkl = ["lapack-src/intel-mkl"]
[dependencies] [dependencies]
nalgebra = { version = "0.27", path = ".." } nalgebra = { version = "0.28", path = ".." }
num-traits = "0.2" num-traits = "0.2"
num-complex = { version = "0.4", default-features = false } num-complex = { version = "0.4", default-features = false }
simba = "0.5" simba = "0.5"
@ -39,7 +39,7 @@ lapack-src = { version = "0.8", default-features = false }
# clippy = "*" # clippy = "*"
[dev-dependencies] [dev-dependencies]
nalgebra = { version = "0.27", features = [ "arbitrary", "rand" ], path = ".." } nalgebra = { version = "0.28", features = [ "arbitrary", "rand" ], path = ".." }
proptest = { version = "1", default-features = false, features = ["std"] } proptest = { version = "1", default-features = false, features = ["std"] }
quickcheck = "1" quickcheck = "1"
approx = "0.5" approx = "0.5"

2
nalgebra-lapack/src/cholesky.rs
View File

@ -80,6 +80,7 @@ where
} }
/// Retrieves the lower-triangular factor of the cholesky decomposition. /// Retrieves the lower-triangular factor of the cholesky decomposition.
#[must_use]
pub fn l(&self) -> OMatrix<T, D, D> { pub fn l(&self) -> OMatrix<T, D, D> {
let mut res = self.l.clone(); let mut res = self.l.clone();
res.fill_upper_triangle(Zero::zero(), 1); res.fill_upper_triangle(Zero::zero(), 1);
@ -91,6 +92,7 @@ where
/// ///
/// This is an allocation-less version of `self.l()`. The values of the strict upper-triangular /// This is an allocation-less version of `self.l()`. The values of the strict upper-triangular
/// part are garbage and should be ignored by further computations. /// part are garbage and should be ignored by further computations.
#[must_use]
pub fn l_dirty(&self) -> &OMatrix<T, D, D> { pub fn l_dirty(&self) -> &OMatrix<T, D, D> {
&self.l &self.l
} }

1
nalgebra-lapack/src/eigen.rs
View File

@ -302,6 +302,7 @@ where
/// The determinant of the decomposed matrix. /// The determinant of the decomposed matrix.
#[inline] #[inline]
#[must_use]
pub fn determinant(&self) -> T { pub fn determinant(&self) -> T {
let mut det = T::one(); let mut det = T::one();
for e in self.eigenvalues.iter() { for e in self.eigenvalues.iter() {

2
nalgebra-lapack/src/hessenberg.rs
View File

@ -89,6 +89,7 @@ where
/// Computes the hessenberg matrix of this decomposition. /// Computes the hessenberg matrix of this decomposition.
#[inline] #[inline]
#[must_use]
pub fn h(&self) -> OMatrix<T, D, D> { pub fn h(&self) -> OMatrix<T, D, D> {
let mut h = self.h.clone_owned(); let mut h = self.h.clone_owned();
h.fill_lower_triangle(T::zero(), 2); h.fill_lower_triangle(T::zero(), 2);
@ -109,6 +110,7 @@ where
/// Computes the unitary matrix `Q` of this decomposition. /// Computes the unitary matrix `Q` of this decomposition.
#[inline] #[inline]
#[must_use]
pub fn q(&self) -> OMatrix<T, D, D> { pub fn q(&self) -> OMatrix<T, D, D> {
let n = self.h.nrows() as i32; let n = self.h.nrows() as i32;
let mut q = self.h.clone_owned(); let mut q = self.h.clone_owned();

4
nalgebra-lapack/src/lib.rs
View File

@ -30,7 +30,7 @@
//! the system installation of netlib without LAPACKE (note the E) or //! the system installation of netlib without LAPACKE (note the E) or
//! CBLAS: //! CBLAS:
//! //!
//! ```.ignore //! ```ignore
//! sudo apt-get install gfortran libblas3gf liblapack3gf //! sudo apt-get install gfortran libblas3gf liblapack3gf
//! export CARGO_FEATURE_SYSTEM_NETLIB=1 //! export CARGO_FEATURE_SYSTEM_NETLIB=1
//! export CARGO_FEATURE_EXCLUDE_LAPACKE=1 //! export CARGO_FEATURE_EXCLUDE_LAPACKE=1
@ -44,7 +44,7 @@
//! //!
//! On macOS, do this to use Apple's Accelerate framework: //! On macOS, do this to use Apple's Accelerate framework:
//! //!
//! ```.ignore //! ```ignore
//! export CARGO_FEATURES="--no-default-features --features accelerate" //! export CARGO_FEATURES="--no-default-features --features accelerate"
//! cargo build ${CARGO_FEATURES} //! cargo build ${CARGO_FEATURES}
//! ``` //! ```

4
nalgebra-lapack/src/lu.rs
View File

@ -85,6 +85,7 @@ where
/// Gets the lower-triangular matrix part of the decomposition. /// Gets the lower-triangular matrix part of the decomposition.
#[inline] #[inline]
#[must_use]
pub fn l(&self) -> OMatrix<T, R, DimMinimum<R, C>> { pub fn l(&self) -> OMatrix<T, R, DimMinimum<R, C>> {
let (nrows, ncols) = self.lu.data.shape(); let (nrows, ncols) = self.lu.data.shape();
let mut res = self.lu.columns_generic(0, nrows.min(ncols)).into_owned(); let mut res = self.lu.columns_generic(0, nrows.min(ncols)).into_owned();
@ -97,6 +98,7 @@ where
/// Gets the upper-triangular matrix part of the decomposition. /// Gets the upper-triangular matrix part of the decomposition.
#[inline] #[inline]
#[must_use]
pub fn u(&self) -> OMatrix<T, DimMinimum<R, C>, C> { pub fn u(&self) -> OMatrix<T, DimMinimum<R, C>, C> {
let (nrows, ncols) = self.lu.data.shape(); let (nrows, ncols) = self.lu.data.shape();
let mut res = self.lu.rows_generic(0, nrows.min(ncols)).into_owned(); let mut res = self.lu.rows_generic(0, nrows.min(ncols)).into_owned();
@ -111,6 +113,7 @@ where
/// Computing the permutation matrix explicitly is costly and usually not necessary. /// Computing the permutation matrix explicitly is costly and usually not necessary.
/// To permute rows of a matrix or vector, use the method `self.permute(...)` instead. /// To permute rows of a matrix or vector, use the method `self.permute(...)` instead.
#[inline] #[inline]
#[must_use]
pub fn p(&self) -> OMatrix<T, R, R> { pub fn p(&self) -> OMatrix<T, R, R> {
let (dim, _) = self.lu.data.shape(); let (dim, _) = self.lu.data.shape();
let mut id = Matrix::identity_generic(dim, dim); let mut id = Matrix::identity_generic(dim, dim);
@ -124,6 +127,7 @@ where
/// Gets the LAPACK permutation indices. /// Gets the LAPACK permutation indices.
#[inline] #[inline]
#[must_use]
pub fn permutation_indices(&self) -> &OVector<i32, DimMinimum<R, C>> { pub fn permutation_indices(&self) -> &OVector<i32, DimMinimum<R, C>> {
&self.p &self.p
} }

2
nalgebra-lapack/src/qr.rs
View File

@ -92,6 +92,7 @@ where
/// Retrieves the upper trapezoidal submatrix `R` of this decomposition. /// Retrieves the upper trapezoidal submatrix `R` of this decomposition.
#[inline] #[inline]
#[must_use]
pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C> { pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C> {
let (nrows, ncols) = self.qr.data.shape(); let (nrows, ncols) = self.qr.data.shape();
self.qr.rows_generic(0, nrows.min(ncols)).upper_triangle() self.qr.rows_generic(0, nrows.min(ncols)).upper_triangle()
@ -117,6 +118,7 @@ where
/// Computes the orthogonal matrix `Q` of this decomposition. /// Computes the orthogonal matrix `Q` of this decomposition.
#[inline] #[inline]
#[must_use]
pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>> { pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>> {
let (nrows, ncols) = self.qr.data.shape(); let (nrows, ncols) = self.qr.data.shape();
let min_nrows_ncols = nrows.min(ncols); let min_nrows_ncols = nrows.min(ncols);

2
nalgebra-lapack/src/schur.rs
View File

@ -138,6 +138,7 @@ where
/// Computes the real eigenvalues of the decomposed matrix. /// Computes the real eigenvalues of the decomposed matrix.
/// ///
/// Return `None` if some eigenvalues are complex. /// Return `None` if some eigenvalues are complex.
#[must_use]
pub fn eigenvalues(&self) -> Option<OVector<T, D>> { pub fn eigenvalues(&self) -> Option<OVector<T, D>> {
if self.im.iter().all(|e| e.is_zero()) { if self.im.iter().all(|e| e.is_zero()) {
Some(self.re.clone()) Some(self.re.clone())
@ -147,6 +148,7 @@ where
} }
/// Computes the complex eigenvalues of the decomposed matrix. /// Computes the complex eigenvalues of the decomposed matrix.
#[must_use]
pub fn complex_eigenvalues(&self) -> OVector<Complex<T>, D> pub fn complex_eigenvalues(&self) -> OVector<Complex<T>, D>
where where
DefaultAllocator: Allocator<Complex<T>, D>, DefaultAllocator: Allocator<Complex<T>, D>,

2
nalgebra-lapack/src/svd.rs
View File

@ -175,6 +175,7 @@ macro_rules! svd_impl(
/// ///
/// All singular value below epsilon will be set to zero instead of being inverted. /// All singular value below epsilon will be set to zero instead of being inverted.
#[inline] #[inline]
#[must_use]
pub fn pseudo_inverse(&self, epsilon: $t) -> OMatrix<$t, C, R> { pub fn pseudo_inverse(&self, epsilon: $t) -> OMatrix<$t, C, R> {
let nrows = self.u.data.shape().0; let nrows = self.u.data.shape().0;
let ncols = self.vt.data.shape().1; let ncols = self.vt.data.shape().1;
@ -207,6 +208,7 @@ macro_rules! svd_impl(
/// This is the number of singular values that are not too small (i.e. greater than /// This is the number of singular values that are not too small (i.e. greater than
/// the given `epsilon`). /// the given `epsilon`).
#[inline] #[inline]
#[must_use]
pub fn rank(&self, epsilon: $t) -> usize { pub fn rank(&self, epsilon: $t) -> usize {
let mut i = 0; let mut i = 0;

2
nalgebra-lapack/src/symmetric_eigen.rs
View File

@ -138,6 +138,7 @@ where
/// The determinant of the decomposed matrix. /// The determinant of the decomposed matrix.
#[inline] #[inline]
#[must_use]
pub fn determinant(&self) -> T { pub fn determinant(&self) -> T {
let mut det = T::one(); let mut det = T::one();
for e in self.eigenvalues.iter() { for e in self.eigenvalues.iter() {
@ -150,6 +151,7 @@ where
/// Rebuild the original matrix. /// Rebuild the original matrix.
/// ///
/// This is useful if some of the eigenvalues have been manually modified. /// This is useful if some of the eigenvalues have been manually modified.
#[must_use]
pub fn recompose(&self) -> OMatrix<T, D, D> { pub fn recompose(&self) -> OMatrix<T, D, D> {
let mut u_t = self.eigenvectors.clone(); let mut u_t = self.eigenvectors.clone();
for i in 0..self.eigenvalues.len() { for i in 0..self.eigenvalues.len() {

2
nalgebra-macros/Cargo.toml
View File

@ -21,5 +21,5 @@ quote = "1.0"
proc-macro2 = "1.0" proc-macro2 = "1.0"
[dev-dependencies] [dev-dependencies]
nalgebra = { version = "0.27.0", path = ".." } nalgebra = { version = "0.28.0", path = ".." }
trybuild = "1.0.42" trybuild = "1.0.42"

6
nalgebra-sparse/Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "nalgebra-sparse" name = "nalgebra-sparse"
version = "0.3.0" version = "0.4.0"
authors = [ "Andreas Longva", "Sébastien Crozet <developer@crozet.re>" ] authors = [ "Andreas Longva", "Sébastien Crozet <developer@crozet.re>" ]
edition = "2018" edition = "2018"
description = "Sparse matrix computation based on nalgebra." description = "Sparse matrix computation based on nalgebra."
@ -20,7 +20,7 @@ compare = [ "matrixcompare-core" ]
slow-tests = [] slow-tests = []
[dependencies] [dependencies]
nalgebra = { version="0.27", path = "../" } nalgebra = { version="0.28", path = "../" }
num-traits = { version = "0.2", default-features = false } num-traits = { version = "0.2", default-features = false }
proptest = { version = "1.0", optional = true } proptest = { version = "1.0", optional = true }
matrixcompare-core = { version = "0.1.0", optional = true } matrixcompare-core = { version = "0.1.0", optional = true }
@ -28,7 +28,7 @@ matrixcompare-core = { version = "0.1.0", optional = true }
[dev-dependencies] [dev-dependencies]
itertools = "0.10" itertools = "0.10"
matrixcompare = { version = "0.3.0", features = [ "proptest-support" ] } matrixcompare = { version = "0.3.0", features = [ "proptest-support" ] }
nalgebra = { version="0.27", path = "../", features = ["compare"] } nalgebra = { version="0.28", path = "../", features = ["compare"] }
[package.metadata.docs.rs] [package.metadata.docs.rs]
# Enable certain features when building docs for docs.rs # Enable certain features when building docs for docs.rs

2
nalgebra-sparse/src/convert/mod.rs
View File

@ -7,7 +7,7 @@
//! The following example illustrates how to convert between matrix formats with the `From` //! The following example illustrates how to convert between matrix formats with the `From`
//! implementations. //! implementations.
//! //!
//! ```rust //! ```
//! use nalgebra_sparse::{csr::CsrMatrix, csc::CscMatrix, coo::CooMatrix}; //! use nalgebra_sparse::{csr::CsrMatrix, csc::CscMatrix, coo::CooMatrix};
//! use nalgebra::DMatrix; //! use nalgebra::DMatrix;
//! //!

45
nalgebra-sparse/src/coo.rs
View File

@ -20,7 +20,7 @@ use crate::SparseFormatError;
/// ///
/// # Examples /// # Examples
/// ///
/// ```rust /// ```
/// use nalgebra_sparse::{coo::CooMatrix, csr::CsrMatrix, csc::CscMatrix}; /// use nalgebra_sparse::{coo::CooMatrix, csr::CsrMatrix, csc::CscMatrix};
/// ///
/// // Initialize a matrix with all zeros (no explicitly stored entries). /// // Initialize a matrix with all zeros (no explicitly stored entries).
@ -45,6 +45,43 @@ pub struct CooMatrix<T> {
values: Vec<T>, values: Vec<T>,
} }
impl<T: na::Scalar> CooMatrix<T> {
/// Pushes a dense matrix into the sparse one.
///
/// This adds the dense matrix `m` starting at the `r`th row and `c`th column
/// to the matrix.
///
/// Panics
/// ------
///
/// Panics if any part of the dense matrix is out of bounds of the sparse matrix
/// when inserted at `(r, c)`.
#[inline]
pub fn push_matrix<R: na::Dim, C: na::Dim, S: nalgebra::storage::Storage<T, R, C>>(
&mut self,
r: usize,
c: usize,
m: &na::Matrix<T, R, C, S>,
) {
let block_nrows = m.nrows();
let block_ncols = m.ncols();
let max_row_with_block = r + block_nrows - 1;
let max_col_with_block = c + block_ncols - 1;
assert!(max_row_with_block < self.nrows);
assert!(max_col_with_block < self.ncols);
self.reserve(block_ncols * block_nrows);
for (col_idx, col) in m.column_iter().enumerate() {
for (row_idx, v) in col.iter().enumerate() {
self.row_indices.push(r + row_idx);
self.col_indices.push(c + col_idx);
self.values.push(v.clone());
}
}
}
}
impl<T> CooMatrix<T> { impl<T> CooMatrix<T> {
/// Construct a zero COO matrix of the given dimensions. /// Construct a zero COO matrix of the given dimensions.
/// ///
@ -173,12 +210,14 @@ impl<T> CooMatrix<T> {
/// The number of rows in the matrix. /// The number of rows in the matrix.
#[inline] #[inline]
#[must_use]
pub fn nrows(&self) -> usize { pub fn nrows(&self) -> usize {
self.nrows self.nrows
} }
/// The number of columns in the matrix. /// The number of columns in the matrix.
#[inline] #[inline]
#[must_use]
pub fn ncols(&self) -> usize { pub fn ncols(&self) -> usize {
self.ncols self.ncols
} }
@ -189,21 +228,25 @@ impl<T> CooMatrix<T> {
/// entries, then it may have a different number of non-zeros as reported by `nnz()` compared /// entries, then it may have a different number of non-zeros as reported by `nnz()` compared
/// to its CSR representation. /// to its CSR representation.
#[inline] #[inline]
#[must_use]
pub fn nnz(&self) -> usize { pub fn nnz(&self) -> usize {
self.values.len() self.values.len()
} }
/// The row indices of the explicitly stored entries. /// The row indices of the explicitly stored entries.
#[must_use]
pub fn row_indices(&self) -> &[usize] { pub fn row_indices(&self) -> &[usize] {
&self.row_indices &self.row_indices
} }
/// The column indices of the explicitly stored entries. /// The column indices of the explicitly stored entries.
#[must_use]
pub fn col_indices(&self) -> &[usize] { pub fn col_indices(&self) -> &[usize] {
&self.col_indices &self.col_indices
} }
/// The values of the explicitly stored entries. /// The values of the explicitly stored entries.
#[must_use]
pub fn values(&self) -> &[T] { pub fn values(&self) -> &[T] {
&self.values &self.values
} }

15
nalgebra-sparse/src/cs.rs
View File

@ -32,11 +32,13 @@ impl<T> CsMatrix<T> {
} }
#[inline] #[inline]
#[must_use]
pub fn pattern(&self) -> &SparsityPattern { pub fn pattern(&self) -> &SparsityPattern {
&self.sparsity_pattern &self.sparsity_pattern
} }
#[inline] #[inline]
#[must_use]
pub fn values(&self) -> &[T] { pub fn values(&self) -> &[T] {
&self.values &self.values
} }
@ -48,6 +50,7 @@ impl<T> CsMatrix<T> {
/// Returns the raw data represented as a tuple `(major_offsets, minor_indices, values)`. /// Returns the raw data represented as a tuple `(major_offsets, minor_indices, values)`.
#[inline] #[inline]
#[must_use]
pub fn cs_data(&self) -> (&[usize], &[usize], &[T]) { pub fn cs_data(&self) -> (&[usize], &[usize], &[T]) {
let pattern = self.pattern(); let pattern = self.pattern();
( (
@ -88,6 +91,7 @@ impl<T> CsMatrix<T> {
/// Internal method for simplifying access to a lane's data /// Internal method for simplifying access to a lane's data
#[inline] #[inline]
#[must_use]
pub fn get_index_range(&self, row_index: usize) -> Option<Range<usize>> { pub fn get_index_range(&self, row_index: usize) -> Option<Range<usize>> {
let row_begin = *self.sparsity_pattern.major_offsets().get(row_index)?; let row_begin = *self.sparsity_pattern.major_offsets().get(row_index)?;
let row_end = *self.sparsity_pattern.major_offsets().get(row_index + 1)?; let row_end = *self.sparsity_pattern.major_offsets().get(row_index + 1)?;
@ -111,6 +115,7 @@ impl<T> CsMatrix<T> {
/// Returns an entry for the given major/minor indices, or `None` if the indices are out /// Returns an entry for the given major/minor indices, or `None` if the indices are out
/// of bounds. /// of bounds.
#[must_use]
pub fn get_entry(&self, major_index: usize, minor_index: usize) -> Option<SparseEntry<T>> { pub fn get_entry(&self, major_index: usize, minor_index: usize) -> Option<SparseEntry<T>> {
let row_range = self.get_index_range(major_index)?; let row_range = self.get_index_range(major_index)?;
let (_, minor_indices, values) = self.cs_data(); let (_, minor_indices, values) = self.cs_data();
@ -139,6 +144,7 @@ impl<T> CsMatrix<T> {
get_mut_entry_from_slices(minor_dim, minor_indices, values, minor_index) get_mut_entry_from_slices(minor_dim, minor_indices, values, minor_index)
} }
#[must_use]
pub fn get_lane(&self, index: usize) -> Option<CsLane<T>> { pub fn get_lane(&self, index: usize) -> Option<CsLane<T>> {
let range = self.get_index_range(index)?; let range = self.get_index_range(index)?;
let (_, minor_indices, values) = self.cs_data(); let (_, minor_indices, values) = self.cs_data();
@ -150,6 +156,7 @@ impl<T> CsMatrix<T> {
} }
#[inline] #[inline]
#[must_use]
pub fn get_lane_mut(&mut self, index: usize) -> Option<CsLaneMut<T>> { pub fn get_lane_mut(&mut self, index: usize) -> Option<CsLaneMut<T>> {
let range = self.get_index_range(index)?; let range = self.get_index_range(index)?;
let minor_dim = self.pattern().minor_dim(); let minor_dim = self.pattern().minor_dim();
@ -172,6 +179,7 @@ impl<T> CsMatrix<T> {
} }
#[inline] #[inline]
#[must_use]
pub fn filter<P>(&self, predicate: P) -> Self pub fn filter<P>(&self, predicate: P) -> Self
where where
T: Clone, T: Clone,
@ -207,6 +215,7 @@ impl<T> CsMatrix<T> {
} }
/// Returns the diagonal of the matrix as a sparse matrix. /// Returns the diagonal of the matrix as a sparse matrix.
#[must_use]
pub fn diagonal_as_matrix(&self) -> Self pub fn diagonal_as_matrix(&self) -> Self
where where
T: Clone, T: Clone,
@ -372,26 +381,31 @@ macro_rules! impl_cs_lane_common_methods {
($name:ty) => { ($name:ty) => {
impl<'a, T> $name { impl<'a, T> $name {
#[inline] #[inline]
#[must_use]
pub fn minor_dim(&self) -> usize { pub fn minor_dim(&self) -> usize {
self.minor_dim self.minor_dim
} }
#[inline] #[inline]
#[must_use]
pub fn nnz(&self) -> usize { pub fn nnz(&self) -> usize {
self.minor_indices.len() self.minor_indices.len()
} }
#[inline] #[inline]
#[must_use]
pub fn minor_indices(&self) -> &[usize] { pub fn minor_indices(&self) -> &[usize] {
self.minor_indices self.minor_indices
} }
#[inline] #[inline]
#[must_use]
pub fn values(&self) -> &[T] { pub fn values(&self) -> &[T] {
self.values self.values
} }
#[inline] #[inline]
#[must_use]
pub fn get_entry(&self, global_col_index: usize) -> Option<SparseEntry<T>> { pub fn get_entry(&self, global_col_index: usize) -> Option<SparseEntry<T>> {
get_entry_from_slices( get_entry_from_slices(
self.minor_dim, self.minor_dim,
@ -416,6 +430,7 @@ impl<'a, T> CsLaneMut<'a, T> {
(self.minor_indices, self.values) (self.minor_indices, self.values)
} }
#[must_use]
pub fn get_entry_mut(&mut self, global_minor_index: usize) -> Option<SparseEntryMut<T>> { pub fn get_entry_mut(&mut self, global_minor_index: usize) -> Option<SparseEntryMut<T>> {
get_mut_entry_from_slices( get_mut_entry_from_slices(
self.minor_dim, self.minor_dim,

28
nalgebra-sparse/src/csc.rs
View File

@ -19,7 +19,7 @@ use std::slice::{Iter, IterMut};
/// ///
/// # Usage /// # Usage
/// ///
/// ```rust /// ```
/// use nalgebra_sparse::csc::CscMatrix; /// use nalgebra_sparse::csc::CscMatrix;
/// use nalgebra::{DMatrix, Matrix3x4}; /// use nalgebra::{DMatrix, Matrix3x4};
/// use matrixcompare::assert_matrix_eq; /// use matrixcompare::assert_matrix_eq;
@ -97,7 +97,7 @@ use std::slice::{Iter, IterMut};
/// represents the matrix in a column-by-column fashion. The entries associated with column `j` are /// represents the matrix in a column-by-column fashion. The entries associated with column `j` are
/// determined as follows: /// determined as follows:
/// ///
/// ```rust /// ```
/// # let col_offsets: Vec<usize> = vec![0, 0]; /// # let col_offsets: Vec<usize> = vec![0, 0];
/// # let row_indices: Vec<usize> = vec![]; /// # let row_indices: Vec<usize> = vec![];
/// # let values: Vec<i32> = vec![]; /// # let values: Vec<i32> = vec![];
@ -192,12 +192,14 @@ impl<T> CscMatrix<T> {
/// The number of rows in the matrix. /// The number of rows in the matrix.
#[inline] #[inline]
#[must_use]
pub fn nrows(&self) -> usize { pub fn nrows(&self) -> usize {
self.cs.pattern().minor_dim() self.cs.pattern().minor_dim()
} }
/// The number of columns in the matrix. /// The number of columns in the matrix.
#[inline] #[inline]
#[must_use]
pub fn ncols(&self) -> usize { pub fn ncols(&self) -> usize {
self.cs.pattern().major_dim() self.cs.pattern().major_dim()
} }
@ -208,24 +210,28 @@ impl<T> CscMatrix<T> {
/// number of algebraically zero entries in the matrix. Explicitly stored entries can still /// number of algebraically zero entries in the matrix. Explicitly stored entries can still
/// be zero. Corresponds to the number of entries in the sparsity pattern. /// be zero. Corresponds to the number of entries in the sparsity pattern.
#[inline] #[inline]
#[must_use]
pub fn nnz(&self) -> usize { pub fn nnz(&self) -> usize {
self.pattern().nnz() self.pattern().nnz()
} }
/// The column offsets defining part of the CSC format. /// The column offsets defining part of the CSC format.
#[inline] #[inline]
#[must_use]
pub fn col_offsets(&self) -> &[usize] { pub fn col_offsets(&self) -> &[usize] {
self.pattern().major_offsets() self.pattern().major_offsets()
} }
/// The row indices defining part of the CSC format. /// The row indices defining part of the CSC format.
#[inline] #[inline]
#[must_use]
pub fn row_indices(&self) -> &[usize] { pub fn row_indices(&self) -> &[usize] {
self.pattern().minor_indices() self.pattern().minor_indices()
} }
/// The non-zero values defining part of the CSC format. /// The non-zero values defining part of the CSC format.
#[inline] #[inline]
#[must_use]
pub fn values(&self) -> &[T] { pub fn values(&self) -> &[T] {
self.cs.values() self.cs.values()
} }
@ -298,6 +304,7 @@ impl<T> CscMatrix<T> {
/// ------ /// ------
/// Panics if column index is out of bounds. /// Panics if column index is out of bounds.
#[inline] #[inline]
#[must_use]
pub fn col(&self, index: usize) -> CscCol<T> { pub fn col(&self, index: usize) -> CscCol<T> {
self.get_col(index).expect("Row index must be in bounds") self.get_col(index).expect("Row index must be in bounds")
} }
@ -315,12 +322,14 @@ impl<T> CscMatrix<T> {
/// Return the column at the given column index, or `None` if out of bounds. /// Return the column at the given column index, or `None` if out of bounds.
#[inline] #[inline]
#[must_use]
pub fn get_col(&self, index: usize) -> Option<CscCol<T>> { pub fn get_col(&self, index: usize) -> Option<CscCol<T>> {
self.cs.get_lane(index).map(|lane| CscCol { lane }) self.cs.get_lane(index).map(|lane| CscCol { lane })
} }
/// Mutable column access for the given column index, or `None` if out of bounds. /// Mutable column access for the given column index, or `None` if out of bounds.
#[inline] #[inline]
#[must_use]
pub fn get_col_mut(&mut self, index: usize) -> Option<CscColMut<T>> { pub fn get_col_mut(&mut self, index: usize) -> Option<CscColMut<T>> {
self.cs.get_lane_mut(index).map(|lane| CscColMut { lane }) self.cs.get_lane_mut(index).map(|lane| CscColMut { lane })
} }
@ -381,6 +390,7 @@ impl<T> CscMatrix<T> {
} }
/// Returns a reference to the underlying sparsity pattern. /// Returns a reference to the underlying sparsity pattern.
#[must_use]
pub fn pattern(&self) -> &SparsityPattern { pub fn pattern(&self) -> &SparsityPattern {
self.cs.pattern() self.cs.pattern()
} }
@ -397,6 +407,7 @@ impl<T> CscMatrix<T> {
/// ///
/// Each call to this function incurs the cost of a binary search among the explicitly /// Each call to this function incurs the cost of a binary search among the explicitly
/// stored row entries for the given column. /// stored row entries for the given column.
#[must_use]
pub fn get_entry(&self, row_index: usize, col_index: usize) -> Option<SparseEntry<T>> { pub fn get_entry(&self, row_index: usize, col_index: usize) -> Option<SparseEntry<T>> {
self.cs.get_entry(col_index, row_index) self.cs.get_entry(col_index, row_index)
} }
@ -422,6 +433,7 @@ impl<T> CscMatrix<T> {
/// Panics /// Panics
/// ------ /// ------
/// Panics if `row_index` or `col_index` is out of bounds. /// Panics if `row_index` or `col_index` is out of bounds.
#[must_use]
pub fn index_entry(&self, row_index: usize, col_index: usize) -> SparseEntry<T> { pub fn index_entry(&self, row_index: usize, col_index: usize) -> SparseEntry<T> {
self.get_entry(row_index, col_index) self.get_entry(row_index, col_index)
.expect("Out of bounds matrix indices encountered") .expect("Out of bounds matrix indices encountered")
@ -441,6 +453,7 @@ impl<T> CscMatrix<T> {
} }
/// Returns a triplet of slices `(col_offsets, row_indices, values)` that make up the CSC data. /// Returns a triplet of slices `(col_offsets, row_indices, values)` that make up the CSC data.
#[must_use]
pub fn csc_data(&self) -> (&[usize], &[usize], &[T]) { pub fn csc_data(&self) -> (&[usize], &[usize], &[T]) {
self.cs.cs_data() self.cs.cs_data()
} }
@ -453,6 +466,7 @@ impl<T> CscMatrix<T> {
/// Creates a sparse matrix that contains only the explicit entries decided by the /// Creates a sparse matrix that contains only the explicit entries decided by the
/// given predicate. /// given predicate.
#[must_use]
pub fn filter<P>(&self, predicate: P) -> Self pub fn filter<P>(&self, predicate: P) -> Self
where where
T: Clone, T: Clone,
@ -470,6 +484,7 @@ impl<T> CscMatrix<T> {
/// Returns a new matrix representing the upper triangular part of this matrix. /// Returns a new matrix representing the upper triangular part of this matrix.
/// ///
/// The result includes the diagonal of the matrix. /// The result includes the diagonal of the matrix.
#[must_use]
pub fn upper_triangle(&self) -> Self pub fn upper_triangle(&self) -> Self
where where
T: Clone, T: Clone,
@ -480,6 +495,7 @@ impl<T> CscMatrix<T> {
/// Returns a new matrix representing the lower triangular part of this matrix. /// Returns a new matrix representing the lower triangular part of this matrix.
/// ///
/// The result includes the diagonal of the matrix. /// The result includes the diagonal of the matrix.
#[must_use]
pub fn lower_triangle(&self) -> Self pub fn lower_triangle(&self) -> Self
where where
T: Clone, T: Clone,
@ -488,6 +504,7 @@ impl<T> CscMatrix<T> {
} }
/// Returns the diagonal of the matrix as a sparse matrix. /// Returns the diagonal of the matrix as a sparse matrix.
#[must_use]
pub fn diagonal_as_csc(&self) -> Self pub fn diagonal_as_csc(&self) -> Self
where where
T: Clone, T: Clone,
@ -498,6 +515,7 @@ impl<T> CscMatrix<T> {
} }
/// Compute the transpose of the matrix. /// Compute the transpose of the matrix.
#[must_use]
pub fn transpose(&self) -> CscMatrix<T> pub fn transpose(&self) -> CscMatrix<T>
where where
T: Scalar, T: Scalar,
@ -617,24 +635,28 @@ macro_rules! impl_csc_col_common_methods {
impl<'a, T> $name { impl<'a, T> $name {
/// The number of global rows in the column. /// The number of global rows in the column.
#[inline] #[inline]
#[must_use]
pub fn nrows(&self) -> usize { pub fn nrows(&self) -> usize {
self.lane.minor_dim() self.lane.minor_dim()
} }
/// The number of non-zeros in this column. /// The number of non-zeros in this column.
#[inline] #[inline]
#[must_use]
pub fn nnz(&self) -> usize { pub fn nnz(&self) -> usize {
self.lane.nnz() self.lane.nnz()
} }
/// The row indices corresponding to explicitly stored entries in this column. /// The row indices corresponding to explicitly stored entries in this column.
#[inline] #[inline]
#[must_use]
pub fn row_indices(&self) -> &[usize] { pub fn row_indices(&self) -> &[usize] {
self.lane.minor_indices() self.lane.minor_indices()
} }
/// The values corresponding to explicitly stored entries in this column. /// The values corresponding to explicitly stored entries in this column.
#[inline] #[inline]
#[must_use]
pub fn values(&self) -> &[T] { pub fn values(&self) -> &[T] {
self.lane.values() self.lane.values()
} }
@ -643,6 +665,7 @@ macro_rules! impl_csc_col_common_methods {
/// ///
/// Each call to this function incurs the cost of a binary search among the explicitly /// Each call to this function incurs the cost of a binary search among the explicitly
/// stored row entries. /// stored row entries.
#[must_use]
pub fn get_entry(&self, global_row_index: usize) -> Option<SparseEntry<T>> { pub fn get_entry(&self, global_row_index: usize) -> Option<SparseEntry<T>> {
self.lane.get_entry(global_row_index) self.lane.get_entry(global_row_index)
} }
@ -669,6 +692,7 @@ impl<'a, T> CscColMut<'a, T> {
} }
/// Returns a mutable entry for the given global row index. /// Returns a mutable entry for the given global row index.
#[must_use]
pub fn get_entry_mut(&mut self, global_row_index: usize) -> Option<SparseEntryMut<T>> { pub fn get_entry_mut(&mut self, global_row_index: usize) -> Option<SparseEntryMut<T>> {
self.lane.get_entry_mut(global_row_index) self.lane.get_entry_mut(global_row_index)
} }

28
nalgebra-sparse/src/csr.rs
View File

@ -19,7 +19,7 @@ use std::slice::{Iter, IterMut};
/// ///
/// # Usage /// # Usage
/// ///
/// ```rust /// ```
/// use nalgebra_sparse::csr::CsrMatrix; /// use nalgebra_sparse::csr::CsrMatrix;
/// use nalgebra::{DMatrix, Matrix3x4}; /// use nalgebra::{DMatrix, Matrix3x4};
/// use matrixcompare::assert_matrix_eq; /// use matrixcompare::assert_matrix_eq;
@ -97,7 +97,7 @@ use std::slice::{Iter, IterMut};
/// represents the matrix in a row-by-row fashion. The entries associated with row `i` are /// represents the matrix in a row-by-row fashion. The entries associated with row `i` are
/// determined as follows: /// determined as follows:
/// ///
/// ```rust /// ```
/// # let row_offsets: Vec<usize> = vec![0, 0]; /// # let row_offsets: Vec<usize> = vec![0, 0];
/// # let col_indices: Vec<usize> = vec![]; /// # let col_indices: Vec<usize> = vec![];
/// # let values: Vec<i32> = vec![]; /// # let values: Vec<i32> = vec![];
@ -192,12 +192,14 @@ impl<T> CsrMatrix<T> {
/// The number of rows in the matrix. /// The number of rows in the matrix.
#[inline] #[inline]
#[must_use]
pub fn nrows(&self) -> usize { pub fn nrows(&self) -> usize {
self.cs.pattern().major_dim() self.cs.pattern().major_dim()
} }
/// The number of columns in the matrix. /// The number of columns in the matrix.
#[inline] #[inline]
#[must_use]
pub fn ncols(&self) -> usize { pub fn ncols(&self) -> usize {
self.cs.pattern().minor_dim() self.cs.pattern().minor_dim()
} }
@ -208,12 +210,14 @@ impl<T> CsrMatrix<T> {
/// number of algebraically zero entries in the matrix. Explicitly stored entries can still /// number of algebraically zero entries in the matrix. Explicitly stored entries can still
/// be zero. Corresponds to the number of entries in the sparsity pattern. /// be zero. Corresponds to the number of entries in the sparsity pattern.
#[inline] #[inline]
#[must_use]
pub fn nnz(&self) -> usize { pub fn nnz(&self) -> usize {
self.cs.pattern().nnz() self.cs.pattern().nnz()
} }
/// The row offsets defining part of the CSR format. /// The row offsets defining part of the CSR format.
#[inline] #[inline]
#[must_use]
pub fn row_offsets(&self) -> &[usize] { pub fn row_offsets(&self) -> &[usize] {
let (offsets, _, _) = self.cs.cs_data(); let (offsets, _, _) = self.cs.cs_data();
offsets offsets
@ -221,6 +225,7 @@ impl<T> CsrMatrix<T> {
/// The column indices defining part of the CSR format. /// The column indices defining part of the CSR format.
#[inline] #[inline]
#[must_use]
pub fn col_indices(&self) -> &[usize] { pub fn col_indices(&self) -> &[usize] {
let (_, indices, _) = self.cs.cs_data(); let (_, indices, _) = self.cs.cs_data();
indices indices
@ -228,6 +233,7 @@ impl<T> CsrMatrix<T> {
/// The non-zero values defining part of the CSR format. /// The non-zero values defining part of the CSR format.
#[inline] #[inline]
#[must_use]
pub fn values(&self) -> &[T] { pub fn values(&self) -> &[T] {
self.cs.values() self.cs.values()
} }
@ -300,6 +306,7 @@ impl<T> CsrMatrix<T> {
/// ------ /// ------
/// Panics if row index is out of bounds. /// Panics if row index is out of bounds.
#[inline] #[inline]
#[must_use]
pub fn row(&self, index: usize) -> CsrRow<T> { pub fn row(&self, index: usize) -> CsrRow<T> {
self.get_row(index).expect("Row index must be in bounds") self.get_row(index).expect("Row index must be in bounds")
} }
@ -317,12 +324,14 @@ impl<T> CsrMatrix<T> {
/// Return the row at the given row index, or `None` if out of bounds. /// Return the row at the given row index, or `None` if out of bounds.
#[inline] #[inline]
#[must_use]
pub fn get_row(&self, index: usize) -> Option<CsrRow<T>> { pub fn get_row(&self, index: usize) -> Option<CsrRow<T>> {
self.cs.get_lane(index).map(|lane| CsrRow { lane }) self.cs.get_lane(index).map(|lane| CsrRow { lane })
} }
/// Mutable row access for the given row index, or `None` if out of bounds. /// Mutable row access for the given row index, or `None` if out of bounds.
#[inline] #[inline]
#[must_use]
pub fn get_row_mut(&mut self, index: usize) -> Option<CsrRowMut<T>> { pub fn get_row_mut(&mut self, index: usize) -> Option<CsrRowMut<T>> {
self.cs.get_lane_mut(index).map(|lane| CsrRowMut { lane }) self.cs.get_lane_mut(index).map(|lane| CsrRowMut { lane })
} }
@ -383,6 +392,7 @@ impl<T> CsrMatrix<T> {
} }
/// Returns a reference to the underlying sparsity pattern. /// Returns a reference to the underlying sparsity pattern.
#[must_use]
pub fn pattern(&self) -> &SparsityPattern { pub fn pattern(&self) -> &SparsityPattern {
self.cs.pattern() self.cs.pattern()
} }
@ -399,6 +409,7 @@ impl<T> CsrMatrix<T> {
/// ///
/// Each call to this function incurs the cost of a binary search among the explicitly /// Each call to this function incurs the cost of a binary search among the explicitly
/// stored column entries for the given row. /// stored column entries for the given row.
#[must_use]
pub fn get_entry(&self, row_index: usize, col_index: usize) -> Option<SparseEntry<T>> { pub fn get_entry(&self, row_index: usize, col_index: usize) -> Option<SparseEntry<T>> {
self.cs.get_entry(row_index, col_index) self.cs.get_entry(row_index, col_index)
} }
@ -424,6 +435,7 @@ impl<T> CsrMatrix<T> {
/// Panics /// Panics
/// ------ /// ------
/// Panics if `row_index` or `col_index` is out of bounds. /// Panics if `row_index` or `col_index` is out of bounds.
#[must_use]
pub fn index_entry(&self, row_index: usize, col_index: usize) -> SparseEntry<T> { pub fn index_entry(&self, row_index: usize, col_index: usize) -> SparseEntry<T> {
self.get_entry(row_index, col_index) self.get_entry(row_index, col_index)
.expect("Out of bounds matrix indices encountered") .expect("Out of bounds matrix indices encountered")
@ -443,6 +455,7 @@ impl<T> CsrMatrix<T> {
} }
/// Returns a triplet of slices `(row_offsets, col_indices, values)` that make up the CSR data. /// Returns a triplet of slices `(row_offsets, col_indices, values)` that make up the CSR data.
#[must_use]
pub fn csr_data(&self) -> (&[usize], &[usize], &[T]) { pub fn csr_data(&self) -> (&[usize], &[usize], &[T]) {
self.cs.cs_data() self.cs.cs_data()
} }
@ -455,6 +468,7 @@ impl<T> CsrMatrix<T> {
/// Creates a sparse matrix that contains only the explicit entries decided by the /// Creates a sparse matrix that contains only the explicit entries decided by the
/// given predicate. /// given predicate.
#[must_use]
pub fn filter<P>(&self, predicate: P) -> Self pub fn filter<P>(&self, predicate: P) -> Self
where where
T: Clone, T: Clone,
@ -470,6 +484,7 @@ impl<T> CsrMatrix<T> {
/// Returns a new matrix representing the upper triangular part of this matrix. /// Returns a new matrix representing the upper triangular part of this matrix.
/// ///
/// The result includes the diagonal of the matrix. /// The result includes the diagonal of the matrix.
#[must_use]
pub fn upper_triangle(&self) -> Self pub fn upper_triangle(&self) -> Self
where where
T: Clone, T: Clone,
@ -480,6 +495,7 @@ impl<T> CsrMatrix<T> {
/// Returns a new matrix representing the lower triangular part of this matrix. /// Returns a new matrix representing the lower triangular part of this matrix.
/// ///
/// The result includes the diagonal of the matrix. /// The result includes the diagonal of the matrix.
#[must_use]
pub fn lower_triangle(&self) -> Self pub fn lower_triangle(&self) -> Self
where where
T: Clone, T: Clone,
@ -488,6 +504,7 @@ impl<T> CsrMatrix<T> {
} }
/// Returns the diagonal of the matrix as a sparse matrix. /// Returns the diagonal of the matrix as a sparse matrix.
#[must_use]
pub fn diagonal_as_csr(&self) -> Self pub fn diagonal_as_csr(&self) -> Self
where where
T: Clone, T: Clone,
@ -498,6 +515,7 @@ impl<T> CsrMatrix<T> {
} }
/// Compute the transpose of the matrix. /// Compute the transpose of the matrix.
#[must_use]
pub fn transpose(&self) -> CsrMatrix<T> pub fn transpose(&self) -> CsrMatrix<T>
where where
T: Scalar, T: Scalar,
@ -617,24 +635,28 @@ macro_rules! impl_csr_row_common_methods {
impl<'a, T> $name { impl<'a, T> $name {
/// The number of global columns in the row. /// The number of global columns in the row.
#[inline] #[inline]
#[must_use]
pub fn ncols(&self) -> usize { pub fn ncols(&self) -> usize {
self.lane.minor_dim() self.lane.minor_dim()
} }
/// The number of non-zeros in this row. /// The number of non-zeros in this row.
#[inline] #[inline]
#[must_use]
pub fn nnz(&self) -> usize { pub fn nnz(&self) -> usize {
self.lane.nnz() self.lane.nnz()
} }
/// The column indices corresponding to explicitly stored entries in this row. /// The column indices corresponding to explicitly stored entries in this row.
#[inline] #[inline]
#[must_use]
pub fn col_indices(&self) -> &[usize] { pub fn col_indices(&self) -> &[usize] {
self.lane.minor_indices() self.lane.minor_indices()
} }
/// The values corresponding to explicitly stored entries in this row. /// The values corresponding to explicitly stored entries in this row.
#[inline] #[inline]
#[must_use]
pub fn values(&self) -> &[T] { pub fn values(&self) -> &[T] {
self.lane.values() self.lane.values()
} }
@ -644,6 +666,7 @@ macro_rules! impl_csr_row_common_methods {
/// Each call to this function incurs the cost of a binary search among the explicitly /// Each call to this function incurs the cost of a binary search among the explicitly
/// stored column entries. /// stored column entries.
#[inline] #[inline]
#[must_use]
pub fn get_entry(&self, global_col_index: usize) -> Option<SparseEntry<T>> { pub fn get_entry(&self, global_col_index: usize) -> Option<SparseEntry<T>> {
self.lane.get_entry(global_col_index) self.lane.get_entry(global_col_index)
} }
@ -673,6 +696,7 @@ impl<'a, T> CsrRowMut<'a, T> {
/// Returns a mutable entry for the given global column index. /// Returns a mutable entry for the given global column index.
#[inline] #[inline]
#[must_use]
pub fn get_entry_mut(&mut self, global_col_index: usize) -> Option<SparseEntryMut<T>> { pub fn get_entry_mut(&mut self, global_col_index: usize) -> Option<SparseEntryMut<T>> {
self.lane.get_entry_mut(global_col_index) self.lane.get_entry_mut(global_col_index)
} }

3
nalgebra-sparse/src/factorization/cholesky.rs
View File

@ -42,6 +42,7 @@ impl CscSymbolicCholesky {
} }
/// The pattern of the Cholesky factor `L`. /// The pattern of the Cholesky factor `L`.
#[must_use]
pub fn l_pattern(&self) -> &SparsityPattern { pub fn l_pattern(&self) -> &SparsityPattern {
&self.l_pattern &self.l_pattern
} }
@ -171,6 +172,7 @@ impl<T: RealField> CscCholesky<T> {
} }
/// Returns a reference to the Cholesky factor `L`. /// Returns a reference to the Cholesky factor `L`.
#[must_use]
pub fn l(&self) -> &CscMatrix<T> { pub fn l(&self) -> &CscMatrix<T> {
&self.l_factor &self.l_factor
} }
@ -260,6 +262,7 @@ impl<T: RealField> CscCholesky<T> {
/// # Panics /// # Panics
/// ///
/// Panics if `B` is not square. /// Panics if `B` is not square.
#[must_use = "Did you mean to use solve_mut()?"]
pub fn solve<'a>(&'a self, b: impl Into<DMatrixSlice<'a, T>>) -> DMatrix<T> { pub fn solve<'a>(&'a self, b: impl Into<DMatrixSlice<'a, T>>) -> DMatrix<T> {
let b = b.into(); let b = b.into();
let mut output = b.clone_owned(); let mut output = b.clone_owned();

6
nalgebra-sparse/src/lib.rs
View File

@ -73,7 +73,7 @@
//! //!
//! # Example: COO -> CSR -> matrix-vector product //! # Example: COO -> CSR -> matrix-vector product
//! //!
//! ```rust //! ```
//! use nalgebra_sparse::{coo::CooMatrix, csr::CsrMatrix}; //! use nalgebra_sparse::{coo::CooMatrix, csr::CsrMatrix};
//! use nalgebra::{DMatrix, DVector}; //! use nalgebra::{DMatrix, DVector};
//! use matrixcompare::assert_matrix_eq; //! use matrixcompare::assert_matrix_eq;
@ -93,6 +93,9 @@
//! coo.push(1, 2, 1.3); //! coo.push(1, 2, 1.3);
//! coo.push(2, 2, 4.1); //! coo.push(2, 2, 4.1);
//! //!
//! // ... or add entire dense matrices like so:
//! // coo.push_matrix(0, 0, &dense);
//!
//! // The simplest way to construct a CSR matrix is to first construct a COO matrix, and //! // The simplest way to construct a CSR matrix is to first construct a COO matrix, and
//! // then convert it to CSR. The `From` trait is implemented for conversions between different //! // then convert it to CSR. The `From` trait is implemented for conversions between different
//! // sparse matrix types. //! // sparse matrix types.
@ -170,6 +173,7 @@ pub struct SparseFormatError {
impl SparseFormatError { impl SparseFormatError {
/// The type of error. /// The type of error.
#[must_use]
pub fn kind(&self) -> &SparseFormatErrorKind { pub fn kind(&self) -> &SparseFormatErrorKind {
&self.kind &self.kind
} }

6
nalgebra-sparse/src/ops/mod.rs
View File

@ -90,7 +90,7 @@
//! `C <- 3.0 * C + 2.0 * A^T * B`, where `A`, `B`, `C` are matrices and `A^T` is the transpose //! `C <- 3.0 * C + 2.0 * A^T * B`, where `A`, `B`, `C` are matrices and `A^T` is the transpose
//! of `A`. The simplest way to write this is: //! of `A`. The simplest way to write this is:
//! //!
//! ```rust //! ```
//! # use nalgebra_sparse::csr::CsrMatrix; //! # use nalgebra_sparse::csr::CsrMatrix;
//! # let a = CsrMatrix::identity(10); let b = CsrMatrix::identity(10); //! # let a = CsrMatrix::identity(10); let b = CsrMatrix::identity(10);
//! # let mut c = CsrMatrix::identity(10); //! # let mut c = CsrMatrix::identity(10);
@ -109,7 +109,7 @@
//! //!
//! An alternative way to implement this expression (here using CSR matrices) is: //! An alternative way to implement this expression (here using CSR matrices) is:
//! //!
//! ```rust //! ```
//! # use nalgebra_sparse::csr::CsrMatrix; //! # use nalgebra_sparse::csr::CsrMatrix;
//! # let a = CsrMatrix::identity(10); let b = CsrMatrix::identity(10); //! # let a = CsrMatrix::identity(10); let b = CsrMatrix::identity(10);
//! # let mut c = CsrMatrix::identity(10); //! # let mut c = CsrMatrix::identity(10);
@ -140,11 +140,13 @@ pub enum Op<T> {
impl<T> Op<T> { impl<T> Op<T> {
/// Returns a reference to the inner value that the operation applies to. /// Returns a reference to the inner value that the operation applies to.
#[must_use]
pub fn inner_ref(&self) -> &T { pub fn inner_ref(&self) -> &T {
self.as_ref().into_inner() self.as_ref().into_inner()
} }
/// Returns an `Op` applied to a reference of the inner value. /// Returns an `Op` applied to a reference of the inner value.
#[must_use]
pub fn as_ref(&self) -> Op<&T> { pub fn as_ref(&self) -> Op<&T> {
match self { match self {
Op::NoOp(obj) => Op::NoOp(&obj), Op::NoOp(obj) => Op::NoOp(&obj),

2
nalgebra-sparse/src/ops/serial/mod.rs
View File

@ -96,11 +96,13 @@ impl OperationError {
} }
/// The operation error kind. /// The operation error kind.
#[must_use]
pub fn kind(&self) -> &OperationErrorKind { pub fn kind(&self) -> &OperationErrorKind {
&self.error_kind &self.error_kind
} }
/// The underlying error message. /// The underlying error message.
#[must_use]
pub fn message(&self) -> &str { pub fn message(&self) -> &str {
self.message.as_str() self.message.as_str()
} }

9
nalgebra-sparse/src/pattern.rs
View File

@ -60,18 +60,21 @@ impl SparsityPattern {
/// The offsets for the major dimension. /// The offsets for the major dimension.
#[inline] #[inline]
#[must_use]
pub fn major_offsets(&self) -> &[usize] { pub fn major_offsets(&self) -> &[usize] {
&self.major_offsets &self.major_offsets
} }
/// The indices for the minor dimension. /// The indices for the minor dimension.
#[inline] #[inline]
#[must_use]
pub fn minor_indices(&self) -> &[usize] { pub fn minor_indices(&self) -> &[usize] {
&self.minor_indices &self.minor_indices
} }
/// The number of major lanes in the pattern. /// The number of major lanes in the pattern.
#[inline] #[inline]
#[must_use]
pub fn major_dim(&self) -> usize { pub fn major_dim(&self) -> usize {
assert!(self.major_offsets.len() > 0); assert!(self.major_offsets.len() > 0);
self.major_offsets.len() - 1 self.major_offsets.len() - 1
@ -79,12 +82,14 @@ impl SparsityPattern {
/// The number of minor lanes in the pattern. /// The number of minor lanes in the pattern.
#[inline] #[inline]
#[must_use]
pub fn minor_dim(&self) -> usize { pub fn minor_dim(&self) -> usize {
self.minor_dim self.minor_dim
} }
/// The number of "non-zeros", i.e. explicitly stored entries in the pattern. /// The number of "non-zeros", i.e. explicitly stored entries in the pattern.
#[inline] #[inline]
#[must_use]
pub fn nnz(&self) -> usize { pub fn nnz(&self) -> usize {
self.minor_indices.len() self.minor_indices.len()
} }
@ -96,12 +101,14 @@ impl SparsityPattern {
/// ///
/// Panics if `major_index` is out of bounds. /// Panics if `major_index` is out of bounds.
#[inline] #[inline]
#[must_use]
pub fn lane(&self, major_index: usize) -> &[usize] { pub fn lane(&self, major_index: usize) -> &[usize] {
self.get_lane(major_index).unwrap() self.get_lane(major_index).unwrap()
} }
/// Get the lane at the given index, or `None` if out of bounds. /// Get the lane at the given index, or `None` if out of bounds.
#[inline] #[inline]
#[must_use]
pub fn get_lane(&self, major_index: usize) -> Option<&[usize]> { pub fn get_lane(&self, major_index: usize) -> Option<&[usize]> {
let offset_begin = *self.major_offsets().get(major_index)?; let offset_begin = *self.major_offsets().get(major_index)?;
let offset_end = *self.major_offsets().get(major_index + 1)?; let offset_end = *self.major_offsets().get(major_index + 1)?;
@ -197,6 +204,7 @@ impl SparsityPattern {
/// assert_eq!(entries, vec![(0, 0), (0, 2), (1, 1), (2, 0)]); /// assert_eq!(entries, vec![(0, 0), (0, 2), (1, 1), (2, 0)]);
/// ``` /// ```
/// ///
#[must_use]
pub fn entries(&self) -> SparsityPatternIter { pub fn entries(&self) -> SparsityPatternIter {
SparsityPatternIter::from_pattern(self) SparsityPatternIter::from_pattern(self)
} }
@ -228,6 +236,7 @@ impl SparsityPattern {
/// ///
/// This is analogous to matrix transposition, i.e. an entry `(i, j)` becomes `(j, i)` in the /// This is analogous to matrix transposition, i.e. an entry `(i, j)` becomes `(j, i)` in the
/// new pattern. /// new pattern.
#[must_use]
pub fn transpose(&self) -> Self { pub fn transpose(&self) -> Self {
// By using unit () values, we can use the same routines as for CSR/CSC matrices // By using unit () values, we can use the same routines as for CSR/CSC matrices
let values = vec![(); self.nnz()]; let values = vec![(); self.nnz()];

92
nalgebra-sparse/tests/unit_tests/coo.rs
View File

@ -252,3 +252,95 @@ fn coo_push_out_of_bounds_entries() {
assert_panics!(coo.clone().push(3, 2, 1)); assert_panics!(coo.clone().push(3, 2, 1));
} }
} }
#[test]
fn coo_push_matrix_valid_entries() {
let mut coo = CooMatrix::new(3, 3);
// Works with static
{
// new is row-major...
let inserted = nalgebra::SMatrix::<i32, 2, 2>::new(1, 2, 3, 4);
coo.push_matrix(1, 1, &inserted);
// insert happens column-major, so expect transposition when read this way
assert_eq!(
coo.triplet_iter().collect::<Vec<_>>(),
vec![(1, 1, &1), (2, 1, &3), (1, 2, &2), (2, 2, &4)]
);
}
// Works with owned dynamic
{
let inserted = nalgebra::DMatrix::<i32>::repeat(1, 2, 5);
coo.push_matrix(0, 0, &inserted);
assert_eq!(
coo.triplet_iter().collect::<Vec<_>>(),
vec![
(1, 1, &1),
(2, 1, &3),
(1, 2, &2),
(2, 2, &4),
(0, 0, &5),
(0, 1, &5)
]
);
}
// Works with sliced
{
let source = nalgebra::SMatrix::<i32, 2, 2>::new(6, 7, 8, 9);
let sliced = source.fixed_slice::<2, 1>(0, 0);
coo.push_matrix(1, 0, &sliced);
assert_eq!(
coo.triplet_iter().collect::<Vec<_>>(),
vec![
(1, 1, &1),
(2, 1, &3),
(1, 2, &2),
(2, 2, &4),
(0, 0, &5),
(0, 1, &5),
(1, 0, &6),
(2, 0, &8)
]
);
}
}
#[test]
fn coo_push_matrix_out_of_bounds_entries() {
// 0x0
{
let inserted = nalgebra::SMatrix::<i32, 1, 1>::new(1);
assert_panics!(CooMatrix::new(0, 0).push_matrix(0, 0, &inserted));
}
// 0x1
{
let inserted = nalgebra::SMatrix::<i32, 1, 1>::new(1);
assert_panics!(CooMatrix::new(1, 0).push_matrix(0, 0, &inserted));
}
// 1x0
{
let inserted = nalgebra::SMatrix::<i32, 1, 1>::new(1);
assert_panics!(CooMatrix::new(0, 1).push_matrix(0, 0, &inserted));
}
// 3x3 exceeds col-dim
{
let inserted = nalgebra::SMatrix::<i32, 1, 2>::repeat(1);
assert_panics!(CooMatrix::new(3, 3).push_matrix(0, 2, &inserted));
}
// 3x3 exceeds row-dim
{
let inserted = nalgebra::SMatrix::<i32, 2, 1>::repeat(1);
assert_panics!(CooMatrix::new(3, 3).push_matrix(2, 0, &inserted));
}
// 3x3 exceeds row-dim and row-dim
{
let inserted = nalgebra::SMatrix::<i32, 2, 2>::repeat(1);
assert_panics!(CooMatrix::new(3, 3).push_matrix(2, 2, &inserted));
}
}

1
src/base/allocator.rs
View File

@ -40,6 +40,7 @@ pub trait Reallocator<T: Scalar, RFrom: Dim, CFrom: Dim, RTo: Dim, CTo: Dim>:
/// Reallocates a buffer of shape `(RTo, CTo)`, possibly reusing a previously allocated buffer /// Reallocates a buffer of shape `(RTo, CTo)`, possibly reusing a previously allocated buffer
/// `buf`. Data stored by `buf` are linearly copied to the output: /// `buf`. Data stored by `buf` are linearly copied to the output:
/// ///
/// # Safety
/// * The copy is performed as if both were just arrays (without a matrix structure). /// * The copy is performed as if both were just arrays (without a matrix structure).
/// * If `buf` is larger than the output size, then extra elements of `buf` are truncated. /// * If `buf` is larger than the output size, then extra elements of `buf` are truncated.
/// * If `buf` is smaller than the output size, then extra elements of the output are left /// * If `buf` is smaller than the output size, then extra elements of the output are left

16
src/base/array_storage.rs
View File

@ -101,8 +101,8 @@ where
} }
#[inline] #[inline]
fn as_slice(&self) -> &[T] { unsafe fn as_slice_unchecked(&self) -> &[T] {
unsafe { std::slice::from_raw_parts(self.ptr(), R * C) } std::slice::from_raw_parts(self.ptr(), R * C)
} }
} }
@ -118,8 +118,8 @@ where
} }
#[inline] #[inline]
fn as_mut_slice(&mut self) -> &mut [T] { unsafe fn as_mut_slice_unchecked(&mut self) -> &mut [T] {
unsafe { std::slice::from_raw_parts_mut(self.ptr_mut(), R * C) } std::slice::from_raw_parts_mut(self.ptr_mut(), R * C)
} }
} }
@ -286,11 +286,7 @@ where
unsafe fn exhume<'a, 'b>(&'a mut self, mut bytes: &'b mut [u8]) -> Option<&'b mut [u8]> { unsafe fn exhume<'a, 'b>(&'a mut self, mut bytes: &'b mut [u8]) -> Option<&'b mut [u8]> {
for element in self.as_mut_slice() { for element in self.as_mut_slice() {
let temp = bytes; let temp = bytes;
bytes = if let Some(remainder) = element.exhume(temp) { bytes = element.exhume(temp)?
remainder
} else {
return None;
}
} }
Some(bytes) Some(bytes)
} }
@ -327,7 +323,7 @@ mod rkyv_impl {
for ArrayStorage<T, R, C> for ArrayStorage<T, R, C>
{ {
fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> { fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
Ok(self.0.serialize(serializer)?) self.0.serialize(serializer)
} }
} }

25
src/base/blas.rs
View File

@ -193,6 +193,7 @@ where
/// ``` /// ```
/// ///
#[inline] #[inline]
#[must_use]
pub fn dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T pub fn dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
where where
SB: Storage<T, R2, C2>, SB: Storage<T, R2, C2>,
@ -221,6 +222,7 @@ where
/// assert_ne!(vec1.dotc(&vec2), vec1.dot(&vec2)); /// assert_ne!(vec1.dotc(&vec2), vec1.dot(&vec2));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn dotc<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T pub fn dotc<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
where where
T: SimdComplexField, T: SimdComplexField,
@ -248,6 +250,7 @@ where
/// assert_eq!(mat1.tr_dot(&mat2), 9.1); /// assert_eq!(mat1.tr_dot(&mat2), 9.1);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn tr_dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T pub fn tr_dot<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> T
where where
SB: Storage<T, R2, C2>, SB: Storage<T, R2, C2>,
@ -275,6 +278,7 @@ where
} }
} }
#[allow(clippy::too_many_arguments)]
fn array_axcpy<T>( fn array_axcpy<T>(
y: &mut [T], y: &mut [T],
a: T, a: T,
@ -331,6 +335,7 @@ where
/// assert_eq!(vec1, Vector3::new(6.0, 12.0, 18.0)); /// assert_eq!(vec1, Vector3::new(6.0, 12.0, 18.0));
/// ``` /// ```
#[inline] #[inline]
#[allow(clippy::many_single_char_names)]
pub fn axcpy<D2: Dim, SB>(&mut self, a: T, x: &Vector<T, D2, SB>, c: T, b: T) pub fn axcpy<D2: Dim, SB>(&mut self, a: T, x: &Vector<T, D2, SB>, c: T, b: T)
where where
SB: Storage<T, D2>, SB: Storage<T, D2>,
@ -341,13 +346,17 @@ where
let rstride1 = self.strides().0; let rstride1 = self.strides().0;
let rstride2 = x.strides().0; let rstride2 = x.strides().0;
let y = self.data.as_mut_slice(); unsafe {
let x = x.data.as_slice(); // SAFETY: the conversion to slices is OK because we access the
// elements taking the strides into account.
let y = self.data.as_mut_slice_unchecked();
let x = x.data.as_slice_unchecked();
if !b.is_zero() { if !b.is_zero() {
array_axcpy(y, a, x, c, b, rstride1, rstride2, x.len()); array_axcpy(y, a, x, c, b, rstride1, rstride2, x.len());
} else { } else {
array_axc(y, a, x, c, rstride1, rstride2, x.len()); array_axc(y, a, x, c, rstride1, rstride2, x.len());
}
} }
} }
@ -1379,12 +1388,12 @@ where
{ {
work.gemv(T::one(), mid, &rhs.column(0), T::zero()); work.gemv(T::one(), mid, &rhs.column(0), T::zero());
self.column_mut(0) self.column_mut(0)
.gemv_tr(alpha.inlined_clone(), &rhs, work, beta.inlined_clone()); .gemv_tr(alpha.inlined_clone(), rhs, work, beta.inlined_clone());
for j in 1..rhs.ncols() { for j in 1..rhs.ncols() {
work.gemv(T::one(), mid, &rhs.column(j), T::zero()); work.gemv(T::one(), mid, &rhs.column(j), T::zero());
self.column_mut(j) self.column_mut(j)
.gemv_tr(alpha.inlined_clone(), &rhs, work, beta.inlined_clone()); .gemv_tr(alpha.inlined_clone(), rhs, work, beta.inlined_clone());
} }
} }

4
src/base/cg.rs
View File

@ -386,7 +386,7 @@ impl<T: Scalar + Zero + One + ClosedMul + ClosedAdd, D: DimName, S: Storage<T, D
(D::dim() - 1, 0), (D::dim() - 1, 0),
(Const::<1>, DimNameDiff::<D, U1>::name()), (Const::<1>, DimNameDiff::<D, U1>::name()),
) )
.tr_dot(&shift); .tr_dot(shift);
let post_translation = self.generic_slice( let post_translation = self.generic_slice(
(0, 0), (0, 0),
(DimNameDiff::<D, U1>::name(), DimNameDiff::<D, U1>::name()), (DimNameDiff::<D, U1>::name(), DimNameDiff::<D, U1>::name()),
@ -423,7 +423,7 @@ where
(D::dim() - 1, 0), (D::dim() - 1, 0),
(Const::<1>, DimNameDiff::<D, U1>::name()), (Const::<1>, DimNameDiff::<D, U1>::name()),
); );
let n = normalizer.tr_dot(&v); let n = normalizer.tr_dot(v);
if !n.is_zero() { if !n.is_zero() {
return transform * (v / n); return transform * (v / n);

5
src/base/componentwise.rs
View File

@ -28,6 +28,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(a.abs(), Matrix2::new(0.0, 1.0, 2.0, 3.0)) /// assert_eq!(a.abs(), Matrix2::new(0.0, 1.0, 2.0, 3.0))
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn abs(&self) -> OMatrix<T, R, C> pub fn abs(&self) -> OMatrix<T, R, C>
where where
T: Signed, T: Signed,
@ -49,6 +50,7 @@ macro_rules! component_binop_impl(
($($binop: ident, $binop_mut: ident, $binop_assign: ident, $cmpy: ident, $Trait: ident . $op: ident . $op_assign: ident, $desc:expr, $desc_cmpy:expr, $desc_mut:expr);* $(;)*) => {$( ($($binop: ident, $binop_mut: ident, $binop_assign: ident, $cmpy: ident, $Trait: ident . $op: ident . $op_assign: ident, $desc:expr, $desc_cmpy:expr, $desc_mut:expr);* $(;)*) => {$(
#[doc = $desc] #[doc = $desc]
#[inline] #[inline]
#[must_use]
pub fn $binop<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> MatrixComponentOp<T, R1, C1, R2, C2> pub fn $binop<R2, C2, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> MatrixComponentOp<T, R1, C1, R2, C2>
where T: $Trait, where T: $Trait,
R2: Dim, C2: Dim, R2: Dim, C2: Dim,
@ -251,6 +253,7 @@ impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
/// assert_eq!(u.inf(&v), expected) /// assert_eq!(u.inf(&v), expected)
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inf(&self, other: &Self) -> OMatrix<T, R1, C1> pub fn inf(&self, other: &Self) -> OMatrix<T, R1, C1>
where where
T: SimdPartialOrd, T: SimdPartialOrd,
@ -271,6 +274,7 @@ impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
/// assert_eq!(u.sup(&v), expected) /// assert_eq!(u.sup(&v), expected)
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn sup(&self, other: &Self) -> OMatrix<T, R1, C1> pub fn sup(&self, other: &Self) -> OMatrix<T, R1, C1>
where where
T: SimdPartialOrd, T: SimdPartialOrd,
@ -291,6 +295,7 @@ impl<T: Scalar, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>> Matrix<T, R1, C1, SA>
/// assert_eq!(u.inf_sup(&v), expected) /// assert_eq!(u.inf_sup(&v), expected)
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inf_sup(&self, other: &Self) -> (OMatrix<T, R1, C1>, OMatrix<T, R1, C1>) pub fn inf_sup(&self, other: &Self) -> (OMatrix<T, R1, C1>, OMatrix<T, R1, C1>)
where where
T: SimdPartialOrd, T: SimdPartialOrd,

10
src/base/construction.rs
View File

@ -53,7 +53,10 @@ impl<T: Scalar, R: Dim, C: Dim> OMatrix<T, R, C>
where where
DefaultAllocator: Allocator<T, R, C>, DefaultAllocator: Allocator<T, R, C>,
{ {
/// Creates a new uninitialized matrix. If the matrix has a compile-time dimension, this panics /// Creates a new uninitialized matrix.
///
/// # Safety
/// If the matrix has a compile-time dimension, this panics
/// if `nrows != R::to_usize()` or `ncols != C::to_usize()`. /// if `nrows != R::to_usize()` or `ncols != C::to_usize()`.
#[inline] #[inline]
pub unsafe fn new_uninitialized_generic(nrows: R, ncols: C) -> mem::MaybeUninit<Self> { pub unsafe fn new_uninitialized_generic(nrows: R, ncols: C) -> mem::MaybeUninit<Self> {
@ -827,7 +830,7 @@ where
Standard: Distribution<T>, Standard: Distribution<T>,
{ {
#[inline] #[inline]
fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> OMatrix<T, R, C> { fn sample<G: Rng + ?Sized>(&self, rng: &mut G) -> OMatrix<T, R, C> {
let nrows = R::try_to_usize().unwrap_or_else(|| rng.gen_range(0..10)); let nrows = R::try_to_usize().unwrap_or_else(|| rng.gen_range(0..10));
let ncols = C::try_to_usize().unwrap_or_else(|| rng.gen_range(0..10)); let ncols = C::try_to_usize().unwrap_or_else(|| rng.gen_range(0..10));
@ -864,7 +867,7 @@ where
{ {
/// Generate a uniformly distributed random unit vector. /// Generate a uniformly distributed random unit vector.
#[inline] #[inline]
fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Unit<OVector<T, D>> { fn sample<G: Rng + ?Sized>(&self, rng: &mut G) -> Unit<OVector<T, D>> {
Unit::new_normalize(OVector::from_distribution_generic( Unit::new_normalize(OVector::from_distribution_generic(
D::name(), D::name(),
Const::<1>, Const::<1>,
@ -906,6 +909,7 @@ macro_rules! componentwise_constructors_impl(
impl<T> Matrix<T, Const<$R>, Const<$C>, ArrayStorage<T, $R, $C>> { impl<T> Matrix<T, Const<$R>, Const<$C>, ArrayStorage<T, $R, $C>> {
/// Initializes this matrix from its components. /// Initializes this matrix from its components.
#[inline] #[inline]
#[allow(clippy::too_many_arguments)]
pub const fn new($($($args: T),*),*) -> Self { pub const fn new($($($args: T),*),*) -> Self {
unsafe { unsafe {
Self::from_data_statically_unchecked( Self::from_data_statically_unchecked(

4
src/base/construction_slice.rs
View File

@ -10,6 +10,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
{ {
/// Creates, without bound-checking, a matrix slice from an array and with dimensions and strides specified by generic types instances. /// Creates, without bound-checking, a matrix slice from an array and with dimensions and strides specified by generic types instances.
/// ///
/// # Safety
/// This method is unsafe because the input data array is not checked to contain enough elements. /// This method is unsafe because the input data array is not checked to contain enough elements.
/// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`. /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`.
#[inline] #[inline]
@ -59,6 +60,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSlice<'a, T, R, C> { impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSlice<'a, T, R, C> {
/// Creates, without bound-checking, a matrix slice from an array and with dimensions specified by generic types instances. /// Creates, without bound-checking, a matrix slice from an array and with dimensions specified by generic types instances.
/// ///
/// # Safety
/// This method is unsafe because the input data array is not checked to contain enough elements. /// This method is unsafe because the input data array is not checked to contain enough elements.
/// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dynamic::new()`. /// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dynamic::new()`.
#[inline] #[inline]
@ -146,6 +148,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
{ {
/// Creates, without bound-checking, a mutable matrix slice from an array and with dimensions and strides specified by generic types instances. /// Creates, without bound-checking, a mutable matrix slice from an array and with dimensions and strides specified by generic types instances.
/// ///
/// # Safety
/// This method is unsafe because the input data array is not checked to contain enough elements. /// This method is unsafe because the input data array is not checked to contain enough elements.
/// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`. /// The generic types `R`, `C`, `RStride`, `CStride` can either be type-level integers or integers wrapped with `Dynamic::new()`.
#[inline] #[inline]
@ -217,6 +220,7 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSliceMutMN<'a, T, R, C> { impl<'a, T: Scalar, R: Dim, C: Dim> MatrixSliceMutMN<'a, T, R, C> {
/// Creates, without bound-checking, a mutable matrix slice from an array and with dimensions specified by generic types instances. /// Creates, without bound-checking, a mutable matrix slice from an array and with dimensions specified by generic types instances.
/// ///
/// # Safety
/// This method is unsafe because the input data array is not checked to contain enough elements. /// This method is unsafe because the input data array is not checked to contain enough elements.
/// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dynamic::new()`. /// The generic types `R` and `C` can either be type-level integers or integers wrapped with `Dynamic::new()`.
#[inline] #[inline]

85
src/base/conversion.rs
View File

@ -1,8 +1,8 @@
#[cfg(all(feature = "alloc", not(feature = "std")))] #[cfg(all(feature = "alloc", not(feature = "std")))]
use alloc::vec::Vec; use alloc::vec::Vec;
use simba::scalar::{SubsetOf, SupersetOf}; use simba::scalar::{SubsetOf, SupersetOf};
use std::borrow::{Borrow, BorrowMut};
use std::convert::{AsMut, AsRef, From, Into}; use std::convert::{AsMut, AsRef, From, Into};
use std::mem;
use simba::simd::{PrimitiveSimdValue, SimdValue}; use simba::simd::{PrimitiveSimdValue, SimdValue};
@ -110,11 +110,11 @@ impl<T: Scalar, const D: usize> From<[T; D]> for SVector<T, D> {
} }
} }
impl<T: Scalar, const D: usize> Into<[T; D]> for SVector<T, D> { impl<T: Scalar, const D: usize> From<SVector<T, D>> for [T; D] {
#[inline] #[inline]
fn into(self) -> [T; D] { fn from(vec: SVector<T, D>) -> Self {
// TODO: unfortunately, we must clone because we can move out of an array. // TODO: unfortunately, we must clone because we can move out of an array.
self.data.0[0].clone() vec.data.0[0].clone()
} }
} }
@ -128,13 +128,13 @@ where
} }
} }
impl<T: Scalar, const D: usize> Into<[T; D]> for RowSVector<T, D> impl<T: Scalar, const D: usize> From<RowSVector<T, D>> for [T; D]
where where
Const<D>: IsNotStaticOne, Const<D>: IsNotStaticOne,
{ {
#[inline] #[inline]
fn into(self) -> [T; D] { fn from(vec: RowSVector<T, D>) -> [T; D] {
self.transpose().into() vec.transpose().into()
} }
} }
@ -146,7 +146,7 @@ macro_rules! impl_from_into_asref_1D(
#[inline] #[inline]
fn as_ref(&self) -> &[T; $SZ] { fn as_ref(&self) -> &[T; $SZ] {
unsafe { unsafe {
mem::transmute(self.data.ptr()) &*(self.data.ptr() as *const [T; $SZ])
} }
} }
} }
@ -157,7 +157,7 @@ macro_rules! impl_from_into_asref_1D(
#[inline] #[inline]
fn as_mut(&mut self) -> &mut [T; $SZ] { fn as_mut(&mut self) -> &mut [T; $SZ] {
unsafe { unsafe {
mem::transmute(self.data.ptr_mut()) &mut *(self.data.ptr_mut() as *mut [T; $SZ])
} }
} }
} }
@ -186,39 +186,54 @@ impl<T: Scalar, const R: usize, const C: usize> From<[[T; R]; C]> for SMatrix<T,
} }
} }
impl<T: Scalar, const R: usize, const C: usize> Into<[[T; R]; C]> for SMatrix<T, R, C> { impl<T: Scalar, const R: usize, const C: usize> From<SMatrix<T, R, C>> for [[T; R]; C] {
#[inline] #[inline]
fn into(self) -> [[T; R]; C] { fn from(vec: SMatrix<T, R, C>) -> Self {
self.data.0 vec.data.0
} }
} }
macro_rules! impl_from_into_asref_2D( macro_rules! impl_from_into_asref_borrow_2D(
($(($NRows: ty, $NCols: ty) => ($SZRows: expr, $SZCols: expr));* $(;)*) => {$(
impl<T: Scalar, S> AsRef<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S> //does the impls on one case for either AsRef/AsMut and Borrow/BorrowMut
(
($NRows: ty, $NCols: ty) => ($SZRows: expr, $SZCols: expr);
$Ref:ident.$ref:ident(), $Mut:ident.$mut:ident()
) => {
impl<T: Scalar, S> $Ref<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S>
where S: ContiguousStorage<T, $NRows, $NCols> { where S: ContiguousStorage<T, $NRows, $NCols> {
#[inline] #[inline]
fn as_ref(&self) -> &[[T; $SZRows]; $SZCols] { fn $ref(&self) -> &[[T; $SZRows]; $SZCols] {
unsafe { unsafe {
mem::transmute(self.data.ptr()) &*(self.data.ptr() as *const [[T; $SZRows]; $SZCols])
} }
} }
} }
impl<T: Scalar, S> AsMut<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S> impl<T: Scalar, S> $Mut<[[T; $SZRows]; $SZCols]> for Matrix<T, $NRows, $NCols, S>
where S: ContiguousStorageMut<T, $NRows, $NCols> { where S: ContiguousStorageMut<T, $NRows, $NCols> {
#[inline] #[inline]
fn as_mut(&mut self) -> &mut [[T; $SZRows]; $SZCols] { fn $mut(&mut self) -> &mut [[T; $SZRows]; $SZCols] {
unsafe { unsafe {
mem::transmute(self.data.ptr_mut()) &mut *(self.data.ptr_mut() as *mut [[T; $SZRows]; $SZCols])
} }
} }
} }
};
//collects the mappings from typenum pairs to consts
($(($NRows: ty, $NCols: ty) => ($SZRows: expr, $SZCols: expr));* $(;)*) => {$(
impl_from_into_asref_borrow_2D!(
($NRows, $NCols) => ($SZRows, $SZCols); AsRef.as_ref(), AsMut.as_mut()
);
impl_from_into_asref_borrow_2D!(
($NRows, $NCols) => ($SZRows, $SZCols); Borrow.borrow(), BorrowMut.borrow_mut()
);
)*} )*}
); );
// Implement for matrices with shape 2x2 .. 6x6. // Implement for matrices with shape 2x2 .. 6x6.
impl_from_into_asref_2D!( impl_from_into_asref_borrow_2D!(
(U2, U2) => (2, 2); (U2, U3) => (2, 3); (U2, U4) => (2, 4); (U2, U5) => (2, 5); (U2, U6) => (2, 6); (U2, U2) => (2, 2); (U2, U3) => (2, 3); (U2, U4) => (2, 4); (U2, U5) => (2, 5); (U2, U6) => (2, 6);
(U3, U2) => (3, 2); (U3, U3) => (3, 3); (U3, U4) => (3, 4); (U3, U5) => (3, 5); (U3, U6) => (3, 6); (U3, U2) => (3, 2); (U3, U3) => (3, 3); (U3, U4) => (3, 4); (U3, U5) => (3, 5); (U3, U6) => (3, 6);
(U4, U2) => (4, 2); (U4, U3) => (4, 3); (U4, U4) => (4, 4); (U4, U5) => (4, 5); (U4, U6) => (4, 6); (U4, U2) => (4, 2); (U4, U3) => (4, 3); (U4, U4) => (4, 4); (U4, U5) => (4, 5); (U4, U6) => (4, 6);
@ -427,21 +442,21 @@ impl<'a, T: Scalar> From<Vec<T>> for DVector<T> {
} }
} }
impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: ContiguousStorage<T, R, C>> Into<&'a [T]> impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: ContiguousStorage<T, R, C>>
for &'a Matrix<T, R, C, S> From<&'a Matrix<T, R, C, S>> for &'a [T]
{ {
#[inline] #[inline]
fn into(self) -> &'a [T] { fn from(matrix: &'a Matrix<T, R, C, S>) -> Self {
self.as_slice() matrix.as_slice()
} }
} }
impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: ContiguousStorageMut<T, R, C>> Into<&'a mut [T]> impl<'a, T: Scalar + Copy, R: Dim, C: Dim, S: ContiguousStorageMut<T, R, C>>
for &'a mut Matrix<T, R, C, S> From<&'a mut Matrix<T, R, C, S>> for &'a mut [T]
{ {
#[inline] #[inline]
fn into(self) -> &'a mut [T] { fn from(matrix: &'a mut Matrix<T, R, C, S>) -> Self {
self.as_mut_slice() matrix.as_mut_slice()
} }
} }
@ -452,6 +467,12 @@ impl<'a, T: Scalar + Copy> From<&'a [T]> for DVectorSlice<'a, T> {
} }
} }
impl<'a, T: Scalar> From<DVectorSlice<'a, T>> for &'a [T] {
fn from(vec: DVectorSlice<'a, T>) -> &'a [T] {
vec.data.into_slice()
}
}
impl<'a, T: Scalar + Copy> From<&'a mut [T]> for DVectorSliceMut<'a, T> { impl<'a, T: Scalar + Copy> From<&'a mut [T]> for DVectorSliceMut<'a, T> {
#[inline] #[inline]
fn from(slice: &'a mut [T]) -> Self { fn from(slice: &'a mut [T]) -> Self {
@ -459,6 +480,12 @@ impl<'a, T: Scalar + Copy> From<&'a mut [T]> for DVectorSliceMut<'a, T> {
} }
} }
impl<'a, T: Scalar> From<DVectorSliceMut<'a, T>> for &'a mut [T] {
fn from(vec: DVectorSliceMut<'a, T>) -> &'a mut [T] {
vec.data.into_slice_mut()
}
}
impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 2]> impl<T: Scalar + PrimitiveSimdValue, R: Dim, C: Dim> From<[OMatrix<T::Element, R, C>; 2]>
for OMatrix<T, R, C> for OMatrix<T, R, C>
where where

5
src/base/coordinates.rs
View File

@ -4,7 +4,6 @@
//! components using their names. For example, if `v` is a 3D vector, one can write `v.z` instead //! components using their names. For example, if `v` is a 3D vector, one can write `v.z` instead
//! of `v[2]`. //! of `v[2]`.
use std::mem;
use std::ops::{Deref, DerefMut}; use std::ops::{Deref, DerefMut};
use crate::base::dimension::{U1, U2, U3, U4, U5, U6}; use crate::base::dimension::{U1, U2, U3, U4, U5, U6};
@ -38,7 +37,7 @@ macro_rules! deref_impl(
#[inline] #[inline]
fn deref(&self) -> &Self::Target { fn deref(&self) -> &Self::Target {
unsafe { mem::transmute(self.data.ptr()) } unsafe { &*(self.data.ptr() as *const Self::Target) }
} }
} }
@ -46,7 +45,7 @@ macro_rules! deref_impl(
where S: ContiguousStorageMut<T, $R, $C> { where S: ContiguousStorageMut<T, $R, $C> {
#[inline] #[inline]
fn deref_mut(&mut self) -> &mut Self::Target { fn deref_mut(&mut self) -> &mut Self::Target {
unsafe { mem::transmute(self.data.ptr_mut()) } unsafe { &mut *(self.data.ptr_mut() as *mut Self::Target) }
} }
} }
} }

2
src/base/default_allocator.rs
View File

@ -16,7 +16,7 @@ use crate::base::array_storage::ArrayStorage;
#[cfg(any(feature = "alloc", feature = "std"))] #[cfg(any(feature = "alloc", feature = "std"))]
use crate::base::dimension::Dynamic; use crate::base::dimension::Dynamic;
use crate::base::dimension::{Dim, DimName}; use crate::base::dimension::{Dim, DimName};
use crate::base::storage::{Storage, StorageMut}; use crate::base::storage::{ContiguousStorageMut, Storage, StorageMut};
#[cfg(any(feature = "std", feature = "alloc"))] #[cfg(any(feature = "std", feature = "alloc"))]
use crate::base::vec_storage::VecStorage; use crate::base::vec_storage::VecStorage;
use crate::base::Scalar; use crate::base::Scalar;

2
src/base/dimension.rs
View File

@ -20,7 +20,7 @@ pub struct Dynamic {
impl Dynamic { impl Dynamic {
/// A dynamic size equal to `value`. /// A dynamic size equal to `value`.
#[inline] #[inline]
pub fn new(value: usize) -> Self { pub const fn new(value: usize) -> Self {
Self { value } Self { value }
} }
} }

8
src/base/edition.rs
View File

@ -11,13 +11,14 @@ use crate::base::constraint::{DimEq, SameNumberOfColumns, SameNumberOfRows, Shap
#[cfg(any(feature = "std", feature = "alloc"))] #[cfg(any(feature = "std", feature = "alloc"))]
use crate::base::dimension::Dynamic; use crate::base::dimension::Dynamic;
use crate::base::dimension::{Const, Dim, DimAdd, DimDiff, DimMin, DimMinimum, DimSub, DimSum, U1}; use crate::base::dimension::{Const, Dim, DimAdd, DimDiff, DimMin, DimMinimum, DimSub, DimSum, U1};
use crate::base::storage::{ReshapableStorage, Storage, StorageMut}; use crate::base::storage::{ContiguousStorageMut, ReshapableStorage, Storage, StorageMut};
use crate::base::{DefaultAllocator, Matrix, OMatrix, RowVector, Scalar, Vector}; use crate::base::{DefaultAllocator, Matrix, OMatrix, RowVector, Scalar, Vector};
/// # Rows and columns extraction /// # Rows and columns extraction
impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> { impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Extracts the upper triangular part of this matrix (including the diagonal). /// Extracts the upper triangular part of this matrix (including the diagonal).
#[inline] #[inline]
#[must_use]
pub fn upper_triangle(&self) -> OMatrix<T, R, C> pub fn upper_triangle(&self) -> OMatrix<T, R, C>
where where
DefaultAllocator: Allocator<T, R, C>, DefaultAllocator: Allocator<T, R, C>,
@ -30,6 +31,7 @@ impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Extracts the lower triangular part of this matrix (including the diagonal). /// Extracts the lower triangular part of this matrix (including the diagonal).
#[inline] #[inline]
#[must_use]
pub fn lower_triangle(&self) -> OMatrix<T, R, C> pub fn lower_triangle(&self) -> OMatrix<T, R, C>
where where
DefaultAllocator: Allocator<T, R, C>, DefaultAllocator: Allocator<T, R, C>,
@ -42,6 +44,7 @@ impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Creates a new matrix by extracting the given set of rows from `self`. /// Creates a new matrix by extracting the given set of rows from `self`.
#[cfg(any(feature = "std", feature = "alloc"))] #[cfg(any(feature = "std", feature = "alloc"))]
#[must_use]
pub fn select_rows<'a, I>(&self, irows: I) -> OMatrix<T, Dynamic, C> pub fn select_rows<'a, I>(&self, irows: I) -> OMatrix<T, Dynamic, C>
where where
I: IntoIterator<Item = &'a usize>, I: IntoIterator<Item = &'a usize>,
@ -78,6 +81,7 @@ impl<T: Scalar + Zero, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Creates a new matrix by extracting the given set of columns from `self`. /// Creates a new matrix by extracting the given set of columns from `self`.
#[cfg(any(feature = "std", feature = "alloc"))] #[cfg(any(feature = "std", feature = "alloc"))]
#[must_use]
pub fn select_columns<'a, I>(&self, icols: I) -> OMatrix<T, R, Dynamic> pub fn select_columns<'a, I>(&self, icols: I) -> OMatrix<T, R, Dynamic>
where where
I: IntoIterator<Item = &'a usize>, I: IntoIterator<Item = &'a usize>,
@ -583,6 +587,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Inserts `ninsert.value()` columns starting at the `i-th` place of this matrix. /// Inserts `ninsert.value()` columns starting at the `i-th` place of this matrix.
/// ///
/// # Safety
/// The added column values are not initialized. /// The added column values are not initialized.
#[inline] #[inline]
pub unsafe fn insert_columns_generic_uninitialized<D>( pub unsafe fn insert_columns_generic_uninitialized<D>(
@ -664,6 +669,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Inserts `ninsert.value()` rows at the `i-th` place of this matrix. /// Inserts `ninsert.value()` rows at the `i-th` place of this matrix.
/// ///
/// # Safety
/// The added rows values are not initialized. /// The added rows values are not initialized.
/// This is the generic implementation of `.insert_rows(...)` and /// This is the generic implementation of `.insert_rows(...)` and
/// `.insert_fixed_rows(...)` which have nicer API interfaces. /// `.insert_fixed_rows(...)` which have nicer API interfaces.

100
src/base/indexing.rs
View File

@ -44,7 +44,7 @@ impl<D: Dim> DimRange<D> for usize {
#[test] #[test]
fn dimrange_usize() { fn dimrange_usize() {
assert_eq!(DimRange::contained_by(&0, Const::<0>), false); assert_eq!(DimRange::contained_by(&0, Const::<0>), false);
assert_eq!(DimRange::contained_by(&0, Const::<1>), true); assert!(DimRange::contained_by(&0, Const::<1>));
} }
impl<D: Dim> DimRange<D> for ops::Range<usize> { impl<D: Dim> DimRange<D> for ops::Range<usize> {
@ -68,24 +68,23 @@ impl<D: Dim> DimRange<D> for ops::Range<usize> {
#[test] #[test]
fn dimrange_range_usize() { fn dimrange_range_usize() {
use std::usize::MAX;
assert_eq!(DimRange::contained_by(&(0..0), Const::<0>), false); assert_eq!(DimRange::contained_by(&(0..0), Const::<0>), false);
assert_eq!(DimRange::contained_by(&(0..1), Const::<0>), false); assert_eq!(DimRange::contained_by(&(0..1), Const::<0>), false);
assert_eq!(DimRange::contained_by(&(0..1), Const::<1>), true); assert!(DimRange::contained_by(&(0..1), Const::<1>));
assert!(DimRange::contained_by(
&((usize::MAX - 1)..usize::MAX),
Dynamic::new(usize::MAX)
));
assert_eq!( assert_eq!(
DimRange::contained_by(&((MAX - 1)..MAX), Dynamic::new(MAX)), DimRange::length(&((usize::MAX - 1)..usize::MAX), Dynamic::new(usize::MAX)),
true
);
assert_eq!(
DimRange::length(&((MAX - 1)..MAX), Dynamic::new(MAX)),
Dynamic::new(1) Dynamic::new(1)
); );
assert_eq!( assert_eq!(
DimRange::length(&(MAX..(MAX - 1)), Dynamic::new(MAX)), DimRange::length(&(usize::MAX..(usize::MAX - 1)), Dynamic::new(usize::MAX)),
Dynamic::new(0) Dynamic::new(0)
); );
assert_eq!( assert_eq!(
DimRange::length(&(MAX..MAX), Dynamic::new(MAX)), DimRange::length(&(usize::MAX..usize::MAX), Dynamic::new(usize::MAX)),
Dynamic::new(0) Dynamic::new(0)
); );
} }
@ -111,20 +110,19 @@ impl<D: Dim> DimRange<D> for ops::RangeFrom<usize> {
#[test] #[test]
fn dimrange_rangefrom_usize() { fn dimrange_rangefrom_usize() {
use std::usize::MAX;
assert_eq!(DimRange::contained_by(&(0..), Const::<0>), false); assert_eq!(DimRange::contained_by(&(0..), Const::<0>), false);
assert_eq!(DimRange::contained_by(&(0..), Const::<0>), false); assert_eq!(DimRange::contained_by(&(0..), Const::<0>), false);
assert_eq!(DimRange::contained_by(&(0..), Const::<1>), true); assert!(DimRange::contained_by(&(0..), Const::<1>));
assert!(DimRange::contained_by(
&((usize::MAX - 1)..),
Dynamic::new(usize::MAX)
));
assert_eq!( assert_eq!(
DimRange::contained_by(&((MAX - 1)..), Dynamic::new(MAX)), DimRange::length(&((usize::MAX - 1)..), Dynamic::new(usize::MAX)),
true
);
assert_eq!(
DimRange::length(&((MAX - 1)..), Dynamic::new(MAX)),
Dynamic::new(1) Dynamic::new(1)
); );
assert_eq!( assert_eq!(
DimRange::length(&(MAX..), Dynamic::new(MAX)), DimRange::length(&(usize::MAX..), Dynamic::new(usize::MAX)),
Dynamic::new(0) Dynamic::new(0)
); );
} }
@ -177,7 +175,7 @@ impl<D: Dim> DimRange<D> for ops::RangeFull {
#[test] #[test]
fn dimrange_rangefull() { fn dimrange_rangefull() {
assert_eq!(DimRange::contained_by(&(..), Const::<0>), true); assert!(DimRange::contained_by(&(..), Const::<0>));
assert_eq!(DimRange::length(&(..), Const::<1>), Const::<1>); assert_eq!(DimRange::length(&(..), Const::<1>), Const::<1>);
} }
@ -206,32 +204,31 @@ impl<D: Dim> DimRange<D> for ops::RangeInclusive<usize> {
#[test] #[test]
fn dimrange_rangeinclusive_usize() { fn dimrange_rangeinclusive_usize() {
use std::usize::MAX;
assert_eq!(DimRange::contained_by(&(0..=0), Const::<0>), false); assert_eq!(DimRange::contained_by(&(0..=0), Const::<0>), false);
assert_eq!(DimRange::contained_by(&(0..=0), Const::<1>), true); assert!(DimRange::contained_by(&(0..=0), Const::<1>));
assert_eq!( assert_eq!(
DimRange::contained_by(&(MAX..=MAX), Dynamic::new(MAX)), DimRange::contained_by(&(usize::MAX..=usize::MAX), Dynamic::new(usize::MAX)),
false false
); );
assert_eq!( assert_eq!(
DimRange::contained_by(&((MAX - 1)..=MAX), Dynamic::new(MAX)), DimRange::contained_by(&((usize::MAX - 1)..=usize::MAX), Dynamic::new(usize::MAX)),
false false
); );
assert_eq!( assert!(DimRange::contained_by(
DimRange::contained_by(&((MAX - 1)..=(MAX - 1)), Dynamic::new(MAX)), &((usize::MAX - 1)..=(usize::MAX - 1)),
true Dynamic::new(usize::MAX)
); ));
assert_eq!(DimRange::length(&(0..=0), Const::<1>), Dynamic::new(1)); assert_eq!(DimRange::length(&(0..=0), Const::<1>), Dynamic::new(1));
assert_eq!( assert_eq!(
DimRange::length(&((MAX - 1)..=MAX), Dynamic::new(MAX)), DimRange::length(&((usize::MAX - 1)..=usize::MAX), Dynamic::new(usize::MAX)),
Dynamic::new(2) Dynamic::new(2)
); );
assert_eq!( assert_eq!(
DimRange::length(&(MAX..=(MAX - 1)), Dynamic::new(MAX)), DimRange::length(&(usize::MAX..=(usize::MAX - 1)), Dynamic::new(usize::MAX)),
Dynamic::new(0) Dynamic::new(0)
); );
assert_eq!( assert_eq!(
DimRange::length(&(MAX..=MAX), Dynamic::new(MAX)), DimRange::length(&(usize::MAX..=usize::MAX), Dynamic::new(usize::MAX)),
Dynamic::new(1) Dynamic::new(1)
); );
} }
@ -257,21 +254,20 @@ impl<D: Dim> DimRange<D> for ops::RangeTo<usize> {
#[test] #[test]
fn dimrange_rangeto_usize() { fn dimrange_rangeto_usize() {
use std::usize::MAX; assert!(DimRange::contained_by(&(..0), Const::<0>));
assert_eq!(DimRange::contained_by(&(..0), Const::<0>), true);
assert_eq!(DimRange::contained_by(&(..1), Const::<0>), false); assert_eq!(DimRange::contained_by(&(..1), Const::<0>), false);
assert_eq!(DimRange::contained_by(&(..0), Const::<1>), true); assert!(DimRange::contained_by(&(..0), Const::<1>));
assert!(DimRange::contained_by(
&(..(usize::MAX - 1)),
Dynamic::new(usize::MAX)
));
assert_eq!( assert_eq!(
DimRange::contained_by(&(..(MAX - 1)), Dynamic::new(MAX)), DimRange::length(&(..(usize::MAX - 1)), Dynamic::new(usize::MAX)),
true Dynamic::new(usize::MAX - 1)
); );
assert_eq!( assert_eq!(
DimRange::length(&(..(MAX - 1)), Dynamic::new(MAX)), DimRange::length(&(..usize::MAX), Dynamic::new(usize::MAX)),
Dynamic::new(MAX - 1) Dynamic::new(usize::MAX)
);
assert_eq!(
DimRange::length(&(..MAX), Dynamic::new(MAX)),
Dynamic::new(MAX)
); );
} }
@ -296,21 +292,20 @@ impl<D: Dim> DimRange<D> for ops::RangeToInclusive<usize> {
#[test] #[test]
fn dimrange_rangetoinclusive_usize() { fn dimrange_rangetoinclusive_usize() {
use std::usize::MAX;
assert_eq!(DimRange::contained_by(&(..=0), Const::<0>), false); assert_eq!(DimRange::contained_by(&(..=0), Const::<0>), false);
assert_eq!(DimRange::contained_by(&(..=1), Const::<0>), false); assert_eq!(DimRange::contained_by(&(..=1), Const::<0>), false);
assert_eq!(DimRange::contained_by(&(..=0), Const::<1>), true); assert!(DimRange::contained_by(&(..=0), Const::<1>));
assert_eq!( assert_eq!(
DimRange::contained_by(&(..=(MAX)), Dynamic::new(MAX)), DimRange::contained_by(&(..=(usize::MAX)), Dynamic::new(usize::MAX)),
false false
); );
assert!(DimRange::contained_by(
&(..=(usize::MAX - 1)),
Dynamic::new(usize::MAX)
));
assert_eq!( assert_eq!(
DimRange::contained_by(&(..=(MAX - 1)), Dynamic::new(MAX)), DimRange::length(&(..=(usize::MAX - 1)), Dynamic::new(usize::MAX)),
true Dynamic::new(usize::MAX)
);
assert_eq!(
DimRange::length(&(..=(MAX - 1)), Dynamic::new(MAX)),
Dynamic::new(MAX)
); );
} }
@ -485,6 +480,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Produces a view of the data at the given index, or /// Produces a view of the data at the given index, or
/// `None` if the index is out of bounds. /// `None` if the index is out of bounds.
#[inline] #[inline]
#[must_use]
pub fn get<'a, I>(&'a self, index: I) -> Option<I::Output> pub fn get<'a, I>(&'a self, index: I) -> Option<I::Output>
where where
I: MatrixIndex<'a, T, R, C, S>, I: MatrixIndex<'a, T, R, C, S>,
@ -495,6 +491,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Produces a mutable view of the data at the given index, or /// Produces a mutable view of the data at the given index, or
/// `None` if the index is out of bounds. /// `None` if the index is out of bounds.
#[inline] #[inline]
#[must_use]
pub fn get_mut<'a, I>(&'a mut self, index: I) -> Option<I::OutputMut> pub fn get_mut<'a, I>(&'a mut self, index: I) -> Option<I::OutputMut>
where where
S: StorageMut<T, R, C>, S: StorageMut<T, R, C>,
@ -506,6 +503,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Produces a view of the data at the given index, or /// Produces a view of the data at the given index, or
/// panics if the index is out of bounds. /// panics if the index is out of bounds.
#[inline] #[inline]
#[must_use]
pub fn index<'a, I>(&'a self, index: I) -> I::Output pub fn index<'a, I>(&'a self, index: I) -> I::Output
where where
I: MatrixIndex<'a, T, R, C, S>, I: MatrixIndex<'a, T, R, C, S>,
@ -527,6 +525,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Produces a view of the data at the given index, without doing /// Produces a view of the data at the given index, without doing
/// any bounds checking. /// any bounds checking.
#[inline] #[inline]
#[must_use]
pub unsafe fn get_unchecked<'a, I>(&'a self, index: I) -> I::Output pub unsafe fn get_unchecked<'a, I>(&'a self, index: I) -> I::Output
where where
I: MatrixIndex<'a, T, R, C, S>, I: MatrixIndex<'a, T, R, C, S>,
@ -537,6 +536,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Returns a mutable view of the data at the given index, without doing /// Returns a mutable view of the data at the given index, without doing
/// any bounds checking. /// any bounds checking.
#[inline] #[inline]
#[must_use]
pub unsafe fn get_unchecked_mut<'a, I>(&'a mut self, index: I) -> I::OutputMut pub unsafe fn get_unchecked_mut<'a, I>(&'a mut self, index: I) -> I::OutputMut
where where
S: StorageMut<T, R, C>, S: StorageMut<T, R, C>,

4
src/base/interpolation.rs
View File

@ -20,6 +20,7 @@ impl<T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Stor
/// let y = Vector3::new(10.0, 20.0, 30.0); /// let y = Vector3::new(10.0, 20.0, 30.0);
/// assert_eq!(x.lerp(&y, 0.1), Vector3::new(1.9, 3.8, 5.7)); /// assert_eq!(x.lerp(&y, 0.1), Vector3::new(1.9, 3.8, 5.7));
/// ``` /// ```
#[must_use]
pub fn lerp<S2: Storage<T, D>>(&self, rhs: &Vector<T, D, S2>, t: T) -> OVector<T, D> pub fn lerp<S2: Storage<T, D>>(&self, rhs: &Vector<T, D, S2>, t: T) -> OVector<T, D>
where where
DefaultAllocator: Allocator<T, D>, DefaultAllocator: Allocator<T, D>,
@ -45,6 +46,7 @@ impl<T: Scalar + Zero + One + ClosedAdd + ClosedSub + ClosedMul, D: Dim, S: Stor
/// ///
/// assert_eq!(v, v2.normalize()); /// assert_eq!(v, v2.normalize());
/// ``` /// ```
#[must_use]
pub fn slerp<S2: Storage<T, D>>(&self, rhs: &Vector<T, D, S2>, t: T) -> OVector<T, D> pub fn slerp<S2: Storage<T, D>>(&self, rhs: &Vector<T, D, S2>, t: T) -> OVector<T, D>
where where
T: RealField, T: RealField,
@ -72,6 +74,7 @@ impl<T: RealField, D: Dim, S: Storage<T, D>> Unit<Vector<T, D, S>> {
/// ///
/// assert_eq!(v, v2); /// assert_eq!(v, v2);
/// ``` /// ```
#[must_use]
pub fn slerp<S2: Storage<T, D>>( pub fn slerp<S2: Storage<T, D>>(
&self, &self,
rhs: &Unit<Vector<T, D, S2>>, rhs: &Unit<Vector<T, D, S2>>,
@ -89,6 +92,7 @@ impl<T: RealField, D: Dim, S: Storage<T, D>> Unit<Vector<T, D, S>> {
/// ///
/// Returns `None` if the two vectors are almost collinear and with opposite direction /// Returns `None` if the two vectors are almost collinear and with opposite direction
/// (in this case, there is an infinity of possible results). /// (in this case, there is an infinity of possible results).
#[must_use]
pub fn try_slerp<S2: Storage<T, D>>( pub fn try_slerp<S2: Storage<T, D>>(
&self, &self,
rhs: &Unit<Vector<T, D, S2>>, rhs: &Unit<Vector<T, D, S2>>,

12
src/base/iter.rs
View File

@ -96,6 +96,10 @@ macro_rules! iterator {
let stride = self.strides.0.value(); let stride = self.strides.0.value();
self.ptr = self.ptr.add(stride); self.ptr = self.ptr.add(stride);
} }
// We want either `& *last` or `&mut *last` here, depending
// on the mutability of `$Ref`.
#[allow(clippy::transmute_ptr_to_ref)]
Some(mem::transmute(old)) Some(mem::transmute(old))
} }
} }
@ -139,13 +143,13 @@ macro_rules! iterator {
let inner_remaining = self.size % inner_size; let inner_remaining = self.size % inner_size;
// Compute pointer to last element // Compute pointer to last element
let last = self.ptr.offset( let last = self
(outer_remaining * outer_stride + inner_remaining * inner_stride) .ptr
as isize, .add((outer_remaining * outer_stride + inner_remaining * inner_stride));
);
// We want either `& *last` or `&mut *last` here, depending // We want either `& *last` or `&mut *last` here, depending
// on the mutability of `$Ref`. // on the mutability of `$Ref`.
#[allow(clippy::transmute_ptr_to_ref)]
Some(mem::transmute(last)) Some(mem::transmute(last))
} }
} }

74
src/base/matrix.rs
View File

@ -336,7 +336,7 @@ mod rkyv_impl {
for Matrix<T, R, C, S> for Matrix<T, R, C, S>
{ {
fn serialize(&self, serializer: &mut _S) -> Result<Self::Resolver, _S::Error> { fn serialize(&self, serializer: &mut _S) -> Result<Self::Resolver, _S::Error> {
Ok(self.data.serialize(serializer)?) self.data.serialize(serializer)
} }
} }
@ -441,6 +441,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// let mat = Matrix3x4::<f32>::zeros(); /// let mat = Matrix3x4::<f32>::zeros();
/// assert_eq!(mat.shape(), (3, 4)); /// assert_eq!(mat.shape(), (3, 4));
#[inline] #[inline]
#[must_use]
pub fn shape(&self) -> (usize, usize) { pub fn shape(&self) -> (usize, usize) {
let (nrows, ncols) = self.data.shape(); let (nrows, ncols) = self.data.shape();
(nrows.value(), ncols.value()) (nrows.value(), ncols.value())
@ -455,6 +456,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// let mat = Matrix3x4::<f32>::zeros(); /// let mat = Matrix3x4::<f32>::zeros();
/// assert_eq!(mat.nrows(), 3); /// assert_eq!(mat.nrows(), 3);
#[inline] #[inline]
#[must_use]
pub fn nrows(&self) -> usize { pub fn nrows(&self) -> usize {
self.shape().0 self.shape().0
} }
@ -468,6 +470,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// let mat = Matrix3x4::<f32>::zeros(); /// let mat = Matrix3x4::<f32>::zeros();
/// assert_eq!(mat.ncols(), 4); /// assert_eq!(mat.ncols(), 4);
#[inline] #[inline]
#[must_use]
pub fn ncols(&self) -> usize { pub fn ncols(&self) -> usize {
self.shape().1 self.shape().1
} }
@ -483,6 +486,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// // The column strides is the number of steps (here 2) multiplied by the corresponding dimension. /// // The column strides is the number of steps (here 2) multiplied by the corresponding dimension.
/// assert_eq!(mat.strides(), (1, 10)); /// assert_eq!(mat.strides(), (1, 10));
#[inline] #[inline]
#[must_use]
pub fn strides(&self) -> (usize, usize) { pub fn strides(&self) -> (usize, usize) {
let (srows, scols) = self.data.strides(); let (srows, scols) = self.data.strides();
(srows.value(), scols.value()) (srows.value(), scols.value())
@ -501,6 +505,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(m[i], m[3]); /// assert_eq!(m[i], m[3]);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn vector_to_matrix_index(&self, i: usize) -> (usize, usize) { pub fn vector_to_matrix_index(&self, i: usize) -> (usize, usize) {
let (nrows, ncols) = self.shape(); let (nrows, ncols) = self.shape();
@ -529,6 +534,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(unsafe { *ptr }, m[0]); /// assert_eq!(unsafe { *ptr }, m[0]);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn as_ptr(&self) -> *const T { pub fn as_ptr(&self) -> *const T {
self.data.ptr() self.data.ptr()
} }
@ -537,6 +543,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// ///
/// See `relative_eq` from the `RelativeEq` trait for more details. /// See `relative_eq` from the `RelativeEq` trait for more details.
#[inline] #[inline]
#[must_use]
pub fn relative_eq<R2, C2, SB>( pub fn relative_eq<R2, C2, SB>(
&self, &self,
other: &Matrix<T, R2, C2, SB>, other: &Matrix<T, R2, C2, SB>,
@ -559,6 +566,8 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Tests whether `self` and `rhs` are exactly equal. /// Tests whether `self` and `rhs` are exactly equal.
#[inline] #[inline]
#[must_use]
#[allow(clippy::should_implement_trait)]
pub fn eq<R2, C2, SB>(&self, other: &Matrix<T, R2, C2, SB>) -> bool pub fn eq<R2, C2, SB>(&self, other: &Matrix<T, R2, C2, SB>) -> bool
where where
T: PartialEq, T: PartialEq,
@ -609,6 +618,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Clones this matrix to one that owns its data. /// Clones this matrix to one that owns its data.
#[inline] #[inline]
#[must_use]
pub fn clone_owned(&self) -> OMatrix<T, R, C> pub fn clone_owned(&self) -> OMatrix<T, R, C>
where where
DefaultAllocator: Allocator<T, R, C>, DefaultAllocator: Allocator<T, R, C>,
@ -619,6 +629,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Clones this matrix into one that owns its data. The actual type of the result depends on /// Clones this matrix into one that owns its data. The actual type of the result depends on
/// matrix storage combination rules for addition. /// matrix storage combination rules for addition.
#[inline] #[inline]
#[must_use]
pub fn clone_owned_sum<R2, C2>(&self) -> MatrixSum<T, R, C, R2, C2> pub fn clone_owned_sum<R2, C2>(&self) -> MatrixSum<T, R, C, R2, C2>
where where
R2: Dim, R2: Dim,
@ -692,6 +703,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> { impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Returns a matrix containing the result of `f` applied to each of its entries. /// Returns a matrix containing the result of `f` applied to each of its entries.
#[inline] #[inline]
#[must_use]
pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, mut f: F) -> OMatrix<T2, R, C> pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, mut f: F) -> OMatrix<T2, R, C>
where where
DefaultAllocator: Allocator<T2, R, C>, DefaultAllocator: Allocator<T2, R, C>,
@ -738,6 +750,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// - If the matrix has has least one component, then `init_f` is called with the first component /// - If the matrix has has least one component, then `init_f` is called with the first component
/// to compute the initial value. Folding then continues on all the remaining components of the matrix. /// to compute the initial value. Folding then continues on all the remaining components of the matrix.
#[inline] #[inline]
#[must_use]
pub fn fold_with<T2>( pub fn fold_with<T2>(
&self, &self,
init_f: impl FnOnce(Option<&T>) -> T2, init_f: impl FnOnce(Option<&T>) -> T2,
@ -751,6 +764,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Returns a matrix containing the result of `f` applied to each of its entries. Unlike `map`, /// Returns a matrix containing the result of `f` applied to each of its entries. Unlike `map`,
/// `f` also gets passed the row and column index, i.e. `f(row, col, value)`. /// `f` also gets passed the row and column index, i.e. `f(row, col, value)`.
#[inline] #[inline]
#[must_use]
pub fn map_with_location<T2: Scalar, F: FnMut(usize, usize, T) -> T2>( pub fn map_with_location<T2: Scalar, F: FnMut(usize, usize, T) -> T2>(
&self, &self,
mut f: F, mut f: F,
@ -778,6 +792,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Returns a matrix containing the result of `f` applied to each entries of `self` and /// Returns a matrix containing the result of `f` applied to each entries of `self` and
/// `rhs`. /// `rhs`.
#[inline] #[inline]
#[must_use]
pub fn zip_map<T2, N3, S2, F>(&self, rhs: &Matrix<T2, R, C, S2>, mut f: F) -> OMatrix<N3, R, C> pub fn zip_map<T2, N3, S2, F>(&self, rhs: &Matrix<T2, R, C, S2>, mut f: F) -> OMatrix<N3, R, C>
where where
T2: Scalar, T2: Scalar,
@ -813,6 +828,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Returns a matrix containing the result of `f` applied to each entries of `self` and /// Returns a matrix containing the result of `f` applied to each entries of `self` and
/// `b`, and `c`. /// `b`, and `c`.
#[inline] #[inline]
#[must_use]
pub fn zip_zip_map<T2, N3, N4, S2, S3, F>( pub fn zip_zip_map<T2, N3, N4, S2, S3, F>(
&self, &self,
b: &Matrix<T2, R, C, S2>, b: &Matrix<T2, R, C, S2>,
@ -860,6 +876,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Folds a function `f` on each entry of `self`. /// Folds a function `f` on each entry of `self`.
#[inline] #[inline]
#[must_use]
pub fn fold<Acc>(&self, init: Acc, mut f: impl FnMut(Acc, T) -> Acc) -> Acc { pub fn fold<Acc>(&self, init: Acc, mut f: impl FnMut(Acc, T) -> Acc) -> Acc {
let (nrows, ncols) = self.data.shape(); let (nrows, ncols) = self.data.shape();
@ -879,6 +896,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Folds a function `f` on each pairs of entries from `self` and `rhs`. /// Folds a function `f` on each pairs of entries from `self` and `rhs`.
#[inline] #[inline]
#[must_use]
pub fn zip_fold<T2, R2, C2, S2, Acc>( pub fn zip_fold<T2, R2, C2, S2, Acc>(
&self, &self,
rhs: &Matrix<T2, R2, C2, S2>, rhs: &Matrix<T2, R2, C2, S2>,
@ -1238,6 +1256,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: StorageMut<T, R, C>> Matrix<T, R, C, S> {
impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> { impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
/// Gets a reference to the i-th element of this column vector without bound checking. /// Gets a reference to the i-th element of this column vector without bound checking.
#[inline] #[inline]
#[must_use]
pub unsafe fn vget_unchecked(&self, i: usize) -> &T { pub unsafe fn vget_unchecked(&self, i: usize) -> &T {
debug_assert!(i < self.nrows(), "Vector index out of bounds."); debug_assert!(i < self.nrows(), "Vector index out of bounds.");
let i = i * self.strides().0; let i = i * self.strides().0;
@ -1248,6 +1267,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
impl<T: Scalar, D: Dim, S: StorageMut<T, D>> Vector<T, D, S> { impl<T: Scalar, D: Dim, S: StorageMut<T, D>> Vector<T, D, S> {
/// Gets a mutable reference to the i-th element of this column vector without bound checking. /// Gets a mutable reference to the i-th element of this column vector without bound checking.
#[inline] #[inline]
#[must_use]
pub unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut T { pub unsafe fn vget_unchecked_mut(&mut self, i: usize) -> &mut T {
debug_assert!(i < self.nrows(), "Vector index out of bounds."); debug_assert!(i < self.nrows(), "Vector index out of bounds.");
let i = i * self.strides().0; let i = i * self.strides().0;
@ -1258,6 +1278,7 @@ impl<T: Scalar, D: Dim, S: StorageMut<T, D>> Vector<T, D, S> {
impl<T: Scalar, R: Dim, C: Dim, S: ContiguousStorage<T, R, C>> Matrix<T, R, C, S> { impl<T: Scalar, R: Dim, C: Dim, S: ContiguousStorage<T, R, C>> Matrix<T, R, C, S> {
/// Extracts a slice containing the entire matrix entries ordered column-by-columns. /// Extracts a slice containing the entire matrix entries ordered column-by-columns.
#[inline] #[inline]
#[must_use]
pub fn as_slice(&self) -> &[T] { pub fn as_slice(&self) -> &[T] {
self.data.as_slice() self.data.as_slice()
} }
@ -1266,6 +1287,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: ContiguousStorage<T, R, C>> Matrix<T, R, C, S
impl<T: Scalar, R: Dim, C: Dim, S: ContiguousStorageMut<T, R, C>> Matrix<T, R, C, S> { impl<T: Scalar, R: Dim, C: Dim, S: ContiguousStorageMut<T, R, C>> Matrix<T, R, C, S> {
/// Extracts a mutable slice containing the entire matrix entries ordered column-by-columns. /// Extracts a mutable slice containing the entire matrix entries ordered column-by-columns.
#[inline] #[inline]
#[must_use]
pub fn as_mut_slice(&mut self) -> &mut [T] { pub fn as_mut_slice(&mut self) -> &mut [T] {
self.data.as_mut_slice() self.data.as_mut_slice()
} }
@ -1446,6 +1468,7 @@ impl<T: SimdComplexField, D: Dim, S: StorageMut<T, D, D>> Matrix<T, D, D, S> {
impl<T: Scalar, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> { impl<T: Scalar, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
/// The diagonal of this matrix. /// The diagonal of this matrix.
#[inline] #[inline]
#[must_use]
pub fn diagonal(&self) -> OVector<T, D> pub fn diagonal(&self) -> OVector<T, D>
where where
DefaultAllocator: Allocator<T, D>, DefaultAllocator: Allocator<T, D>,
@ -1457,6 +1480,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
/// ///
/// This is a more efficient version of `self.diagonal().map(f)` since this /// This is a more efficient version of `self.diagonal().map(f)` since this
/// allocates only once. /// allocates only once.
#[must_use]
pub fn map_diagonal<T2: Scalar>(&self, mut f: impl FnMut(T) -> T2) -> OVector<T2, D> pub fn map_diagonal<T2: Scalar>(&self, mut f: impl FnMut(T) -> T2) -> OVector<T2, D>
where where
DefaultAllocator: Allocator<T2, D>, DefaultAllocator: Allocator<T2, D>,
@ -1481,6 +1505,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
/// Computes a trace of a square matrix, i.e., the sum of its diagonal elements. /// Computes a trace of a square matrix, i.e., the sum of its diagonal elements.
#[inline] #[inline]
#[must_use]
pub fn trace(&self) -> T pub fn trace(&self) -> T
where where
T: Scalar + Zero + ClosedAdd, T: Scalar + Zero + ClosedAdd,
@ -1504,6 +1529,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> { impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
/// The symmetric part of `self`, i.e., `0.5 * (self + self.transpose())`. /// The symmetric part of `self`, i.e., `0.5 * (self + self.transpose())`.
#[inline] #[inline]
#[must_use]
pub fn symmetric_part(&self) -> OMatrix<T, D, D> pub fn symmetric_part(&self) -> OMatrix<T, D, D>
where where
DefaultAllocator: Allocator<T, D, D>, DefaultAllocator: Allocator<T, D, D>,
@ -1520,6 +1546,7 @@ impl<T: SimdComplexField, D: Dim, S: Storage<T, D, D>> SquareMatrix<T, D, S> {
/// The hermitian part of `self`, i.e., `0.5 * (self + self.adjoint())`. /// The hermitian part of `self`, i.e., `0.5 * (self + self.adjoint())`.
#[inline] #[inline]
#[must_use]
pub fn hermitian_part(&self) -> OMatrix<T, D, D> pub fn hermitian_part(&self) -> OMatrix<T, D, D>
where where
DefaultAllocator: Allocator<T, D, D>, DefaultAllocator: Allocator<T, D, D>,
@ -1542,6 +1569,7 @@ impl<T: Scalar + Zero + One, D: DimAdd<U1> + IsNotStaticOne, S: Storage<T, D, D>
/// Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and /// Yields the homogeneous matrix for this matrix, i.e., appending an additional dimension and
/// and setting the diagonal element to `1`. /// and setting the diagonal element to `1`.
#[inline] #[inline]
#[must_use]
pub fn to_homogeneous(&self) -> OMatrix<T, DimSum<D, U1>, DimSum<D, U1>> pub fn to_homogeneous(&self) -> OMatrix<T, DimSum<D, U1>, DimSum<D, U1>>
where where
DefaultAllocator: Allocator<T, DimSum<D, U1>, DimSum<D, U1>>, DefaultAllocator: Allocator<T, DimSum<D, U1>, DimSum<D, U1>>,
@ -1553,7 +1581,7 @@ impl<T: Scalar + Zero + One, D: DimAdd<U1> + IsNotStaticOne, S: Storage<T, D, D>
let dim = DimSum::<D, U1>::from_usize(self.nrows() + 1); let dim = DimSum::<D, U1>::from_usize(self.nrows() + 1);
let mut res = OMatrix::identity_generic(dim, dim); let mut res = OMatrix::identity_generic(dim, dim);
res.generic_slice_mut::<D, D>((0, 0), self.data.shape()) res.generic_slice_mut::<D, D>((0, 0), self.data.shape())
.copy_from(&self); .copy_from(self);
res res
} }
} }
@ -1562,6 +1590,7 @@ impl<T: Scalar + Zero, D: DimAdd<U1>, S: Storage<T, D>> Vector<T, D, S> {
/// Computes the coordinates in projective space of this vector, i.e., appends a `0` to its /// Computes the coordinates in projective space of this vector, i.e., appends a `0` to its
/// coordinates. /// coordinates.
#[inline] #[inline]
#[must_use]
pub fn to_homogeneous(&self) -> OVector<T, DimSum<D, U1>> pub fn to_homogeneous(&self) -> OVector<T, DimSum<D, U1>>
where where
DefaultAllocator: Allocator<T, DimSum<D, U1>>, DefaultAllocator: Allocator<T, DimSum<D, U1>>,
@ -1589,6 +1618,7 @@ impl<T: Scalar + Zero, D: DimAdd<U1>, S: Storage<T, D>> Vector<T, D, S> {
impl<T: Scalar + Zero, D: DimAdd<U1>, S: Storage<T, D>> Vector<T, D, S> { impl<T: Scalar + Zero, D: DimAdd<U1>, S: Storage<T, D>> Vector<T, D, S> {
/// Constructs a new vector of higher dimension by appending `element` to the end of `self`. /// Constructs a new vector of higher dimension by appending `element` to the end of `self`.
#[inline] #[inline]
#[must_use]
pub fn push(&self, element: T) -> OVector<T, DimSum<D, U1>> pub fn push(&self, element: T) -> OVector<T, DimSum<D, U1>>
where where
DefaultAllocator: Allocator<T, DimSum<D, U1>>, DefaultAllocator: Allocator<T, DimSum<D, U1>>,
@ -1789,7 +1819,6 @@ macro_rules! impl_fmt {
where where
T: Scalar + $trait, T: Scalar + $trait,
S: Storage<T, R, C>, S: Storage<T, R, C>,
DefaultAllocator: Allocator<usize, R, C>,
{ {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
#[cfg(feature = "std")] #[cfg(feature = "std")]
@ -1807,20 +1836,17 @@ macro_rules! impl_fmt {
4 4
} }
let (nrows, ncols) = self.data.shape(); let (nrows, ncols) = self.shape();
if nrows.value() == 0 || ncols.value() == 0 { if nrows == 0 || ncols == 0 {
return write!(f, "[ ]"); return write!(f, "[ ]");
} }
let mut max_length = 0; let mut max_length = 0;
let mut lengths: OMatrix<usize, R, C> = Matrix::zeros_generic(nrows, ncols);
let (nrows, ncols) = self.shape();
for i in 0..nrows { for i in 0..nrows {
for j in 0..ncols { for j in 0..ncols {
lengths[(i, j)] = val_width(&self[(i, j)], f); max_length = crate::max(max_length, val_width(&self[(i, j)], f));
max_length = crate::max(max_length, lengths[(i, j)]);
} }
} }
@ -1837,7 +1863,7 @@ macro_rules! impl_fmt {
for i in 0..nrows { for i in 0..nrows {
write!(f, " │")?; write!(f, " │")?;
for j in 0..ncols { for j in 0..ncols {
let number_length = lengths[(i, j)] + 1; let number_length = val_width(&self[(i, j)], f) + 1;
let pad = max_length_with_space - number_length; let pad = max_length_with_space - number_length;
write!(f, " {:>thepad$}", "", thepad = pad)?; write!(f, " {:>thepad$}", "", thepad = pad)?;
match f.precision() { match f.precision() {
@ -1870,19 +1896,29 @@ impl_fmt!(fmt::UpperHex, "{:X}", "{:1$X}");
impl_fmt!(fmt::Binary, "{:b}", "{:.1$b}"); impl_fmt!(fmt::Binary, "{:b}", "{:.1$b}");
impl_fmt!(fmt::Pointer, "{:p}", "{:.1$p}"); impl_fmt!(fmt::Pointer, "{:p}", "{:.1$p}");
#[test] #[cfg(test)]
fn lower_exp() { mod tests {
let test = crate::Matrix2::new(1e6, 2e5, 2e-5, 1.); #[test]
assert_eq!( fn empty_display() {
format!("{:e}", test), let vec: Vec<f64> = Vec::new();
r" let dvector = crate::DVector::from_vec(vec);
assert_eq!(format!("{}", dvector), "[ ]")
}
#[test]
fn lower_exp() {
let test = crate::Matrix2::new(1e6, 2e5, 2e-5, 1.);
assert_eq!(
format!("{:e}", test),
r"
┌ ┐ ┌ ┐
│ 1e6 2e5 │ │ 1e6 2e5 │
│ 2e-5 1e0 │ │ 2e-5 1e0 │
└ ┘ └ ┘
" "
) )
}
} }
/// # Cross product /// # Cross product
@ -1891,6 +1927,7 @@ impl<T: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<T
{ {
/// The perpendicular product between two 2D column vectors, i.e. `a.x * b.y - a.y * b.x`. /// The perpendicular product between two 2D column vectors, i.e. `a.x * b.y - a.y * b.x`.
#[inline] #[inline]
#[must_use]
pub fn perp<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> T pub fn perp<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> T
where where
R2: Dim, R2: Dim,
@ -1920,6 +1957,7 @@ impl<T: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<T
/// Panics if the shape is not 3D vector. In the future, this will be implemented only for /// Panics if the shape is not 3D vector. In the future, this will be implemented only for
/// dynamically-sized matrices and statically-sized 3D matrices. /// dynamically-sized matrices and statically-sized 3D matrices.
#[inline] #[inline]
#[must_use]
pub fn cross<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> MatrixCross<T, R, C, R2, C2> pub fn cross<R2, C2, SB>(&self, b: &Matrix<T, R2, C2, SB>) -> MatrixCross<T, R, C, R2, C2>
where where
R2: Dim, R2: Dim,
@ -1993,6 +2031,7 @@ impl<T: Scalar + ClosedAdd + ClosedSub + ClosedMul, R: Dim, C: Dim, S: Storage<T
impl<T: Scalar + Field, S: Storage<T, U3>> Vector<T, U3, S> { impl<T: Scalar + Field, S: Storage<T, U3>> Vector<T, U3, S> {
/// Computes the matrix `M` such that for all vector `v` we have `M * v == self.cross(&v)`. /// Computes the matrix `M` such that for all vector `v` we have `M * v == self.cross(&v)`.
#[inline] #[inline]
#[must_use]
pub fn cross_matrix(&self) -> OMatrix<T, U3, U3> { pub fn cross_matrix(&self) -> OMatrix<T, U3, U3> {
OMatrix::<T, U3, U3>::new( OMatrix::<T, U3, U3>::new(
T::zero(), T::zero(),
@ -2011,6 +2050,7 @@ impl<T: Scalar + Field, S: Storage<T, U3>> Vector<T, U3, S> {
impl<T: SimdComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> { impl<T: SimdComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// The smallest angle between two vectors. /// The smallest angle between two vectors.
#[inline] #[inline]
#[must_use]
pub fn angle<R2: Dim, C2: Dim, SB>(&self, other: &Matrix<T, R2, C2, SB>) -> T::SimdRealField pub fn angle<R2: Dim, C2: Dim, SB>(&self, other: &Matrix<T, R2, C2, SB>) -> T::SimdRealField
where where
SB: Storage<T, R2, C2>, SB: Storage<T, R2, C2>,

70
src/base/matrix_slice.rs
View File

@ -1,5 +1,5 @@
use std::marker::PhantomData; use std::marker::PhantomData;
use std::ops::{Range, RangeFrom, RangeFull, RangeTo}; use std::ops::{Range, RangeFrom, RangeFull, RangeInclusive, RangeTo};
use std::slice; use std::slice;
use crate::base::allocator::Allocator; use crate::base::allocator::Allocator;
@ -77,6 +77,23 @@ macro_rules! slice_storage_impl(
$T::from_raw_parts(storage.$get_addr(start.0, start.1), shape, strides) $T::from_raw_parts(storage.$get_addr(start.0, start.1), shape, strides)
} }
} }
impl <'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
$T<'a, T, R, C, RStride, CStride>
where
Self: ContiguousStorage<T, R, C>
{
/// Extracts the original slice from this storage
pub fn into_slice(self) -> &'a [T] {
let (nrows, ncols) = self.shape();
if nrows.value() != 0 && ncols.value() != 0 {
let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1);
unsafe { slice::from_raw_parts(self.ptr, sz + 1) }
} else {
unsafe { slice::from_raw_parts(self.ptr, 0) }
}
}
}
} }
); );
@ -108,6 +125,23 @@ impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Clone
} }
} }
impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim>
SliceStorageMut<'a, T, R, C, RStride, CStride>
where
Self: ContiguousStorageMut<T, R, C>,
{
/// Extracts the original slice from this storage
pub fn into_slice_mut(self) -> &'a mut [T] {
let (nrows, ncols) = self.shape();
if nrows.value() != 0 && ncols.value() != 0 {
let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1);
unsafe { slice::from_raw_parts_mut(self.ptr, sz + 1) }
} else {
unsafe { slice::from_raw_parts_mut(self.ptr, 0) }
}
}
}
macro_rules! storage_impl( macro_rules! storage_impl(
($($T: ident),* $(,)*) => {$( ($($T: ident),* $(,)*) => {$(
unsafe impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Storage<T, R, C> unsafe impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> Storage<T, R, C>
@ -162,14 +196,14 @@ macro_rules! storage_impl(
} }
#[inline] #[inline]
fn as_slice(&self) -> &[T] { unsafe fn as_slice_unchecked(&self) -> &[T] {
let (nrows, ncols) = self.shape(); let (nrows, ncols) = self.shape();
if nrows.value() != 0 && ncols.value() != 0 { if nrows.value() != 0 && ncols.value() != 0 {
let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1); let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1);
unsafe { slice::from_raw_parts(self.ptr, sz + 1) } slice::from_raw_parts(self.ptr, sz + 1)
} }
else { else {
unsafe { slice::from_raw_parts(self.ptr, 0) } slice::from_raw_parts(self.ptr, 0)
} }
} }
} }
@ -187,13 +221,13 @@ unsafe impl<'a, T: Scalar, R: Dim, C: Dim, RStride: Dim, CStride: Dim> StorageMu
} }
#[inline] #[inline]
fn as_mut_slice(&mut self) -> &mut [T] { unsafe fn as_mut_slice_unchecked(&mut self) -> &mut [T] {
let (nrows, ncols) = self.shape(); let (nrows, ncols) = self.shape();
if nrows.value() != 0 && ncols.value() != 0 { if nrows.value() != 0 && ncols.value() != 0 {
let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1); let sz = self.linear_index(nrows.value() - 1, ncols.value() - 1);
unsafe { slice::from_raw_parts_mut(self.ptr, sz + 1) } slice::from_raw_parts_mut(self.ptr, sz + 1)
} else { } else {
unsafe { slice::from_raw_parts_mut(self.ptr, 0) } slice::from_raw_parts_mut(self.ptr, 0)
} }
} }
} }
@ -806,12 +840,32 @@ impl<D: Dim> SliceRange<D> for RangeFull {
} }
} }
impl<D: Dim> SliceRange<D> for RangeInclusive<usize> {
type Size = Dynamic;
#[inline(always)]
fn begin(&self, _: D) -> usize {
*self.start()
}
#[inline(always)]
fn end(&self, _: D) -> usize {
*self.end() + 1
}
#[inline(always)]
fn size(&self, _: D) -> Self::Size {
Dynamic::new(*self.end() + 1 - *self.start())
}
}
// TODO: see how much of this overlaps with the general indexing // TODO: see how much of this overlaps with the general indexing
// methods from indexing.rs. // methods from indexing.rs.
impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> { impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Slices a sub-matrix containing the rows indexed by the range `rows` and the columns indexed /// Slices a sub-matrix containing the rows indexed by the range `rows` and the columns indexed
/// by the range `cols`. /// by the range `cols`.
#[inline] #[inline]
#[must_use]
pub fn slice_range<RowRange, ColRange>( pub fn slice_range<RowRange, ColRange>(
&self, &self,
rows: RowRange, rows: RowRange,
@ -830,6 +884,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Slice containing all the rows indexed by the range `rows`. /// Slice containing all the rows indexed by the range `rows`.
#[inline] #[inline]
#[must_use]
pub fn rows_range<RowRange: SliceRange<R>>( pub fn rows_range<RowRange: SliceRange<R>>(
&self, &self,
rows: RowRange, rows: RowRange,
@ -839,6 +894,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Slice containing all the columns indexed by the range `rows`. /// Slice containing all the columns indexed by the range `rows`.
#[inline] #[inline]
#[must_use]
pub fn columns_range<ColRange: SliceRange<C>>( pub fn columns_range<ColRange: SliceRange<C>>(
&self, &self,
cols: ColRange, cols: ColRange,

15
src/base/min_max.rs
View File

@ -13,6 +13,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(Vector3::new(-1.0, -2.0, -3.0).amax(), 3.0); /// assert_eq!(Vector3::new(-1.0, -2.0, -3.0).amax(), 3.0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn amax(&self) -> T pub fn amax(&self) -> T
where where
T: Zero + SimdSigned + SimdPartialOrd, T: Zero + SimdSigned + SimdPartialOrd,
@ -33,6 +34,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Complex::new(1.0, 3.0)).camax(), 5.0); /// Complex::new(1.0, 3.0)).camax(), 5.0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn camax(&self) -> T::SimdRealField pub fn camax(&self) -> T::SimdRealField
where where
T: SimdComplexField, T: SimdComplexField,
@ -52,6 +54,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(Vector3::new(5u32, 2, 3).max(), 5); /// assert_eq!(Vector3::new(5u32, 2, 3).max(), 5);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn max(&self) -> T pub fn max(&self) -> T
where where
T: SimdPartialOrd + Zero, T: SimdPartialOrd + Zero,
@ -70,6 +73,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(Vector3::new(10.0, 2.0, 30.0).amin(), 2.0); /// assert_eq!(Vector3::new(10.0, 2.0, 30.0).amin(), 2.0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn amin(&self) -> T pub fn amin(&self) -> T
where where
T: Zero + SimdPartialOrd + SimdSigned, T: Zero + SimdPartialOrd + SimdSigned,
@ -90,6 +94,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Complex::new(1.0, 3.0)).camin(), 3.0); /// Complex::new(1.0, 3.0)).camin(), 3.0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn camin(&self) -> T::SimdRealField pub fn camin(&self) -> T::SimdRealField
where where
T: SimdComplexField, T: SimdComplexField,
@ -112,6 +117,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(Vector3::new(5u32, 2, 3).min(), 2); /// assert_eq!(Vector3::new(5u32, 2, 3).min(), 2);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn min(&self) -> T pub fn min(&self) -> T
where where
T: SimdPartialOrd + Zero, T: SimdPartialOrd + Zero,
@ -136,6 +142,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(mat.icamax_full(), (1, 0)); /// assert_eq!(mat.icamax_full(), (1, 0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn icamax_full(&self) -> (usize, usize) pub fn icamax_full(&self) -> (usize, usize)
where where
T: ComplexField, T: ComplexField,
@ -172,6 +179,7 @@ impl<T: Scalar + PartialOrd + Signed, R: Dim, C: Dim, S: Storage<T, R, C>> Matri
/// assert_eq!(mat.iamax_full(), (1, 2)); /// assert_eq!(mat.iamax_full(), (1, 2));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn iamax_full(&self) -> (usize, usize) { pub fn iamax_full(&self) -> (usize, usize) {
assert!(!self.is_empty(), "The input matrix must not be empty."); assert!(!self.is_empty(), "The input matrix must not be empty.");
@ -209,6 +217,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
/// assert_eq!(vec.icamax(), 2); /// assert_eq!(vec.icamax(), 2);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn icamax(&self) -> usize pub fn icamax(&self) -> usize
where where
T: ComplexField, T: ComplexField,
@ -240,6 +249,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
/// assert_eq!(vec.argmax(), (2, 13)); /// assert_eq!(vec.argmax(), (2, 13));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn argmax(&self) -> (usize, T) pub fn argmax(&self) -> (usize, T)
where where
T: PartialOrd, T: PartialOrd,
@ -271,6 +281,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
/// assert_eq!(vec.imax(), 2); /// assert_eq!(vec.imax(), 2);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn imax(&self) -> usize pub fn imax(&self) -> usize
where where
T: PartialOrd, T: PartialOrd,
@ -288,6 +299,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
/// assert_eq!(vec.iamax(), 1); /// assert_eq!(vec.iamax(), 1);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn iamax(&self) -> usize pub fn iamax(&self) -> usize
where where
T: PartialOrd + Signed, T: PartialOrd + Signed,
@ -319,6 +331,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
/// assert_eq!(vec.argmin(), (1, -15)); /// assert_eq!(vec.argmin(), (1, -15));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn argmin(&self) -> (usize, T) pub fn argmin(&self) -> (usize, T)
where where
T: PartialOrd, T: PartialOrd,
@ -350,6 +363,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
/// assert_eq!(vec.imin(), 1); /// assert_eq!(vec.imin(), 1);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn imin(&self) -> usize pub fn imin(&self) -> usize
where where
T: PartialOrd, T: PartialOrd,
@ -367,6 +381,7 @@ impl<T: Scalar, D: Dim, S: Storage<T, D>> Vector<T, D, S> {
/// assert_eq!(vec.iamin(), 0); /// assert_eq!(vec.iamin(), 0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn iamin(&self) -> usize pub fn iamin(&self) -> usize
where where
T: PartialOrd + Signed, T: PartialOrd + Signed,

10
src/base/norm.rs
View File

@ -158,6 +158,7 @@ impl<T: SimdComplexField> Norm<T> for UniformNorm {
impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> { impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// The squared L2 norm of this vector. /// The squared L2 norm of this vector.
#[inline] #[inline]
#[must_use]
pub fn norm_squared(&self) -> T::SimdRealField pub fn norm_squared(&self) -> T::SimdRealField
where where
T: SimdComplexField, T: SimdComplexField,
@ -176,6 +177,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// ///
/// Use `.apply_norm` to apply a custom norm. /// Use `.apply_norm` to apply a custom norm.
#[inline] #[inline]
#[must_use]
pub fn norm(&self) -> T::SimdRealField pub fn norm(&self) -> T::SimdRealField
where where
T: SimdComplexField, T: SimdComplexField,
@ -187,6 +189,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// ///
/// Use `.apply_metric_distance` to apply a custom norm. /// Use `.apply_metric_distance` to apply a custom norm.
#[inline] #[inline]
#[must_use]
pub fn metric_distance<R2, C2, S2>(&self, rhs: &Matrix<T, R2, C2, S2>) -> T::SimdRealField pub fn metric_distance<R2, C2, S2>(&self, rhs: &Matrix<T, R2, C2, S2>) -> T::SimdRealField
where where
T: SimdComplexField, T: SimdComplexField,
@ -211,6 +214,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(v.apply_norm(&EuclideanNorm), v.norm()); /// assert_eq!(v.apply_norm(&EuclideanNorm), v.norm());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn apply_norm(&self, norm: &impl Norm<T>) -> T::SimdRealField pub fn apply_norm(&self, norm: &impl Norm<T>) -> T::SimdRealField
where where
T: SimdComplexField, T: SimdComplexField,
@ -233,6 +237,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(v1.apply_metric_distance(&v2, &EuclideanNorm), (v1 - v2).norm()); /// assert_eq!(v1.apply_metric_distance(&v2, &EuclideanNorm), (v1 - v2).norm());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn apply_metric_distance<R2, C2, S2>( pub fn apply_metric_distance<R2, C2, S2>(
&self, &self,
rhs: &Matrix<T, R2, C2, S2>, rhs: &Matrix<T, R2, C2, S2>,
@ -254,6 +259,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// ///
/// This function is simply implemented as a call to `norm()` /// This function is simply implemented as a call to `norm()`
#[inline] #[inline]
#[must_use]
pub fn magnitude(&self) -> T::SimdRealField pub fn magnitude(&self) -> T::SimdRealField
where where
T: SimdComplexField, T: SimdComplexField,
@ -267,6 +273,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// ///
/// This function is simply implemented as a call to `norm_squared()` /// This function is simply implemented as a call to `norm_squared()`
#[inline] #[inline]
#[must_use]
pub fn magnitude_squared(&self) -> T::SimdRealField pub fn magnitude_squared(&self) -> T::SimdRealField
where where
T: SimdComplexField, T: SimdComplexField,
@ -298,6 +305,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// The Lp norm of this matrix. /// The Lp norm of this matrix.
#[inline] #[inline]
#[must_use]
pub fn lp_norm(&self, p: i32) -> T::SimdRealField pub fn lp_norm(&self, p: i32) -> T::SimdRealField
where where
T: SimdComplexField, T: SimdComplexField,
@ -341,6 +349,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Returns a new vector with the same magnitude as `self` clamped between `0.0` and `max`. /// Returns a new vector with the same magnitude as `self` clamped between `0.0` and `max`.
#[inline] #[inline]
#[must_use]
pub fn cap_magnitude(&self, max: T::RealField) -> OMatrix<T, R, C> pub fn cap_magnitude(&self, max: T::RealField) -> OMatrix<T, R, C>
where where
T: ComplexField, T: ComplexField,
@ -357,6 +366,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Returns a new vector with the same magnitude as `self` clamped between `0.0` and `max`. /// Returns a new vector with the same magnitude as `self` clamped between `0.0` and `max`.
#[inline] #[inline]
#[must_use]
pub fn simd_cap_magnitude(&self, max: T::SimdRealField) -> OMatrix<T, R, C> pub fn simd_cap_magnitude(&self, max: T::SimdRealField) -> OMatrix<T, R, C>
where where
T: SimdComplexField, T: SimdComplexField,

66
src/base/ops.rs
View File

@ -158,20 +158,17 @@ macro_rules! componentwise_binop_impl(
// This is the most common case and should be deduced at compile-time. // This is the most common case and should be deduced at compile-time.
// TODO: use specialization instead? // TODO: use specialization instead?
if self.data.is_contiguous() && rhs.data.is_contiguous() && out.data.is_contiguous() { unsafe {
let arr1 = self.data.as_slice(); if self.data.is_contiguous() && rhs.data.is_contiguous() && out.data.is_contiguous() {
let arr2 = rhs.data.as_slice(); let arr1 = self.data.as_slice_unchecked();
let out = out.data.as_mut_slice(); let arr2 = rhs.data.as_slice_unchecked();
for i in 0 .. arr1.len() { let out = out.data.as_mut_slice_unchecked();
unsafe { for i in 0 .. arr1.len() {
*out.get_unchecked_mut(i) = arr1.get_unchecked(i).inlined_clone().$method(arr2.get_unchecked(i).inlined_clone()); *out.get_unchecked_mut(i) = arr1.get_unchecked(i).inlined_clone().$method(arr2.get_unchecked(i).inlined_clone());
} }
} } else {
} for j in 0 .. self.ncols() {
else { for i in 0 .. self.nrows() {
for j in 0 .. self.ncols() {
for i in 0 .. self.nrows() {
unsafe {
let val = self.get_unchecked((i, j)).inlined_clone().$method(rhs.get_unchecked((i, j)).inlined_clone()); let val = self.get_unchecked((i, j)).inlined_clone().$method(rhs.get_unchecked((i, j)).inlined_clone());
*out.get_unchecked_mut((i, j)) = val; *out.get_unchecked_mut((i, j)) = val;
} }
@ -191,19 +188,17 @@ macro_rules! componentwise_binop_impl(
// This is the most common case and should be deduced at compile-time. // This is the most common case and should be deduced at compile-time.
// TODO: use specialization instead? // TODO: use specialization instead?
if self.data.is_contiguous() && rhs.data.is_contiguous() { unsafe {
let arr1 = self.data.as_mut_slice(); if self.data.is_contiguous() && rhs.data.is_contiguous() {
let arr2 = rhs.data.as_slice(); let arr1 = self.data.as_mut_slice_unchecked();
for i in 0 .. arr2.len() { let arr2 = rhs.data.as_slice_unchecked();
unsafe {
for i in 0 .. arr2.len() {
arr1.get_unchecked_mut(i).$method_assign(arr2.get_unchecked(i).inlined_clone()); arr1.get_unchecked_mut(i).$method_assign(arr2.get_unchecked(i).inlined_clone());
} }
} } else {
} for j in 0 .. rhs.ncols() {
else { for i in 0 .. rhs.nrows() {
for j in 0 .. rhs.ncols() {
for i in 0 .. rhs.nrows() {
unsafe {
self.get_unchecked_mut((i, j)).$method_assign(rhs.get_unchecked((i, j)).inlined_clone()) self.get_unchecked_mut((i, j)).$method_assign(rhs.get_unchecked((i, j)).inlined_clone())
} }
} }
@ -221,20 +216,18 @@ macro_rules! componentwise_binop_impl(
// This is the most common case and should be deduced at compile-time. // This is the most common case and should be deduced at compile-time.
// TODO: use specialization instead? // TODO: use specialization instead?
if self.data.is_contiguous() && rhs.data.is_contiguous() { unsafe {
let arr1 = self.data.as_slice(); if self.data.is_contiguous() && rhs.data.is_contiguous() {
let arr2 = rhs.data.as_mut_slice(); let arr1 = self.data.as_slice_unchecked();
for i in 0 .. arr1.len() { let arr2 = rhs.data.as_mut_slice_unchecked();
unsafe {
for i in 0 .. arr1.len() {
let res = arr1.get_unchecked(i).inlined_clone().$method(arr2.get_unchecked(i).inlined_clone()); let res = arr1.get_unchecked(i).inlined_clone().$method(arr2.get_unchecked(i).inlined_clone());
*arr2.get_unchecked_mut(i) = res; *arr2.get_unchecked_mut(i) = res;
} }
} } else {
} for j in 0 .. self.ncols() {
else { for i in 0 .. self.nrows() {
for j in 0 .. self.ncols() {
for i in 0 .. self.nrows() {
unsafe {
let r = rhs.get_unchecked_mut((i, j)); let r = rhs.get_unchecked_mut((i, j));
*r = self.get_unchecked((i, j)).inlined_clone().$method(r.inlined_clone()) *r = self.get_unchecked((i, j)).inlined_clone().$method(r.inlined_clone())
} }
@ -536,7 +529,7 @@ macro_rules! left_scalar_mul_impl(
// for rhs in res.iter_mut() { // for rhs in res.iter_mut() {
for rhs in res.as_mut_slice().iter_mut() { for rhs in res.as_mut_slice().iter_mut() {
*rhs = self * *rhs *rhs *= self
} }
res res
@ -676,6 +669,7 @@ where
{ {
/// Equivalent to `self.transpose() * rhs`. /// Equivalent to `self.transpose() * rhs`.
#[inline] #[inline]
#[must_use]
pub fn tr_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> OMatrix<T, C1, C2> pub fn tr_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> OMatrix<T, C1, C2>
where where
SB: Storage<T, R2, C2>, SB: Storage<T, R2, C2>,
@ -692,6 +686,7 @@ where
/// Equivalent to `self.adjoint() * rhs`. /// Equivalent to `self.adjoint() * rhs`.
#[inline] #[inline]
#[must_use]
pub fn ad_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> OMatrix<T, C1, C2> pub fn ad_mul<R2: Dim, C2: Dim, SB>(&self, rhs: &Matrix<T, R2, C2, SB>) -> OMatrix<T, C1, C2>
where where
T: SimdComplexField, T: SimdComplexField,
@ -801,6 +796,7 @@ where
/// The kronecker product of two matrices (aka. tensor product of the corresponding linear /// The kronecker product of two matrices (aka. tensor product of the corresponding linear
/// maps). /// maps).
#[must_use]
pub fn kronecker<R2: Dim, C2: Dim, SB>( pub fn kronecker<R2: Dim, C2: Dim, SB>(
&self, &self,
rhs: &Matrix<T, R2, C2, SB>, rhs: &Matrix<T, R2, C2, SB>,

7
src/base/properties.rs
View File

@ -20,6 +20,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(mat.len(), 12); /// assert_eq!(mat.len(), 12);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
let (nrows, ncols) = self.shape(); let (nrows, ncols) = self.shape();
nrows * ncols nrows * ncols
@ -35,12 +36,14 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert!(!mat.is_empty()); /// assert!(!mat.is_empty());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
self.len() == 0 self.len() == 0
} }
/// Indicates if this is a square matrix. /// Indicates if this is a square matrix.
#[inline] #[inline]
#[must_use]
pub fn is_square(&self) -> bool { pub fn is_square(&self) -> bool {
let (nrows, ncols) = self.shape(); let (nrows, ncols) = self.shape();
nrows == ncols nrows == ncols
@ -52,6 +55,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// If the matrix is diagonal, this checks that diagonal elements (i.e. at coordinates `(i, i)` /// If the matrix is diagonal, this checks that diagonal elements (i.e. at coordinates `(i, i)`
/// for i from `0` to `min(R, C)`) are equal one; and that all other elements are zero. /// for i from `0` to `min(R, C)`) are equal one; and that all other elements are zero.
#[inline] #[inline]
#[must_use]
pub fn is_identity(&self, eps: T::Epsilon) -> bool pub fn is_identity(&self, eps: T::Epsilon) -> bool
where where
T: Zero + One + RelativeEq, T: Zero + One + RelativeEq,
@ -112,6 +116,7 @@ impl<T: ComplexField, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// In this definition `Id` is approximately equal to the identity matrix with a relative error /// In this definition `Id` is approximately equal to the identity matrix with a relative error
/// equal to `eps`. /// equal to `eps`.
#[inline] #[inline]
#[must_use]
pub fn is_orthogonal(&self, eps: T::Epsilon) -> bool pub fn is_orthogonal(&self, eps: T::Epsilon) -> bool
where where
T: Zero + One + ClosedAdd + ClosedMul + RelativeEq, T: Zero + One + ClosedAdd + ClosedMul + RelativeEq,
@ -129,6 +134,7 @@ where
{ {
/// Checks that this matrix is orthogonal and has a determinant equal to 1. /// Checks that this matrix is orthogonal and has a determinant equal to 1.
#[inline] #[inline]
#[must_use]
pub fn is_special_orthogonal(&self, eps: T) -> bool pub fn is_special_orthogonal(&self, eps: T) -> bool
where where
D: DimMin<D, Output = D>, D: DimMin<D, Output = D>,
@ -139,6 +145,7 @@ where
/// Returns `true` if this matrix is invertible. /// Returns `true` if this matrix is invertible.
#[inline] #[inline]
#[must_use]
pub fn is_invertible(&self) -> bool { pub fn is_invertible(&self) -> bool {
// TODO: improve this? // TODO: improve this?
self.clone_owned().try_inverse().is_some() self.clone_owned().try_inverse().is_some()

15
src/base/statistics.rs
View File

@ -9,6 +9,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Returns a row vector where each element is the result of the application of `f` on the /// Returns a row vector where each element is the result of the application of `f` on the
/// corresponding column of the original matrix. /// corresponding column of the original matrix.
#[inline] #[inline]
#[must_use]
pub fn compress_rows( pub fn compress_rows(
&self, &self,
f: impl Fn(VectorSlice<T, R, S::RStride, S::CStride>) -> T, f: impl Fn(VectorSlice<T, R, S::RStride, S::CStride>) -> T,
@ -35,6 +36,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// ///
/// This is the same as `self.compress_rows(f).transpose()`. /// This is the same as `self.compress_rows(f).transpose()`.
#[inline] #[inline]
#[must_use]
pub fn compress_rows_tr( pub fn compress_rows_tr(
&self, &self,
f: impl Fn(VectorSlice<T, R, S::RStride, S::CStride>) -> T, f: impl Fn(VectorSlice<T, R, S::RStride, S::CStride>) -> T,
@ -58,6 +60,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// Returns a column vector resulting from the folding of `f` on each column of this matrix. /// Returns a column vector resulting from the folding of `f` on each column of this matrix.
#[inline] #[inline]
#[must_use]
pub fn compress_columns( pub fn compress_columns(
&self, &self,
init: OVector<T, R>, init: OVector<T, R>,
@ -95,6 +98,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(m.sum(), 21.0); /// assert_eq!(m.sum(), 21.0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn sum(&self) -> T pub fn sum(&self) -> T
where where
T: ClosedAdd + Zero, T: ClosedAdd + Zero,
@ -120,6 +124,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(mint.row_sum(), RowVector2::new(9,12)); /// assert_eq!(mint.row_sum(), RowVector2::new(9,12));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn row_sum(&self) -> RowOVector<T, C> pub fn row_sum(&self) -> RowOVector<T, C>
where where
T: ClosedAdd + Zero, T: ClosedAdd + Zero,
@ -144,6 +149,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(mint.row_sum_tr(), Vector2::new(9,12)); /// assert_eq!(mint.row_sum_tr(), Vector2::new(9,12));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn row_sum_tr(&self) -> OVector<T, C> pub fn row_sum_tr(&self) -> OVector<T, C>
where where
T: ClosedAdd + Zero, T: ClosedAdd + Zero,
@ -168,6 +174,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(mint.column_sum(), Vector3::new(3,7,11)); /// assert_eq!(mint.column_sum(), Vector3::new(3,7,11));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn column_sum(&self) -> OVector<T, R> pub fn column_sum(&self) -> OVector<T, R>
where where
T: ClosedAdd + Zero, T: ClosedAdd + Zero,
@ -197,6 +204,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_relative_eq!(m.variance(), 35.0 / 12.0, epsilon = 1.0e-8); /// assert_relative_eq!(m.variance(), 35.0 / 12.0, epsilon = 1.0e-8);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn variance(&self) -> T pub fn variance(&self) -> T
where where
T: Field + SupersetOf<f64>, T: Field + SupersetOf<f64>,
@ -226,6 +234,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(m.row_variance(), RowVector3::new(2.25, 2.25, 2.25)); /// assert_eq!(m.row_variance(), RowVector3::new(2.25, 2.25, 2.25));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn row_variance(&self) -> RowOVector<T, C> pub fn row_variance(&self) -> RowOVector<T, C>
where where
T: Field + SupersetOf<f64>, T: Field + SupersetOf<f64>,
@ -246,6 +255,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(m.row_variance_tr(), Vector3::new(2.25, 2.25, 2.25)); /// assert_eq!(m.row_variance_tr(), Vector3::new(2.25, 2.25, 2.25));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn row_variance_tr(&self) -> OVector<T, C> pub fn row_variance_tr(&self) -> OVector<T, C>
where where
T: Field + SupersetOf<f64>, T: Field + SupersetOf<f64>,
@ -267,6 +277,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_relative_eq!(m.column_variance(), Vector2::new(2.0 / 3.0, 2.0 / 3.0), epsilon = 1.0e-8); /// assert_relative_eq!(m.column_variance(), Vector2::new(2.0 / 3.0, 2.0 / 3.0), epsilon = 1.0e-8);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn column_variance(&self) -> OVector<T, R> pub fn column_variance(&self) -> OVector<T, R>
where where
T: Field + SupersetOf<f64>, T: Field + SupersetOf<f64>,
@ -306,6 +317,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(m.mean(), 3.5); /// assert_eq!(m.mean(), 3.5);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn mean(&self) -> T pub fn mean(&self) -> T
where where
T: Field + SupersetOf<f64>, T: Field + SupersetOf<f64>,
@ -331,6 +343,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(m.row_mean(), RowVector3::new(2.5, 3.5, 4.5)); /// assert_eq!(m.row_mean(), RowVector3::new(2.5, 3.5, 4.5));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn row_mean(&self) -> RowOVector<T, C> pub fn row_mean(&self) -> RowOVector<T, C>
where where
T: Field + SupersetOf<f64>, T: Field + SupersetOf<f64>,
@ -351,6 +364,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(m.row_mean_tr(), Vector3::new(2.5, 3.5, 4.5)); /// assert_eq!(m.row_mean_tr(), Vector3::new(2.5, 3.5, 4.5));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn row_mean_tr(&self) -> OVector<T, C> pub fn row_mean_tr(&self) -> OVector<T, C>
where where
T: Field + SupersetOf<f64>, T: Field + SupersetOf<f64>,
@ -371,6 +385,7 @@ impl<T: Scalar, R: Dim, C: Dim, S: Storage<T, R, C>> Matrix<T, R, C, S> {
/// assert_eq!(m.column_mean(), Vector2::new(2.0, 5.0)); /// assert_eq!(m.column_mean(), Vector2::new(2.0, 5.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn column_mean(&self) -> OVector<T, R> pub fn column_mean(&self) -> OVector<T, R>
where where
T: Field + SupersetOf<f64>, T: Field + SupersetOf<f64>,

74
src/base/storage.rs
View File

@ -1,7 +1,7 @@
//! Abstract definition of a matrix data storage. //! Abstract definition of a matrix data storage.
use std::fmt::Debug; use std::fmt::Debug;
use std::mem; use std::ptr;
use crate::base::allocator::{Allocator, SameShapeC, SameShapeR}; use crate::base::allocator::{Allocator, SameShapeC, SameShapeR};
use crate::base::default_allocator::DefaultAllocator; use crate::base::default_allocator::DefaultAllocator;
@ -58,7 +58,7 @@ pub unsafe trait Storage<T: Scalar, R: Dim, C: Dim = U1>: Debug + Sized {
/// Compute the index corresponding to the irow-th row and icol-th column of this matrix. The /// Compute the index corresponding to the irow-th row and icol-th column of this matrix. The
/// index must be such that the following holds: /// index must be such that the following holds:
/// ///
/// ```.ignore /// ```ignore
/// let lindex = self.linear_index(irow, icol); /// let lindex = self.linear_index(irow, icol);
/// assert!(*self.get_unchecked(irow, icol) == *self.get_unchecked_linear(lindex)) /// assert!(*self.get_unchecked(irow, icol) == *self.get_unchecked_linear(lindex))
/// ``` /// ```
@ -70,36 +70,57 @@ pub unsafe trait Storage<T: Scalar, R: Dim, C: Dim = U1>: Debug + Sized {
} }
/// Gets the address of the i-th matrix component without performing bound-checking. /// Gets the address of the i-th matrix component without performing bound-checking.
///
/// # Safety
/// If the index is out of bounds, dereferencing the result will cause undefined behavior.
#[inline] #[inline]
unsafe fn get_address_unchecked_linear(&self, i: usize) -> *const T { fn get_address_unchecked_linear(&self, i: usize) -> *const T {
self.ptr().wrapping_add(i) self.ptr().wrapping_add(i)
} }
/// Gets the address of the i-th matrix component without performing bound-checking. /// Gets the address of the i-th matrix component without performing bound-checking.
///
/// # Safety
/// If the index is out of bounds, dereferencing the result will cause undefined behavior.
#[inline] #[inline]
unsafe fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const T { fn get_address_unchecked(&self, irow: usize, icol: usize) -> *const T {
self.get_address_unchecked_linear(self.linear_index(irow, icol)) self.get_address_unchecked_linear(self.linear_index(irow, icol))
} }
/// Retrieves a reference to the i-th element without bound-checking. /// Retrieves a reference to the i-th element without bound-checking.
///
/// # Safety
/// If the index is out of bounds, the method will cause undefined behavior.
#[inline] #[inline]
unsafe fn get_unchecked_linear(&self, i: usize) -> &T { unsafe fn get_unchecked_linear(&self, i: usize) -> &T {
&*self.get_address_unchecked_linear(i) &*self.get_address_unchecked_linear(i)
} }
/// Retrieves a reference to the i-th element without bound-checking. /// Retrieves a reference to the i-th element without bound-checking.
///
/// # Safety
/// If the index is out of bounds, the method will cause undefined behavior.
#[inline] #[inline]
unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &T { unsafe fn get_unchecked(&self, irow: usize, icol: usize) -> &T {
self.get_unchecked_linear(self.linear_index(irow, icol)) self.get_unchecked_linear(self.linear_index(irow, icol))
} }
/// Indicates whether this data buffer stores its elements contiguously. /// Indicates whether this data buffer stores its elements contiguously.
///
/// # Safety
/// This function must not return `true` if the underlying storage is not contiguous,
/// or undefined behaviour will occur.
fn is_contiguous(&self) -> bool; fn is_contiguous(&self) -> bool;
/// Retrieves the data buffer as a contiguous slice. /// Retrieves the data buffer as a contiguous slice.
/// ///
/// # Safety
/// The matrix components may not be stored in a contiguous way, depending on the strides. /// The matrix components may not be stored in a contiguous way, depending on the strides.
fn as_slice(&self) -> &[T]; /// This method is unsafe because this can yield to invalid aliasing when called on some pairs
/// of matrix slices originating from the same matrix with strides.
///
/// Call the safe alternative `matrix.as_slice()` instead.
unsafe fn as_slice_unchecked(&self) -> &[T];
/// Builds a matrix data storage that does not contain any reference. /// Builds a matrix data storage that does not contain any reference.
fn into_owned(self) -> Owned<T, R, C> fn into_owned(self) -> Owned<T, R, C>
@ -122,39 +143,57 @@ pub unsafe trait StorageMut<T: Scalar, R: Dim, C: Dim = U1>: Storage<T, R, C> {
fn ptr_mut(&mut self) -> *mut T; fn ptr_mut(&mut self) -> *mut T;
/// Gets the mutable address of the i-th matrix component without performing bound-checking. /// Gets the mutable address of the i-th matrix component without performing bound-checking.
///
/// # Safety
/// If the index is out of bounds, dereferencing the result will cause undefined behavior.
#[inline] #[inline]
unsafe fn get_address_unchecked_linear_mut(&mut self, i: usize) -> *mut T { fn get_address_unchecked_linear_mut(&mut self, i: usize) -> *mut T {
self.ptr_mut().wrapping_add(i) self.ptr_mut().wrapping_add(i)
} }
/// Gets the mutable address of the i-th matrix component without performing bound-checking. /// Gets the mutable address of the i-th matrix component without performing bound-checking.
///
/// # Safety
/// If the index is out of bounds, dereferencing the result will cause undefined behavior.
#[inline] #[inline]
unsafe fn get_address_unchecked_mut(&mut self, irow: usize, icol: usize) -> *mut T { fn get_address_unchecked_mut(&mut self, irow: usize, icol: usize) -> *mut T {
let lid = self.linear_index(irow, icol); let lid = self.linear_index(irow, icol);
self.get_address_unchecked_linear_mut(lid) self.get_address_unchecked_linear_mut(lid)
} }
/// Retrieves a mutable reference to the i-th element without bound-checking. /// Retrieves a mutable reference to the i-th element without bound-checking.
///
/// # Safety
/// If the index is out of bounds, the method will cause undefined behavior.
unsafe fn get_unchecked_linear_mut(&mut self, i: usize) -> &mut T { unsafe fn get_unchecked_linear_mut(&mut self, i: usize) -> &mut T {
&mut *self.get_address_unchecked_linear_mut(i) &mut *self.get_address_unchecked_linear_mut(i)
} }
/// Retrieves a mutable reference to the element at `(irow, icol)` without bound-checking. /// Retrieves a mutable reference to the element at `(irow, icol)` without bound-checking.
///
/// # Safety
/// If the index is out of bounds, the method will cause undefined behavior.
#[inline] #[inline]
unsafe fn get_unchecked_mut(&mut self, irow: usize, icol: usize) -> &mut T { unsafe fn get_unchecked_mut(&mut self, irow: usize, icol: usize) -> &mut T {
&mut *self.get_address_unchecked_mut(irow, icol) &mut *self.get_address_unchecked_mut(irow, icol)
} }
/// Swaps two elements using their linear index without bound-checking. /// Swaps two elements using their linear index without bound-checking.
///
/// # Safety
/// If the indices are out of bounds, the method will cause undefined behavior.
#[inline] #[inline]
unsafe fn swap_unchecked_linear(&mut self, i1: usize, i2: usize) { unsafe fn swap_unchecked_linear(&mut self, i1: usize, i2: usize) {
let a = self.get_address_unchecked_linear_mut(i1); let a = self.get_address_unchecked_linear_mut(i1);
let b = self.get_address_unchecked_linear_mut(i2); let b = self.get_address_unchecked_linear_mut(i2);
mem::swap(&mut *a, &mut *b); ptr::swap(a, b);
} }
/// Swaps two elements without bound-checking. /// Swaps two elements without bound-checking.
///
/// # Safety
/// If the indices are out of bounds, the method will cause undefined behavior.
#[inline] #[inline]
unsafe fn swap_unchecked(&mut self, row_col1: (usize, usize), row_col2: (usize, usize)) { unsafe fn swap_unchecked(&mut self, row_col1: (usize, usize), row_col2: (usize, usize)) {
let lid1 = self.linear_index(row_col1.0, row_col1.1); let lid1 = self.linear_index(row_col1.0, row_col1.1);
@ -166,7 +205,12 @@ pub unsafe trait StorageMut<T: Scalar, R: Dim, C: Dim = U1>: Storage<T, R, C> {
/// Retrieves the mutable data buffer as a contiguous slice. /// Retrieves the mutable data buffer as a contiguous slice.
/// ///
/// Matrix components may not be contiguous, depending on its strides. /// Matrix components may not be contiguous, depending on its strides.
fn as_mut_slice(&mut self) -> &mut [T]; ///
/// # Safety
/// The matrix components may not be stored in a contiguous way, depending on the strides.
/// This method is unsafe because this can yield to invalid aliasing when called on some pairs
/// of matrix slices originating from the same matrix with strides.
unsafe fn as_mut_slice_unchecked(&mut self) -> &mut [T];
} }
/// A matrix storage that is stored contiguously in memory. /// A matrix storage that is stored contiguously in memory.
@ -177,6 +221,12 @@ pub unsafe trait StorageMut<T: Scalar, R: Dim, C: Dim = U1>: Storage<T, R, C> {
pub unsafe trait ContiguousStorage<T: Scalar, R: Dim, C: Dim = U1>: pub unsafe trait ContiguousStorage<T: Scalar, R: Dim, C: Dim = U1>:
Storage<T, R, C> Storage<T, R, C>
{ {
/// Converts this data storage to a contiguous slice.
fn as_slice(&self) -> &[T] {
// SAFETY: this is safe because this trait guarantees the fact
// that the data is stored contiguously.
unsafe { self.as_slice_unchecked() }
}
} }
/// A mutable matrix storage that is stored contiguously in memory. /// A mutable matrix storage that is stored contiguously in memory.
@ -187,6 +237,12 @@ pub unsafe trait ContiguousStorage<T: Scalar, R: Dim, C: Dim = U1>:
pub unsafe trait ContiguousStorageMut<T: Scalar, R: Dim, C: Dim = U1>: pub unsafe trait ContiguousStorageMut<T: Scalar, R: Dim, C: Dim = U1>:
ContiguousStorage<T, R, C> + StorageMut<T, R, C> ContiguousStorage<T, R, C> + StorageMut<T, R, C>
{ {
/// Converts this data storage to a contiguous mutable slice.
fn as_mut_slice(&mut self) -> &mut [T] {
// SAFETY: this is safe because this trait guarantees the fact
// that the data is stored contiguously.
unsafe { self.as_mut_slice_unchecked() }
}
} }
/// A matrix storage that can be reshaped in-place. /// A matrix storage that can be reshaped in-place.

1
src/base/swizzle.rs
View File

@ -8,6 +8,7 @@ macro_rules! impl_swizzle {
$( $(
/// Builds a new vector from components of `self`. /// Builds a new vector from components of `self`.
#[inline] #[inline]
#[must_use]
pub fn $name(&self) -> $Result<T> pub fn $name(&self) -> $Result<T>
where D::Typenum: Cmp<typenum::$BaseDim, Output=Greater> { where D::Typenum: Cmp<typenum::$BaseDim, Output=Greater> {
$Result::new($(self[$i].inlined_clone()),*) $Result::new($(self[$i].inlined_clone()),*)

11
src/base/unit.rs
View File

@ -1,6 +1,5 @@
#[cfg(feature = "abomonation-serialize")] #[cfg(feature = "abomonation-serialize")]
use std::io::{Result as IOResult, Write}; use std::io::{Result as IOResult, Write};
use std::mem;
use std::ops::Deref; use std::ops::Deref;
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
@ -96,7 +95,7 @@ mod rkyv_impl {
impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Unit<T> { impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Unit<T> {
fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> { fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
Ok(self.value.serialize(serializer)?) self.value.serialize(serializer)
} }
} }
@ -222,14 +221,14 @@ impl<T: Normed> Unit<T> {
impl<T> Unit<T> { impl<T> Unit<T> {
/// Wraps the given value, assuming it is already normalized. /// Wraps the given value, assuming it is already normalized.
#[inline] #[inline]
pub fn new_unchecked(value: T) -> Self { pub const fn new_unchecked(value: T) -> Self {
Unit { value } Unit { value }
} }
/// Wraps the given reference, assuming it is already normalized. /// Wraps the given reference, assuming it is already normalized.
#[inline] #[inline]
pub fn from_ref_unchecked<'a>(value: &'a T) -> &'a Self { pub fn from_ref_unchecked(value: &T) -> &Self {
unsafe { mem::transmute(value) } unsafe { &*(value as *const T as *const Self) }
} }
/// Retrieves the underlying value. /// Retrieves the underlying value.
@ -332,7 +331,7 @@ impl<T> Deref for Unit<T> {
#[inline] #[inline]
fn deref(&self) -> &T { fn deref(&self) -> &T {
unsafe { mem::transmute(self) } unsafe { &*(self as *const Self as *const T) }
} }
} }

19
src/base/vec_storage.rs
View File

@ -95,12 +95,14 @@ impl<T, R: Dim, C: Dim> VecStorage<T, R, C> {
/// The underlying data storage. /// The underlying data storage.
#[inline] #[inline]
#[must_use]
pub fn as_vec(&self) -> &Vec<T> { pub fn as_vec(&self) -> &Vec<T> {
&self.data &self.data
} }
/// The underlying mutable data storage. /// The underlying mutable data storage.
/// ///
/// # Safety
/// This is unsafe because this may cause UB if the size of the vector is changed /// This is unsafe because this may cause UB if the size of the vector is changed
/// by the user. /// by the user.
#[inline] #[inline]
@ -110,6 +112,7 @@ impl<T, R: Dim, C: Dim> VecStorage<T, R, C> {
/// Resizes the underlying mutable data storage and unwraps it. /// Resizes the underlying mutable data storage and unwraps it.
/// ///
/// # Safety
/// If `sz` is larger than the current size, additional elements are uninitialized. /// If `sz` is larger than the current size, additional elements are uninitialized.
/// If `sz` is smaller than the current size, additional elements are truncated. /// If `sz` is smaller than the current size, additional elements are truncated.
#[inline] #[inline]
@ -129,20 +132,22 @@ impl<T, R: Dim, C: Dim> VecStorage<T, R, C> {
/// The number of elements on the underlying vector. /// The number of elements on the underlying vector.
#[inline] #[inline]
#[must_use]
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.data.len() self.data.len()
} }
/// Returns true if the underlying vector contains no elements. /// Returns true if the underlying vector contains no elements.
#[inline] #[inline]
#[must_use]
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
self.len() == 0 self.len() == 0
} }
} }
impl<T, R: Dim, C: Dim> Into<Vec<T>> for VecStorage<T, R, C> { impl<T, R: Dim, C: Dim> From<VecStorage<T, R, C>> for Vec<T> {
fn into(self) -> Vec<T> { fn from(vec: VecStorage<T, R, C>) -> Self {
self.data vec.data
} }
} }
@ -196,7 +201,7 @@ where
} }
#[inline] #[inline]
fn as_slice(&self) -> &[T] { unsafe fn as_slice_unchecked(&self) -> &[T] {
&self.data &self.data
} }
} }
@ -245,7 +250,7 @@ where
} }
#[inline] #[inline]
fn as_slice(&self) -> &[T] { unsafe fn as_slice_unchecked(&self) -> &[T] {
&self.data &self.data
} }
} }
@ -265,7 +270,7 @@ where
} }
#[inline] #[inline]
fn as_mut_slice(&mut self) -> &mut [T] { unsafe fn as_mut_slice_unchecked(&mut self) -> &mut [T] {
&mut self.data[..] &mut self.data[..]
} }
} }
@ -326,7 +331,7 @@ where
} }
#[inline] #[inline]
fn as_mut_slice(&mut self) -> &mut [T] { unsafe fn as_mut_slice_unchecked(&mut self) -> &mut [T] {
&mut self.data[..] &mut self.data[..]
} }
} }

45
src/geometry/dual_quaternion.rs
View File

@ -1,3 +1,6 @@
// The macros break if the references are taken out, for some reason.
#![allow(clippy::op_ref)]
use crate::{ use crate::{
Isometry3, Matrix4, Normed, OVector, Point3, Quaternion, Scalar, SimdRealField, Translation3, Isometry3, Matrix4, Normed, OVector, Point3, Quaternion, Scalar, SimdRealField, Translation3,
Unit, UnitQuaternion, Vector3, Zero, U8, Unit, UnitQuaternion, Vector3, Zero, U8,
@ -35,14 +38,23 @@ use simba::scalar::{ClosedNeg, RealField};
/// If a feature that you need is missing, feel free to open an issue or a PR. /// 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 /// See https://github.com/dimforge/nalgebra/issues/487
#[repr(C)] #[repr(C)]
#[derive(Debug, Eq, PartialEq, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub struct DualQuaternion<T: Scalar> { pub struct DualQuaternion<T> {
/// The real component of the quaternion /// The real component of the quaternion
pub real: Quaternion<T>, pub real: Quaternion<T>,
/// The dual component of the quaternion /// The dual component of the quaternion
pub dual: Quaternion<T>, pub dual: Quaternion<T>,
} }
impl<T: Scalar + Eq> Eq for DualQuaternion<T> {}
impl<T: Scalar> PartialEq for DualQuaternion<T> {
#[inline]
fn eq(&self, right: &Self) -> bool {
self.real == right.real && self.dual == right.dual
}
}
impl<T: Scalar + Zero> Default for DualQuaternion<T> { impl<T: Scalar + Zero> Default for DualQuaternion<T> {
fn default() -> Self { fn default() -> Self {
Self { Self {
@ -232,6 +244,7 @@ where
/// )); /// ));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn lerp(&self, other: &Self, t: T) -> Self { pub fn lerp(&self, other: &Self, t: T) -> Self {
self * (T::one() - t) + other * t self * (T::one() - t) + other * t
} }
@ -271,8 +284,8 @@ where
} }
impl<T: RealField> DualQuaternion<T> { impl<T: RealField> DualQuaternion<T> {
fn to_vector(&self) -> OVector<T, U8> { fn to_vector(self) -> OVector<T, U8> {
self.as_ref().clone().into() (*self.as_ref()).into()
} }
} }
@ -381,6 +394,7 @@ where
/// )); /// ));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn dual_quaternion(&self) -> &DualQuaternion<T> { pub fn dual_quaternion(&self) -> &DualQuaternion<T> {
self.as_ref() self.as_ref()
} }
@ -463,7 +477,6 @@ where
/// assert_relative_eq!(inv * unit, UnitDualQuaternion::identity(), epsilon = 1.0e-6); /// assert_relative_eq!(inv * unit, UnitDualQuaternion::identity(), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use = "Did you mean to use inverse_mut()?"]
pub fn inverse_mut(&mut self) { pub fn inverse_mut(&mut self) {
let quat = self.as_mut_unchecked(); let quat = self.as_mut_unchecked();
quat.real = Unit::new_unchecked(quat.real).inverse().into_inner(); quat.real = Unit::new_unchecked(quat.real).inverse().into_inner();
@ -486,6 +499,7 @@ where
/// assert_relative_eq!(dq_to * dq1, dq2, epsilon = 1.0e-6); /// assert_relative_eq!(dq_to * dq1, dq2, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn isometry_to(&self, other: &Self) -> Self { pub fn isometry_to(&self, other: &Self) -> Self {
other / self other / self
} }
@ -518,6 +532,7 @@ where
/// ); /// );
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn lerp(&self, other: &Self, t: T) -> DualQuaternion<T> { pub fn lerp(&self, other: &Self, t: T) -> DualQuaternion<T> {
self.as_ref().lerp(other.as_ref(), t) self.as_ref().lerp(other.as_ref(), t)
} }
@ -546,6 +561,7 @@ where
/// ), epsilon = 1.0e-6); /// ), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn nlerp(&self, other: &Self, t: T) -> Self { pub fn nlerp(&self, other: &Self, t: T) -> Self {
let mut res = self.lerp(other, t); let mut res = self.lerp(other, t);
let _ = res.normalize_mut(); let _ = res.normalize_mut();
@ -581,6 +597,7 @@ where
/// ); /// );
/// assert_relative_eq!(dq.translation().vector.y, 3.0, epsilon = 1.0e-6); /// assert_relative_eq!(dq.translation().vector.y, 3.0, epsilon = 1.0e-6);
#[inline] #[inline]
#[must_use]
pub fn sclerp(&self, other: &Self, t: T) -> Self pub fn sclerp(&self, other: &Self, t: T) -> Self
where where
T: RealField, T: RealField,
@ -600,6 +617,7 @@ where
/// * `epsilon`: the value below which the sinus of the angle separating both quaternion /// * `epsilon`: the value below which the sinus of the angle separating both quaternion
/// must be to return `None`. /// must be to return `None`.
#[inline] #[inline]
#[must_use]
pub fn try_sclerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self> pub fn try_sclerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>
where where
T: RealField, T: RealField,
@ -612,9 +630,9 @@ where
let other = { let other = {
let dot_product = self.as_ref().real.coords.dot(&other.as_ref().real.coords); let dot_product = self.as_ref().real.coords.dot(&other.as_ref().real.coords);
if dot_product < T::zero() { if dot_product < T::zero() {
-other.clone() -*other
} else { } else {
other.clone() *other
} }
}; };
@ -667,6 +685,7 @@ where
/// ); /// );
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn rotation(&self) -> UnitQuaternion<T> { pub fn rotation(&self) -> UnitQuaternion<T> {
Unit::new_unchecked(self.as_ref().real) Unit::new_unchecked(self.as_ref().real)
} }
@ -686,6 +705,7 @@ where
/// ); /// );
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn translation(&self) -> Translation3<T> { pub fn translation(&self) -> Translation3<T> {
let two = T::one() + T::one(); let two = T::one() + T::one();
Translation3::from( Translation3::from(
@ -712,7 +732,8 @@ where
/// assert_relative_eq!(iso.translation.vector, translation, epsilon = 1.0e-6); /// assert_relative_eq!(iso.translation.vector, translation, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
pub fn to_isometry(&self) -> Isometry3<T> { #[must_use]
pub fn to_isometry(self) -> Isometry3<T> {
Isometry3::from_parts(self.translation(), self.rotation()) Isometry3::from_parts(self.translation(), self.rotation())
} }
@ -735,6 +756,7 @@ where
/// ); /// );
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_point(&self, pt: &Point3<T>) -> Point3<T> { pub fn transform_point(&self, pt: &Point3<T>) -> Point3<T> {
self * pt self * pt
} }
@ -758,6 +780,7 @@ where
/// ); /// );
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T> { pub fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
self * v self * v
} }
@ -781,6 +804,7 @@ where
/// ); /// );
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T> { pub fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T> {
self.inverse() * pt self.inverse() * pt
} }
@ -805,6 +829,7 @@ where
/// ); /// );
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T> { pub fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
self.inverse() * v self.inverse() * v
} }
@ -830,6 +855,7 @@ where
/// ); /// );
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector3<T>>) -> Unit<Vector3<T>> { pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector3<T>>) -> Unit<Vector3<T>> {
self.inverse() * v self.inverse() * v
} }
@ -857,7 +883,8 @@ where
/// assert_relative_eq!(dq.to_homogeneous(), expected, epsilon = 1.0e-6); /// assert_relative_eq!(dq.to_homogeneous(), expected, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
pub fn to_homogeneous(&self) -> Matrix4<T> { #[must_use]
pub fn to_homogeneous(self) -> Matrix4<T> {
self.to_isometry().to_homogeneous() self.to_isometry().to_homogeneous()
} }
} }

4
src/geometry/dual_quaternion_construction.rs
View File

@ -186,9 +186,9 @@ where
pub fn from_parts(translation: Translation3<T>, rotation: UnitQuaternion<T>) -> Self { pub fn from_parts(translation: Translation3<T>, rotation: UnitQuaternion<T>) -> Self {
let half: T = crate::convert(0.5f64); let half: T = crate::convert(0.5f64);
UnitDualQuaternion::new_unchecked(DualQuaternion { UnitDualQuaternion::new_unchecked(DualQuaternion {
real: rotation.clone().into_inner(), real: rotation.into_inner(),
dual: Quaternion::from_parts(T::zero(), translation.vector) dual: Quaternion::from_parts(T::zero(), translation.vector)
* rotation.clone().into_inner() * rotation.into_inner()
* half, * half,
}) })
} }

26
src/geometry/dual_quaternion_ops.rs
View File

@ -1,3 +1,6 @@
// The macros break if the references are taken out, for some reason.
#![allow(clippy::op_ref)]
/* /*
* This file provides: * This file provides:
* *
@ -49,7 +52,6 @@ use crate::{
DualQuaternion, Isometry3, Point, Point3, Quaternion, SimdRealField, Translation3, Unit, DualQuaternion, Isometry3, Point, Point3, Quaternion, SimdRealField, Translation3, Unit,
UnitDualQuaternion, UnitQuaternion, Vector, Vector3, U3, UnitDualQuaternion, UnitQuaternion, Vector, Vector3, U3,
}; };
use std::mem;
use std::ops::{ use std::ops::{
Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign, Add, AddAssign, Div, DivAssign, Index, IndexMut, Mul, MulAssign, Neg, Sub, SubAssign,
}; };
@ -57,14 +59,14 @@ use std::ops::{
impl<T: SimdRealField> AsRef<[T; 8]> for DualQuaternion<T> { impl<T: SimdRealField> AsRef<[T; 8]> for DualQuaternion<T> {
#[inline] #[inline]
fn as_ref(&self) -> &[T; 8] { fn as_ref(&self) -> &[T; 8] {
unsafe { mem::transmute(self) } unsafe { &*(self as *const Self as *const [T; 8]) }
} }
} }
impl<T: SimdRealField> AsMut<[T; 8]> for DualQuaternion<T> { impl<T: SimdRealField> AsMut<[T; 8]> for DualQuaternion<T> {
#[inline] #[inline]
fn as_mut(&mut self) -> &mut [T; 8] { fn as_mut(&mut self) -> &mut [T; 8] {
unsafe { mem::transmute(self) } unsafe { &mut *(self as *mut Self as *mut [T; 8]) }
} }
} }
@ -564,7 +566,7 @@ dual_quaternion_op_impl!(
(U4, U1), (U3, U1); (U4, U1), (U3, U1);
self: &'a UnitDualQuaternion<T>, rhs: &'b Translation3<T>, self: &'a UnitDualQuaternion<T>, rhs: &'b Translation3<T>,
Output = UnitDualQuaternion<T> => U3, U1; Output = UnitDualQuaternion<T> => U3, U1;
self * UnitDualQuaternion::<T>::from_parts(rhs.clone(), UnitQuaternion::identity()); self * UnitDualQuaternion::<T>::from_parts(*rhs, UnitQuaternion::identity());
'a, 'b); 'a, 'b);
dual_quaternion_op_impl!( dual_quaternion_op_impl!(
@ -580,7 +582,7 @@ dual_quaternion_op_impl!(
(U4, U1), (U3, U3); (U4, U1), (U3, U3);
self: UnitDualQuaternion<T>, rhs: &'b Translation3<T>, self: UnitDualQuaternion<T>, rhs: &'b Translation3<T>,
Output = UnitDualQuaternion<T> => U3, U1; Output = UnitDualQuaternion<T> => U3, U1;
self * UnitDualQuaternion::<T>::from_parts(rhs.clone(), UnitQuaternion::identity()); self * UnitDualQuaternion::<T>::from_parts(*rhs, UnitQuaternion::identity());
'b); 'b);
dual_quaternion_op_impl!( dual_quaternion_op_impl!(
@ -632,7 +634,7 @@ dual_quaternion_op_impl!(
(U3, U1), (U4, U1); (U3, U1), (U4, U1);
self: &'b Translation3<T>, rhs: &'a UnitDualQuaternion<T>, self: &'b Translation3<T>, rhs: &'a UnitDualQuaternion<T>,
Output = UnitDualQuaternion<T> => U3, U1; Output = UnitDualQuaternion<T> => U3, U1;
UnitDualQuaternion::<T>::from_parts(self.clone(), UnitQuaternion::identity()) * rhs; UnitDualQuaternion::<T>::from_parts(*self, UnitQuaternion::identity()) * rhs;
'a, 'b); 'a, 'b);
dual_quaternion_op_impl!( dual_quaternion_op_impl!(
@ -640,7 +642,7 @@ dual_quaternion_op_impl!(
(U3, U1), (U4, U1); (U3, U1), (U4, U1);
self: &'a Translation3<T>, rhs: UnitDualQuaternion<T>, self: &'a Translation3<T>, rhs: UnitDualQuaternion<T>,
Output = UnitDualQuaternion<T> => U3, U1; Output = UnitDualQuaternion<T> => U3, U1;
UnitDualQuaternion::<T>::from_parts(self.clone(), UnitQuaternion::identity()) * rhs; UnitDualQuaternion::<T>::from_parts(*self, UnitQuaternion::identity()) * rhs;
'a); 'a);
dual_quaternion_op_impl!( dual_quaternion_op_impl!(
@ -664,7 +666,7 @@ dual_quaternion_op_impl!(
(U3, U1), (U4, U1); (U3, U1), (U4, U1);
self: &'b Translation3<T>, rhs: &'a UnitDualQuaternion<T>, self: &'b Translation3<T>, rhs: &'a UnitDualQuaternion<T>,
Output = UnitDualQuaternion<T> => U3, U1; Output = UnitDualQuaternion<T> => U3, U1;
UnitDualQuaternion::<T>::from_parts(self.clone(), UnitQuaternion::identity()) / rhs; UnitDualQuaternion::<T>::from_parts(*self, UnitQuaternion::identity()) / rhs;
'a, 'b); 'a, 'b);
dual_quaternion_op_impl!( dual_quaternion_op_impl!(
@ -672,7 +674,7 @@ dual_quaternion_op_impl!(
(U3, U1), (U4, U1); (U3, U1), (U4, U1);
self: &'a Translation3<T>, rhs: UnitDualQuaternion<T>, self: &'a Translation3<T>, rhs: UnitDualQuaternion<T>,
Output = UnitDualQuaternion<T> => U3, U1; Output = UnitDualQuaternion<T> => U3, U1;
UnitDualQuaternion::<T>::from_parts(self.clone(), UnitQuaternion::identity()) / rhs; UnitDualQuaternion::<T>::from_parts(*self, UnitQuaternion::identity()) / rhs;
'a); 'a);
dual_quaternion_op_impl!( dual_quaternion_op_impl!(
@ -860,7 +862,7 @@ dual_quaternion_op_impl!(
Output = Point3<T> => U3, U1; Output = Point3<T> => U3, U1;
{ {
let two: T = crate::convert(2.0f64); let two: T = crate::convert(2.0f64);
let q_point = Quaternion::from_parts(T::zero(), rhs.coords.clone()); let q_point = Quaternion::from_parts(T::zero(), rhs.coords);
Point::from( Point::from(
((self.as_ref().real * q_point + self.as_ref().dual * two) * self.as_ref().real.conjugate()) ((self.as_ref().real * q_point + self.as_ref().dual * two) * self.as_ref().real.conjugate())
.vector() .vector()
@ -1115,7 +1117,7 @@ dual_quaternion_op_impl!(
MulAssign, mul_assign; MulAssign, mul_assign;
(U4, U1), (U4, U1); (U4, U1), (U4, U1);
self: UnitDualQuaternion<T>, rhs: &'b UnitQuaternion<T>; self: UnitDualQuaternion<T>, rhs: &'b UnitQuaternion<T>;
*self *= rhs.clone(); 'b); *self *= *rhs; 'b);
// UnitDualQuaternion ÷= UnitQuaternion // UnitDualQuaternion ÷= UnitQuaternion
dual_quaternion_op_impl!( dual_quaternion_op_impl!(
@ -1151,7 +1153,7 @@ dual_quaternion_op_impl!(
MulAssign, mul_assign; MulAssign, mul_assign;
(U4, U1), (U4, U1); (U4, U1), (U4, U1);
self: UnitDualQuaternion<T>, rhs: &'b Translation3<T>; self: UnitDualQuaternion<T>, rhs: &'b Translation3<T>;
*self *= rhs.clone(); 'b); *self *= *rhs; 'b);
// UnitDualQuaternion ÷= Translation3 // UnitDualQuaternion ÷= Translation3
dual_quaternion_op_impl!( dual_quaternion_op_impl!(

20
src/geometry/isometry.rs
View File

@ -60,15 +60,17 @@ use crate::geometry::{AbstractRotation, Point, Translation};
feature = "serde-serialize-no-std", feature = "serde-serialize-no-std",
serde(bound(serialize = "R: Serialize, serde(bound(serialize = "R: Serialize,
DefaultAllocator: Allocator<T, Const<D>>, DefaultAllocator: Allocator<T, Const<D>>,
Owned<T, Const<D>>: Serialize")) Owned<T, Const<D>>: Serialize,
T: Scalar"))
)] )]
#[cfg_attr( #[cfg_attr(
feature = "serde-serialize-no-std", feature = "serde-serialize-no-std",
serde(bound(deserialize = "R: Deserialize<'de>, serde(bound(deserialize = "R: Deserialize<'de>,
DefaultAllocator: Allocator<T, Const<D>>, DefaultAllocator: Allocator<T, Const<D>>,
Owned<T, Const<D>>: Deserialize<'de>")) Owned<T, Const<D>>: Deserialize<'de>,
T: Scalar"))
)] )]
pub struct Isometry<T: Scalar, R, const D: usize> { pub struct Isometry<T, R, const D: usize> {
/// The pure rotational part of this isometry. /// The pure rotational part of this isometry.
pub rotation: R, pub rotation: R,
/// The pure translational part of this isometry. /// The pure translational part of this isometry.
@ -267,9 +269,10 @@ where
/// assert_eq!(iso1.inverse() * iso2, iso1.inv_mul(&iso2)); /// assert_eq!(iso1.inverse() * iso2, iso1.inv_mul(&iso2));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inv_mul(&self, rhs: &Isometry<T, R, D>) -> Self { pub fn inv_mul(&self, rhs: &Isometry<T, R, D>) -> Self {
let inv_rot1 = self.rotation.inverse(); let inv_rot1 = self.rotation.inverse();
let tr_12 = rhs.translation.vector.clone() - self.translation.vector.clone(); let tr_12 = rhs.translation.vector - self.translation.vector;
Isometry::from_parts( Isometry::from_parts(
inv_rot1.transform_vector(&tr_12).into(), inv_rot1.transform_vector(&tr_12).into(),
inv_rot1 * rhs.rotation.clone(), inv_rot1 * rhs.rotation.clone(),
@ -384,6 +387,7 @@ where
/// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, 2.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, 2.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> { pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
self * pt self * pt
} }
@ -407,6 +411,7 @@ where
/// assert_relative_eq!(transformed_point, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> { pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
self * v self * v
} }
@ -429,9 +434,10 @@ where
/// assert_relative_eq!(transformed_point, Point3::new(0.0, 2.0, 1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, Point3::new(0.0, 2.0, 1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> { pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
self.rotation self.rotation
.inverse_transform_point(&(pt - &self.translation.vector)) .inverse_transform_point(&(pt - self.translation.vector))
} }
/// Transform the given vector by the inverse of this isometry, ignoring the /// Transform the given vector by the inverse of this isometry, ignoring the
@ -453,6 +459,7 @@ where
/// assert_relative_eq!(transformed_point, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> { pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
self.rotation.inverse_transform_vector(v) self.rotation.inverse_transform_vector(v)
} }
@ -476,6 +483,7 @@ where
/// assert_relative_eq!(transformed_point, -Vector3::y_axis(), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, -Vector3::y_axis(), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_unit_vector(&self, v: &Unit<SVector<T, D>>) -> Unit<SVector<T, D>> { pub fn inverse_transform_unit_vector(&self, v: &Unit<SVector<T, D>>) -> Unit<SVector<T, D>> {
self.rotation.inverse_transform_unit_vector(v) self.rotation.inverse_transform_unit_vector(v)
} }
@ -505,6 +513,7 @@ impl<T: SimdRealField, R, const D: usize> Isometry<T, R, D> {
/// assert_relative_eq!(iso.to_homogeneous(), expected, epsilon = 1.0e-6); /// assert_relative_eq!(iso.to_homogeneous(), expected, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
where where
Const<D>: DimNameAdd<U1>, Const<D>: DimNameAdd<U1>,
@ -536,6 +545,7 @@ impl<T: SimdRealField, R, const D: usize> Isometry<T, R, D> {
/// assert_relative_eq!(iso.to_matrix(), expected, epsilon = 1.0e-6); /// assert_relative_eq!(iso.to_matrix(), expected, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn to_matrix(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> pub fn to_matrix(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
where where
Const<D>: DimNameAdd<U1>, Const<D>: DimNameAdd<U1>,

2
src/geometry/isometry_construction.rs
View File

@ -86,7 +86,7 @@ where
Standard: Distribution<T> + Distribution<R>, Standard: Distribution<T> + Distribution<R>,
{ {
#[inline] #[inline]
fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Isometry<T, R, D> { fn sample<G: Rng + ?Sized>(&self, rng: &mut G) -> Isometry<T, R, D> {
Isometry::from_parts(rng.gen(), rng.gen()) Isometry::from_parts(rng.gen(), rng.gen())
} }
} }

58
src/geometry/isometry_conversion.rs
View File

@ -239,7 +239,7 @@ where
{ {
#[inline] #[inline]
fn from(arr: [Isometry<T::Element, R::Element, D>; 2]) -> Self { fn from(arr: [Isometry<T::Element, R::Element, D>; 2]) -> Self {
let tra = Translation::from([arr[0].translation.clone(), arr[1].translation.clone()]); let tra = Translation::from([arr[0].translation, arr[1].translation]);
let rot = R::from([arr[0].rotation, arr[0].rotation]); let rot = R::from([arr[0].rotation, arr[0].rotation]);
Self::from_parts(tra, rot) Self::from_parts(tra, rot)
@ -258,10 +258,10 @@ where
#[inline] #[inline]
fn from(arr: [Isometry<T::Element, R::Element, D>; 4]) -> Self { fn from(arr: [Isometry<T::Element, R::Element, D>; 4]) -> Self {
let tra = Translation::from([ let tra = Translation::from([
arr[0].translation.clone(), arr[0].translation,
arr[1].translation.clone(), arr[1].translation,
arr[2].translation.clone(), arr[2].translation,
arr[3].translation.clone(), arr[3].translation,
]); ]);
let rot = R::from([ let rot = R::from([
arr[0].rotation, arr[0].rotation,
@ -286,14 +286,14 @@ where
#[inline] #[inline]
fn from(arr: [Isometry<T::Element, R::Element, D>; 8]) -> Self { fn from(arr: [Isometry<T::Element, R::Element, D>; 8]) -> Self {
let tra = Translation::from([ let tra = Translation::from([
arr[0].translation.clone(), arr[0].translation,
arr[1].translation.clone(), arr[1].translation,
arr[2].translation.clone(), arr[2].translation,
arr[3].translation.clone(), arr[3].translation,
arr[4].translation.clone(), arr[4].translation,
arr[5].translation.clone(), arr[5].translation,
arr[6].translation.clone(), arr[6].translation,
arr[7].translation.clone(), arr[7].translation,
]); ]);
let rot = R::from([ let rot = R::from([
arr[0].rotation, arr[0].rotation,
@ -322,22 +322,22 @@ where
#[inline] #[inline]
fn from(arr: [Isometry<T::Element, R::Element, D>; 16]) -> Self { fn from(arr: [Isometry<T::Element, R::Element, D>; 16]) -> Self {
let tra = Translation::from([ let tra = Translation::from([
arr[0].translation.clone(), arr[0].translation,
arr[1].translation.clone(), arr[1].translation,
arr[2].translation.clone(), arr[2].translation,
arr[3].translation.clone(), arr[3].translation,
arr[4].translation.clone(), arr[4].translation,
arr[5].translation.clone(), arr[5].translation,
arr[6].translation.clone(), arr[6].translation,
arr[7].translation.clone(), arr[7].translation,
arr[8].translation.clone(), arr[8].translation,
arr[9].translation.clone(), arr[9].translation,
arr[10].translation.clone(), arr[10].translation,
arr[11].translation.clone(), arr[11].translation,
arr[12].translation.clone(), arr[12].translation,
arr[13].translation.clone(), arr[13].translation,
arr[14].translation.clone(), arr[14].translation,
arr[15].translation.clone(), arr[15].translation,
]); ]);
let rot = R::from([ let rot = R::from([
arr[0].rotation, arr[0].rotation,

6
src/geometry/isometry_interpolation.rs
View File

@ -26,6 +26,7 @@ impl<T: SimdRealField> Isometry3<T> {
/// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn lerp_slerp(&self, other: &Self, t: T) -> Self pub fn lerp_slerp(&self, other: &Self, t: T) -> Self
where where
T: RealField, T: RealField,
@ -59,6 +60,7 @@ impl<T: SimdRealField> Isometry3<T> {
/// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn try_lerp_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self> pub fn try_lerp_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>
where where
T: RealField, T: RealField,
@ -94,6 +96,7 @@ impl<T: SimdRealField> IsometryMatrix3<T> {
/// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn lerp_slerp(&self, other: &Self, t: T) -> Self pub fn lerp_slerp(&self, other: &Self, t: T) -> Self
where where
T: RealField, T: RealField,
@ -127,6 +130,7 @@ impl<T: SimdRealField> IsometryMatrix3<T> {
/// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn try_lerp_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self> pub fn try_lerp_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>
where where
T: RealField, T: RealField,
@ -163,6 +167,7 @@ impl<T: SimdRealField> Isometry2<T> {
/// assert_relative_eq!(iso3.rotation.angle(), std::f32::consts::FRAC_PI_2); /// assert_relative_eq!(iso3.rotation.angle(), std::f32::consts::FRAC_PI_2);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn lerp_slerp(&self, other: &Self, t: T) -> Self pub fn lerp_slerp(&self, other: &Self, t: T) -> Self
where where
T: RealField, T: RealField,
@ -199,6 +204,7 @@ impl<T: SimdRealField> IsometryMatrix2<T> {
/// assert_relative_eq!(iso3.rotation.angle(), std::f32::consts::FRAC_PI_2); /// assert_relative_eq!(iso3.rotation.angle(), std::f32::consts::FRAC_PI_2);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn lerp_slerp(&self, other: &Self, t: T) -> Self pub fn lerp_slerp(&self, other: &Self, t: T) -> Self
where where
T: RealField, T: RealField,

47
src/geometry/isometry_ops.rs
View File

@ -1,3 +1,6 @@
// The macros break if the references are taken out, for some reason.
#![allow(clippy::op_ref)]
use num::{One, Zero}; use num::{One, Zero};
use std::ops::{Div, DivAssign, Mul, MulAssign}; use std::ops::{Div, DivAssign, Mul, MulAssign};
@ -198,7 +201,7 @@ md_assign_impl_all!(
const D; for; where; const D; for; where;
self: Isometry<T, Rotation<T, D>, D>, rhs: Rotation<T, D>; self: Isometry<T, Rotation<T, D>, D>, rhs: Rotation<T, D>;
[val] => self.rotation *= rhs; [val] => self.rotation *= rhs;
[ref] => self.rotation *= rhs.clone(); [ref] => self.rotation *= *rhs;
); );
md_assign_impl_all!( md_assign_impl_all!(
@ -365,9 +368,9 @@ isometry_from_composition_impl_all!(
D; D;
self: Rotation<T, D>, right: Translation<T, D>, Output = Isometry<T, Rotation<T, D>, D>; self: Rotation<T, D>, right: Translation<T, D>, Output = Isometry<T, Rotation<T, D>, D>;
[val val] => Isometry::from_parts(Translation::from(&self * right.vector), self); [val val] => Isometry::from_parts(Translation::from(&self * right.vector), self);
[ref val] => Isometry::from_parts(Translation::from(self * right.vector), self.clone()); [ref val] => Isometry::from_parts(Translation::from(self * right.vector), *self);
[val ref] => Isometry::from_parts(Translation::from(&self * &right.vector), self); [val ref] => Isometry::from_parts(Translation::from(&self * &right.vector), self);
[ref ref] => Isometry::from_parts(Translation::from(self * &right.vector), self.clone()); [ref ref] => Isometry::from_parts(Translation::from(self * &right.vector), *self);
); );
// UnitQuaternion × Translation // UnitQuaternion × Translation
@ -389,9 +392,9 @@ isometry_from_composition_impl_all!(
self: Isometry<T, Rotation<T, D>, D>, rhs: Rotation<T, D>, self: Isometry<T, Rotation<T, D>, D>, rhs: Rotation<T, D>,
Output = Isometry<T, Rotation<T, D>, D>; Output = Isometry<T, Rotation<T, D>, D>;
[val val] => Isometry::from_parts(self.translation, self.rotation * rhs); [val val] => Isometry::from_parts(self.translation, self.rotation * rhs);
[ref val] => Isometry::from_parts(self.translation.clone(), self.rotation.clone() * rhs); // TODO: do not clone. [ref val] => Isometry::from_parts(self.translation, self.rotation * rhs);
[val ref] => Isometry::from_parts(self.translation, self.rotation * rhs.clone()); [val ref] => Isometry::from_parts(self.translation, self.rotation * *rhs);
[ref ref] => Isometry::from_parts(self.translation.clone(), self.rotation.clone() * rhs.clone()); [ref ref] => Isometry::from_parts(self.translation, self.rotation * *rhs);
); );
// Rotation × Isometry // Rotation × Isometry
@ -416,9 +419,9 @@ isometry_from_composition_impl_all!(
self: Isometry<T, Rotation<T, D>, D>, rhs: Rotation<T, D>, self: Isometry<T, Rotation<T, D>, D>, rhs: Rotation<T, D>,
Output = Isometry<T, Rotation<T, D>, D>; Output = Isometry<T, Rotation<T, D>, D>;
[val val] => Isometry::from_parts(self.translation, self.rotation / rhs); [val val] => Isometry::from_parts(self.translation, self.rotation / rhs);
[ref val] => Isometry::from_parts(self.translation.clone(), self.rotation.clone() / rhs); // TODO: do not clone. [ref val] => Isometry::from_parts(self.translation, self.rotation / rhs);
[val ref] => Isometry::from_parts(self.translation, self.rotation / rhs.clone()); [val ref] => Isometry::from_parts(self.translation, self.rotation / *rhs);
[ref ref] => Isometry::from_parts(self.translation.clone(), self.rotation.clone() / rhs.clone()); [ref ref] => Isometry::from_parts(self.translation, self.rotation / *rhs);
); );
// Rotation ÷ Isometry // Rotation ÷ Isometry
@ -441,9 +444,9 @@ isometry_from_composition_impl_all!(
self: Isometry<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>, self: Isometry<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>,
Output = Isometry<T, UnitQuaternion<T>, 3>; Output = Isometry<T, UnitQuaternion<T>, 3>;
[val val] => Isometry::from_parts(self.translation, self.rotation * rhs); [val val] => Isometry::from_parts(self.translation, self.rotation * rhs);
[ref val] => Isometry::from_parts(self.translation.clone(), self.rotation * rhs); // TODO: do not clone. [ref val] => Isometry::from_parts(self.translation, self.rotation * rhs);
[val ref] => Isometry::from_parts(self.translation, self.rotation * *rhs); [val ref] => Isometry::from_parts(self.translation, self.rotation * *rhs);
[ref ref] => Isometry::from_parts(self.translation.clone(), self.rotation * *rhs); [ref ref] => Isometry::from_parts(self.translation, self.rotation * *rhs);
); );
// UnitQuaternion × Isometry // UnitQuaternion × Isometry
@ -468,9 +471,9 @@ isometry_from_composition_impl_all!(
self: Isometry<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>, self: Isometry<T, UnitQuaternion<T>, 3>, rhs: UnitQuaternion<T>,
Output = Isometry<T, UnitQuaternion<T>, 3>; Output = Isometry<T, UnitQuaternion<T>, 3>;
[val val] => Isometry::from_parts(self.translation, self.rotation / rhs); [val val] => Isometry::from_parts(self.translation, self.rotation / rhs);
[ref val] => Isometry::from_parts(self.translation.clone(), self.rotation / rhs); // TODO: do not clone. [ref val] => Isometry::from_parts(self.translation, self.rotation / rhs);
[val ref] => Isometry::from_parts(self.translation, self.rotation / *rhs); [val ref] => Isometry::from_parts(self.translation, self.rotation / *rhs);
[ref ref] => Isometry::from_parts(self.translation.clone(), self.rotation / *rhs); [ref ref] => Isometry::from_parts(self.translation, self.rotation / *rhs);
); );
// UnitQuaternion ÷ Isometry // UnitQuaternion ÷ Isometry
@ -492,9 +495,9 @@ isometry_from_composition_impl_all!(
D; D;
self: Translation<T, D>, right: Rotation<T, D>, Output = Isometry<T, Rotation<T, D>, D>; self: Translation<T, D>, right: Rotation<T, D>, Output = Isometry<T, Rotation<T, D>, D>;
[val val] => Isometry::from_parts(self, right); [val val] => Isometry::from_parts(self, right);
[ref val] => Isometry::from_parts(self.clone(), right); [ref val] => Isometry::from_parts(*self, right);
[val ref] => Isometry::from_parts(self, right.clone()); [val ref] => Isometry::from_parts(self, *right);
[ref ref] => Isometry::from_parts(self.clone(), right.clone()); [ref ref] => Isometry::from_parts(*self, *right);
); );
// Translation × UnitQuaternion // Translation × UnitQuaternion
@ -503,9 +506,9 @@ isometry_from_composition_impl_all!(
; ;
self: Translation<T, 3>, right: UnitQuaternion<T>, Output = Isometry<T, UnitQuaternion<T>, 3>; self: Translation<T, 3>, right: UnitQuaternion<T>, Output = Isometry<T, UnitQuaternion<T>, 3>;
[val val] => Isometry::from_parts(self, right); [val val] => Isometry::from_parts(self, right);
[ref val] => Isometry::from_parts(self.clone(), right); [ref val] => Isometry::from_parts(*self, right);
[val ref] => Isometry::from_parts(self, *right); [val ref] => Isometry::from_parts(self, *right);
[ref ref] => Isometry::from_parts(self.clone(), *right); [ref ref] => Isometry::from_parts(*self, *right);
); );
// Isometry × UnitComplex // Isometry × UnitComplex
@ -515,9 +518,9 @@ isometry_from_composition_impl_all!(
self: Isometry<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>, self: Isometry<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>,
Output = Isometry<T, UnitComplex<T>, 2>; Output = Isometry<T, UnitComplex<T>, 2>;
[val val] => Isometry::from_parts(self.translation, self.rotation * rhs); [val val] => Isometry::from_parts(self.translation, self.rotation * rhs);
[ref val] => Isometry::from_parts(self.translation.clone(), self.rotation * rhs); // TODO: do not clone. [ref val] => Isometry::from_parts(self.translation, self.rotation * rhs);
[val ref] => Isometry::from_parts(self.translation, self.rotation * *rhs); [val ref] => Isometry::from_parts(self.translation, self.rotation * *rhs);
[ref ref] => Isometry::from_parts(self.translation.clone(), self.rotation * *rhs); [ref ref] => Isometry::from_parts(self.translation, self.rotation * *rhs);
); );
// Isometry ÷ UnitComplex // Isometry ÷ UnitComplex
@ -527,7 +530,7 @@ isometry_from_composition_impl_all!(
self: Isometry<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>, self: Isometry<T, UnitComplex<T>, 2>, rhs: UnitComplex<T>,
Output = Isometry<T, UnitComplex<T>, 2>; Output = Isometry<T, UnitComplex<T>, 2>;
[val val] => Isometry::from_parts(self.translation, self.rotation / rhs); [val val] => Isometry::from_parts(self.translation, self.rotation / rhs);
[ref val] => Isometry::from_parts(self.translation.clone(), self.rotation / rhs); // TODO: do not clone. [ref val] => Isometry::from_parts(self.translation, self.rotation / rhs);
[val ref] => Isometry::from_parts(self.translation, self.rotation / *rhs); [val ref] => Isometry::from_parts(self.translation, self.rotation / *rhs);
[ref ref] => Isometry::from_parts(self.translation.clone(), self.rotation / *rhs); [ref ref] => Isometry::from_parts(self.translation, self.rotation / *rhs);
); );

23
src/geometry/orthographic.rs
View File

@ -8,7 +8,6 @@ use rand::{
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
use serde::{Deserialize, Deserializer, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::fmt; use std::fmt;
use std::mem;
use simba::scalar::RealField; use simba::scalar::RealField;
@ -19,7 +18,7 @@ use crate::base::{Matrix4, Vector, Vector3};
use crate::geometry::{Point3, Projective3}; use crate::geometry::{Point3, Projective3};
/// A 3D orthographic projection stored as a homogeneous 4x4 matrix. /// A 3D orthographic projection stored as a homogeneous 4x4 matrix.
pub struct Orthographic3<T: RealField> { pub struct Orthographic3<T> {
matrix: Matrix4<T>, matrix: Matrix4<T>,
} }
@ -188,6 +187,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_relative_eq!(proj.as_matrix() * inv, Matrix4::identity()); /// assert_relative_eq!(proj.as_matrix() * inv, Matrix4::identity());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse(&self) -> Matrix4<T> { pub fn inverse(&self) -> Matrix4<T> {
let mut res = self.to_homogeneous(); let mut res = self.to_homogeneous();
@ -221,7 +221,8 @@ impl<T: RealField> Orthographic3<T> {
/// assert_eq!(proj.to_homogeneous(), expected); /// assert_eq!(proj.to_homogeneous(), expected);
/// ``` /// ```
#[inline] #[inline]
pub fn to_homogeneous(&self) -> Matrix4<T> { #[must_use]
pub fn to_homogeneous(self) -> Matrix4<T> {
self.matrix self.matrix
} }
@ -240,6 +241,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_eq!(*proj.as_matrix(), expected); /// assert_eq!(*proj.as_matrix(), expected);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn as_matrix(&self) -> &Matrix4<T> { pub fn as_matrix(&self) -> &Matrix4<T> {
&self.matrix &self.matrix
} }
@ -253,8 +255,9 @@ impl<T: RealField> Orthographic3<T> {
/// assert_eq!(proj.as_projective().to_homogeneous(), proj.to_homogeneous()); /// assert_eq!(proj.as_projective().to_homogeneous(), proj.to_homogeneous());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn as_projective(&self) -> &Projective3<T> { pub fn as_projective(&self) -> &Projective3<T> {
unsafe { mem::transmute(self) } unsafe { &*(self as *const Orthographic3<T> as *const Projective3<T>) }
} }
/// This transformation seen as a `Projective3`. /// This transformation seen as a `Projective3`.
@ -266,7 +269,8 @@ impl<T: RealField> Orthographic3<T> {
/// assert_eq!(proj.to_projective().to_homogeneous(), proj.to_homogeneous()); /// assert_eq!(proj.to_projective().to_homogeneous(), proj.to_homogeneous());
/// ``` /// ```
#[inline] #[inline]
pub fn to_projective(&self) -> Projective3<T> { #[must_use]
pub fn to_projective(self) -> Projective3<T> {
Projective3::from_matrix_unchecked(self.matrix) Projective3::from_matrix_unchecked(self.matrix)
} }
@ -310,6 +314,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_relative_eq!(proj.left(), 10.0, epsilon = 1.0e-6); /// assert_relative_eq!(proj.left(), 10.0, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn left(&self) -> T { pub fn left(&self) -> T {
(-T::one() - self.matrix[(0, 3)]) / self.matrix[(0, 0)] (-T::one() - self.matrix[(0, 3)]) / self.matrix[(0, 0)]
} }
@ -326,6 +331,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_relative_eq!(proj.right(), 1.0, epsilon = 1.0e-6); /// assert_relative_eq!(proj.right(), 1.0, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn right(&self) -> T { pub fn right(&self) -> T {
(T::one() - self.matrix[(0, 3)]) / self.matrix[(0, 0)] (T::one() - self.matrix[(0, 3)]) / self.matrix[(0, 0)]
} }
@ -342,6 +348,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_relative_eq!(proj.bottom(), 20.0, epsilon = 1.0e-6); /// assert_relative_eq!(proj.bottom(), 20.0, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn bottom(&self) -> T { pub fn bottom(&self) -> T {
(-T::one() - self.matrix[(1, 3)]) / self.matrix[(1, 1)] (-T::one() - self.matrix[(1, 3)]) / self.matrix[(1, 1)]
} }
@ -358,6 +365,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_relative_eq!(proj.top(), 2.0, epsilon = 1.0e-6); /// assert_relative_eq!(proj.top(), 2.0, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn top(&self) -> T { pub fn top(&self) -> T {
(T::one() - self.matrix[(1, 3)]) / self.matrix[(1, 1)] (T::one() - self.matrix[(1, 3)]) / self.matrix[(1, 1)]
} }
@ -374,6 +382,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_relative_eq!(proj.znear(), 1000.0, epsilon = 1.0e-6); /// assert_relative_eq!(proj.znear(), 1000.0, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn znear(&self) -> T { pub fn znear(&self) -> T {
(T::one() + self.matrix[(2, 3)]) / self.matrix[(2, 2)] (T::one() + self.matrix[(2, 3)]) / self.matrix[(2, 2)]
} }
@ -390,6 +399,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_relative_eq!(proj.zfar(), 0.1, epsilon = 1.0e-6); /// assert_relative_eq!(proj.zfar(), 0.1, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn zfar(&self) -> T { pub fn zfar(&self) -> T {
(-T::one() + self.matrix[(2, 3)]) / self.matrix[(2, 2)] (-T::one() + self.matrix[(2, 3)]) / self.matrix[(2, 2)]
} }
@ -422,6 +432,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_relative_eq!(proj.project_point(&p8), Point3::new( 1.0, 1.0, 1.0)); /// assert_relative_eq!(proj.project_point(&p8), Point3::new( 1.0, 1.0, 1.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn project_point(&self, p: &Point3<T>) -> Point3<T> { pub fn project_point(&self, p: &Point3<T>) -> Point3<T> {
Point3::new( Point3::new(
self.matrix[(0, 0)] * p[0] + self.matrix[(0, 3)], self.matrix[(0, 0)] * p[0] + self.matrix[(0, 3)],
@ -457,6 +468,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_relative_eq!(proj.unproject_point(&p8), Point3::new(10.0, 20.0, -1000.0), epsilon = 1.0e-6); /// assert_relative_eq!(proj.unproject_point(&p8), Point3::new(10.0, 20.0, -1000.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn unproject_point(&self, p: &Point3<T>) -> Point3<T> { pub fn unproject_point(&self, p: &Point3<T>) -> Point3<T> {
Point3::new( Point3::new(
(p[0] - self.matrix[(0, 3)]) / self.matrix[(0, 0)], (p[0] - self.matrix[(0, 3)]) / self.matrix[(0, 0)],
@ -485,6 +497,7 @@ impl<T: RealField> Orthographic3<T> {
/// assert_relative_eq!(proj.project_vector(&v3), Vector3::z() * -2.0 / 999.9); /// assert_relative_eq!(proj.project_vector(&v3), Vector3::z() * -2.0 / 999.9);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn project_vector<SB>(&self, p: &Vector<T, U3, SB>) -> Vector3<T> pub fn project_vector<SB>(&self, p: &Vector<T, U3, SB>) -> Vector3<T>
where where
SB: Storage<T, U3>, SB: Storage<T, U3>,

30
src/geometry/perspective.rs
View File

@ -9,18 +9,17 @@ use rand::{
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
use serde::{Deserialize, Deserializer, Serialize, Serializer}; use serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::fmt; use std::fmt;
use std::mem;
use simba::scalar::RealField; use simba::scalar::RealField;
use crate::base::dimension::U3; use crate::base::dimension::U3;
use crate::base::storage::Storage; use crate::base::storage::Storage;
use crate::base::{Matrix4, Scalar, Vector, Vector3}; use crate::base::{Matrix4, Vector, Vector3};
use crate::geometry::{Point3, Projective3}; use crate::geometry::{Point3, Projective3};
/// A 3D perspective projection stored as a homogeneous 4x4 matrix. /// A 3D perspective projection stored as a homogeneous 4x4 matrix.
pub struct Perspective3<T: Scalar> { pub struct Perspective3<T> {
matrix: Matrix4<T>, matrix: Matrix4<T>,
} }
@ -104,6 +103,7 @@ impl<T: RealField> Perspective3<T> {
/// Retrieves the inverse of the underlying homogeneous matrix. /// Retrieves the inverse of the underlying homogeneous matrix.
#[inline] #[inline]
#[must_use]
pub fn inverse(&self) -> Matrix4<T> { pub fn inverse(&self) -> Matrix4<T> {
let mut res = self.to_homogeneous(); let mut res = self.to_homogeneous();
@ -123,25 +123,29 @@ impl<T: RealField> Perspective3<T> {
/// Computes the corresponding homogeneous matrix. /// Computes the corresponding homogeneous matrix.
#[inline] #[inline]
pub fn to_homogeneous(&self) -> Matrix4<T> { #[must_use]
pub fn to_homogeneous(self) -> Matrix4<T> {
self.matrix.clone_owned() self.matrix.clone_owned()
} }
/// A reference to the underlying homogeneous transformation matrix. /// A reference to the underlying homogeneous transformation matrix.
#[inline] #[inline]
#[must_use]
pub fn as_matrix(&self) -> &Matrix4<T> { pub fn as_matrix(&self) -> &Matrix4<T> {
&self.matrix &self.matrix
} }
/// A reference to this transformation seen as a `Projective3`. /// A reference to this transformation seen as a `Projective3`.
#[inline] #[inline]
#[must_use]
pub fn as_projective(&self) -> &Projective3<T> { pub fn as_projective(&self) -> &Projective3<T> {
unsafe { mem::transmute(self) } unsafe { &*(self as *const Perspective3<T> as *const Projective3<T>) }
} }
/// This transformation seen as a `Projective3`. /// This transformation seen as a `Projective3`.
#[inline] #[inline]
pub fn to_projective(&self) -> Projective3<T> { #[must_use]
pub fn to_projective(self) -> Projective3<T> {
Projective3::from_matrix_unchecked(self.matrix) Projective3::from_matrix_unchecked(self.matrix)
} }
@ -161,18 +165,21 @@ impl<T: RealField> Perspective3<T> {
/// Gets the `width / height` aspect ratio of the view frustum. /// Gets the `width / height` aspect ratio of the view frustum.
#[inline] #[inline]
#[must_use]
pub fn aspect(&self) -> T { pub fn aspect(&self) -> T {
self.matrix[(1, 1)] / self.matrix[(0, 0)] self.matrix[(1, 1)] / self.matrix[(0, 0)]
} }
/// Gets the y field of view of the view frustum. /// Gets the y field of view of the view frustum.
#[inline] #[inline]
#[must_use]
pub fn fovy(&self) -> T { pub fn fovy(&self) -> T {
(T::one() / self.matrix[(1, 1)]).atan() * crate::convert(2.0) (T::one() / self.matrix[(1, 1)]).atan() * crate::convert(2.0)
} }
/// Gets the near plane offset of the view frustum. /// Gets the near plane offset of the view frustum.
#[inline] #[inline]
#[must_use]
pub fn znear(&self) -> T { pub fn znear(&self) -> T {
let ratio = (-self.matrix[(2, 2)] + T::one()) / (-self.matrix[(2, 2)] - T::one()); let ratio = (-self.matrix[(2, 2)] + T::one()) / (-self.matrix[(2, 2)] - T::one());
@ -182,6 +189,7 @@ impl<T: RealField> Perspective3<T> {
/// Gets the far plane offset of the view frustum. /// Gets the far plane offset of the view frustum.
#[inline] #[inline]
#[must_use]
pub fn zfar(&self) -> T { pub fn zfar(&self) -> T {
let ratio = (-self.matrix[(2, 2)] + T::one()) / (-self.matrix[(2, 2)] - T::one()); let ratio = (-self.matrix[(2, 2)] + T::one()) / (-self.matrix[(2, 2)] - T::one());
@ -193,6 +201,7 @@ impl<T: RealField> Perspective3<T> {
// TODO: when we get specialization, specialize the Mul impl instead. // TODO: when we get specialization, specialize the Mul impl instead.
/// Projects a point. Faster than matrix multiplication. /// Projects a point. Faster than matrix multiplication.
#[inline] #[inline]
#[must_use]
pub fn project_point(&self, p: &Point3<T>) -> Point3<T> { pub fn project_point(&self, p: &Point3<T>) -> Point3<T> {
let inverse_denom = -T::one() / p[2]; let inverse_denom = -T::one() / p[2];
Point3::new( Point3::new(
@ -204,6 +213,7 @@ impl<T: RealField> Perspective3<T> {
/// Un-projects a point. Faster than multiplication by the matrix inverse. /// Un-projects a point. Faster than multiplication by the matrix inverse.
#[inline] #[inline]
#[must_use]
pub fn unproject_point(&self, p: &Point3<T>) -> Point3<T> { pub fn unproject_point(&self, p: &Point3<T>) -> Point3<T> {
let inverse_denom = self.matrix[(2, 3)] / (p[2] + self.matrix[(2, 2)]); let inverse_denom = self.matrix[(2, 3)] / (p[2] + self.matrix[(2, 2)]);
@ -217,6 +227,7 @@ impl<T: RealField> Perspective3<T> {
// TODO: when we get specialization, specialize the Mul impl instead. // TODO: when we get specialization, specialize the Mul impl instead.
/// Projects a vector. Faster than matrix multiplication. /// Projects a vector. Faster than matrix multiplication.
#[inline] #[inline]
#[must_use]
pub fn project_vector<SB>(&self, p: &Vector<T, U3, SB>) -> Vector3<T> pub fn project_vector<SB>(&self, p: &Vector<T, U3, SB>) -> Vector3<T>
where where
SB: Storage<T, U3>, SB: Storage<T, U3>,
@ -244,8 +255,9 @@ impl<T: RealField> Perspective3<T> {
#[inline] #[inline]
pub fn set_fovy(&mut self, fovy: T) { pub fn set_fovy(&mut self, fovy: T) {
let old_m22 = self.matrix[(1, 1)]; let old_m22 = self.matrix[(1, 1)];
self.matrix[(1, 1)] = T::one() / (fovy / crate::convert(2.0)).tan(); let new_m22 = T::one() / (fovy / crate::convert(2.0)).tan();
self.matrix[(0, 0)] = self.matrix[(0, 0)] * (self.matrix[(1, 1)] / old_m22); self.matrix[(1, 1)] = new_m22;
self.matrix[(0, 0)] *= new_m22 / old_m22;
} }
/// Updates this perspective matrix with a new near plane offset of the view frustum. /// Updates this perspective matrix with a new near plane offset of the view frustum.
@ -276,7 +288,7 @@ where
Standard: Distribution<T>, Standard: Distribution<T>,
{ {
/// Generate an arbitrary random variate for testing purposes. /// Generate an arbitrary random variate for testing purposes.
fn sample<'a, R: Rng + ?Sized>(&self, r: &'a mut R) -> Perspective3<T> { fn sample<R: Rng + ?Sized>(&self, r: &mut R) -> Perspective3<T> {
use crate::base::helper; use crate::base::helper;
let znear = r.gen(); let znear = r.gen();
let zfar = helper::reject_rand(r, |&x: &T| !(x - znear).is_zero()); let zfar = helper::reject_rand(r, |&x: &T| !(x - znear).is_zero());

132
src/geometry/point.rs
View File

@ -17,7 +17,7 @@ use simba::simd::SimdPartialOrd;
use crate::base::allocator::Allocator; use crate::base::allocator::Allocator;
use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1}; use crate::base::dimension::{DimName, DimNameAdd, DimNameSum, U1};
use crate::base::iter::{MatrixIter, MatrixIterMut}; use crate::base::iter::{MatrixIter, MatrixIterMut};
use crate::base::{Const, DefaultAllocator, OVector, SVector, Scalar}; use crate::base::{Const, DefaultAllocator, OVector, Scalar};
/// A point in an euclidean space. /// A point in an euclidean space.
/// ///
@ -40,35 +40,53 @@ use crate::base::{Const, DefaultAllocator, OVector, SVector, Scalar};
/// of said transformations for details. /// of said transformations for details.
#[repr(C)] #[repr(C)]
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct Point<T, const D: usize> { pub struct OPoint<T: Scalar, D: DimName>
where
DefaultAllocator: Allocator<T, D>,
{
/// The coordinates of this point, i.e., the shift from the origin. /// The coordinates of this point, i.e., the shift from the origin.
pub coords: SVector<T, D>, pub coords: OVector<T, D>,
} }
impl<T: Scalar + hash::Hash, const D: usize> hash::Hash for Point<T, D> { impl<T: Scalar + hash::Hash, D: DimName> hash::Hash for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
fn hash<H: hash::Hasher>(&self, state: &mut H) { fn hash<H: hash::Hasher>(&self, state: &mut H) {
self.coords.hash(state) self.coords.hash(state)
} }
} }
impl<T: Scalar + Copy, const D: usize> Copy for Point<T, D> {} impl<T: Scalar + Copy, D: DimName> Copy for OPoint<T, D>
where
#[cfg(feature = "bytemuck")] DefaultAllocator: Allocator<T, D>,
unsafe impl<T: Scalar, const D: usize> bytemuck::Zeroable for Point<T, D> where OVector<T, D>: Copy,
SVector<T, D>: bytemuck::Zeroable
{ {
} }
#[cfg(feature = "bytemuck")] #[cfg(feature = "bytemuck")]
unsafe impl<T: Scalar, const D: usize> bytemuck::Pod for Point<T, D> unsafe impl<T: Scalar, D: DimName> bytemuck::Zeroable for OPoint<T, D>
where
OVector<T, D>: bytemuck::Zeroable,
DefaultAllocator: Allocator<T, D>,
{
}
#[cfg(feature = "bytemuck")]
unsafe impl<T: Scalar, D: DimName> bytemuck::Pod for OPoint<T, D>
where where
T: Copy, T: Copy,
SVector<T, D>: bytemuck::Pod, OVector<T, D>: bytemuck::Pod,
DefaultAllocator: Allocator<T, D>,
{ {
} }
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
impl<T: Scalar + Serialize, const D: usize> Serialize for Point<T, D> { impl<T: Scalar + Serialize, D: DimName> Serialize for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
<DefaultAllocator as Allocator<T, D>>::Buffer: Serialize,
{
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
S: Serializer, S: Serializer,
@ -78,22 +96,27 @@ impl<T: Scalar + Serialize, const D: usize> Serialize for Point<T, D> {
} }
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
impl<'a, T: Scalar + Deserialize<'a>, const D: usize> Deserialize<'a> for Point<T, D> { impl<'a, T: Scalar + Deserialize<'a>, D: DimName> Deserialize<'a> for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
<DefaultAllocator as Allocator<T, D>>::Buffer: Deserialize<'a>,
{
fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error> fn deserialize<Des>(deserializer: Des) -> Result<Self, Des::Error>
where where
Des: Deserializer<'a>, Des: Deserializer<'a>,
{ {
let coords = SVector::<T, D>::deserialize(deserializer)?; let coords = OVector::<T, D>::deserialize(deserializer)?;
Ok(Self::from(coords)) Ok(Self::from(coords))
} }
} }
#[cfg(feature = "abomonation-serialize")] #[cfg(feature = "abomonation-serialize")]
impl<T, const D: usize> Abomonation for Point<T, D> impl<T, D: DimName> Abomonation for OPoint<T, D>
where where
T: Scalar, T: Scalar,
SVector<T, D>: Abomonation, OVector<T, D>: Abomonation,
DefaultAllocator: Allocator<T, D>,
{ {
unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> { unsafe fn entomb<W: Write>(&self, writer: &mut W) -> IOResult<()> {
self.coords.entomb(writer) self.coords.entomb(writer)
@ -108,7 +131,10 @@ where
} }
} }
impl<T: Scalar, const D: usize> Point<T, D> { impl<T: Scalar, D: DimName> OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
/// Returns a point containing the result of `f` applied to each of its entries. /// Returns a point containing the result of `f` applied to each of its entries.
/// ///
/// # Example /// # Example
@ -122,7 +148,11 @@ impl<T: Scalar, const D: usize> Point<T, D> {
/// assert_eq!(p.map(|e| e as u32), Point3::new(1, 2, 3)); /// assert_eq!(p.map(|e| e as u32), Point3::new(1, 2, 3));
/// ``` /// ```
#[inline] #[inline]
pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, f: F) -> Point<T2, D> { #[must_use]
pub fn map<T2: Scalar, F: FnMut(T) -> T2>(&self, f: F) -> OPoint<T2, D>
where
DefaultAllocator: Allocator<T2, D>,
{
self.coords.map(f).into() self.coords.map(f).into()
} }
@ -161,20 +191,22 @@ impl<T: Scalar, const D: usize> Point<T, D> {
/// assert_eq!(p.to_homogeneous(), Vector4::new(10.0, 20.0, 30.0, 1.0)); /// assert_eq!(p.to_homogeneous(), Vector4::new(10.0, 20.0, 30.0, 1.0));
/// ``` /// ```
#[inline] #[inline]
pub fn to_homogeneous(&self) -> OVector<T, DimNameSum<Const<D>, U1>> #[must_use]
pub fn to_homogeneous(&self) -> OVector<T, DimNameSum<D, U1>>
where where
T: One, T: One,
Const<D>: DimNameAdd<U1>, D: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>>, DefaultAllocator: Allocator<T, DimNameSum<D, U1>>,
{ {
let mut res = unsafe { let mut res = unsafe {
crate::unimplemented_or_uninitialized_generic!( crate::unimplemented_or_uninitialized_generic!(
<DimNameSum<Const<D>, U1> as DimName>::name(), <DimNameSum<D, U1> as DimName>::name(),
Const::<1> Const::<1>
) )
}; };
res.fixed_slice_mut::<D, 1>(0, 0).copy_from(&self.coords); res.generic_slice_mut((0, 0), (D::name(), Const::<1>))
res[(D, 0)] = T::one(); .copy_from(&self.coords);
res[(D::dim(), 0)] = T::one();
res res
} }
@ -182,7 +214,7 @@ impl<T: Scalar, const D: usize> Point<T, D> {
/// Creates a new point with the given coordinates. /// Creates a new point with the given coordinates.
#[deprecated(note = "Use Point::from(vector) instead.")] #[deprecated(note = "Use Point::from(vector) instead.")]
#[inline] #[inline]
pub fn from_coordinates(coords: SVector<T, D>) -> Self { pub fn from_coordinates(coords: OVector<T, D>) -> Self {
Self { coords } Self { coords }
} }
@ -199,6 +231,7 @@ impl<T: Scalar, const D: usize> Point<T, D> {
/// assert_eq!(p.len(), 3); /// assert_eq!(p.len(), 3);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
self.coords.len() self.coords.len()
} }
@ -212,6 +245,7 @@ impl<T: Scalar, const D: usize> Point<T, D> {
/// assert!(!p.is_empty()); /// assert!(!p.is_empty());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
self.len() == 0 self.len() == 0
} }
@ -239,13 +273,13 @@ impl<T: Scalar, const D: usize> Point<T, D> {
#[inline] #[inline]
pub fn iter( pub fn iter(
&self, &self,
) -> MatrixIter<T, Const<D>, Const<1>, <DefaultAllocator as Allocator<T, Const<D>>>::Buffer> ) -> MatrixIter<T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::Buffer> {
{
self.coords.iter() self.coords.iter()
} }
/// Gets a reference to i-th element of this point without bound-checking. /// Gets a reference to i-th element of this point without bound-checking.
#[inline] #[inline]
#[must_use]
pub unsafe fn get_unchecked(&self, i: usize) -> &T { pub unsafe fn get_unchecked(&self, i: usize) -> &T {
self.coords.vget_unchecked(i) self.coords.vget_unchecked(i)
} }
@ -265,13 +299,13 @@ impl<T: Scalar, const D: usize> Point<T, D> {
#[inline] #[inline]
pub fn iter_mut( pub fn iter_mut(
&mut self, &mut self,
) -> MatrixIterMut<T, Const<D>, Const<1>, <DefaultAllocator as Allocator<T, Const<D>>>::Buffer> ) -> MatrixIterMut<T, D, Const<1>, <DefaultAllocator as Allocator<T, D>>::Buffer> {
{
self.coords.iter_mut() self.coords.iter_mut()
} }
/// Gets a mutable reference to i-th element of this point without bound-checking. /// Gets a mutable reference to i-th element of this point without bound-checking.
#[inline] #[inline]
#[must_use]
pub unsafe fn get_unchecked_mut(&mut self, i: usize) -> &mut T { pub unsafe fn get_unchecked_mut(&mut self, i: usize) -> &mut T {
self.coords.vget_unchecked_mut(i) self.coords.vget_unchecked_mut(i)
} }
@ -283,9 +317,10 @@ impl<T: Scalar, const D: usize> Point<T, D> {
} }
} }
impl<T: Scalar + AbsDiffEq, const D: usize> AbsDiffEq for Point<T, D> impl<T: Scalar + AbsDiffEq, D: DimName> AbsDiffEq for OPoint<T, D>
where where
T::Epsilon: Copy, T::Epsilon: Copy,
DefaultAllocator: Allocator<T, D>,
{ {
type Epsilon = T::Epsilon; type Epsilon = T::Epsilon;
@ -300,9 +335,10 @@ where
} }
} }
impl<T: Scalar + RelativeEq, const D: usize> RelativeEq for Point<T, D> impl<T: Scalar + RelativeEq, D: DimName> RelativeEq for OPoint<T, D>
where where
T::Epsilon: Copy, T::Epsilon: Copy,
DefaultAllocator: Allocator<T, D>,
{ {
#[inline] #[inline]
fn default_max_relative() -> Self::Epsilon { fn default_max_relative() -> Self::Epsilon {
@ -321,9 +357,10 @@ where
} }
} }
impl<T: Scalar + UlpsEq, const D: usize> UlpsEq for Point<T, D> impl<T: Scalar + UlpsEq, D: DimName> UlpsEq for OPoint<T, D>
where where
T::Epsilon: Copy, T::Epsilon: Copy,
DefaultAllocator: Allocator<T, D>,
{ {
#[inline] #[inline]
fn default_max_ulps() -> u32 { fn default_max_ulps() -> u32 {
@ -336,16 +373,22 @@ where
} }
} }
impl<T: Scalar + Eq, const D: usize> Eq for Point<T, D> {} impl<T: Scalar + Eq, D: DimName> Eq for OPoint<T, D> where DefaultAllocator: Allocator<T, D> {}
impl<T: Scalar, const D: usize> PartialEq for Point<T, D> { impl<T: Scalar, D: DimName> PartialEq for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
#[inline] #[inline]
fn eq(&self, right: &Self) -> bool { fn eq(&self, right: &Self) -> bool {
self.coords == right.coords self.coords == right.coords
} }
} }
impl<T: Scalar + PartialOrd, const D: usize> PartialOrd for Point<T, D> { impl<T: Scalar + PartialOrd, D: DimName> PartialOrd for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
#[inline] #[inline]
fn partial_cmp(&self, other: &Self) -> Option<Ordering> { fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
self.coords.partial_cmp(&other.coords) self.coords.partial_cmp(&other.coords)
@ -375,22 +418,28 @@ impl<T: Scalar + PartialOrd, const D: usize> PartialOrd for Point<T, D> {
/* /*
* inf/sup * inf/sup
*/ */
impl<T: Scalar + SimdPartialOrd, const D: usize> Point<T, D> { impl<T: Scalar + SimdPartialOrd, D: DimName> OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
/// Computes the infimum (aka. componentwise min) of two points. /// Computes the infimum (aka. componentwise min) of two points.
#[inline] #[inline]
pub fn inf(&self, other: &Self) -> Point<T, D> { #[must_use]
pub fn inf(&self, other: &Self) -> OPoint<T, D> {
self.coords.inf(&other.coords).into() self.coords.inf(&other.coords).into()
} }
/// Computes the supremum (aka. componentwise max) of two points. /// Computes the supremum (aka. componentwise max) of two points.
#[inline] #[inline]
pub fn sup(&self, other: &Self) -> Point<T, D> { #[must_use]
pub fn sup(&self, other: &Self) -> OPoint<T, D> {
self.coords.sup(&other.coords).into() self.coords.sup(&other.coords).into()
} }
/// Computes the (infimum, supremum) of two points. /// Computes the (infimum, supremum) of two points.
#[inline] #[inline]
pub fn inf_sup(&self, other: &Self) -> (Point<T, D>, Point<T, D>) { #[must_use]
pub fn inf_sup(&self, other: &Self) -> (OPoint<T, D>, OPoint<T, D>) {
let (inf, sup) = self.coords.inf_sup(&other.coords); let (inf, sup) = self.coords.inf_sup(&other.coords);
(inf.into(), sup.into()) (inf.into(), sup.into())
} }
@ -401,7 +450,10 @@ impl<T: Scalar + SimdPartialOrd, const D: usize> Point<T, D> {
* Display * Display
* *
*/ */
impl<T: Scalar + fmt::Display, const D: usize> fmt::Display for Point<T, D> { impl<T: Scalar + fmt::Display, D: DimName> fmt::Display for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{{")?; write!(f, "{{")?;

6
src/geometry/point_alias.rs
View File

@ -1,4 +1,8 @@
use crate::geometry::Point; use crate::geometry::OPoint;
use crate::Const;
/// A point with `D` elements.
pub type Point<T, const D: usize> = OPoint<T, Const<D>>;
/// A statically sized 1-dimensional column point. /// A statically sized 1-dimensional column point.
/// ///

65
src/geometry/point_construction.rs
View File

@ -10,22 +10,26 @@ use rand::{
use crate::base::allocator::Allocator; use crate::base::allocator::Allocator;
use crate::base::dimension::{DimNameAdd, DimNameSum, U1}; use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
use crate::base::{DefaultAllocator, SVector, Scalar}; use crate::base::{DefaultAllocator, Scalar};
use crate::{ use crate::{
Const, OVector, Point1, Point2, Point3, Point4, Point5, Point6, Vector1, Vector2, Vector3, Const, DimName, OPoint, OVector, Point1, Point2, Point3, Point4, Point5, Point6, Vector1,
Vector4, Vector5, Vector6, Vector2, Vector3, Vector4, Vector5, Vector6,
}; };
use simba::scalar::{ClosedDiv, SupersetOf}; use simba::scalar::{ClosedDiv, SupersetOf};
use crate::geometry::Point; use crate::geometry::Point;
/// # Other construction methods /// # Other construction methods
impl<T: Scalar, const D: usize> Point<T, D> { impl<T: Scalar, D: DimName> OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
/// Creates a new point with uninitialized coordinates. /// Creates a new point with uninitialized coordinates.
#[inline] #[inline]
pub unsafe fn new_uninitialized() -> Self { pub unsafe fn new_uninitialized() -> Self {
Self::from(crate::unimplemented_or_uninitialized_generic!( Self::from(crate::unimplemented_or_uninitialized_generic!(
Const::<D>, Const::<1> D::name(),
Const::<1>
)) ))
} }
@ -49,7 +53,7 @@ impl<T: Scalar, const D: usize> Point<T, D> {
where where
T: Zero, T: Zero,
{ {
Self::from(SVector::from_element(T::zero())) Self::from(OVector::from_element(T::zero()))
} }
/// Creates a new point from a slice. /// Creates a new point from a slice.
@ -68,7 +72,7 @@ impl<T: Scalar, const D: usize> Point<T, D> {
/// ``` /// ```
#[inline] #[inline]
pub fn from_slice(components: &[T]) -> Self { pub fn from_slice(components: &[T]) -> Self {
Self::from(SVector::from_row_slice(components)) Self::from(OVector::from_row_slice(components))
} }
/// Creates a new point from its homogeneous vector representation. /// Creates a new point from its homogeneous vector representation.
@ -102,14 +106,15 @@ impl<T: Scalar, const D: usize> Point<T, D> {
/// assert_eq!(pt, Some(Point2::new(1.0, 2.0))); /// assert_eq!(pt, Some(Point2::new(1.0, 2.0)));
/// ``` /// ```
#[inline] #[inline]
pub fn from_homogeneous(v: OVector<T, DimNameSum<Const<D>, U1>>) -> Option<Self> pub fn from_homogeneous(v: OVector<T, DimNameSum<D, U1>>) -> Option<Self>
where where
T: Scalar + Zero + One + ClosedDiv, T: Scalar + Zero + One + ClosedDiv,
Const<D>: DimNameAdd<U1>, D: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>>, DefaultAllocator: Allocator<T, DimNameSum<D, U1>>,
{ {
if !v[D].is_zero() { if !v[D::dim()].is_zero() {
let coords = v.fixed_slice::<D, 1>(0, 0) / v[D].inlined_clone(); let coords =
v.generic_slice((0, 0), (D::name(), Const::<1>)) / v[D::dim()].inlined_clone();
Some(Self::from(coords)) Some(Self::from(coords))
} else { } else {
None None
@ -125,9 +130,10 @@ impl<T: Scalar, const D: usize> Point<T, D> {
/// let pt2 = pt.cast::<f32>(); /// let pt2 = pt.cast::<f32>();
/// assert_eq!(pt2, Point2::new(1.0f32, 2.0)); /// assert_eq!(pt2, Point2::new(1.0f32, 2.0));
/// ``` /// ```
pub fn cast<To: Scalar>(self) -> Point<To, D> pub fn cast<To: Scalar>(self) -> OPoint<To, D>
where where
Point<To, D>: SupersetOf<Self>, OPoint<To, D>: SupersetOf<Self>,
DefaultAllocator: Allocator<To, D>,
{ {
crate::convert(self) crate::convert(self)
} }
@ -138,38 +144,43 @@ impl<T: Scalar, const D: usize> Point<T, D> {
* Traits that build points. * Traits that build points.
* *
*/ */
impl<T: Scalar + Bounded, const D: usize> Bounded for Point<T, D> { impl<T: Scalar + Bounded, D: DimName> Bounded for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
#[inline] #[inline]
fn max_value() -> Self { fn max_value() -> Self {
Self::from(SVector::max_value()) Self::from(OVector::max_value())
} }
#[inline] #[inline]
fn min_value() -> Self { fn min_value() -> Self {
Self::from(SVector::min_value()) Self::from(OVector::min_value())
} }
} }
#[cfg(feature = "rand-no-std")] #[cfg(feature = "rand-no-std")]
impl<T: Scalar, const D: usize> Distribution<Point<T, D>> for Standard impl<T: Scalar, D: DimName> Distribution<OPoint<T, D>> for Standard
where where
Standard: Distribution<T>, Standard: Distribution<T>,
DefaultAllocator: Allocator<T, D>,
{ {
/// Generate a `Point` where each coordinate is an independent variate from `[0, 1)`. /// Generate a `Point` where each coordinate is an independent variate from `[0, 1)`.
#[inline] #[inline]
fn sample<'a, G: Rng + ?Sized>(&self, rng: &mut G) -> Point<T, D> { fn sample<'a, G: Rng + ?Sized>(&self, rng: &mut G) -> OPoint<T, D> {
Point::from(rng.gen::<SVector<T, D>>()) OPoint::from(rng.gen::<OVector<T, D>>())
} }
} }
#[cfg(feature = "arbitrary")] #[cfg(feature = "arbitrary")]
impl<T: Scalar + Arbitrary + Send, const D: usize> Arbitrary for Point<T, D> impl<T: Scalar + Arbitrary + Send, D: DimName> Arbitrary for OPoint<T, D>
where where
<DefaultAllocator as Allocator<T, Const<D>>>::Buffer: Send, <DefaultAllocator as Allocator<T, D>>::Buffer: Send,
DefaultAllocator: Allocator<T, D>,
{ {
#[inline] #[inline]
fn arbitrary(g: &mut Gen) -> Self { fn arbitrary(g: &mut Gen) -> Self {
Self::from(SVector::arbitrary(g)) Self::from(OVector::arbitrary(g))
} }
} }
@ -181,7 +192,7 @@ where
// NOTE: the impl for Point1 is not with the others so that we // NOTE: the impl for Point1 is not with the others so that we
// can add a section with the impl block comment. // can add a section with the impl block comment.
/// # Construction from individual components /// # Construction from individual components
impl<T> Point1<T> { impl<T: Scalar> Point1<T> {
/// Initializes this point from its components. /// Initializes this point from its components.
/// ///
/// # Example /// # Example
@ -192,7 +203,7 @@ impl<T> Point1<T> {
/// assert_eq!(p.x, 1.0); /// assert_eq!(p.x, 1.0);
/// ``` /// ```
#[inline] #[inline]
pub const fn new(x: T) -> Self { pub fn new(x: T) -> Self {
Point { Point {
coords: Vector1::new(x), coords: Vector1::new(x),
} }
@ -200,13 +211,13 @@ impl<T> Point1<T> {
} }
macro_rules! componentwise_constructors_impl( macro_rules! componentwise_constructors_impl(
($($doc: expr; $Point: ident, $Vector: ident, $($args: ident:$irow: expr),*);* $(;)*) => {$( ($($doc: expr; $Point: ident, $Vector: ident, $($args: ident:$irow: expr),*);* $(;)*) => {$(
impl<T> $Point<T> { impl<T: Scalar> $Point<T> {
#[doc = "Initializes this point from its components."] #[doc = "Initializes this point from its components."]
#[doc = "# Example\n```"] #[doc = "# Example\n```"]
#[doc = $doc] #[doc = $doc]
#[doc = "```"] #[doc = "```"]
#[inline] #[inline]
pub const fn new($($args: T),*) -> Self { pub fn new($($args: T),*) -> Self {
Point { coords: $Vector::new($($args),*) } Point { coords: $Vector::new($($args),*) }
} }
} }

58
src/geometry/point_conversion.rs
View File

@ -7,6 +7,7 @@ use crate::base::dimension::{DimNameAdd, DimNameSum, U1};
use crate::base::{Const, DefaultAllocator, Matrix, OVector, Scalar}; use crate::base::{Const, DefaultAllocator, Matrix, OVector, Scalar};
use crate::geometry::Point; use crate::geometry::Point;
use crate::{DimName, OPoint};
/* /*
* This file provides the following conversions: * This file provides the following conversions:
@ -16,67 +17,69 @@ use crate::geometry::Point;
* Point -> Vector (homogeneous) * Point -> Vector (homogeneous)
*/ */
impl<T1, T2, const D: usize> SubsetOf<Point<T2, D>> for Point<T1, D> impl<T1, T2, D: DimName> SubsetOf<OPoint<T2, D>> for OPoint<T1, D>
where where
T1: Scalar, T1: Scalar,
T2: Scalar + SupersetOf<T1>, T2: Scalar + SupersetOf<T1>,
DefaultAllocator: Allocator<T1, D> + Allocator<T2, D>,
{ {
#[inline] #[inline]
fn to_superset(&self) -> Point<T2, D> { fn to_superset(&self) -> OPoint<T2, D> {
Point::from(self.coords.to_superset()) OPoint::from(self.coords.to_superset())
} }
#[inline] #[inline]
fn is_in_subset(m: &Point<T2, D>) -> bool { fn is_in_subset(m: &OPoint<T2, D>) -> bool {
// TODO: is there a way to reuse the `.is_in_subset` from the matrix implementation of // TODO: is there a way to reuse the `.is_in_subset` from the matrix implementation of
// SubsetOf? // SubsetOf?
m.iter().all(|e| e.is_in_subset()) m.iter().all(|e| e.is_in_subset())
} }
#[inline] #[inline]
fn from_superset_unchecked(m: &Point<T2, D>) -> Self { fn from_superset_unchecked(m: &OPoint<T2, D>) -> Self {
Self::from(Matrix::from_superset_unchecked(&m.coords)) Self::from(Matrix::from_superset_unchecked(&m.coords))
} }
} }
impl<T1, T2, const D: usize> SubsetOf<OVector<T2, DimNameSum<Const<D>, U1>>> for Point<T1, D> impl<T1, T2, D> SubsetOf<OVector<T2, DimNameSum<D, U1>>> for OPoint<T1, D>
where where
Const<D>: DimNameAdd<U1>, D: DimNameAdd<U1>,
T1: Scalar, T1: Scalar,
T2: Scalar + Zero + One + ClosedDiv + SupersetOf<T1>, T2: Scalar + Zero + One + ClosedDiv + SupersetOf<T1>,
DefaultAllocator: DefaultAllocator: Allocator<T1, D>
Allocator<T1, DimNameSum<Const<D>, U1>> + Allocator<T2, DimNameSum<Const<D>, U1>>, + Allocator<T2, D>
+ Allocator<T1, DimNameSum<D, U1>>
+ Allocator<T2, DimNameSum<D, U1>>,
// + Allocator<T1, D> // + Allocator<T1, D>
// + Allocator<T2, D>, // + Allocator<T2, D>,
{ {
#[inline] #[inline]
fn to_superset(&self) -> OVector<T2, DimNameSum<Const<D>, U1>> { fn to_superset(&self) -> OVector<T2, DimNameSum<D, U1>> {
let p: Point<T2, D> = self.to_superset(); let p: OPoint<T2, D> = self.to_superset();
p.to_homogeneous() p.to_homogeneous()
} }
#[inline] #[inline]
fn is_in_subset(v: &OVector<T2, DimNameSum<Const<D>, U1>>) -> bool { fn is_in_subset(v: &OVector<T2, DimNameSum<D, U1>>) -> bool {
crate::is_convertible::<_, OVector<T1, DimNameSum<Const<D>, U1>>>(v) && !v[D].is_zero() crate::is_convertible::<_, OVector<T1, DimNameSum<D, U1>>>(v) && !v[D::dim()].is_zero()
} }
#[inline] #[inline]
fn from_superset_unchecked(v: &OVector<T2, DimNameSum<Const<D>, U1>>) -> Self { fn from_superset_unchecked(v: &OVector<T2, DimNameSum<D, U1>>) -> Self {
let coords = v.fixed_slice::<D, 1>(0, 0) / v[D].inlined_clone(); let coords = v.generic_slice((0, 0), (D::name(), Const::<1>)) / v[D::dim()].inlined_clone();
Self { Self {
coords: crate::convert_unchecked(coords), coords: crate::convert_unchecked(coords),
} }
} }
} }
impl<T: Scalar + Zero + One, const D: usize> From<Point<T, D>> impl<T: Scalar + Zero + One, D: DimName> From<OPoint<T, D>> for OVector<T, DimNameSum<D, U1>>
for OVector<T, DimNameSum<Const<D>, U1>>
where where
Const<D>: DimNameAdd<U1>, D: DimNameAdd<U1>,
DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>>, DefaultAllocator: Allocator<T, DimNameSum<D, U1>> + Allocator<T, D>,
{ {
#[inline] #[inline]
fn from(t: Point<T, D>) -> Self { fn from(t: OPoint<T, D>) -> Self {
t.to_homogeneous() t.to_homogeneous()
} }
} }
@ -90,17 +93,20 @@ impl<T: Scalar, const D: usize> From<[T; D]> for Point<T, D> {
} }
} }
impl<T: Scalar, const D: usize> Into<[T; D]> for Point<T, D> { impl<T: Scalar, const D: usize> From<Point<T, D>> for [T; D] {
#[inline] #[inline]
fn into(self) -> [T; D] { fn from(p: Point<T, D>) -> Self {
self.coords.into() p.coords.into()
} }
} }
impl<T: Scalar, const D: usize> From<OVector<T, Const<D>>> for Point<T, D> { impl<T: Scalar, D: DimName> From<OVector<T, D>> for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
#[inline] #[inline]
fn from(coords: OVector<T, Const<D>>) -> Self { fn from(coords: OVector<T, D>) -> Self {
Point { coords } OPoint { coords }
} }
} }

22
src/geometry/point_coordinates.rs
View File

@ -1,9 +1,9 @@
use std::ops::{Deref, DerefMut}; use std::ops::{Deref, DerefMut};
use crate::base::coordinates::{X, XY, XYZ, XYZW, XYZWA, XYZWAB}; use crate::base::coordinates::{X, XY, XYZ, XYZW, XYZWA, XYZWAB};
use crate::base::Scalar; use crate::base::{Scalar, U1, U2, U3, U4, U5, U6};
use crate::geometry::Point; use crate::geometry::OPoint;
/* /*
* *
@ -12,8 +12,8 @@ use crate::geometry::Point;
*/ */
macro_rules! deref_impl( macro_rules! deref_impl(
($D: expr, $Target: ident $(, $comps: ident)*) => { ($D: ty, $Target: ident $(, $comps: ident)*) => {
impl<T: Scalar> Deref for Point<T, $D> impl<T: Scalar> Deref for OPoint<T, $D>
{ {
type Target = $Target<T>; type Target = $Target<T>;
@ -23,7 +23,7 @@ macro_rules! deref_impl(
} }
} }
impl<T: Scalar> DerefMut for Point<T, $D> impl<T: Scalar> DerefMut for OPoint<T, $D>
{ {
#[inline] #[inline]
fn deref_mut(&mut self) -> &mut Self::Target { fn deref_mut(&mut self) -> &mut Self::Target {
@ -33,9 +33,9 @@ macro_rules! deref_impl(
} }
); );
deref_impl!(1, X, x); deref_impl!(U1, X, x);
deref_impl!(2, XY, x, y); deref_impl!(U2, XY, x, y);
deref_impl!(3, XYZ, x, y, z); deref_impl!(U3, XYZ, x, y, z);
deref_impl!(4, XYZW, x, y, z, w); deref_impl!(U4, XYZW, x, y, z, w);
deref_impl!(5, XYZWA, x, y, z, w, a); deref_impl!(U5, XYZWA, x, y, z, w, a);
deref_impl!(6, XYZWAB, x, y, z, w, a, b); deref_impl!(U6, XYZWAB, x, y, z, w, a, b);

180
src/geometry/point_ops.rs
View File

@ -8,18 +8,23 @@ use simba::scalar::{ClosedAdd, ClosedDiv, ClosedMul, ClosedNeg, ClosedSub};
use crate::base::constraint::{ use crate::base::constraint::{
AreMultipliable, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint, AreMultipliable, SameNumberOfColumns, SameNumberOfRows, ShapeConstraint,
}; };
use crate::base::dimension::{Dim, U1}; use crate::base::dimension::{Dim, DimName, U1};
use crate::base::storage::Storage; use crate::base::storage::Storage;
use crate::base::{Const, Matrix, SVector, Scalar, Vector}; use crate::base::{Const, Matrix, OVector, Scalar, Vector};
use crate::geometry::Point; use crate::allocator::Allocator;
use crate::geometry::{OPoint, Point};
use crate::DefaultAllocator;
/* /*
* *
* Indexing. * Indexing.
* *
*/ */
impl<T: Scalar, const D: usize> Index<usize> for Point<T, D> { impl<T: Scalar, D: DimName> Index<usize> for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
type Output = T; type Output = T;
#[inline] #[inline]
@ -28,7 +33,10 @@ impl<T: Scalar, const D: usize> Index<usize> for Point<T, D> {
} }
} }
impl<T: Scalar, const D: usize> IndexMut<usize> for Point<T, D> { impl<T: Scalar, D: DimName> IndexMut<usize> for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
#[inline] #[inline]
fn index_mut(&mut self, i: usize) -> &mut Self::Output { fn index_mut(&mut self, i: usize) -> &mut Self::Output {
&mut self.coords[i] &mut self.coords[i]
@ -40,7 +48,10 @@ impl<T: Scalar, const D: usize> IndexMut<usize> for Point<T, D> {
* Neg. * Neg.
* *
*/ */
impl<T: Scalar + ClosedNeg, const D: usize> Neg for Point<T, D> { impl<T: Scalar + ClosedNeg, D: DimName> Neg for OPoint<T, D>
where
DefaultAllocator: Allocator<T, D>,
{
type Output = Self; type Output = Self;
#[inline] #[inline]
@ -49,8 +60,11 @@ impl<T: Scalar + ClosedNeg, const D: usize> Neg for Point<T, D> {
} }
} }
impl<'a, T: Scalar + ClosedNeg, const D: usize> Neg for &'a Point<T, D> { impl<'a, T: Scalar + ClosedNeg, D: DimName> Neg for &'a OPoint<T, D>
type Output = Point<T, D>; where
DefaultAllocator: Allocator<T, D>,
{
type Output = OPoint<T, D>;
#[inline] #[inline]
fn neg(self) -> Self::Output { fn neg(self) -> Self::Output {
@ -66,102 +80,103 @@ impl<'a, T: Scalar + ClosedNeg, const D: usize> Neg for &'a Point<T, D> {
// Point - Point // Point - Point
add_sub_impl!(Sub, sub, ClosedSub; add_sub_impl!(Sub, sub, ClosedSub;
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1) (D, U1), (D, U1) -> (D, U1)
const D; for; where; const; for D; where D: DimName, DefaultAllocator: Allocator<T, D>;
self: &'a Point<T, D>, right: &'b Point<T, D>, Output = SVector<T, D>; self: &'a OPoint<T, D>, right: &'b OPoint<T, D>, Output = OVector<T, D>;
&self.coords - &right.coords; 'a, 'b); &self.coords - &right.coords; 'a, 'b);
add_sub_impl!(Sub, sub, ClosedSub; add_sub_impl!(Sub, sub, ClosedSub;
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1) (D, U1), (D, U1) -> (D, U1)
const D; for; where; const; for D; where D: DimName, DefaultAllocator: Allocator<T, D>;
self: &'a Point<T, D>, right: Point<T, D>, Output = SVector<T, D>; self: &'a OPoint<T, D>, right: OPoint<T, D>, Output = OVector<T, D>;
&self.coords - right.coords; 'a); &self.coords - right.coords; 'a);
add_sub_impl!(Sub, sub, ClosedSub; add_sub_impl!(Sub, sub, ClosedSub;
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1) (D, U1), (D, U1) -> (D, U1)
const D; for; where; const; for D; where D: DimName, DefaultAllocator: Allocator<T, D>;
self: Point<T, D>, right: &'b Point<T, D>, Output = SVector<T, D>; self: OPoint<T, D>, right: &'b OPoint<T, D>, Output = OVector<T, D>;
self.coords - &right.coords; 'b); self.coords - &right.coords; 'b);
add_sub_impl!(Sub, sub, ClosedSub; add_sub_impl!(Sub, sub, ClosedSub;
(Const<D>, U1), (Const<D>, U1) -> (Const<D>, U1) (D, U1), (D, U1) -> (D, U1)
const D; for; where; const; for D; where D: DimName, DefaultAllocator: Allocator<T, D>;
self: Point<T, D>, right: Point<T, D>, Output = SVector<T, D>; self: OPoint<T, D>, right: OPoint<T, D>, Output = OVector<T, D>;
self.coords - right.coords; ); self.coords - right.coords; );
// Point - Vector // Point - Vector
add_sub_impl!(Sub, sub, ClosedSub; add_sub_impl!(Sub, sub, ClosedSub;
(Const<D1>, U1), (D2, U1) -> (Const<D1>, U1) (D1, U1), (D2, U1) -> (D1, U1)
const D1; const;
for D2, SB; for D1, D2, SB;
where D2: Dim, SB: Storage<T, D2>; where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
self: &'a Point<T, D1>, right: &'b Vector<T, D2, SB>, Output = Point<T, D1>; self: &'a OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
Self::Output::from(&self.coords - right); 'a, 'b); Self::Output::from(&self.coords - right); 'a, 'b);
add_sub_impl!(Sub, sub, ClosedSub; add_sub_impl!(Sub, sub, ClosedSub;
(Const<D1>, U1), (D2, U1) -> (Const<D1>, U1) (D1, U1), (D2, U1) -> (D1, U1)
const D1; const;
for D2, SB; for D1, D2, SB;
where D2: Dim, SB: Storage<T, D2>; where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
self: &'a Point<T, D1>, right: Vector<T, D2, SB>, Output = Point<T, D1>; self: &'a OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
Self::Output::from(&self.coords - &right); 'a); // TODO: should not be a ref to `right`. Self::Output::from(&self.coords - &right); 'a); // TODO: should not be a ref to `right`.
add_sub_impl!(Sub, sub, ClosedSub; add_sub_impl!(Sub, sub, ClosedSub;
(Const<D1>, U1), (D2, U1) -> (Const<D1>, U1) (D1, U1), (D2, U1) -> (D1, U1)
const D1; const;
for D2, SB; for D1, D2, SB;
where D2: Dim, SB: Storage<T, D2>; where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
self: Point<T, D1>, right: &'b Vector<T, D2, SB>, Output = Point<T, D1>; self: OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
Self::Output::from(self.coords - right); 'b); Self::Output::from(self.coords - right); 'b);
add_sub_impl!(Sub, sub, ClosedSub; add_sub_impl!(Sub, sub, ClosedSub;
(Const<D1>, U1), (D2, U1) -> (Const<D1>, U1) (D1, U1), (D2, U1) -> (D1, U1)
const D1; const;
for D2, SB; for D1, D2, SB;
where D2: Dim, SB: Storage<T, D2>; where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
self: Point<T, D1>, right: Vector<T, D2, SB>, Output = Point<T, D1>; self: OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
Self::Output::from(self.coords - right); ); Self::Output::from(self.coords - right); );
// Point + Vector // Point + Vector
add_sub_impl!(Add, add, ClosedAdd; add_sub_impl!(Add, add, ClosedAdd;
(Const<D1>, U1), (D2, U1) -> (Const<D1>, U1) (D1, U1), (D2, U1) -> (D1, U1)
const D1; const;
for D2, SB; for D1, D2, SB;
where D2: Dim, SB: Storage<T, D2>; where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
self: &'a Point<T, D1>, right: &'b Vector<T, D2, SB>, Output = Point<T, D1>; self: &'a OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
Self::Output::from(&self.coords + right); 'a, 'b); Self::Output::from(&self.coords + right); 'a, 'b);
add_sub_impl!(Add, add, ClosedAdd; add_sub_impl!(Add, add, ClosedAdd;
(Const<D1>, U1), (D2, U1) -> (Const<D1>, U1) (D1, U1), (D2, U1) -> (D1, U1)
const D1; const;
for D2, SB; for D1, D2, SB;
where D2: Dim, SB: Storage<T, D2>; where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
self: &'a Point<T, D1>, right: Vector<T, D2, SB>, Output = Point<T, D1>; self: &'a OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
Self::Output::from(&self.coords + &right); 'a); // TODO: should not be a ref to `right`. Self::Output::from(&self.coords + &right); 'a); // TODO: should not be a ref to `right`.
add_sub_impl!(Add, add, ClosedAdd; add_sub_impl!(Add, add, ClosedAdd;
(Const<D1>, U1), (D2, U1) -> (Const<D1>, U1) (D1, U1), (D2, U1) -> (D1, U1)
const D1; const;
for D2, SB; for D1, D2, SB;
where D2: Dim, SB: Storage<T, D2>; where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
self: Point<T, D1>, right: &'b Vector<T, D2, SB>, Output = Point<T, D1>; self: OPoint<T, D1>, right: &'b Vector<T, D2, SB>, Output = OPoint<T, D1>;
Self::Output::from(self.coords + right); 'b); Self::Output::from(self.coords + right); 'b);
add_sub_impl!(Add, add, ClosedAdd; add_sub_impl!(Add, add, ClosedAdd;
(Const<D1>, U1), (D2, U1) -> (Const<D1>, U1) (D1, U1), (D2, U1) -> (D1, U1)
const D1; const;
for D2, SB; for D1, D2, SB;
where D2: Dim, SB: Storage<T, D2>; where D1: DimName, D2: Dim, SB: Storage<T, D2>, DefaultAllocator: Allocator<T, D1>;
self: Point<T, D1>, right: Vector<T, D2, SB>, Output = Point<T, D1>; self: OPoint<T, D1>, right: Vector<T, D2, SB>, Output = OPoint<T, D1>;
Self::Output::from(self.coords + right); ); Self::Output::from(self.coords + right); );
// TODO: replace by the shared macro: add_sub_assign_impl? // TODO: replace by the shared macro: add_sub_assign_impl?
macro_rules! op_assign_impl( macro_rules! op_assign_impl(
($($TraitAssign: ident, $method_assign: ident, $bound: ident);* $(;)*) => {$( ($($TraitAssign: ident, $method_assign: ident, $bound: ident);* $(;)*) => {$(
impl<'b, T, D2: Dim, SB, const D1: usize> $TraitAssign<&'b Vector<T, D2, SB>> for Point<T, D1> impl<'b, T, D1: DimName, D2: Dim, SB> $TraitAssign<&'b Vector<T, D2, SB>> for OPoint<T, D1>
where T: Scalar + $bound, where T: Scalar + $bound,
SB: Storage<T, D2>, SB: Storage<T, D2>,
ShapeConstraint: SameNumberOfRows<Const<D1>, D2> { ShapeConstraint: SameNumberOfRows<D1, D2>,
DefaultAllocator: Allocator<T, D1> {
#[inline] #[inline]
fn $method_assign(&mut self, right: &'b Vector<T, D2, SB>) { fn $method_assign(&mut self, right: &'b Vector<T, D2, SB>) {
@ -169,10 +184,11 @@ macro_rules! op_assign_impl(
} }
} }
impl<T, D2: Dim, SB, const D1: usize> $TraitAssign<Vector<T, D2, SB>> for Point<T, D1> impl<T, D1: DimName, D2: Dim, SB> $TraitAssign<Vector<T, D2, SB>> for OPoint<T, D1>
where T: Scalar + $bound, where T: Scalar + $bound,
SB: Storage<T, D2>, SB: Storage<T, D2>,
ShapeConstraint: SameNumberOfRows<Const<D1>, D2> { ShapeConstraint: SameNumberOfRows<D1, D2>,
DefaultAllocator: Allocator<T, D1> {
#[inline] #[inline]
fn $method_assign(&mut self, right: Vector<T, D2, SB>) { fn $method_assign(&mut self, right: Vector<T, D2, SB>) {
@ -214,28 +230,30 @@ md_impl_all!(
macro_rules! componentwise_scalarop_impl( macro_rules! componentwise_scalarop_impl(
($Trait: ident, $method: ident, $bound: ident; ($Trait: ident, $method: ident, $bound: ident;
$TraitAssign: ident, $method_assign: ident) => { $TraitAssign: ident, $method_assign: ident) => {
impl<T: Scalar + $bound, const D: usize> $Trait<T> for Point<T, D> impl<T: Scalar + $bound, D: DimName> $Trait<T> for OPoint<T, D>
where DefaultAllocator: Allocator<T, D>
{ {
type Output = Point<T, D>; type Output = OPoint<T, D>;
#[inline] #[inline]
fn $method(self, right: T) -> Self::Output { fn $method(self, right: T) -> Self::Output {
Point::from(self.coords.$method(right)) OPoint::from(self.coords.$method(right))
} }
} }
impl<'a, T: Scalar + $bound, const D: usize> $Trait<T> for &'a Point<T, D> impl<'a, T: Scalar + $bound, D: DimName> $Trait<T> for &'a OPoint<T, D>
where DefaultAllocator: Allocator<T, D>
{ {
type Output = Point<T, D>; type Output = OPoint<T, D>;
#[inline] #[inline]
fn $method(self, right: T) -> Self::Output { fn $method(self, right: T) -> Self::Output {
Point::from((&self.coords).$method(right)) OPoint::from((&self.coords).$method(right))
} }
} }
impl<T: Scalar + $bound, const D: usize> $TraitAssign<T> for Point<T, D> impl<T: Scalar + $bound, D: DimName> $TraitAssign<T> for OPoint<T, D>
/* where DefaultAllocator: Allocator<T, D> */ where DefaultAllocator: Allocator<T, D>
{ {
#[inline] #[inline]
fn $method_assign(&mut self, right: T) { fn $method_assign(&mut self, right: T) {
@ -250,23 +268,25 @@ componentwise_scalarop_impl!(Div, div, ClosedDiv; DivAssign, div_assign);
macro_rules! left_scalar_mul_impl( macro_rules! left_scalar_mul_impl(
($($T: ty),* $(,)*) => {$( ($($T: ty),* $(,)*) => {$(
impl<const D: usize> Mul<Point<$T, D>> for $T impl<D: DimName> Mul<OPoint<$T, D>> for $T
where DefaultAllocator: Allocator<$T, D>
{ {
type Output = Point<$T, D>; type Output = OPoint<$T, D>;
#[inline] #[inline]
fn mul(self, right: Point<$T, D>) -> Self::Output { fn mul(self, right: OPoint<$T, D>) -> Self::Output {
Point::from(self * right.coords) OPoint::from(self * right.coords)
} }
} }
impl<'b, const D: usize> Mul<&'b Point<$T, D>> for $T impl<'b, D: DimName> Mul<&'b OPoint<$T, D>> for $T
where DefaultAllocator: Allocator<$T, D>
{ {
type Output = Point<$T, D>; type Output = OPoint<$T, D>;
#[inline] #[inline]
fn mul(self, right: &'b Point<$T, D>) -> Self::Output { fn mul(self, right: &'b OPoint<$T, D>) -> Self::Output {
Point::from(self * &right.coords) OPoint::from(self * &right.coords)
} }
} }
)*} )*}

69
src/geometry/quaternion.rs
View File

@ -139,7 +139,7 @@ mod rkyv_impl {
impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Quaternion<T> { impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Quaternion<T> {
fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> { fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
Ok(self.coords.serialize(serializer)?) self.coords.serialize(serializer)
} }
} }
@ -191,6 +191,7 @@ where
/// The imaginary part of this quaternion. /// The imaginary part of this quaternion.
#[inline] #[inline]
#[must_use]
pub fn imag(&self) -> Vector3<T> { pub fn imag(&self) -> Vector3<T> {
self.coords.xyz() self.coords.xyz()
} }
@ -223,6 +224,7 @@ where
/// assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(1.9, 3.8, 5.7, 7.6)); /// assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(1.9, 3.8, 5.7, 7.6));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn lerp(&self, other: &Self, t: T) -> Self { pub fn lerp(&self, other: &Self, t: T) -> Self {
self * (T::one() - t) + other * t self * (T::one() - t) + other * t
} }
@ -238,6 +240,7 @@ where
/// assert_eq!(q.vector()[2], 4.0); /// assert_eq!(q.vector()[2], 4.0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn vector(&self) -> MatrixSlice<T, U3, U1, RStride<T, U4, U1>, CStride<T, U4, U1>> { pub fn vector(&self) -> MatrixSlice<T, U3, U1, RStride<T, U4, U1>, CStride<T, U4, U1>> {
self.coords.fixed_rows::<3>(0) self.coords.fixed_rows::<3>(0)
} }
@ -251,6 +254,7 @@ where
/// assert_eq!(q.scalar(), 1.0); /// assert_eq!(q.scalar(), 1.0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn scalar(&self) -> T { pub fn scalar(&self) -> T {
self.coords[3] self.coords[3]
} }
@ -266,6 +270,7 @@ where
/// assert_eq!(*q.as_vector(), Vector4::new(2.0, 3.0, 4.0, 1.0)); /// assert_eq!(*q.as_vector(), Vector4::new(2.0, 3.0, 4.0, 1.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn as_vector(&self) -> &Vector4<T> { pub fn as_vector(&self) -> &Vector4<T> {
&self.coords &self.coords
} }
@ -280,6 +285,7 @@ where
/// assert_relative_eq!(q.norm(), 5.47722557, epsilon = 1.0e-6); /// assert_relative_eq!(q.norm(), 5.47722557, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn norm(&self) -> T { pub fn norm(&self) -> T {
self.coords.norm() self.coords.norm()
} }
@ -297,6 +303,7 @@ where
/// assert_relative_eq!(q.magnitude(), 5.47722557, epsilon = 1.0e-6); /// assert_relative_eq!(q.magnitude(), 5.47722557, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn magnitude(&self) -> T { pub fn magnitude(&self) -> T {
self.norm() self.norm()
} }
@ -310,6 +317,7 @@ where
/// assert_eq!(q.magnitude_squared(), 30.0); /// assert_eq!(q.magnitude_squared(), 30.0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn norm_squared(&self) -> T { pub fn norm_squared(&self) -> T {
self.coords.norm_squared() self.coords.norm_squared()
} }
@ -326,6 +334,7 @@ where
/// assert_eq!(q.magnitude_squared(), 30.0); /// assert_eq!(q.magnitude_squared(), 30.0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn magnitude_squared(&self) -> T { pub fn magnitude_squared(&self) -> T {
self.norm_squared() self.norm_squared()
} }
@ -340,6 +349,7 @@ where
/// assert_eq!(q1.dot(&q2), 70.0); /// assert_eq!(q1.dot(&q2), 70.0);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn dot(&self, rhs: &Self) -> T { pub fn dot(&self, rhs: &Self) -> T {
self.coords.dot(&rhs.coords) self.coords.dot(&rhs.coords)
} }
@ -409,6 +419,7 @@ where
/// let result = a.inner(&b); /// let result = a.inner(&b);
/// assert_relative_eq!(expected, result, epsilon = 1.0e-5); /// assert_relative_eq!(expected, result, epsilon = 1.0e-5);
#[inline] #[inline]
#[must_use]
pub fn inner(&self, other: &Self) -> Self { pub fn inner(&self, other: &Self) -> Self {
(self * other + other * self).half() (self * other + other * self).half()
} }
@ -428,6 +439,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-5); /// assert_relative_eq!(expected, result, epsilon = 1.0e-5);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn outer(&self, other: &Self) -> Self { pub fn outer(&self, other: &Self) -> Self {
#[allow(clippy::eq_op)] #[allow(clippy::eq_op)]
(self * other - other * self).half() (self * other - other * self).half()
@ -448,6 +460,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-5); /// assert_relative_eq!(expected, result, epsilon = 1.0e-5);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn project(&self, other: &Self) -> Option<Self> pub fn project(&self, other: &Self) -> Option<Self>
where where
T: RealField, T: RealField,
@ -470,6 +483,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-5); /// assert_relative_eq!(expected, result, epsilon = 1.0e-5);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn reject(&self, other: &Self) -> Option<Self> pub fn reject(&self, other: &Self) -> Option<Self>
where where
T: RealField, T: RealField,
@ -492,6 +506,7 @@ where
/// assert_eq!(half_ang, f32::consts::FRAC_PI_2); /// assert_eq!(half_ang, f32::consts::FRAC_PI_2);
/// assert_eq!(axis, Some(Vector3::x_axis())); /// assert_eq!(axis, Some(Vector3::x_axis()));
/// ``` /// ```
#[must_use]
pub fn polar_decomposition(&self) -> (T, T, Option<Unit<Vector3<T>>>) pub fn polar_decomposition(&self) -> (T, T, Option<Unit<Vector3<T>>>)
where where
T: RealField, T: RealField,
@ -519,6 +534,7 @@ where
/// 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)
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn ln(&self) -> Self { pub fn ln(&self) -> Self {
let n = self.norm(); let n = self.norm();
let v = self.vector(); let v = self.vector();
@ -537,6 +553,7 @@ where
/// 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)
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn exp(&self) -> Self { pub fn exp(&self) -> Self {
self.exp_eps(T::simd_default_epsilon()) self.exp_eps(T::simd_default_epsilon())
} }
@ -556,6 +573,7 @@ where
/// assert_eq!(q.exp_eps(1.0e-6), Quaternion::identity()); /// assert_eq!(q.exp_eps(1.0e-6), Quaternion::identity());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn exp_eps(&self, eps: T) -> Self { pub fn exp_eps(&self, eps: T) -> Self {
let v = self.vector(); let v = self.vector();
let nn = v.norm_squared(); let nn = v.norm_squared();
@ -579,6 +597,7 @@ where
/// 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);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn powf(&self, n: T) -> Self { pub fn powf(&self, n: T) -> Self {
(self.ln() * n).exp() (self.ln() * n).exp()
} }
@ -674,18 +693,21 @@ where
/// Calculates square of a quaternion. /// Calculates square of a quaternion.
#[inline] #[inline]
#[must_use]
pub fn squared(&self) -> Self { pub fn squared(&self) -> Self {
self * self self * self
} }
/// Divides quaternion into two. /// Divides quaternion into two.
#[inline] #[inline]
#[must_use]
pub fn half(&self) -> Self { pub fn half(&self) -> Self {
self / crate::convert(2.0f64) self / crate::convert(2.0f64)
} }
/// Calculates square root. /// Calculates square root.
#[inline] #[inline]
#[must_use]
pub fn sqrt(&self) -> Self { pub fn sqrt(&self) -> Self {
self.powf(crate::convert(0.5)) self.powf(crate::convert(0.5))
} }
@ -694,12 +716,14 @@ where
/// ///
/// A quaternion is pure if it has no real part (`self.w == 0.0`). /// A quaternion is pure if it has no real part (`self.w == 0.0`).
#[inline] #[inline]
#[must_use]
pub fn is_pure(&self) -> bool { pub fn is_pure(&self) -> bool {
self.w.is_zero() self.w.is_zero()
} }
/// Convert quaternion to pure quaternion. /// Convert quaternion to pure quaternion.
#[inline] #[inline]
#[must_use]
pub fn pure(&self) -> Self { pub fn pure(&self) -> Self {
Self::from_imag(self.imag()) Self::from_imag(self.imag())
} }
@ -708,6 +732,7 @@ where
/// ///
/// Calculates B<sup>-1</sup> * A where A = self, B = other. /// Calculates B<sup>-1</sup> * A where A = self, B = other.
#[inline] #[inline]
#[must_use]
pub fn left_div(&self, other: &Self) -> Option<Self> pub fn left_div(&self, other: &Self) -> Option<Self>
where where
T: RealField, T: RealField,
@ -730,6 +755,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// assert_relative_eq!(expected, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn right_div(&self, other: &Self) -> Option<Self> pub fn right_div(&self, other: &Self) -> Option<Self>
where where
T: RealField, T: RealField,
@ -749,6 +775,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// assert_relative_eq!(expected, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn cos(&self) -> Self { pub fn cos(&self) -> Self {
let z = self.imag().magnitude(); let z = self.imag().magnitude();
let w = -self.w.simd_sin() * z.simd_sinhc(); let w = -self.w.simd_sin() * z.simd_sinhc();
@ -766,6 +793,7 @@ where
/// assert_relative_eq!(input, result, epsilon = 1.0e-7); /// assert_relative_eq!(input, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn acos(&self) -> Self { pub fn acos(&self) -> Self {
let u = Self::from_imag(self.imag().normalize()); let u = Self::from_imag(self.imag().normalize());
let identity = Self::identity(); let identity = Self::identity();
@ -787,6 +815,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// assert_relative_eq!(expected, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn sin(&self) -> Self { pub fn sin(&self) -> Self {
let z = self.imag().magnitude(); let z = self.imag().magnitude();
let w = self.w.simd_cos() * z.simd_sinhc(); let w = self.w.simd_cos() * z.simd_sinhc();
@ -804,6 +833,7 @@ where
/// assert_relative_eq!(input, result, epsilon = 1.0e-7); /// assert_relative_eq!(input, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn asin(&self) -> Self { pub fn asin(&self) -> Self {
let u = Self::from_imag(self.imag().normalize()); let u = Self::from_imag(self.imag().normalize());
let identity = Self::identity(); let identity = Self::identity();
@ -825,6 +855,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// assert_relative_eq!(expected, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn tan(&self) -> Self pub fn tan(&self) -> Self
where where
T: RealField, T: RealField,
@ -843,6 +874,7 @@ where
/// assert_relative_eq!(input, result, epsilon = 1.0e-7); /// assert_relative_eq!(input, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn atan(&self) -> Self pub fn atan(&self) -> Self
where where
T: RealField, T: RealField,
@ -867,6 +899,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// assert_relative_eq!(expected, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn sinh(&self) -> Self { pub fn sinh(&self) -> Self {
(self.exp() - (-self).exp()).half() (self.exp() - (-self).exp()).half()
} }
@ -883,6 +916,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// assert_relative_eq!(expected, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn asinh(&self) -> Self { pub fn asinh(&self) -> Self {
let identity = Self::identity(); let identity = Self::identity();
(self + (identity + self.squared()).sqrt()).ln() (self + (identity + self.squared()).sqrt()).ln()
@ -900,6 +934,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// assert_relative_eq!(expected, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn cosh(&self) -> Self { pub fn cosh(&self) -> Self {
(self.exp() + (-self).exp()).half() (self.exp() + (-self).exp()).half()
} }
@ -916,6 +951,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// assert_relative_eq!(expected, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn acosh(&self) -> Self { pub fn acosh(&self) -> Self {
let identity = Self::identity(); let identity = Self::identity();
(self + (self + identity).sqrt() * (self - identity).sqrt()).ln() (self + (self + identity).sqrt() * (self - identity).sqrt()).ln()
@ -933,6 +969,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// assert_relative_eq!(expected, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn tanh(&self) -> Self pub fn tanh(&self) -> Self
where where
T: RealField, T: RealField,
@ -952,6 +989,7 @@ where
/// assert_relative_eq!(expected, result, epsilon = 1.0e-7); /// assert_relative_eq!(expected, result, epsilon = 1.0e-7);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn atanh(&self) -> Self { pub fn atanh(&self) -> Self {
let identity = Self::identity(); let identity = Self::identity();
((identity + self).ln() - (identity - self).ln()).half() ((identity + self).ln() - (identity - self).ln()).half()
@ -1069,6 +1107,7 @@ where
/// assert_eq!(rot.angle(), 1.78); /// assert_eq!(rot.angle(), 1.78);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn angle(&self) -> T { pub fn angle(&self) -> T {
let w = self.quaternion().scalar().simd_abs(); let w = self.quaternion().scalar().simd_abs();
self.quaternion().imag().norm().simd_atan2(w) * crate::convert(2.0f64) self.quaternion().imag().norm().simd_atan2(w) * crate::convert(2.0f64)
@ -1085,6 +1124,7 @@ where
/// assert_eq!(*axis.quaternion(), Quaternion::new(1.0, 0.0, 0.0, 0.0)); /// assert_eq!(*axis.quaternion(), Quaternion::new(1.0, 0.0, 0.0, 0.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn quaternion(&self) -> &Quaternion<T> { pub fn quaternion(&self) -> &Quaternion<T> {
self.as_ref() self.as_ref()
} }
@ -1133,6 +1173,7 @@ where
/// assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6); /// assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn angle_to(&self, other: &Self) -> T { pub fn angle_to(&self, other: &Self) -> T {
let delta = self.rotation_to(other); let delta = self.rotation_to(other);
delta.angle() delta.angle()
@ -1152,6 +1193,7 @@ where
/// assert_relative_eq!(rot_to * rot1, rot2, epsilon = 1.0e-6); /// assert_relative_eq!(rot_to * rot1, rot2, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn rotation_to(&self, other: &Self) -> Self { pub fn rotation_to(&self, other: &Self) -> Self {
other / self other / self
} }
@ -1168,6 +1210,7 @@ where
/// assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(0.9, 0.1, 0.0, 0.0)); /// assert_eq!(q1.lerp(&q2, 0.1), Quaternion::new(0.9, 0.1, 0.0, 0.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn lerp(&self, other: &Self, t: T) -> Quaternion<T> { pub fn lerp(&self, other: &Self, t: T) -> Quaternion<T> {
self.as_ref().lerp(other.as_ref(), t) self.as_ref().lerp(other.as_ref(), t)
} }
@ -1184,6 +1227,7 @@ where
/// assert_eq!(q1.nlerp(&q2, 0.1), UnitQuaternion::new_normalize(Quaternion::new(0.9, 0.1, 0.0, 0.0))); /// assert_eq!(q1.nlerp(&q2, 0.1), UnitQuaternion::new_normalize(Quaternion::new(0.9, 0.1, 0.0, 0.0)));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn nlerp(&self, other: &Self, t: T) -> Self { pub fn nlerp(&self, other: &Self, t: T) -> Self {
let mut res = self.lerp(other, t); let mut res = self.lerp(other, t);
let _ = res.normalize_mut(); let _ = res.normalize_mut();
@ -1209,6 +1253,7 @@ where
/// assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn slerp(&self, other: &Self, t: T) -> Self pub fn slerp(&self, other: &Self, t: T) -> Self
where where
T: RealField, T: RealField,
@ -1228,6 +1273,7 @@ where
/// * `epsilon`: the value below which the sinus of the angle separating both quaternion /// * `epsilon`: the value below which the sinus of the angle separating both quaternion
/// must be to return `None`. /// must be to return `None`.
#[inline] #[inline]
#[must_use]
pub fn try_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self> pub fn try_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>
where where
T: RealField, T: RealField,
@ -1287,6 +1333,7 @@ where
/// assert!(rot.axis().is_none()); /// assert!(rot.axis().is_none());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn axis(&self) -> Option<Unit<Vector3<T>>> pub fn axis(&self) -> Option<Unit<Vector3<T>>>
where where
T: RealField, T: RealField,
@ -1311,6 +1358,7 @@ where
/// assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6); /// assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn scaled_axis(&self) -> Vector3<T> pub fn scaled_axis(&self) -> Vector3<T>
where where
T: RealField, T: RealField,
@ -1339,6 +1387,7 @@ where
/// assert!(rot.axis_angle().is_none()); /// assert!(rot.axis_angle().is_none());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn axis_angle(&self) -> Option<(Unit<Vector3<T>>, T)> pub fn axis_angle(&self) -> Option<(Unit<Vector3<T>>, T)>
where where
T: RealField, T: RealField,
@ -1350,6 +1399,7 @@ where
/// ///
/// Note that this function yields a `Quaternion<T>` because it loses the unit property. /// Note that this function yields a `Quaternion<T>` because it loses the unit property.
#[inline] #[inline]
#[must_use]
pub fn exp(&self) -> Quaternion<T> { pub fn exp(&self) -> Quaternion<T> {
self.as_ref().exp() self.as_ref().exp()
} }
@ -1369,6 +1419,7 @@ where
/// assert_relative_eq!(q.ln().vector().into_owned(), axisangle, epsilon = 1.0e-6); /// assert_relative_eq!(q.ln().vector().into_owned(), axisangle, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn ln(&self) -> Quaternion<T> pub fn ln(&self) -> Quaternion<T>
where where
T: RealField, T: RealField,
@ -1397,6 +1448,7 @@ where
/// assert_eq!(pow.angle(), 2.4); /// assert_eq!(pow.angle(), 2.4);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn powf(&self, n: T) -> Self pub fn powf(&self, n: T) -> Self
where where
T: RealField, T: RealField,
@ -1425,7 +1477,8 @@ where
/// assert_relative_eq!(*rot.matrix(), expected, epsilon = 1.0e-6); /// assert_relative_eq!(*rot.matrix(), expected, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
pub fn to_rotation_matrix(&self) -> Rotation<T, 3> { #[must_use]
pub fn to_rotation_matrix(self) -> Rotation<T, 3> {
let i = self.as_ref()[0]; let i = self.as_ref()[0];
let j = self.as_ref()[1]; let j = self.as_ref()[1];
let k = self.as_ref()[2]; let k = self.as_ref()[2];
@ -1460,7 +1513,7 @@ where
/// The angles are produced in the form (roll, pitch, yaw). /// The angles are produced in the form (roll, pitch, yaw).
#[inline] #[inline]
#[deprecated(note = "This is renamed to use `.euler_angles()`.")] #[deprecated(note = "This is renamed to use `.euler_angles()`.")]
pub fn to_euler_angles(&self) -> (T, T, T) pub fn to_euler_angles(self) -> (T, T, T)
where where
T: RealField, T: RealField,
{ {
@ -1482,6 +1535,7 @@ where
/// assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6); /// assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn euler_angles(&self) -> (T, T, T) pub fn euler_angles(&self) -> (T, T, T)
where where
T: RealField, T: RealField,
@ -1506,7 +1560,8 @@ where
/// assert_relative_eq!(rot.to_homogeneous(), expected, epsilon = 1.0e-6); /// assert_relative_eq!(rot.to_homogeneous(), expected, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
pub fn to_homogeneous(&self) -> Matrix4<T> { #[must_use]
pub fn to_homogeneous(self) -> Matrix4<T> {
self.to_rotation_matrix().to_homogeneous() self.to_rotation_matrix().to_homogeneous()
} }
@ -1526,6 +1581,7 @@ where
/// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_point(&self, pt: &Point3<T>) -> Point3<T> { pub fn transform_point(&self, pt: &Point3<T>) -> Point3<T> {
self * pt self * pt
} }
@ -1546,6 +1602,7 @@ where
/// assert_relative_eq!(transformed_vector, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_vector, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T> { pub fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
self * v self * v
} }
@ -1566,6 +1623,7 @@ where
/// assert_relative_eq!(transformed_point, Point3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, Point3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T> { pub fn inverse_transform_point(&self, pt: &Point3<T>) -> Point3<T> {
// TODO: would it be useful performancewise not to call inverse explicitly (i-e. implement // TODO: would it be useful performancewise not to call inverse explicitly (i-e. implement
// the inverse transformation explicitly here) ? // the inverse transformation explicitly here) ?
@ -1588,6 +1646,7 @@ where
/// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T> { pub fn inverse_transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
self.inverse() * v self.inverse() * v
} }
@ -1608,6 +1667,7 @@ where
/// assert_relative_eq!(transformed_vector, -Vector3::y_axis(), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_vector, -Vector3::y_axis(), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector3<T>>) -> Unit<Vector3<T>> { pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector3<T>>) -> Unit<Vector3<T>> {
self.inverse() * v self.inverse() * v
} }
@ -1616,6 +1676,7 @@ where
/// ///
/// This is faster, but approximate, way to compute `UnitQuaternion::new(axisangle) * self`. /// This is faster, but approximate, way to compute `UnitQuaternion::new(axisangle) * self`.
#[inline] #[inline]
#[must_use]
pub fn append_axisangle_linearized(&self, axisangle: &Vector3<T>) -> Self { pub fn append_axisangle_linearized(&self, axisangle: &Vector3<T>) -> Self {
let half: T = crate::convert(0.5); let half: T = crate::convert(0.5);
let q1 = self.into_inner(); let q1 = self.into_inner();

10
src/geometry/quaternion_construction.rs
View File

@ -171,7 +171,7 @@ where
Standard: Distribution<T>, Standard: Distribution<T>,
{ {
#[inline] #[inline]
fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> Quaternion<T> { fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Quaternion<T> {
Quaternion::new(rng.gen(), rng.gen(), rng.gen(), rng.gen()) Quaternion::new(rng.gen(), rng.gen(), rng.gen(), rng.gen())
} }
} }
@ -535,10 +535,10 @@ where
SC: Storage<T, U3>, SC: Storage<T, U3>,
{ {
// TODO: code duplication with Rotation. // TODO: code duplication with Rotation.
let c = na.cross(&nb); let c = na.cross(nb);
if let Some(axis) = Unit::try_new(c, T::default_epsilon()) { if let Some(axis) = Unit::try_new(c, T::default_epsilon()) {
let cos = na.dot(&nb); let cos = na.dot(nb);
// The cosinus may be out of [-1, 1] because of inaccuracies. // The cosinus may be out of [-1, 1] because of inaccuracies.
if cos <= -T::one() { if cos <= -T::one() {
@ -548,7 +548,7 @@ where
} else { } else {
Some(Self::from_axis_angle(&axis, cos.acos() * s)) Some(Self::from_axis_angle(&axis, cos.acos() * s))
} }
} else if na.dot(&nb) < T::zero() { } else if na.dot(nb) < T::zero() {
// PI // PI
// //
// The rotation axis is undefined but the angle not zero. This is not a // The rotation axis is undefined but the angle not zero. This is not a
@ -860,7 +860,7 @@ where
{ {
/// Generate a uniformly distributed random rotation quaternion. /// Generate a uniformly distributed random rotation quaternion.
#[inline] #[inline]
fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> UnitQuaternion<T> { fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> UnitQuaternion<T> {
// Ken Shoemake's Subgroup Algorithm // Ken Shoemake's Subgroup Algorithm
// Uniform random rotations. // Uniform random rotations.
// In D. Kirk, editor, Graphics Gems III, pages 124-132. Academic, New York, 1992. // In D. Kirk, editor, Graphics Gems III, pages 124-132. Academic, New York, 1992.

5
src/geometry/quaternion_coordinates.rs
View File

@ -1,4 +1,3 @@
use std::mem;
use std::ops::{Deref, DerefMut}; use std::ops::{Deref, DerefMut};
use simba::simd::SimdValue; use simba::simd::SimdValue;
@ -13,13 +12,13 @@ impl<T: Scalar + SimdValue> Deref for Quaternion<T> {
#[inline] #[inline]
fn deref(&self) -> &Self::Target { fn deref(&self) -> &Self::Target {
unsafe { mem::transmute(self) } unsafe { &*(self as *const Self as *const Self::Target) }
} }
} }
impl<T: Scalar + SimdValue> DerefMut for Quaternion<T> { impl<T: Scalar + SimdValue> DerefMut for Quaternion<T> {
#[inline] #[inline]
fn deref_mut(&mut self) -> &mut Self::Target { fn deref_mut(&mut self) -> &mut Self::Target {
unsafe { mem::transmute(self) } unsafe { &mut *(self as *mut Self as *mut Self::Target) }
} }
} }

3
src/geometry/quaternion_ops.rs
View File

@ -1,3 +1,6 @@
// The macros break if the references are taken out, for some reason.
#![allow(clippy::op_ref)]
/* /*
* This file provides: * This file provides:
* =================== * ===================

9
src/geometry/reflection.rs
View File

@ -1,5 +1,5 @@
use crate::base::constraint::{AreMultipliable, DimEq, SameNumberOfRows, ShapeConstraint}; use crate::base::constraint::{AreMultipliable, DimEq, SameNumberOfRows, ShapeConstraint};
use crate::base::{Const, Matrix, Scalar, Unit, Vector}; use crate::base::{Const, Matrix, Unit, Vector};
use crate::dimension::{Dim, U1}; use crate::dimension::{Dim, U1};
use crate::storage::{Storage, StorageMut}; use crate::storage::{Storage, StorageMut};
use simba::scalar::ComplexField; use simba::scalar::ComplexField;
@ -7,7 +7,7 @@ use simba::scalar::ComplexField;
use crate::geometry::Point; use crate::geometry::Point;
/// A reflection wrt. a plane. /// A reflection wrt. a plane.
pub struct Reflection<T: Scalar, D: Dim, S: Storage<T, D>> { pub struct Reflection<T, D, S> {
axis: Vector<T, D, S>, axis: Vector<T, D, S>,
bias: T, bias: T,
} }
@ -34,6 +34,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D>> Reflection<T, D, S> {
} }
/// The reflexion axis. /// The reflexion axis.
#[must_use]
pub fn axis(&self) -> &Vector<T, D, S> { pub fn axis(&self) -> &Vector<T, D, S> {
&self.axis &self.axis
} }
@ -89,7 +90,7 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D>> Reflection<T, D, S> {
} }
let m_two: T = crate::convert(-2.0f64); let m_two: T = crate::convert(-2.0f64);
lhs.gerc(m_two, &work, &self.axis, T::one()); lhs.gerc(m_two, work, &self.axis, T::one());
} }
/// Applies the reflection to the rows of `lhs`. /// Applies the reflection to the rows of `lhs`.
@ -110,6 +111,6 @@ impl<T: ComplexField, D: Dim, S: Storage<T, D>> Reflection<T, D, S> {
} }
let m_two = sign.scale(crate::convert(-2.0f64)); let m_two = sign.scale(crate::convert(-2.0f64));
lhs.gerc(m_two, &work, &self.axis, sign); lhs.gerc(m_two, work, &self.axis, sign);
} }
} }

15
src/geometry/rotation.rs
View File

@ -55,7 +55,7 @@ use crate::geometry::Point;
/// ///
#[repr(C)] #[repr(C)]
#[derive(Debug)] #[derive(Debug)]
pub struct Rotation<T: Scalar, const D: usize> { pub struct Rotation<T, const D: usize> {
matrix: SMatrix<T, D, D>, matrix: SMatrix<T, D, D>,
} }
@ -185,6 +185,7 @@ impl<T: Scalar, const D: usize> Rotation<T, D> {
/// assert_eq!(*rot.matrix(), expected); /// assert_eq!(*rot.matrix(), expected);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn matrix(&self) -> &SMatrix<T, D, D> { pub fn matrix(&self) -> &SMatrix<T, D, D> {
&self.matrix &self.matrix
} }
@ -198,9 +199,9 @@ impl<T: Scalar, const D: usize> Rotation<T, D> {
/// A mutable reference to the underlying matrix representation of this rotation. /// A mutable reference to the underlying matrix representation of this rotation.
/// ///
/// This is suffixed by "_unchecked" because this allows the user to replace the matrix by another one that is /// This is suffixed by "_unchecked" because this allows the user to replace the
/// non-square, non-inversible, or non-orthonormal. If one of those properties is broken, /// matrix by another one that is non-inversible or non-orthonormal. If one of
/// subsequent method calls may be UB. /// those properties is broken, subsequent method calls may return bogus results.
#[inline] #[inline]
pub fn matrix_mut_unchecked(&mut self) -> &mut SMatrix<T, D, D> { pub fn matrix_mut_unchecked(&mut self) -> &mut SMatrix<T, D, D> {
&mut self.matrix &mut self.matrix
@ -262,6 +263,7 @@ impl<T: Scalar, const D: usize> Rotation<T, D> {
/// assert_eq!(rot.to_homogeneous(), expected); /// assert_eq!(rot.to_homogeneous(), expected);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
where where
T: Zero + One, T: Zero + One,
@ -403,6 +405,7 @@ where
/// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> { pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
self * pt self * pt
} }
@ -422,6 +425,7 @@ where
/// assert_relative_eq!(transformed_vector, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_vector, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> { pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
self * v self * v
} }
@ -441,6 +445,7 @@ where
/// assert_relative_eq!(transformed_point, Point3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, Point3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> { pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
Point::from(self.inverse_transform_vector(&pt.coords)) Point::from(self.inverse_transform_vector(&pt.coords))
} }
@ -460,6 +465,7 @@ where
/// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> { pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
self.matrix().tr_mul(v) self.matrix().tr_mul(v)
} }
@ -479,6 +485,7 @@ where
/// assert_relative_eq!(transformed_vector, -Vector3::y_axis(), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_vector, -Vector3::y_axis(), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_unit_vector(&self, v: &Unit<SVector<T, D>>) -> Unit<SVector<T, D>> { pub fn inverse_transform_unit_vector(&self, v: &Unit<SVector<T, D>>) -> Unit<SVector<T, D>> {
Unit::new_unchecked(self.inverse_transform_vector(&**v)) Unit::new_unchecked(self.inverse_transform_vector(&**v))
} }

61
src/geometry/rotation_conversion.rs
View File

@ -267,10 +267,7 @@ where
{ {
#[inline] #[inline]
fn from(arr: [Rotation<T::Element, D>; 2]) -> Self { fn from(arr: [Rotation<T::Element, D>; 2]) -> Self {
Self::from_matrix_unchecked(OMatrix::from([ Self::from_matrix_unchecked(OMatrix::from([arr[0].into_inner(), arr[1].into_inner()]))
arr[0].clone().into_inner(),
arr[1].clone().into_inner(),
]))
} }
} }
@ -283,10 +280,10 @@ where
#[inline] #[inline]
fn from(arr: [Rotation<T::Element, D>; 4]) -> Self { fn from(arr: [Rotation<T::Element, D>; 4]) -> Self {
Self::from_matrix_unchecked(OMatrix::from([ Self::from_matrix_unchecked(OMatrix::from([
arr[0].clone().into_inner(), arr[0].into_inner(),
arr[1].clone().into_inner(), arr[1].into_inner(),
arr[2].clone().into_inner(), arr[2].into_inner(),
arr[3].clone().into_inner(), arr[3].into_inner(),
])) ]))
} }
} }
@ -300,14 +297,14 @@ where
#[inline] #[inline]
fn from(arr: [Rotation<T::Element, D>; 8]) -> Self { fn from(arr: [Rotation<T::Element, D>; 8]) -> Self {
Self::from_matrix_unchecked(OMatrix::from([ Self::from_matrix_unchecked(OMatrix::from([
arr[0].clone().into_inner(), arr[0].into_inner(),
arr[1].clone().into_inner(), arr[1].into_inner(),
arr[2].clone().into_inner(), arr[2].into_inner(),
arr[3].clone().into_inner(), arr[3].into_inner(),
arr[4].clone().into_inner(), arr[4].into_inner(),
arr[5].clone().into_inner(), arr[5].into_inner(),
arr[6].clone().into_inner(), arr[6].into_inner(),
arr[7].clone().into_inner(), arr[7].into_inner(),
])) ]))
} }
} }
@ -321,22 +318,22 @@ where
#[inline] #[inline]
fn from(arr: [Rotation<T::Element, D>; 16]) -> Self { fn from(arr: [Rotation<T::Element, D>; 16]) -> Self {
Self::from_matrix_unchecked(OMatrix::from([ Self::from_matrix_unchecked(OMatrix::from([
arr[0].clone().into_inner(), arr[0].into_inner(),
arr[1].clone().into_inner(), arr[1].into_inner(),
arr[2].clone().into_inner(), arr[2].into_inner(),
arr[3].clone().into_inner(), arr[3].into_inner(),
arr[4].clone().into_inner(), arr[4].into_inner(),
arr[5].clone().into_inner(), arr[5].into_inner(),
arr[6].clone().into_inner(), arr[6].into_inner(),
arr[7].clone().into_inner(), arr[7].into_inner(),
arr[8].clone().into_inner(), arr[8].into_inner(),
arr[9].clone().into_inner(), arr[9].into_inner(),
arr[10].clone().into_inner(), arr[10].into_inner(),
arr[11].clone().into_inner(), arr[11].into_inner(),
arr[12].clone().into_inner(), arr[12].into_inner(),
arr[13].clone().into_inner(), arr[13].into_inner(),
arr[14].clone().into_inner(), arr[14].into_inner(),
arr[15].clone().into_inner(), arr[15].into_inner(),
])) ]))
} }
} }

7
src/geometry/rotation_interpolation.rs
View File

@ -18,6 +18,7 @@ impl<T: SimdRealField> Rotation2<T> {
/// assert_relative_eq!(rot.angle(), std::f32::consts::FRAC_PI_2); /// assert_relative_eq!(rot.angle(), std::f32::consts::FRAC_PI_2);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn slerp(&self, other: &Self, t: T) -> Self pub fn slerp(&self, other: &Self, t: T) -> Self
where where
T::Element: SimdRealField, T::Element: SimdRealField,
@ -47,6 +48,7 @@ impl<T: SimdRealField> Rotation3<T> {
/// assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0)); /// assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn slerp(&self, other: &Self, t: T) -> Self pub fn slerp(&self, other: &Self, t: T) -> Self
where where
T: RealField, T: RealField,
@ -67,12 +69,13 @@ impl<T: SimdRealField> Rotation3<T> {
/// * `epsilon`: the value below which the sinus of the angle separating both rotations /// * `epsilon`: the value below which the sinus of the angle separating both rotations
/// must be to return `None`. /// must be to return `None`.
#[inline] #[inline]
#[must_use]
pub fn try_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self> pub fn try_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self>
where where
T: RealField, T: RealField,
{ {
let q1 = Rotation3::from(*self); let q1 = UnitQuaternion::from(*self);
let q2 = Rotation3::from(*other); let q2 = UnitQuaternion::from(*other);
q1.try_slerp(&q2, t, epsilon).map(|q| q.into()) q1.try_slerp(&q2, t, epsilon).map(|q| q.into())
} }
} }

23
src/geometry/rotation_specialization.rs
View File

@ -186,6 +186,7 @@ impl<T: SimdRealField> Rotation2<T> {
/// assert_relative_eq!(rot_to.inverse() * rot2, rot1); /// assert_relative_eq!(rot_to.inverse() * rot2, rot1);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn rotation_to(&self, other: &Self) -> Self { pub fn rotation_to(&self, other: &Self) -> Self {
other * self.inverse() other * self.inverse()
} }
@ -215,6 +216,7 @@ impl<T: SimdRealField> Rotation2<T> {
/// assert_relative_eq!(pow.angle(), 2.0 * 0.78); /// assert_relative_eq!(pow.angle(), 2.0 * 0.78);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn powf(&self, n: T) -> Self { pub fn powf(&self, n: T) -> Self {
Self::new(self.angle() * n) Self::new(self.angle() * n)
} }
@ -232,6 +234,7 @@ impl<T: SimdRealField> Rotation2<T> {
/// assert_relative_eq!(rot.angle(), 1.78); /// assert_relative_eq!(rot.angle(), 1.78);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn angle(&self) -> T { pub fn angle(&self) -> T {
self.matrix()[(1, 0)].simd_atan2(self.matrix()[(0, 0)]) self.matrix()[(1, 0)].simd_atan2(self.matrix()[(0, 0)])
} }
@ -247,6 +250,7 @@ impl<T: SimdRealField> Rotation2<T> {
/// assert_relative_eq!(rot1.angle_to(&rot2), 1.6); /// assert_relative_eq!(rot1.angle_to(&rot2), 1.6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn angle_to(&self, other: &Self) -> T { pub fn angle_to(&self, other: &Self) -> T {
self.rotation_to(other).angle() self.rotation_to(other).angle()
} }
@ -256,6 +260,7 @@ impl<T: SimdRealField> Rotation2<T> {
/// This is generally used in the context of generic programming. Using /// This is generally used in the context of generic programming. Using
/// the `.angle()` method instead is more common. /// the `.angle()` method instead is more common.
#[inline] #[inline]
#[must_use]
pub fn scaled_axis(&self) -> SVector<T, 1> { pub fn scaled_axis(&self) -> SVector<T, 1> {
Vector1::new(self.angle()) Vector1::new(self.angle())
} }
@ -269,7 +274,7 @@ where
{ {
/// Generate a uniformly distributed random rotation. /// Generate a uniformly distributed random rotation.
#[inline] #[inline]
fn sample<'a, R: Rng + ?Sized>(&self, rng: &'a mut R) -> Rotation2<T> { fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Rotation2<T> {
let twopi = Uniform::new(T::zero(), T::simd_two_pi()); let twopi = Uniform::new(T::zero(), T::simd_two_pi());
Rotation2::new(rng.sample(twopi)) Rotation2::new(rng.sample(twopi))
} }
@ -640,6 +645,7 @@ where
/// assert_relative_eq!(rot_to * rot1, rot2, epsilon = 1.0e-6); /// assert_relative_eq!(rot_to * rot1, rot2, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn rotation_to(&self, other: &Self) -> Self { pub fn rotation_to(&self, other: &Self) -> Self {
other * self.inverse() other * self.inverse()
} }
@ -659,6 +665,7 @@ where
/// assert_eq!(pow.angle(), 2.4); /// assert_eq!(pow.angle(), 2.4);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn powf(&self, n: T) -> Self pub fn powf(&self, n: T) -> Self
where where
T: RealField, T: RealField,
@ -765,6 +772,7 @@ impl<T: SimdRealField> Rotation3<T> {
/// assert_relative_eq!(rot.angle(), 1.78); /// assert_relative_eq!(rot.angle(), 1.78);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn angle(&self) -> T { pub fn angle(&self) -> T {
((self.matrix()[(0, 0)] + self.matrix()[(1, 1)] + self.matrix()[(2, 2)] - T::one()) ((self.matrix()[(0, 0)] + self.matrix()[(1, 1)] + self.matrix()[(2, 2)] - T::one())
/ crate::convert(2.0)) / crate::convert(2.0))
@ -787,6 +795,7 @@ impl<T: SimdRealField> Rotation3<T> {
/// assert!(rot.axis().is_none()); /// assert!(rot.axis().is_none());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn axis(&self) -> Option<Unit<Vector3<T>>> pub fn axis(&self) -> Option<Unit<Vector3<T>>>
where where
T: RealField, T: RealField,
@ -811,6 +820,7 @@ impl<T: SimdRealField> Rotation3<T> {
/// assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6); /// assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn scaled_axis(&self) -> Vector3<T> pub fn scaled_axis(&self) -> Vector3<T>
where where
T: RealField, T: RealField,
@ -842,15 +852,12 @@ impl<T: SimdRealField> Rotation3<T> {
/// assert!(rot.axis_angle().is_none()); /// assert!(rot.axis_angle().is_none());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn axis_angle(&self) -> Option<(Unit<Vector3<T>>, T)> pub fn axis_angle(&self) -> Option<(Unit<Vector3<T>>, T)>
where where
T: RealField, T: RealField,
{ {
if let Some(axis) = self.axis() { self.axis().map(|axis| (axis, self.angle()))
Some((axis, self.angle()))
} else {
None
}
} }
/// The rotation angle needed to make `self` and `other` coincide. /// The rotation angle needed to make `self` and `other` coincide.
@ -864,6 +871,7 @@ impl<T: SimdRealField> Rotation3<T> {
/// assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6); /// assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn angle_to(&self, other: &Self) -> T pub fn angle_to(&self, other: &Self) -> T
where where
T::Element: SimdRealField, T::Element: SimdRealField,
@ -875,7 +883,7 @@ impl<T: SimdRealField> Rotation3<T> {
/// ///
/// The angles are produced in the form (roll, pitch, yaw). /// The angles are produced in the form (roll, pitch, yaw).
#[deprecated(note = "This is renamed to use `.euler_angles()`.")] #[deprecated(note = "This is renamed to use `.euler_angles()`.")]
pub fn to_euler_angles(&self) -> (T, T, T) pub fn to_euler_angles(self) -> (T, T, T)
where where
T: RealField, T: RealField,
{ {
@ -896,6 +904,7 @@ impl<T: SimdRealField> Rotation3<T> {
/// assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6); /// assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6);
/// assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6); /// assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);
/// ``` /// ```
#[must_use]
pub fn euler_angles(&self) -> (T, T, T) pub fn euler_angles(&self) -> (T, T, T)
where where
T: RealField, T: RealField,

14
src/geometry/similarity.rs
View File

@ -27,19 +27,19 @@ use crate::geometry::{AbstractRotation, Isometry, Point, Translation};
#[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))] #[cfg_attr(feature = "serde-serialize-no-std", derive(Serialize, Deserialize))]
#[cfg_attr( #[cfg_attr(
feature = "serde-serialize-no-std", feature = "serde-serialize-no-std",
serde(bound(serialize = "T: Serialize, serde(bound(serialize = "T: Scalar + Serialize,
R: Serialize, R: Serialize,
DefaultAllocator: Allocator<T, Const<D>>, DefaultAllocator: Allocator<T, Const<D>>,
Owned<T, Const<D>>: Serialize")) Owned<T, Const<D>>: Serialize"))
)] )]
#[cfg_attr( #[cfg_attr(
feature = "serde-serialize-no-std", feature = "serde-serialize-no-std",
serde(bound(deserialize = "T: Deserialize<'de>, serde(bound(deserialize = "T: Scalar + Deserialize<'de>,
R: Deserialize<'de>, R: Deserialize<'de>,
DefaultAllocator: Allocator<T, Const<D>>, DefaultAllocator: Allocator<T, Const<D>>,
Owned<T, Const<D>>: Deserialize<'de>")) Owned<T, Const<D>>: Deserialize<'de>"))
)] )]
pub struct Similarity<T: Scalar, R, const D: usize> { pub struct Similarity<T, R, const D: usize> {
/// The part of this similarity that does not include the scaling factor. /// The part of this similarity that does not include the scaling factor.
pub isometry: Isometry<T, R, D>, pub isometry: Isometry<T, R, D>,
scaling: T, scaling: T,
@ -122,6 +122,7 @@ where
impl<T: Scalar, R, const D: usize> Similarity<T, R, D> { impl<T: Scalar, R, const D: usize> Similarity<T, R, D> {
/// The scaling factor of this similarity transformation. /// The scaling factor of this similarity transformation.
#[inline] #[inline]
#[must_use]
pub fn scaling(&self) -> T { pub fn scaling(&self) -> T {
self.scaling.inlined_clone() self.scaling.inlined_clone()
} }
@ -177,7 +178,7 @@ where
); );
Self::from_parts( Self::from_parts(
Translation::from(&self.isometry.translation.vector * scaling), Translation::from(self.isometry.translation.vector * scaling),
self.isometry.rotation.clone(), self.isometry.rotation.clone(),
self.scaling * scaling, self.scaling * scaling,
) )
@ -248,6 +249,7 @@ where
/// assert_relative_eq!(transformed_point, Point3::new(19.0, 17.0, -9.0), epsilon = 1.0e-5); /// assert_relative_eq!(transformed_point, Point3::new(19.0, 17.0, -9.0), epsilon = 1.0e-5);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> { pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
self * pt self * pt
} }
@ -269,6 +271,7 @@ where
/// assert_relative_eq!(transformed_vector, Vector3::new(18.0, 15.0, -12.0), epsilon = 1.0e-5); /// assert_relative_eq!(transformed_vector, Vector3::new(18.0, 15.0, -12.0), epsilon = 1.0e-5);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> { pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
self * v self * v
} }
@ -289,6 +292,7 @@ where
/// assert_relative_eq!(transformed_point, Point3::new(-1.5, 1.5, 1.5), epsilon = 1.0e-5); /// assert_relative_eq!(transformed_point, Point3::new(-1.5, 1.5, 1.5), epsilon = 1.0e-5);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> { pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
self.isometry.inverse_transform_point(pt) / self.scaling() self.isometry.inverse_transform_point(pt) / self.scaling()
} }
@ -309,6 +313,7 @@ where
/// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.5, 2.0), epsilon = 1.0e-5); /// assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.5, 2.0), epsilon = 1.0e-5);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> { pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
self.isometry.inverse_transform_vector(v) / self.scaling() self.isometry.inverse_transform_vector(v) / self.scaling()
} }
@ -321,6 +326,7 @@ where
impl<T: SimdRealField, R, const D: usize> Similarity<T, R, D> { impl<T: SimdRealField, R, const D: usize> Similarity<T, R, D> {
/// Converts this similarity into its equivalent homogeneous transformation matrix. /// Converts this similarity into its equivalent homogeneous transformation matrix.
#[inline] #[inline]
#[must_use]
pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
where where
Const<D>: DimNameAdd<U1>, Const<D>: DimNameAdd<U1>,

58
src/geometry/similarity_conversion.rs
View File

@ -197,7 +197,7 @@ where
{ {
#[inline] #[inline]
fn from(arr: [Similarity<T::Element, R::Element, D>; 2]) -> Self { fn from(arr: [Similarity<T::Element, R::Element, D>; 2]) -> Self {
let iso = Isometry::from([arr[0].isometry.clone(), arr[1].isometry.clone()]); let iso = Isometry::from([arr[0].isometry, arr[1].isometry]);
let scale = T::from([arr[0].scaling(), arr[1].scaling()]); let scale = T::from([arr[0].scaling(), arr[1].scaling()]);
Self::from_isometry(iso, scale) Self::from_isometry(iso, scale)
@ -216,10 +216,10 @@ where
#[inline] #[inline]
fn from(arr: [Similarity<T::Element, R::Element, D>; 4]) -> Self { fn from(arr: [Similarity<T::Element, R::Element, D>; 4]) -> Self {
let iso = Isometry::from([ let iso = Isometry::from([
arr[0].isometry.clone(), arr[0].isometry,
arr[1].isometry.clone(), arr[1].isometry,
arr[2].isometry.clone(), arr[2].isometry,
arr[3].isometry.clone(), arr[3].isometry,
]); ]);
let scale = T::from([ let scale = T::from([
arr[0].scaling(), arr[0].scaling(),
@ -244,14 +244,14 @@ where
#[inline] #[inline]
fn from(arr: [Similarity<T::Element, R::Element, D>; 8]) -> Self { fn from(arr: [Similarity<T::Element, R::Element, D>; 8]) -> Self {
let iso = Isometry::from([ let iso = Isometry::from([
arr[0].isometry.clone(), arr[0].isometry,
arr[1].isometry.clone(), arr[1].isometry,
arr[2].isometry.clone(), arr[2].isometry,
arr[3].isometry.clone(), arr[3].isometry,
arr[4].isometry.clone(), arr[4].isometry,
arr[5].isometry.clone(), arr[5].isometry,
arr[6].isometry.clone(), arr[6].isometry,
arr[7].isometry.clone(), arr[7].isometry,
]); ]);
let scale = T::from([ let scale = T::from([
arr[0].scaling(), arr[0].scaling(),
@ -280,22 +280,22 @@ where
#[inline] #[inline]
fn from(arr: [Similarity<T::Element, R::Element, D>; 16]) -> Self { fn from(arr: [Similarity<T::Element, R::Element, D>; 16]) -> Self {
let iso = Isometry::from([ let iso = Isometry::from([
arr[0].isometry.clone(), arr[0].isometry,
arr[1].isometry.clone(), arr[1].isometry,
arr[2].isometry.clone(), arr[2].isometry,
arr[3].isometry.clone(), arr[3].isometry,
arr[4].isometry.clone(), arr[4].isometry,
arr[5].isometry.clone(), arr[5].isometry,
arr[6].isometry.clone(), arr[6].isometry,
arr[7].isometry.clone(), arr[7].isometry,
arr[8].isometry.clone(), arr[8].isometry,
arr[9].isometry.clone(), arr[9].isometry,
arr[10].isometry.clone(), arr[10].isometry,
arr[11].isometry.clone(), arr[11].isometry,
arr[12].isometry.clone(), arr[12].isometry,
arr[13].isometry.clone(), arr[13].isometry,
arr[14].isometry.clone(), arr[14].isometry,
arr[15].isometry.clone(), arr[15].isometry,
]); ]);
let scale = T::from([ let scale = T::from([
arr[0].scaling(), arr[0].scaling(),

5
src/geometry/similarity_ops.rs
View File

@ -1,3 +1,6 @@
// The macros break if the references are taken out, for some reason.
#![allow(clippy::op_ref)]
use num::{One, Zero}; use num::{One, Zero};
use std::ops::{Div, DivAssign, Mul, MulAssign}; use std::ops::{Div, DivAssign, Mul, MulAssign};
@ -219,7 +222,7 @@ md_assign_impl_all!(
const D; for; where; const D; for; where;
self: Similarity<T, Rotation<T, D>, D>, rhs: Rotation<T, D>; self: Similarity<T, Rotation<T, D>, D>, rhs: Rotation<T, D>;
[val] => self.isometry.rotation *= rhs; [val] => self.isometry.rotation *= rhs;
[ref] => self.isometry.rotation *= rhs.clone(); [ref] => self.isometry.rotation *= *rhs;
); );
md_assign_impl_all!( md_assign_impl_all!(

1
src/geometry/swizzle.rs
View File

@ -8,6 +8,7 @@ macro_rules! impl_swizzle {
$( $(
/// Builds a new point from components of `self`. /// Builds a new point from components of `self`.
#[inline] #[inline]
#[must_use]
pub fn $name(&self) -> $Result<T> pub fn $name(&self) -> $Result<T>
where <Const<D> as ToTypenum>::Typenum: Cmp<typenum::$BaseDim, Output=Greater> { where <Const<D> as ToTypenum>::Typenum: Cmp<typenum::$BaseDim, Output=Greater> {
$Result::new($(self[$i].inlined_clone()),*) $Result::new($(self[$i].inlined_clone()),*)

33
src/geometry/transform.rs
View File

@ -1,6 +1,7 @@
use approx::{AbsDiffEq, RelativeEq, UlpsEq}; use approx::{AbsDiffEq, RelativeEq, UlpsEq};
use std::any::Any; use std::any::Any;
use std::fmt::Debug; use std::fmt::Debug;
use std::hash;
use std::marker::PhantomData; use std::marker::PhantomData;
#[cfg(feature = "serde-serialize-no-std")] #[cfg(feature = "serde-serialize-no-std")]
@ -166,14 +167,16 @@ where
_phantom: PhantomData<C>, _phantom: PhantomData<C>,
} }
// TODO impl<T: RealField + hash::Hash, C: TCategory, const D: usize> hash::Hash for Transform<T, C, D>
// impl<T: RealField + hash::Hash, D: DimNameAdd<U1> + hash::Hash, C: TCategory> hash::Hash for Transform<T, C, D> where
// where DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, Const<D>: DimNameAdd<U1>,
// Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: hash::Hash { DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,
// fn hash<H: hash::Hasher>(&self, state: &mut H) { Owned<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>: hash::Hash,
// self.matrix.hash(state); {
// } fn hash<H: hash::Hasher>(&self, state: &mut H) {
// } self.matrix.hash(state);
}
}
impl<T: RealField, C: TCategory, const D: usize> Copy for Transform<T, C, D> impl<T: RealField, C: TCategory, const D: usize> Copy for Transform<T, C, D>
where where
@ -301,6 +304,7 @@ where
/// assert_eq!(*t.matrix(), m); /// assert_eq!(*t.matrix(), m);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn matrix(&self) -> &OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> { pub fn matrix(&self) -> &OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
&self.matrix &self.matrix
} }
@ -367,6 +371,7 @@ where
/// assert_eq!(t.into_inner(), m); /// assert_eq!(t.into_inner(), m);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> { pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> {
self.matrix().clone_owned() self.matrix().clone_owned()
} }
@ -397,11 +402,9 @@ where
#[inline] #[inline]
#[must_use = "Did you mean to use try_inverse_mut()?"] #[must_use = "Did you mean to use try_inverse_mut()?"]
pub fn try_inverse(self) -> Option<Transform<T, C, D>> { pub fn try_inverse(self) -> Option<Transform<T, C, D>> {
if let Some(m) = self.matrix.try_inverse() { self.matrix
Some(Transform::from_matrix_unchecked(m)) .try_inverse()
} else { .map(Transform::from_matrix_unchecked)
None
}
} }
/// Inverts this transformation. Use `.try_inverse` if this transform has the `TGeneral` /// Inverts this transformation. Use `.try_inverse` if this transform has the `TGeneral`
@ -498,6 +501,7 @@ where
/// ///
/// This is the same as the multiplication `self * pt`. /// This is the same as the multiplication `self * pt`.
#[inline] #[inline]
#[must_use]
pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> { pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
self * pt self * pt
} }
@ -507,6 +511,7 @@ where
/// ///
/// This is the same as the multiplication `self * v`. /// This is the same as the multiplication `self * v`.
#[inline] #[inline]
#[must_use]
pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> { pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
self * v self * v
} }
@ -524,6 +529,7 @@ where
/// This may be cheaper than inverting the transformation and transforming /// This may be cheaper than inverting the transformation and transforming
/// the point. /// the point.
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> { pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
self.clone().inverse() * pt self.clone().inverse() * pt
} }
@ -532,6 +538,7 @@ where
/// This may be cheaper than inverting the transformation and transforming /// This may be cheaper than inverting the transformation and transforming
/// the vector. /// the vector.
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> { pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D> {
self.clone().inverse() * v self.clone().inverse() * v
} }

5
src/geometry/transform_ops.rs
View File

@ -1,3 +1,6 @@
// The macros break if the references are taken out, for some reason.
#![allow(clippy::op_ref)]
use num::{One, Zero}; use num::{One, Zero};
use std::ops::{Div, DivAssign, Index, IndexMut, Mul, MulAssign}; use std::ops::{Div, DivAssign, Index, IndexMut, Mul, MulAssign};
@ -121,7 +124,7 @@ md_impl_all!(
if C::has_normalizer() { if C::has_normalizer() {
let normalizer = self.matrix().fixed_slice::<1, D>(D, 0); let normalizer = self.matrix().fixed_slice::<1, D>(D, 0);
let n = normalizer.tr_dot(&rhs); let n = normalizer.tr_dot(rhs);
if !n.is_zero() { if !n.is_zero() {
return transform * (rhs / n); return transform * (rhs / n);

7
src/geometry/translation.rs
View File

@ -38,7 +38,7 @@ where
} }
} }
impl<T: Scalar + Copy, const D: usize> Copy for Translation<T, D> where Owned<T, Const<D>>: Copy {} impl<T: Scalar + Copy, const D: usize> Copy for Translation<T, D> {}
impl<T: Scalar, const D: usize> Clone for Translation<T, D> impl<T: Scalar, const D: usize> Clone for Translation<T, D>
where where
@ -123,7 +123,7 @@ mod rkyv_impl {
impl<T: Serialize<S>, S: Fallible + ?Sized, const D: usize> Serialize<S> for Translation<T, D> { impl<T: Serialize<S>, S: Fallible + ?Sized, const D: usize> Serialize<S> for Translation<T, D> {
fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> { fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
Ok(self.vector.serialize(serializer)?) self.vector.serialize(serializer)
} }
} }
@ -190,6 +190,7 @@ impl<T: Scalar, const D: usize> Translation<T, D> {
/// assert_eq!(t.to_homogeneous(), expected); /// assert_eq!(t.to_homogeneous(), expected);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> pub fn to_homogeneous(&self) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>
where where
T: Zero + One, T: Zero + One,
@ -241,6 +242,7 @@ impl<T: Scalar + ClosedAdd, const D: usize> Translation<T, D> {
/// let transformed_point = t.transform_point(&Point3::new(4.0, 5.0, 6.0)); /// let transformed_point = t.transform_point(&Point3::new(4.0, 5.0, 6.0));
/// assert_eq!(transformed_point, Point3::new(5.0, 7.0, 9.0)); /// assert_eq!(transformed_point, Point3::new(5.0, 7.0, 9.0));
#[inline] #[inline]
#[must_use]
pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> { pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
pt + &self.vector pt + &self.vector
} }
@ -256,6 +258,7 @@ impl<T: Scalar + ClosedSub, const D: usize> Translation<T, D> {
/// let transformed_point = t.inverse_transform_point(&Point3::new(4.0, 5.0, 6.0)); /// let transformed_point = t.inverse_transform_point(&Point3::new(4.0, 5.0, 6.0));
/// assert_eq!(transformed_point, Point3::new(3.0, 3.0, 3.0)); /// assert_eq!(transformed_point, Point3::new(3.0, 3.0, 3.0));
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> { pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D> {
pt - &self.vector pt - &self.vector
} }

2
src/geometry/translation_construction.rs
View File

@ -69,7 +69,7 @@ where
{ {
/// Generate an arbitrary random variate for testing purposes. /// Generate an arbitrary random variate for testing purposes.
#[inline] #[inline]
fn sample<'a, G: Rng + ?Sized>(&self, rng: &'a mut G) -> Translation<T, D> { fn sample<G: Rng + ?Sized>(&self, rng: &mut G) -> Translation<T, D> {
Translation::from(rng.gen::<SVector<T, D>>()) Translation::from(rng.gen::<SVector<T, D>>())
} }
} }

12
src/geometry/translation_conversion.rs
View File

@ -77,7 +77,7 @@ where
{ {
#[inline] #[inline]
fn to_superset(&self) -> UnitDualQuaternion<T2> { fn to_superset(&self) -> UnitDualQuaternion<T2> {
let dq = UnitDualQuaternion::<T1>::from_parts(self.clone(), UnitQuaternion::identity()); let dq = UnitDualQuaternion::<T1>::from_parts(*self, UnitQuaternion::identity());
dq.to_superset() dq.to_superset()
} }
@ -212,16 +212,14 @@ impl<T: Scalar, const D: usize> From<[T; D]> for Translation<T, D> {
impl<T: Scalar, const D: usize> From<Point<T, D>> for Translation<T, D> { impl<T: Scalar, const D: usize> From<Point<T, D>> for Translation<T, D> {
#[inline] #[inline]
fn from(pt: Point<T, D>) -> Self { fn from(pt: Point<T, D>) -> Self {
Translation { Translation { vector: pt.coords }
vector: pt.coords.into(),
}
} }
} }
impl<T: Scalar, const D: usize> Into<[T; D]> for Translation<T, D> { impl<T: Scalar, const D: usize> From<Translation<T, D>> for [T; D] {
#[inline] #[inline]
fn into(self) -> [T; D] { fn from(t: Translation<T, D>) -> Self {
self.vector.into() t.vector.into()
} }
} }

8
src/geometry/translation_coordinates.rs
View File

@ -1,4 +1,3 @@
use std::mem;
use std::ops::{Deref, DerefMut}; use std::ops::{Deref, DerefMut};
use crate::base::coordinates::{X, XY, XYZ, XYZW, XYZWA, XYZWAB}; use crate::base::coordinates::{X, XY, XYZ, XYZW, XYZWA, XYZWAB};
@ -19,15 +18,14 @@ macro_rules! deref_impl(
#[inline] #[inline]
fn deref(&self) -> &Self::Target { fn deref(&self) -> &Self::Target {
unsafe { mem::transmute(self) } unsafe { &*(self as *const Translation<T, $D> as *const Self::Target) }
} }
} }
impl<T: Scalar> DerefMut for Translation<T, $D> impl<T: Scalar> DerefMut for Translation<T, $D> {
{
#[inline] #[inline]
fn deref_mut(&mut self) -> &mut Self::Target { fn deref_mut(&mut self) -> &mut Self::Target {
unsafe { mem::transmute(self) } unsafe { &mut *(self as *mut Translation<T, $D> as *mut Self::Target) }
} }
} }
} }

18
src/geometry/unit_complex.rs
View File

@ -84,6 +84,7 @@ where
/// assert_eq!(rot.angle(), 1.78); /// assert_eq!(rot.angle(), 1.78);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn angle(&self) -> T { pub fn angle(&self) -> T {
self.im.simd_atan2(self.re) self.im.simd_atan2(self.re)
} }
@ -98,6 +99,7 @@ where
/// assert_eq!(rot.sin_angle(), angle.sin()); /// assert_eq!(rot.sin_angle(), angle.sin());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn sin_angle(&self) -> T { pub fn sin_angle(&self) -> T {
self.im self.im
} }
@ -112,6 +114,7 @@ where
/// assert_eq!(rot.cos_angle(),angle.cos()); /// assert_eq!(rot.cos_angle(),angle.cos());
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn cos_angle(&self) -> T { pub fn cos_angle(&self) -> T {
self.re self.re
} }
@ -121,6 +124,7 @@ where
/// This is generally used in the context of generic programming. Using /// This is generally used in the context of generic programming. Using
/// the `.angle()` method instead is more common. /// the `.angle()` method instead is more common.
#[inline] #[inline]
#[must_use]
pub fn scaled_axis(&self) -> Vector1<T> { pub fn scaled_axis(&self) -> Vector1<T> {
Vector1::new(self.angle()) Vector1::new(self.angle())
} }
@ -131,6 +135,7 @@ where
/// the `.angle()` method instead is more common. /// the `.angle()` method instead is more common.
/// Returns `None` if the angle is zero. /// Returns `None` if the angle is zero.
#[inline] #[inline]
#[must_use]
pub fn axis_angle(&self) -> Option<(Unit<Vector1<T>>, T)> pub fn axis_angle(&self) -> Option<(Unit<Vector1<T>>, T)>
where where
T: RealField, T: RealField,
@ -157,6 +162,7 @@ where
/// assert_relative_eq!(rot1.angle_to(&rot2), 1.6); /// assert_relative_eq!(rot1.angle_to(&rot2), 1.6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn angle_to(&self, other: &Self) -> T { pub fn angle_to(&self, other: &Self) -> T {
let delta = self.rotation_to(other); let delta = self.rotation_to(other);
delta.angle() delta.angle()
@ -254,7 +260,8 @@ where
/// assert_eq!(rot.to_rotation_matrix(), expected); /// assert_eq!(rot.to_rotation_matrix(), expected);
/// ``` /// ```
#[inline] #[inline]
pub fn to_rotation_matrix(&self) -> Rotation2<T> { #[must_use]
pub fn to_rotation_matrix(self) -> Rotation2<T> {
let r = self.re; let r = self.re;
let i = self.im; let i = self.im;
@ -274,7 +281,8 @@ where
/// assert_eq!(rot.to_homogeneous(), expected); /// assert_eq!(rot.to_homogeneous(), expected);
/// ``` /// ```
#[inline] #[inline]
pub fn to_homogeneous(&self) -> Matrix3<T> { #[must_use]
pub fn to_homogeneous(self) -> Matrix3<T> {
self.to_rotation_matrix().to_homogeneous() self.to_rotation_matrix().to_homogeneous()
} }
} }
@ -298,6 +306,7 @@ where
/// assert_relative_eq!(transformed_point, Point2::new(-2.0, 1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, Point2::new(-2.0, 1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_point(&self, pt: &Point2<T>) -> Point2<T> { pub fn transform_point(&self, pt: &Point2<T>) -> Point2<T> {
self * pt self * pt
} }
@ -316,6 +325,7 @@ where
/// assert_relative_eq!(transformed_vector, Vector2::new(-2.0, 1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_vector, Vector2::new(-2.0, 1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn transform_vector(&self, v: &Vector2<T>) -> Vector2<T> { pub fn transform_vector(&self, v: &Vector2<T>) -> Vector2<T> {
self * v self * v
} }
@ -332,6 +342,7 @@ where
/// assert_relative_eq!(transformed_point, Point2::new(2.0, -1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_point, Point2::new(2.0, -1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_point(&self, pt: &Point2<T>) -> Point2<T> { pub fn inverse_transform_point(&self, pt: &Point2<T>) -> Point2<T> {
// TODO: would it be useful performancewise not to call inverse explicitly (i-e. implement // TODO: would it be useful performancewise not to call inverse explicitly (i-e. implement
// the inverse transformation explicitly here) ? // the inverse transformation explicitly here) ?
@ -350,6 +361,7 @@ where
/// assert_relative_eq!(transformed_vector, Vector2::new(2.0, -1.0), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_vector, Vector2::new(2.0, -1.0), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_vector(&self, v: &Vector2<T>) -> Vector2<T> { pub fn inverse_transform_vector(&self, v: &Vector2<T>) -> Vector2<T> {
self.inverse() * v self.inverse() * v
} }
@ -366,6 +378,7 @@ where
/// assert_relative_eq!(transformed_vector, -Vector2::y_axis(), epsilon = 1.0e-6); /// assert_relative_eq!(transformed_vector, -Vector2::y_axis(), epsilon = 1.0e-6);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector2<T>>) -> Unit<Vector2<T>> { pub fn inverse_transform_unit_vector(&self, v: &Unit<Vector2<T>>) -> Unit<Vector2<T>> {
self.inverse() * v self.inverse() * v
} }
@ -392,6 +405,7 @@ where
/// assert_relative_eq!(rot.angle(), std::f32::consts::FRAC_PI_2); /// assert_relative_eq!(rot.angle(), std::f32::consts::FRAC_PI_2);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn slerp(&self, other: &Self, t: T) -> Self { pub fn slerp(&self, other: &Self, t: T) -> Self {
Self::new(self.angle() * (T::one() - t) + other.angle() * t) Self::new(self.angle() * (T::one() - t) + other.angle() * t)
} }

7
src/geometry/unit_complex_construction.rs
View File

@ -148,6 +148,7 @@ where
/// assert_eq!(*rot.complex(), Complex::new(angle.cos(), angle.sin())); /// assert_eq!(*rot.complex(), Complex::new(angle.cos(), angle.sin()));
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn complex(&self) -> &Complex<T> { pub fn complex(&self) -> &Complex<T> {
self.as_ref() self.as_ref()
} }
@ -244,6 +245,7 @@ where
/// assert_relative_eq!(rot_to.inverse() * rot2, rot1); /// assert_relative_eq!(rot_to.inverse() * rot2, rot1);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn rotation_to(&self, other: &Self) -> Self { pub fn rotation_to(&self, other: &Self) -> Self {
other / self other / self
} }
@ -262,6 +264,7 @@ where
/// assert_relative_eq!(pow.angle(), 2.0 * 0.78); /// assert_relative_eq!(pow.angle(), 2.0 * 0.78);
/// ``` /// ```
#[inline] #[inline]
#[must_use]
pub fn powf(&self, n: T) -> Self { pub fn powf(&self, n: T) -> Self {
Self::from_angle(self.angle() * n) Self::from_angle(self.angle() * n)
} }
@ -380,8 +383,8 @@ where
SB: Storage<T, U2>, SB: Storage<T, U2>,
SC: Storage<T, U2>, SC: Storage<T, U2>,
{ {
let sang = na.perp(&nb); let sang = na.perp(nb);
let cang = na.dot(&nb); let cang = na.dot(nb);
Self::from_angle(sang.simd_atan2(cang) * s) Self::from_angle(sang.simd_atan2(cang) * s)
} }

27
src/geometry/unit_complex_ops.rs
View File

@ -1,3 +1,6 @@
// The macros break if the references are taken out, for some reason.
#![allow(clippy::op_ref)]
use std::ops::{Div, DivAssign, Mul, MulAssign}; use std::ops::{Div, DivAssign, Mul, MulAssign};
use crate::base::storage::Storage; use crate::base::storage::Storage;
@ -314,10 +317,10 @@ complex_op_impl_all!(
; ;
self: Translation<T, 2>, right: UnitComplex<T>, self: Translation<T, 2>, right: UnitComplex<T>,
Output = Isometry<T, UnitComplex<T>, 2>; Output = Isometry<T, UnitComplex<T>, 2>;
[val val] => Isometry::from_parts(self, right); [val val] => Isometry::from_parts(self, right);
[ref val] => Isometry::from_parts(self.clone(), right); [ref val] => Isometry::from_parts(*self, right);
[val ref] => Isometry::from_parts(self, *right); [val ref] => Isometry::from_parts(self, *right);
[ref ref] => Isometry::from_parts(self.clone(), *right); [ref ref] => Isometry::from_parts(*self, *right);
); );
// UnitComplex ×= UnitComplex // UnitComplex ×= UnitComplex
@ -327,7 +330,7 @@ where
{ {
#[inline] #[inline]
fn mul_assign(&mut self, rhs: UnitComplex<T>) { fn mul_assign(&mut self, rhs: UnitComplex<T>) {
*self = &*self * rhs *self = *self * rhs
} }
} }
@ -337,7 +340,7 @@ where
{ {
#[inline] #[inline]
fn mul_assign(&mut self, rhs: &'b UnitComplex<T>) { fn mul_assign(&mut self, rhs: &'b UnitComplex<T>) {
*self = &*self * rhs *self = *self * rhs
} }
} }
@ -348,7 +351,7 @@ where
{ {
#[inline] #[inline]
fn div_assign(&mut self, rhs: UnitComplex<T>) { fn div_assign(&mut self, rhs: UnitComplex<T>) {
*self = &*self / rhs *self = *self / rhs
} }
} }
@ -358,7 +361,7 @@ where
{ {
#[inline] #[inline]
fn div_assign(&mut self, rhs: &'b UnitComplex<T>) { fn div_assign(&mut self, rhs: &'b UnitComplex<T>) {
*self = &*self / rhs *self = *self / rhs
} }
} }
@ -369,7 +372,7 @@ where
{ {
#[inline] #[inline]
fn mul_assign(&mut self, rhs: Rotation<T, 2>) { fn mul_assign(&mut self, rhs: Rotation<T, 2>) {
*self = &*self * rhs *self = *self * rhs
} }
} }
@ -379,7 +382,7 @@ where
{ {
#[inline] #[inline]
fn mul_assign(&mut self, rhs: &'b Rotation<T, 2>) { fn mul_assign(&mut self, rhs: &'b Rotation<T, 2>) {
*self = &*self * rhs *self = *self * rhs
} }
} }
@ -390,7 +393,7 @@ where
{ {
#[inline] #[inline]
fn div_assign(&mut self, rhs: Rotation<T, 2>) { fn div_assign(&mut self, rhs: Rotation<T, 2>) {
*self = &*self / rhs *self = *self / rhs
} }
} }
@ -400,7 +403,7 @@ where
{ {
#[inline] #[inline]
fn div_assign(&mut self, rhs: &'b Rotation<T, 2>) { fn div_assign(&mut self, rhs: &'b Rotation<T, 2>) {
*self = &*self / rhs *self = *self / rhs
} }
} }

23
src/lib.rs
View File

@ -1,3 +1,4 @@
#![allow(clippy::type_complexity)]
/*! /*!
# nalgebra # nalgebra
@ -13,7 +14,7 @@ and the official package manager: [cargo](https://github.com/rust-lang/cargo).
Simply add the following to your `Cargo.toml` file: Simply add the following to your `Cargo.toml` file:
```.ignore ```ignore
[dependencies] [dependencies]
// TODO: replace the * by the latest version. // TODO: replace the * by the latest version.
nalgebra = "*" nalgebra = "*"
@ -25,7 +26,7 @@ Most useful functionalities of **nalgebra** are grouped in the root module `nalg
However, the recommended way to use **nalgebra** is to import types and traits However, the recommended way to use **nalgebra** is to import types and traits
explicitly, and call free-functions using the `na::` prefix: explicitly, and call free-functions using the `na::` prefix:
```.rust ```
#[macro_use] #[macro_use]
extern crate approx; // For the macro relative_eq! extern crate approx; // For the macro relative_eq!
extern crate nalgebra as na; extern crate nalgebra as na;
@ -86,7 +87,6 @@ an optimized set of tools for computer graphics and physics. Those features incl
html_root_url = "https://docs.rs/nalgebra/0.25.0" html_root_url = "https://docs.rs/nalgebra/0.25.0"
)] )]
#![cfg_attr(not(feature = "std"), no_std)] #![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(all(feature = "alloc", not(feature = "std")), feature(alloc))]
#![cfg_attr(feature = "no_unsound_assume_init", allow(unreachable_code))] #![cfg_attr(feature = "no_unsound_assume_init", allow(unreachable_code))]
#[cfg(feature = "rand-no-std")] #[cfg(feature = "rand-no-std")]
@ -101,6 +101,7 @@ extern crate approx;
extern crate num_traits as num; extern crate num_traits as num;
#[cfg(all(feature = "alloc", not(feature = "std")))] #[cfg(all(feature = "alloc", not(feature = "std")))]
#[cfg_attr(test, macro_use)]
extern crate alloc; extern crate alloc;
#[cfg(not(feature = "std"))] #[cfg(not(feature = "std"))]
@ -184,6 +185,7 @@ pub fn zero<T: Zero>() -> T {
/// Wraps `val` into the range `[min, max]` using modular arithmetics. /// Wraps `val` into the range `[min, max]` using modular arithmetics.
/// ///
/// The range must not be empty. /// The range must not be empty.
#[must_use]
#[inline] #[inline]
pub fn wrap<T>(mut val: T, min: T, max: T) -> T pub fn wrap<T>(mut val: T, min: T, max: T) -> T
where where
@ -198,19 +200,15 @@ where
while val < min { while val < min {
val += width val += width
} }
val
} else if val > max { } else if val > max {
val -= width; val -= width;
while val > max { while val > max {
val -= width val -= width
} }
val
} else {
val
} }
val
} }
/// Returns a reference to the input value clamped to the interval `[min, max]`. /// Returns a reference to the input value clamped to the interval `[min, max]`.
@ -219,6 +217,7 @@ where
/// * If `min < val < max`, this returns `val`. /// * If `min < val < max`, this returns `val`.
/// * If `val <= min`, this returns `min`. /// * If `val <= min`, this returns `min`.
/// * If `val >= max`, this returns `max`. /// * If `val >= max`, this returns `max`.
#[must_use]
#[inline] #[inline]
pub fn clamp<T: PartialOrd>(val: T, min: T, max: T) -> T { pub fn clamp<T: PartialOrd>(val: T, min: T, max: T) -> T {
if val > min { if val > min {
@ -391,7 +390,7 @@ pub fn center<T: SimdComplexField, const D: usize>(
p1: &Point<T, D>, p1: &Point<T, D>,
p2: &Point<T, D>, p2: &Point<T, D>,
) -> Point<T, D> { ) -> Point<T, D> {
((&p1.coords + &p2.coords) * convert::<_, T>(0.5)).into() ((p1.coords + p2.coords) * convert::<_, T>(0.5)).into()
} }
/// The distance between two points. /// The distance between two points.
@ -405,7 +404,7 @@ pub fn distance<T: SimdComplexField, const D: usize>(
p1: &Point<T, D>, p1: &Point<T, D>,
p2: &Point<T, D>, p2: &Point<T, D>,
) -> T::SimdRealField { ) -> T::SimdRealField {
(&p2.coords - &p1.coords).norm() (p2.coords - p1.coords).norm()
} }
/// The squared distance between two points. /// The squared distance between two points.
@ -419,7 +418,7 @@ pub fn distance_squared<T: SimdComplexField, const D: usize>(
p1: &Point<T, D>, p1: &Point<T, D>,
p2: &Point<T, D>, p2: &Point<T, D>,
) -> T::SimdRealField { ) -> T::SimdRealField {
(&p2.coords - &p1.coords).norm_squared() (p2.coords - p1.coords).norm_squared()
} }
/* /*

39
src/linalg/balancing.rs
View File

@ -8,17 +8,17 @@ use crate::base::dimension::Dim;
use crate::base::storage::Storage; use crate::base::storage::Storage;
use crate::base::{Const, DefaultAllocator, OMatrix, OVector}; use crate::base::{Const, DefaultAllocator, OMatrix, OVector};
/// Applies in-place a modified Parlett and Reinsch matrix balancing with 2-norm to the matrix `m` and returns /// Applies in-place a modified Parlett and Reinsch matrix balancing with 2-norm to the matrix and returns
/// the corresponding diagonal transformation. /// the corresponding diagonal transformation.
/// ///
/// See https://arxiv.org/pdf/1401.5766.pdf /// See https://arxiv.org/pdf/1401.5766.pdf
pub fn balance_parlett_reinsch<T: RealField, D: Dim>(m: &mut OMatrix<T, D, D>) -> OVector<T, D> pub fn balance_parlett_reinsch<T: RealField, D: Dim>(matrix: &mut OMatrix<T, D, D>) -> OVector<T, D>
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>, DefaultAllocator: Allocator<T, D, D> + Allocator<T, D>,
{ {
assert!(m.is_square(), "Unable to balance a non-square matrix."); assert!(matrix.is_square(), "Unable to balance a non-square matrix.");
let dim = m.data.shape().0; let dim = matrix.data.shape().0;
let radix: T = crate::convert(2.0f64); let radix: T = crate::convert(2.0f64);
let mut d = OVector::from_element_generic(dim, Const::<1>, T::one()); let mut d = OVector::from_element_generic(dim, Const::<1>, T::one());
@ -28,36 +28,37 @@ where
converged = true; converged = true;
for i in 0..dim.value() { for i in 0..dim.value() {
let mut c = m.column(i).norm_squared(); let mut n_col = matrix.column(i).norm_squared();
let mut r = m.row(i).norm_squared(); let mut n_row = matrix.row(i).norm_squared();
let mut f = T::one(); let mut f = T::one();
let s = c + r; let s = n_col + n_row;
c = c.sqrt(); n_col = n_col.sqrt();
r = r.sqrt(); n_row = n_row.sqrt();
if c.is_zero() || r.is_zero() { if n_col.is_zero() || n_row.is_zero() {
continue; continue;
} }
while c < r / radix { while n_col < n_row / radix {
c *= radix; n_col *= radix;
r /= radix; n_row /= radix;
f *= radix; f *= radix;
} }
while c >= r * radix { while n_col >= n_row * radix {
c /= radix; n_col /= radix;
r *= radix; n_row *= radix;
f /= radix; f /= radix;
} }
let eps: T = crate::convert(0.95); let eps: T = crate::convert(0.95);
if c * c + r * r < eps * s { #[allow(clippy::suspicious_operation_groupings)]
if n_col * n_col + n_row * n_row < eps * s {
converged = false; converged = false;
d[i] *= f; d[i] *= f;
m.column_mut(i).mul_assign(f); matrix.column_mut(i).mul_assign(f);
m.row_mut(i).div_assign(f); matrix.row_mut(i).div_assign(f);
} }
} }
} }

6
src/linalg/bidiagonal.rs
View File

@ -153,6 +153,7 @@ where
/// Indicates whether this decomposition contains an upper-diagonal matrix. /// Indicates whether this decomposition contains an upper-diagonal matrix.
#[inline] #[inline]
#[must_use]
pub fn is_upper_diagonal(&self) -> bool { pub fn is_upper_diagonal(&self) -> bool {
self.upper_diagonal self.upper_diagonal
} }
@ -188,6 +189,7 @@ where
/// Retrieves the upper trapezoidal submatrix `R` of this decomposition. /// Retrieves the upper trapezoidal submatrix `R` of this decomposition.
#[inline] #[inline]
#[must_use]
pub fn d(&self) -> OMatrix<T, DimMinimum<R, C>, DimMinimum<R, C>> pub fn d(&self) -> OMatrix<T, DimMinimum<R, C>, DimMinimum<R, C>>
where where
DefaultAllocator: Allocator<T, DimMinimum<R, C>, DimMinimum<R, C>>, DefaultAllocator: Allocator<T, DimMinimum<R, C>, DimMinimum<R, C>>,
@ -207,6 +209,7 @@ where
/// Computes the orthogonal matrix `U` of this `U * D * V` decomposition. /// Computes the orthogonal matrix `U` of this `U * D * V` decomposition.
// TODO: code duplication with householder::assemble_q. // TODO: code duplication with householder::assemble_q.
// Except that we are returning a rectangular matrix here. // Except that we are returning a rectangular matrix here.
#[must_use]
pub fn u(&self) -> OMatrix<T, R, DimMinimum<R, C>> pub fn u(&self) -> OMatrix<T, R, DimMinimum<R, C>>
where where
DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>, DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
@ -237,6 +240,7 @@ where
} }
/// Computes the orthogonal matrix `V_t` of this `U * D * V_t` decomposition. /// Computes the orthogonal matrix `V_t` of this `U * D * V_t` decomposition.
#[must_use]
pub fn v_t(&self) -> OMatrix<T, DimMinimum<R, C>, C> pub fn v_t(&self) -> OMatrix<T, DimMinimum<R, C>, C>
where where
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>, DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
@ -274,6 +278,7 @@ where
} }
/// The diagonal part of this decomposed matrix. /// The diagonal part of this decomposed matrix.
#[must_use]
pub fn diagonal(&self) -> OVector<T::RealField, DimMinimum<R, C>> pub fn diagonal(&self) -> OVector<T::RealField, DimMinimum<R, C>>
where where
DefaultAllocator: Allocator<T::RealField, DimMinimum<R, C>>, DefaultAllocator: Allocator<T::RealField, DimMinimum<R, C>>,
@ -282,6 +287,7 @@ where
} }
/// The off-diagonal part of this decomposed matrix. /// The off-diagonal part of this decomposed matrix.
#[must_use]
pub fn off_diagonal(&self) -> OVector<T::RealField, DimDiff<DimMinimum<R, C>, U1>> pub fn off_diagonal(&self) -> OVector<T::RealField, DimDiff<DimMinimum<R, C>, U1>>
where where
DefaultAllocator: Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>, DefaultAllocator: Allocator<T::RealField, DimDiff<DimMinimum<R, C>, U1>>,

6
src/linalg/cholesky.rs
View File

@ -92,6 +92,7 @@ where
/// Retrieves the lower-triangular factor of the Cholesky decomposition with its strictly /// Retrieves the lower-triangular factor of the Cholesky decomposition with its strictly
/// uppen-triangular part filled with zeros. /// uppen-triangular part filled with zeros.
#[must_use]
pub fn l(&self) -> OMatrix<T, D, D> { pub fn l(&self) -> OMatrix<T, D, D> {
self.chol.lower_triangle() self.chol.lower_triangle()
} }
@ -101,6 +102,7 @@ where
/// ///
/// This is an allocation-less version of `self.l()`. The values of the strict upper-triangular /// This is an allocation-less version of `self.l()`. The values of the strict upper-triangular
/// part are garbage and should be ignored by further computations. /// part are garbage and should be ignored by further computations.
#[must_use]
pub fn l_dirty(&self) -> &OMatrix<T, D, D> { pub fn l_dirty(&self) -> &OMatrix<T, D, D> {
&self.chol &self.chol
} }
@ -119,6 +121,7 @@ where
/// Returns the solution of the system `self * x = b` where `self` is the decomposed matrix and /// Returns the solution of the system `self * x = b` where `self` is the decomposed matrix and
/// `x` the unknown. /// `x` the unknown.
#[must_use = "Did you mean to use solve_mut()?"]
pub fn solve<R2: Dim, C2: Dim, S2>(&self, b: &Matrix<T, R2, C2, S2>) -> OMatrix<T, R2, C2> pub fn solve<R2: Dim, C2: Dim, S2>(&self, b: &Matrix<T, R2, C2, S2>) -> OMatrix<T, R2, C2>
where where
S2: Storage<T, R2, C2>, S2: Storage<T, R2, C2>,
@ -131,6 +134,7 @@ where
} }
/// Computes the inverse of the decomposed matrix. /// Computes the inverse of the decomposed matrix.
#[must_use]
pub fn inverse(&self) -> OMatrix<T, D, D> { pub fn inverse(&self) -> OMatrix<T, D, D> {
let shape = self.chol.data.shape(); let shape = self.chol.data.shape();
let mut res = OMatrix::identity_generic(shape.0, shape.1); let mut res = OMatrix::identity_generic(shape.0, shape.1);
@ -140,6 +144,7 @@ where
} }
/// Computes the determinant of the decomposed matrix. /// Computes the determinant of the decomposed matrix.
#[must_use]
pub fn determinant(&self) -> T::SimdRealField { pub fn determinant(&self) -> T::SimdRealField {
let dim = self.chol.nrows(); let dim = self.chol.nrows();
let mut prod_diag = T::one(); let mut prod_diag = T::one();
@ -287,6 +292,7 @@ where
/// Updates the decomposition such that we get the decomposition of the factored matrix with its `j`th column removed. /// Updates the decomposition such that we get the decomposition of the factored matrix with its `j`th column removed.
/// Since the matrix is square, the `j`th row will also be removed. /// Since the matrix is square, the `j`th row will also be removed.
#[must_use]
pub fn remove_column(&self, j: usize) -> Cholesky<T, DimDiff<D, U1>> pub fn remove_column(&self, j: usize) -> Cholesky<T, DimDiff<D, U1>>
where where
D: DimSub<U1>, D: DimSub<U1>,

7
src/linalg/col_piv_qr.rs
View File

@ -95,6 +95,7 @@ where
/// Retrieves the upper trapezoidal submatrix `R` of this decomposition. /// Retrieves the upper trapezoidal submatrix `R` of this decomposition.
#[inline] #[inline]
#[must_use]
pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C> pub fn r(&self) -> OMatrix<T, DimMinimum<R, C>, C>
where where
DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>, DefaultAllocator: Allocator<T, DimMinimum<R, C>, C>,
@ -126,6 +127,7 @@ where
} }
/// Computes the orthogonal matrix `Q` of this decomposition. /// Computes the orthogonal matrix `Q` of this decomposition.
#[must_use]
pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>> pub fn q(&self) -> OMatrix<T, R, DimMinimum<R, C>>
where where
DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>, DefaultAllocator: Allocator<T, R, DimMinimum<R, C>>,
@ -150,6 +152,7 @@ where
} }
/// Retrieves the column permutation of this decomposition. /// Retrieves the column permutation of this decomposition.
#[inline] #[inline]
#[must_use]
pub fn p(&self) -> &PermutationSequence<DimMinimum<R, C>> { pub fn p(&self) -> &PermutationSequence<DimMinimum<R, C>> {
&self.p &self.p
} }
@ -201,6 +204,7 @@ where
/// Solves the linear system `self * x = b`, where `x` is the unknown to be determined. /// Solves the linear system `self * x = b`, where `x` is the unknown to be determined.
/// ///
/// Returns `None` if `self` is not invertible. /// Returns `None` if `self` is not invertible.
#[must_use = "Did you mean to use solve_mut()?"]
pub fn solve<R2: Dim, C2: Dim, S2>( pub fn solve<R2: Dim, C2: Dim, S2>(
&self, &self,
b: &Matrix<T, R2, C2, S2>, b: &Matrix<T, R2, C2, S2>,
@ -283,6 +287,7 @@ where
/// Computes the inverse of the decomposed matrix. /// Computes the inverse of the decomposed matrix.
/// ///
/// Returns `None` if the decomposed matrix is not invertible. /// Returns `None` if the decomposed matrix is not invertible.
#[must_use]
pub fn try_inverse(&self) -> Option<OMatrix<T, D, D>> { pub fn try_inverse(&self) -> Option<OMatrix<T, D, D>> {
assert!( assert!(
self.col_piv_qr.is_square(), self.col_piv_qr.is_square(),
@ -301,6 +306,7 @@ where
} }
/// Indicates if the decomposed matrix is invertible. /// Indicates if the decomposed matrix is invertible.
#[must_use]
pub fn is_invertible(&self) -> bool { pub fn is_invertible(&self) -> bool {
assert!( assert!(
self.col_piv_qr.is_square(), self.col_piv_qr.is_square(),
@ -317,6 +323,7 @@ where
} }
/// Computes the determinant of the decomposed matrix. /// Computes the determinant of the decomposed matrix.
#[must_use]
pub fn determinant(&self) -> T { pub fn determinant(&self) -> T {
let dim = self.col_piv_qr.nrows(); let dim = self.col_piv_qr.nrows();
assert!( assert!(

1
src/linalg/convolution.rs
View File

@ -112,6 +112,7 @@ impl<T: RealField, D1: Dim, S1: Storage<T, D1>> Vector<T, D1, S1> {
/// ///
/// # Errors /// # Errors
/// Inputs must satisfy `self.len() >= kernel.len() > 0`. /// Inputs must satisfy `self.len() >= kernel.len() > 0`.
#[must_use]
pub fn convolve_same<D2, S2>(&self, kernel: Vector<T, D2, S2>) -> OVector<T, D1> pub fn convolve_same<D2, S2>(&self, kernel: Vector<T, D2, S2>) -> OVector<T, D1>
where where
D2: Dim, D2: Dim,

1
src/linalg/determinant.rs
View File

@ -12,6 +12,7 @@ impl<T: ComplexField, D: DimMin<D, Output = D>, S: Storage<T, D, D>> SquareMatri
/// ///
/// If the matrix has a dimension larger than 3, an LU decomposition is used. /// If the matrix has a dimension larger than 3, an LU decomposition is used.
#[inline] #[inline]
#[must_use]
pub fn determinant(&self) -> T pub fn determinant(&self) -> T
where where
DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), D>, DefaultAllocator: Allocator<T, D, D> + Allocator<(usize, usize), D>,

34
src/linalg/exp.rs
View File

@ -435,37 +435,38 @@ where
+ Allocator<T::RealField, D, D>, + Allocator<T::RealField, D, D>,
{ {
/// Computes exponential of this matrix /// Computes exponential of this matrix
#[must_use]
pub fn exp(&self) -> Self { pub fn exp(&self) -> Self {
// Simple case // Simple case
if self.nrows() == 1 { if self.nrows() == 1 {
return self.map(|v| v.exp()); return self.map(|v| v.exp());
} }
let mut h = ExpmPadeHelper::new(self.clone(), true); let mut helper = ExpmPadeHelper::new(self.clone(), true);
let eta_1 = T::RealField::max(h.d4_loose(), h.d6_loose()); let eta_1 = T::RealField::max(helper.d4_loose(), helper.d6_loose());
if eta_1 < convert(1.495_585_217_958_292e-2) && ell(&h.a, 3) == 0 { if eta_1 < convert(1.495_585_217_958_292e-2) && ell(&helper.a, 3) == 0 {
let (u, v) = h.pade3(); let (u, v) = helper.pade3();
return solve_p_q(u, v); return solve_p_q(u, v);
} }
let eta_2 = T::RealField::max(h.d4_tight(), h.d6_loose()); let eta_2 = T::RealField::max(helper.d4_tight(), helper.d6_loose());
if eta_2 < convert(2.539_398_330_063_230e-1) && ell(&h.a, 5) == 0 { if eta_2 < convert(2.539_398_330_063_23e-1) && ell(&helper.a, 5) == 0 {
let (u, v) = h.pade5(); let (u, v) = helper.pade5();
return solve_p_q(u, v); return solve_p_q(u, v);
} }
let eta_3 = T::RealField::max(h.d6_tight(), h.d8_loose()); let eta_3 = T::RealField::max(helper.d6_tight(), helper.d8_loose());
if eta_3 < convert(9.504_178_996_162_932e-1) && ell(&h.a, 7) == 0 { if eta_3 < convert(9.504_178_996_162_932e-1) && ell(&helper.a, 7) == 0 {
let (u, v) = h.pade7(); let (u, v) = helper.pade7();
return solve_p_q(u, v); return solve_p_q(u, v);
} }
if eta_3 < convert(2.097_847_961_257_068e+0) && ell(&h.a, 9) == 0 { if eta_3 < convert(2.097_847_961_257_068e0) && ell(&helper.a, 9) == 0 {
let (u, v) = h.pade9(); let (u, v) = helper.pade9();
return solve_p_q(u, v); return solve_p_q(u, v);
} }
let eta_4 = T::RealField::max(h.d8_loose(), h.d10_loose()); let eta_4 = T::RealField::max(helper.d8_loose(), helper.d10_loose());
let eta_5 = T::RealField::min(eta_3, eta_4); let eta_5 = T::RealField::min(eta_3, eta_4);
let theta_13 = convert(4.25); let theta_13 = convert(4.25);
@ -481,9 +482,12 @@ where
} }
}; };
s += ell(&(&h.a * convert::<f64, T>(2.0_f64.powf(-(s as f64)))), 13); s += ell(
&(&helper.a * convert::<f64, T>(2.0_f64.powf(-(s as f64)))),
13,
);
let (u, v) = h.pade13_scaled(s); let (u, v) = helper.pade13_scaled(s);
let mut x = solve_p_q(u, v); let mut x = solve_p_q(u, v);
for _ in 0..s { for _ in 0..s {

Some files were not shown because too many files have changed in this diff Show More