From 64e97c85d5baaff0310eb6412fb46c1223ee2505 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Crozet?= Date: Wed, 12 Jun 2024 11:13:12 +0200 Subject: [PATCH] Release v0.32.6 --- CHANGELOG.md | 864 ++++++++++++++++++++++++++++++--------------------- Cargo.toml | 150 ++++----- 2 files changed, 584 insertions(+), 430 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index fa522ad2..2ff797d4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,5 @@ # Change Log + All notable changes to `nalgebra`, starting with the version 0.6.0 will be documented here. @@ -6,6 +7,8 @@ This project adheres to [Semantic Versioning](https://semver.org/). ## Unreleased +## [0.32.6] (12 June 2024) + ### Added - Add the `convert-glam027` feature to enable conversion from/to types from `glam` v0.27. @@ -25,11 +28,13 @@ This project adheres to [Semantic Versioning](https://semver.org/). ## [0.32.3] (09 July 2023) ### Modified + - Statically sized matrices are now serialized as tuples to match how serde serialized plain arrays. - Don’t require `Scalar` for matrix `PartialEq` and `Eq`. ### Added + - Allow trailing punctuation in macros `vector!`, `matrix!`, `point!`, etc. - Add the methods `Matrix1::as_scalar`, `::as_scalar_mut`, `::to_scalar`, `::into_scalar`. - Add `Rotation3::euler_angles_ordered`, a generalized euler angles calculation. @@ -38,21 +43,25 @@ This project adheres to [Semantic Versioning](https://semver.org/). - Implement `Clone` for `MatrixIter`. ### Fixed + - Fixed severe catastrophic cancellation issue in variance calculation. ## [0.32.2] (07 March 2023) ### Added -- Add the `glam-0.23` to enable conversion from/to type from `glam` v0.23. + +- Add the `glam-0.23` to enable conversion from/to type from `glam` v0.23. ## [0.32.1] (14 Jan. 2023) ### Modified + - Updated `nalgebra-macros` to use the new `Dyn`, avoiding macro-generated deprecation warnings. ## [0.32.0] (14 Jan. 2023) ### Modified + - Renamed all `MatrixSlice` types to `MatrixView`. In general all occurrences of the world `Slice` or `slice` have been replaced by `View` or `view`. - Deprecated all the types involving `Slice` in its name, in favor of the word `View`. @@ -60,10 +69,12 @@ This project adheres to [Semantic Versioning](https://semver.org/). - Renamed `Dynamic` to `Dyn` and make `Dyn` a tuple struct. ### Added -- Add `Cholesky::ln_determinant` to compute the natural logarithm of the determinant of a matrix decomposed + +- Add `Cholesky::ln_determinant` to compute the natural logarithm of the determinant of a matrix decomposed with Cholesky. This can be more numerically stable than computing the determinant itself when very small and/or large values are involved. -- Added new methods `Matrix::as_view` and `Matrix::as_view_mut`, which are very useful when working with view-based APIs. +- Added new methods `Matrix::as_view` and `Matrix::as_view_mut`, which are very useful when working with view-based + APIs. - Added parallel column iterator using `rayon`: `Matrix::par_column_iter` and `Matrix::par_column_iter_mut`. The `rayon` feature must be enabled to access these methods. - Implement `ReshapableStorage` for matrix slices (only for unit strides at the moment). @@ -71,85 +82,99 @@ This project adheres to [Semantic Versioning](https://semver.org/). `Const::<4>` when we need const dimensions. ### Fixed + - Fixed the implementation of `Rotation3::euler_angles` to return the angles in the documented order (roll, pitch, yaw). ## [0.31.4] (13 Nov. 2022) ### Added -- Add a `convert-glam022` feature to enable conversion between `nalgebra` and `glam v0.22`. +- Add a `convert-glam022` feature to enable conversion between `nalgebra` and `glam v0.22`. ## [0.31.3] (30 Oct. 2022) ### Added + - Add `Matrix::try_cast` to attempt casting the inner scalar types when that cast may fail. ### Fixed + - Fixed the usage of `CheckBytes` with `rkyv`. ## [0.31.2] (09 Oct. 2022) ### Modified + - Use `#[inline]` on the `Dim` implementation for `Const` to improve opt-level 1 performance. - Make the `Point::new` constructions const-fn. ### Added -- Add `UnitVector::cast` to change the underlying scalar type. +- Add `UnitVector::cast` to change the underlying scalar type. ## [0.31.1] (31 July 2022) ### Modified + - Improve performances of multiplication of two sparse matrices. ### Added + - Add `Matrix::from_row_iterator` to build a matrix from an iterator yielding components in row-major order. - Add support for conversion from/to types of `glam` 0.21. - `nalgebra-sparse`: add support for the matrix-market export of sparse matrices. - `nalgebra-lapack`: add a `GE` for solving the generalized eigenvalues problem. ### Fixed + - Fix `Rotation3::from_matrix` and `UnitQuaternion::from_matrix` when the input matrix is already a valid rotation matrix. ## [0.31.0] (30 Apr. 2022) ### Breaking changes + - Switch to `cust` 0.3 (for CUDA support). - Switch to `rkyv` 0.7 - Remove support for serialization based on `abomonation`. - Remove support for conversions between `nalgebra` types and `glam` 0.13. ### Modified + - The aliases for `Const` types have been simplified to help `rust-analyzer`. ### Added + - Add `TryFrom` conversion between `UnitVector2/3/4` and `glam`’s `Vec2/3/4`. - `nalgebra-sparse`: added support for serialization of sparse matrices with `serde`. - `nalgebra-sparse`: add a CSC matrix constructor from unsorted (but valid) data. - `nalgebra-lapack`: add generalized eigenvalues/eigenvectors calculation + QZ decomposition. ### Fixed + - Improve stability of SVD. - Fix slerp for `UnitComplex`. ## [0.30.1] (09 Jan. 2022) ### Added + - Add conversion from/to types of `glam` 0.19 and 0.20. ## [0.30.0] (02 Jan. 2022) ### Breaking changes + - The `Dim` trait is now marked as unsafe. - The `Matrix::pow` and `Matrix::pow_mut` methods only allow positive integer exponents now. To compute negative exponents, the user is free to invert the matrix before calling `pow` with the exponent’s absolute value. - Remove the `Bounded` requirement from `RealField`. Replace it by methods returning `Option` so that they can still be implemented by unbounded types (by returning `None`). -- The `ComplexField` trait derives from `FromPrimitive` again. We can actually keep this because all its methods +- The `ComplexField` trait derives from `FromPrimitive` again. We can actually keep this because all its methods return `Option`, meaning that it could be implemented by any type. ### Modified + - Use more concise debug impls for matrices and geometric transformation types. - The singular values computed by the SVD are now sorted in increasing order by default. Use `SVD::new_unordered` instead to reproduce the older behavior without the sorting overhead. @@ -159,6 +184,7 @@ This project adheres to [Semantic Versioning](https://semver.org/). - The `Matrix::pow` and `Matrix::pow_mut` methods will now also work with integer matrices. ### Added + - Added the conversion trait `From>` and method `from_vec_storage` for `RowDVector`. - Added implementation of `From` and `Into` for converting between `nalgebra` types and types from `glam 0.18`. These can be enabled by enabling the `convert-glam018` cargo features. @@ -179,6 +205,7 @@ This project adheres to [Semantic Versioning](https://semver.org/). - `nalgebra-sparse`: added reading MatrixMarked data files to a sparse `CooMatrix`. ### Fixed + - Fixed a potential unsoundness with `matrix.get(i)` and `matrix.get_mut(i)` where `i` is an `usize`, and `matrix` is a matrix slice with non-default strides. - Fixed potential unsoundness with `vector.perp` where `vector` isn’t actually a 2D vector as expected. @@ -187,11 +214,12 @@ This project adheres to [Semantic Versioning](https://semver.org/). - Fixed the `no-std` build of `nalgebra-glm`. - Fix the `pow` and `pow_mut` functions (the result was incorrect for some exponent values). - ## [0.29.0] + ### Breaking changes + - We updated to the version 0.6 of `simba`. This means that the trait bounds `T: na::RealField`, `na::ComplexField`, - `na::SimdRealField`, `na:SimdComplexField` no imply that `T: Copy` (they only imply that `T: Clone`). This may affect + `na::SimdRealField`, `na:SimdComplexField` no imply that `T: Copy` (they only imply that `T: Clone`). This may affect generic code. - The closure given to `apply`, `zip_apply`, `zip_zip_apply` must now modify the first argument inplace, instead of returning a new value. This makes these @@ -201,6 +229,7 @@ This project adheres to [Semantic Versioning](https://semver.org/). way. ### Modified + - `Orthographic3::from_matrix_unchecked` is now `const fn`. - `Perspective3::from_matrix_unchecked` is now `const fn`. - `Rotation::from_matrix_unchecked` is now `const fn`. @@ -208,6 +237,7 @@ This project adheres to [Semantic Versioning](https://semver.org/). `Copy` are now much safer to work with thanks to the refactoring of the `Allocator` system. ### Added + - The conversion traits form the `bytemuck` crates are now implemented for the geometric types too. - Added operator overloading for `Transform * UnitComplex`, `UnitComplex * Transform`, `Transform ×= UnitComplex`, `Transform ÷= UnitComplex`. @@ -218,47 +248,60 @@ This project adheres to [Semantic Versioning](https://semver.org/). cargo features. ## [0.28.0] + ### Added + - Implement `Hash` for `Transform`. - Implement `Borrow` and `BorrowMut` for contiguous slices. ### Modified -- The `OPoint` type has been added. It takes the dimension number as a type-level integer (e.g. `Const<3>`) instead + +- The `OPoint` 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` 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`) +- 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] + 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 conversions targeting the versions 0.13, 0.14, and 0.15 of `glam`. ### Added + - Add macros `matrix!`, `dmatrix!`, `vector!`, `dvector!`, `point!` for constructing matrices/vectors/points in a - more convenient way. See [#886](https://github.com/dimforge/nalgebra/pull/886) and [#899](https://github.com/dimforge/nalgebra/pull/899). -- Add `CooMatrix::reserve` to `nalgebra-sparse`. + more convenient way. See [#886](https://github.com/dimforge/nalgebra/pull/886) + and [#899](https://github.com/dimforge/nalgebra/pull/899). +- Add `CooMatrix::reserve` to `nalgebra-sparse`. - Add basic support for serialization using `rkyv`. Can be enabled with the features `rkyv-serialize` or `rkyv-serialize-no-std`. - ### Fixed + - Fixed a potential unsoundness issue after deserializing an invalid `DVector` using `serde`. ## [0.26.2] + ### Added + - Conversion from an array `[T; D]` to an isometry `Isometry` (as a translation). - Conversion from a static vector `SVector` to an isometry `Isometry` (as a translation). - Conversion from a point `Point` to an isometry `Isometry` (as a translation). @@ -268,23 +311,26 @@ conversions targeting the versions 0.13, 0.14, and 0.15 of `glam`. - Conversion of a glam type `Vec2/3/4` from/to a `Translation2/3/4`. ## [0.26.1] + Fix a regression introduced in 0.26.0 preventing `DVector` from being serialized with `serde`. ## [0.26.0] + 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) for details about this release. ### Added + - Add type aliases for unit vector, e.g., `UnitVector3`. - Add a `pow` and `pow_mut` function to square matrices. - Add `Cholesky::determinant` to compute the determinant of a matrix decomposed with Cholesky. - Add the `serde-serialize-no-std` feature to enable serialization of static matrices/vectors with serde, but without requiring `std`. - ### Modified + - The `serde` crate isn't enabled by default now. Enable the `serde-serialize` or the `serde-serialize-no-std` features instead. - The `Const` type has been introduced to represent dimensions known @@ -306,16 +352,22 @@ for details about this release. constructor is also a `const fn` now. ## [0.25.4] + ### Fixed + - Fix a compilation error when only the `serde-serialize` feature is enabled. ## [0.25.3] + ### Added + - The `Vector::simd_cap_magnitude` method to cap the magnitude of the vector with SIMD components. ## [0.25.2] + ### Added + - A `convert-glam` cargo feature to enable implementations of `From` traits to convert between `glam` types and `nalgebra` types. - A `convert-glam-unchecked` cargo feature to enable some extra `glam`/`nalgebra` conversions that may @@ -326,56 +378,70 @@ for details about this release. type of the components of a given entity. Example: `vector.cast::()`. ## [0.25.1] + This release replaces the version 0.25.0 which has been yanked. The 0.25.0 version added significant complication to build `nalgebra` targeting a `#[no-std]` platform not supported by `rand`. The `rand` dependency is now optional (and disabled by default). You may enable it with: + - The `rand-no-std` cargo feature when targeting a `#[no-std]` environment. - The `rand` cargo feature when targeting a `std` environment. ## [0.25.0] - Yanked + This updates all the dependencies of nalgebra to their latest version, including: + - rand 0.8 - proptest 1.0 - simba 0.4 ### New crate: nalgebra-sparse + 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, but it will be deprecated soon in favor of the `nalgebra-sparse` crate. ### Added + * Add `UnitDualQuaternion`, a dual-quaternion with unit magnitude which can be used as an isometry transformation. * Add `UDU::new()` and `matrix.udu()` to compute the UDU factorization of a matrix. * Add `ColPivQR::new()` and `matrix.col_piv_qr()` to compute the QR decomposition with column pivoting of a matrix. -* Add `from_basis_unchecked` to all the rotation types. This builds a rotation from a set of basis vectors (representing the columns of the corresponding rotation matrix). +* Add `from_basis_unchecked` to all the rotation types. This builds a rotation from a set of basis vectors (representing + the columns of the corresponding rotation matrix). * Add `Matrix::cap_magnitude` to cap the magnitude of a vector. -* Add `UnitQuaternion::append_axisangle_linearized` to approximately append a rotation represented as an axis-angle to a rotation represented as an unit quaternion. +* Add `UnitQuaternion::append_axisangle_linearized` to approximately append a rotation represented as an axis-angle to a + rotation represented as an unit quaternion. * Mark the iterators on matrix components as `DoubleEndedIter`. * Re-export `simba::simd::SimdValue` at the root of the `nalgebra` crate. ## [0.24.0] ### Added + * The `DualQuaternion` type. It is still work-in-progress, but the basics are here: creation from its real and dual part, multiplication of two dual quaternions, and normalization. - + ### Removed + * There is no blanket `impl PartialEq for Unit` anymore. Instead, it is implemented specifically for `UnitComplex`, `UnitQuaternion` and `Unit`. ## [0.23.2] + In this release, we improved the documentation of some of the geometric types by applying changes similar to what we did in the version 0.23.1 for matrices. ### Added + * The `Isometry::inv_mul` method which is a more efficient way of doing `isometry1.inverse() * isometry2`. ## [0.23.1] + In this release we improved the documentation of the matrix and vector types by: + - Grouping `impl` bocks logically, adding a title comment to these impl blocks. - Reference these impl blocks docs at the top of the documentation page for `Matrix`. - Reduce the depth of type aliasing. Now all vector and matrix types are aliases of `Matrix` @@ -384,237 +450,290 @@ In this release we improved the documentation of the matrix and vector types by: ## [0.23.0] ### Added - * The `.inverse_transform_unit_vector(v)` was added to `Rotation2/3`, `Isometry2/3`, `UnitQuaternion`, and `UnitComplex`. - It applies the corresponding rotation to a unit vector `Unit`. - * The `Point.map(f)` and `Point.apply(f)` to apply a function to each component of the point, similarly to `Vector.map(f)` - and `Vector.apply(f)`. - * 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 `Vector::ith_axis(i)` which build a unit vector, e.g., `Unit>` with its i-th component set to 1.0, and the - others set to zero. - * 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. - * The `Rotation2.slerp`, `Rotation3.slerp`, and `UnitQuaternion.slerp` method for - spherical interpolation. - + +* The `.inverse_transform_unit_vector(v)` was added to `Rotation2/3`, `Isometry2/3`, `UnitQuaternion`, + and `UnitComplex`. + It applies the corresponding rotation to a unit vector `Unit`. +* The `Point.map(f)` and `Point.apply(f)` to apply a function to each component of the point, similarly + to `Vector.map(f)` + and `Vector.apply(f)`. +* 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 `Vector::ith_axis(i)` which build a unit vector, e.g., `Unit>` with its i-th component set to 1.0, + and the + others set to zero. +* 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. +* The `Rotation2.slerp`, `Rotation3.slerp`, and `UnitQuaternion.slerp` method for + spherical interpolation. + ## [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 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 of nalgebra for your code to compile again. ### Added - * 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. - * `Cholesky::new_unchecked` which build a Cholesky decomposition without checking that its input is - 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, - except for `UnitQuaternion` which is initialized with the identity. - * Matrix exponential `matrix.exp()`. - * The `Vector::ith(i, x)` that builds a vector filled with zeros except for the `i`-th component set to `x`. + +* 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. +* `Cholesky::new_unchecked` which build a Cholesky decomposition without checking that its input is + 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, + except for `UnitQuaternion` which is initialized with the identity. +* Matrix exponential `matrix.exp()`. +* The `Vector::ith(i, x)` that builds a vector filled with zeros except for the `i`-th component set to `x`. ## [0.21.0] + In this release, we are no longer relying on traits from the __alga__ crate for our generic code. Instead, we use traits from the new [simba](https://crates.io/crates/simba) crate which are both -simpler, and allow for significant optimizations like AoSoA SIMD. +simpler, and allow for significant optimizations like AoSoA SIMD. Refer to the [monthly dimforge blogpost](https://www.dimforge.org/blog/2020/04/01/this-month-in-dimforge/) for details about this switch and its benefits. ### Added - * It is now possible to use SIMD types like `simba::f32x4` as scalar types for nalgebra's matrices and - geometric types. + +* It is now possible to use SIMD types like `simba::f32x4` as scalar types for nalgebra's matrices and + geometric types. + ### Modified - * Use of traits like `alga::general::{RealField, ComplexField}` have now been replaced by - `simba::scalar::{RealField, ComplexField}`. - * The implementation of traits from the __alga__ crate (and well as the dependency to _alga__) are now - omitted unless the `alga` cargo feature is activated. + +* Use of traits like `alga::general::{RealField, ComplexField}` have now been replaced by + `simba::scalar::{RealField, ComplexField}`. +* The implementation of traits from the __alga__ crate (and well as the dependency to _alga__) are now + omitted unless the `alga` cargo feature is activated. + ### Removed - * The `Neg` unary operator is no longer implemented for `UnitComplex` and `UnitQuaternion`. This caused - hard-to-track errors when we mistakenly write, e.g., `-q * v` instead of `-(q * v)`. - * The `na::convert_unchecked` is no longer marked as unsafe. + +* The `Neg` unary operator is no longer implemented for `UnitComplex` and `UnitQuaternion`. This caused + hard-to-track errors when we mistakenly write, e.g., `-q * v` instead of `-(q * v)`. +* The `na::convert_unchecked` is no longer marked as unsafe. ## [0.20.0] + ### Added - * `cholesky.rank_one_update(...)` which performs a rank-one update on the cholesky decomposition of a matrix. - * `From<&Matrix>` is now implemented for matrix slices. - * `.try_set_magnitude(...)` which sets the magnitude of a vector, while keeping its direction. - * Implementations of `From` and `Into` for the conversion between matrix slices and standard (`&[N]` `&mut [N]`) slices. + +* `cholesky.rank_one_update(...)` which performs a rank-one update on the cholesky decomposition of a matrix. +* `From<&Matrix>` is now implemented for matrix slices. +* `.try_set_magnitude(...)` which sets the magnitude of a vector, while keeping its direction. +* Implementations of `From` and `Into` for the conversion between matrix slices and standard (`&[N]` `&mut [N]`) slices. ### Modified - * We started some major changes in order to allow non-Copy types to be used as scalar types inside of matrices/vectors. + +* We started some major changes in order to allow non-Copy types to be used as scalar types inside of matrices/vectors. ## [0.19.0] + ### Added - * `.remove_rows_at` and `remove_columns_at` which removes a set of rows or columns (specified by indices) from a matrix. - * Several formatting traits have been implemented for all matrices/vectors: `LowerExp`, `UpperExp`, `Octal`, `LowerHex`, - `UpperHex`, `Binary`, `Pointer`. - * `UnitQuaternion::quaternions_mean(...)` which computes the mean rotation of a set of unit quaternions. This implements - the algorithm from _Oshman, Yaakov, and Avishy Carmi, "Attitude estimation from vector observations using a genetic-algorithm-embedded quaternion particle filter." + +* `.remove_rows_at` and `remove_columns_at` which removes a set of rows or columns (specified by indices) from a matrix. +* Several formatting traits have been implemented for all matrices/vectors: `LowerExp`, `UpperExp`, `Octal`, `LowerHex`, + `UpperHex`, `Binary`, `Pointer`. +* `UnitQuaternion::quaternions_mean(...)` which computes the mean rotation of a set of unit quaternions. This implements + the algorithm from _Oshman, Yaakov, and Avishy Carmi, "Attitude estimation from vector observations using a + genetic-algorithm-embedded quaternion particle filter." ### Modified - * It is now possible to get the `min/max` element of unsigned integer matrices. + +* It is now possible to get the `min/max` element of unsigned integer matrices. ### Added to nalgebra-glm - * Some infinite and reversed perspectives: `::infinite_perspective_rh_no`, `::infinite_perspective_rh_zo`, - `::reversed_perspective_rh_zo`, and `::reversed_infinite_perspective_rh_zo`. + +* Some infinite and reversed perspectives: `::infinite_perspective_rh_no`, `::infinite_perspective_rh_zo`, + `::reversed_perspective_rh_zo`, and `::reversed_infinite_perspective_rh_zo`. ## [0.18.0] + This release adds full complex number support to nalgebra. This includes all common vector/matrix operations as well as matrix decomposition. This excludes geometric type (like `Isometry`, `Rotation`, `Translation`, etc.) from the `geometry` module. ### Added + #### Quaternion and geometric operations - * Add trigonometric functions for quaternions: `.cos, .sin, .tan, .acos, .asin, .atan, .cosh, .sinh, .tanh, .acosh, .asinh, .atanh`. - * Add geometric algebra operations for quaternions: `.inner, .outer, .project, .rejection` - * Add `.left_div, .right_div` for quaternions. - * Add `.renormalize` to `Unit<...>` and `Rotation3` to correct potential drift due to repeated operations. - Those drifts could cause them not to be pure rotations anymore. + +* Add trigonometric functions for + quaternions: `.cos, .sin, .tan, .acos, .asin, .atan, .cosh, .sinh, .tanh, .acosh, .asinh, .atanh`. +* Add geometric algebra operations for quaternions: `.inner, .outer, .project, .rejection` +* Add `.left_div, .right_div` for quaternions. +* Add `.renormalize` to `Unit<...>` and `Rotation3` to correct potential drift due to repeated operations. + Those drifts could cause them not to be pure rotations anymore. #### Convolution - * `.convolve_full(kernel)` returns the convolution of `self` by `kernel`. - * `.convolve_valid(kernel)` returns the convolution of `self` by `kernel` after removal of all the elements relying on zero-padding. - * `.convolve_same(kernel)` returns the convolution of `self` by `kernel` with a result of the same size as `self`. + +* `.convolve_full(kernel)` returns the convolution of `self` by `kernel`. +* `.convolve_valid(kernel)` returns the convolution of `self` by `kernel` after removal of all the elements relying on + zero-padding. +* `.convolve_same(kernel)` returns the convolution of `self` by `kernel` with a result of the same size as `self`. #### Complex number support - * Add the `::from_matrix` constructor too all rotation types to extract a rotation from a raw matrix. - * Add the `::from_matrix_eps` constructor too all rotation types to extract a rotation from a raw matrix. This takes - more argument than `::from_matrix` to control the convergence of the underlying optimization algorithm. - * Add `.camax()` which returns the matrix component with the greatest L1-norm. - * Add `.camin()` which returns the matrix component with the smallest L1-norm. - * Add `.ad_mul(b)` for matrix-multiplication of `self.adjoint() * b`. - * Add `.ad_mul_to(b)` which is the same as `.ad_mul` but with a provided matrix to be filled with the result of the multiplication. - * Add BLAS operations involving complex conjugation (following similar names as the original BLAS spec): - * `.dotc(rhs)` equal to `self.adjoint() * rhs`. - * `.gerc(alpha, x, y, beta)` equivalent to `self = alpha * x * y.adjoint() + beta * self` - * `.hegerc` which is like `gerc` but for Hermitian matrices. - * `.syger` which is the new name of `.ger_symm` which is equivalent to `self = alpha * x * y.transpose() + beta * self`. - * `.sygemv` which is the new name of `.gemv_symm` which is equivalent to `self = alpha * a * x + beta * self` with `a` symmetric. - * `.hegemv(alpha, a, x, beta)` which is like `.sygemv` but with `a` Hermitian. - * `.gemv_ad(alpha, a, x, beta)` which is equivalent to `self = alpha * a.adjoint() * x + beta * self`. - * `.gemm_ad(alpha, a, b, beta)` which is equivalent to `self = alpha * a.adjoint() * b + beta * self`. - * `.icamax()` which returns the index of the complex vector component with the greatest L1-norm. + +* Add the `::from_matrix` constructor too all rotation types to extract a rotation from a raw matrix. +* Add the `::from_matrix_eps` constructor too all rotation types to extract a rotation from a raw matrix. This takes + more argument than `::from_matrix` to control the convergence of the underlying optimization algorithm. +* Add `.camax()` which returns the matrix component with the greatest L1-norm. +* Add `.camin()` which returns the matrix component with the smallest L1-norm. +* Add `.ad_mul(b)` for matrix-multiplication of `self.adjoint() * b`. +* Add `.ad_mul_to(b)` which is the same as `.ad_mul` but with a provided matrix to be filled with the result of the + multiplication. +* Add BLAS operations involving complex conjugation (following similar names as the original BLAS spec): + * `.dotc(rhs)` equal to `self.adjoint() * rhs`. + * `.gerc(alpha, x, y, beta)` equivalent to `self = alpha * x * y.adjoint() + beta * self` + * `.hegerc` which is like `gerc` but for Hermitian matrices. + * `.syger` which is the new name of `.ger_symm` which is equivalent + to `self = alpha * x * y.transpose() + beta * self`. + * `.sygemv` which is the new name of `.gemv_symm` which is equivalent to `self = alpha * a * x + beta * self` + with `a` symmetric. + * `.hegemv(alpha, a, x, beta)` which is like `.sygemv` but with `a` Hermitian. + * `.gemv_ad(alpha, a, x, beta)` which is equivalent to `self = alpha * a.adjoint() * x + beta * self`. + * `.gemm_ad(alpha, a, b, beta)` which is equivalent to `self = alpha * a.adjoint() * b + beta * self`. + * `.icamax()` which returns the index of the complex vector component with the greatest L1-norm. Note that all the other BLAS operation will continue to work for all fields, including floats and complex numbers. ### Renamed - * `RealSchur` has been renamed `Schur` because it can now work with complex matrices. +* `RealSchur` has been renamed `Schur` because it can now work with complex matrices. ## [0.17.0] ### Added - * Add swizzling up to dimension 3 for vectors. For example, you can do `v.zxy()` as an equivalent to `Vector3::new(v.z, v.x, v.y)`. - * Add swizzling up to dimension 3 for points. For example, you can do `p.zxy()` as an equivalent to `Point3::new(p.z, p.x, p.y)`. - * Add `.copy_from_slice` to copy matrix components from a slice in column-major order. - * Add `.dot` to quaternions. - * Add `.zip_zip_map` for iterating on three matrices simultaneously, and applying a closure to them. - * Add `.slerp` and `.try_slerp` to unit vectors. - * Add `.lerp` to vectors. - * Add `.to_projective` and `.as_projective` to `Perspective3` and `Orthographic3` in order to - use them as `Projective3` structures. - * Add `From/Into` impls to allow the conversion of any transformation type to a matrix. - * Add `Into` impls to convert a matrix slice into an owned matrix. - * Add `Point*::from_slice` to create a point from a slice. - * Add `.map_with_location` to matrices to apply a map which passes the component indices to the user-defined closure alongside - the component itself. - * Add impl `From` for `Point`. - * Add impl `From` for `Quaternion`. - * Add impl `From` for `Translation`. - * Add the `::from_vec` constructor to construct a matrix from a `Vec` (a `DMatrix` will reuse the original `Vec` - as-is for its storage). - * Add `.to_homogeneous` to square matrices (and with dimensions higher than 1x1). This will increase their number of row - and columns by 1. The new column and row are filled with 0, except for the diagonal element which is set to 1. - * Implement `Extend` for matrices with a dynamic storage. The provided `Vec` is assumed to represent a column-major - matrix with the same number of rows as the one being extended. This will effectively append new columns on the right of - the matrix being extended. - * Implement `Extend` for vectors with a dynamic storage. This will concatenate the vector with the given `Vec`. - * Implement `Extend>` for matrices with dynamic storage. This will concatenate the columns of both matrices. - * Implement `Into` for the `MatrixVec` storage. - * Implement `Hash` for all matrices. - * Add a `.len()` method to retrieve the size of a `MatrixVec`. + +* Add swizzling up to dimension 3 for vectors. For example, you can do `v.zxy()` as an equivalent + to `Vector3::new(v.z, v.x, v.y)`. +* Add swizzling up to dimension 3 for points. For example, you can do `p.zxy()` as an equivalent + to `Point3::new(p.z, p.x, p.y)`. +* Add `.copy_from_slice` to copy matrix components from a slice in column-major order. +* Add `.dot` to quaternions. +* Add `.zip_zip_map` for iterating on three matrices simultaneously, and applying a closure to them. +* Add `.slerp` and `.try_slerp` to unit vectors. +* Add `.lerp` to vectors. +* Add `.to_projective` and `.as_projective` to `Perspective3` and `Orthographic3` in order to + use them as `Projective3` structures. +* Add `From/Into` impls to allow the conversion of any transformation type to a matrix. +* Add `Into` impls to convert a matrix slice into an owned matrix. +* Add `Point*::from_slice` to create a point from a slice. +* Add `.map_with_location` to matrices to apply a map which passes the component indices to the user-defined closure + alongside + the component itself. +* Add impl `From` for `Point`. +* Add impl `From` for `Quaternion`. +* Add impl `From` for `Translation`. +* Add the `::from_vec` constructor to construct a matrix from a `Vec` (a `DMatrix` will reuse the original `Vec` + as-is for its storage). +* Add `.to_homogeneous` to square matrices (and with dimensions higher than 1x1). This will increase their number of row + and columns by 1. The new column and row are filled with 0, except for the diagonal element which is set to 1. +* Implement `Extend` for matrices with a dynamic storage. The provided `Vec` is assumed to represent a column-major + matrix with the same number of rows as the one being extended. This will effectively append new columns on the right + of + the matrix being extended. +* Implement `Extend` for vectors with a dynamic storage. This will concatenate the vector with the given `Vec`. +* Implement `Extend>` for matrices with dynamic storage. This will concatenate the columns of both matrices. +* Implement `Into` for the `MatrixVec` storage. +* Implement `Hash` for all matrices. +* Add a `.len()` method to retrieve the size of a `MatrixVec`. ### Modified - * The orthographic projection no longer require that `bottom < top`, that `left < right`, and that `znear < zfar`. The - only restriction now ith that they must not be equal (in which case the projection would be singular). - * The `Point::from_coordinates` methods is deprecated. Use `Point::from` instead. - * The `.transform_point` and `.transform_vector` methods are now inherent methods for matrices so that the user does not have to - explicitly import the `Transform` trait from the alga crate. - * Renamed the matrix storage types: `MatrixArray` -> `ArrayStorage` and `MatrixVec` -> `VecStorage`. - * Renamed `.unwrap()` to `.into_inner()` for geometric types that wrap another type. - This is for the case of `Unit`, `Transform`, `Orthographic3`, `Perspective3`, `Rotation`. - * Deprecate several functions at the root of the crate (replaced by methods). + +* The orthographic projection no longer require that `bottom < top`, that `left < right`, and that `znear < zfar`. The + only restriction now ith that they must not be equal (in which case the projection would be singular). +* The `Point::from_coordinates` methods is deprecated. Use `Point::from` instead. +* The `.transform_point` and `.transform_vector` methods are now inherent methods for matrices so that the user does not + have to + explicitly import the `Transform` trait from the alga crate. +* Renamed the matrix storage types: `MatrixArray` -> `ArrayStorage` and `MatrixVec` -> `VecStorage`. +* Renamed `.unwrap()` to `.into_inner()` for geometric types that wrap another type. + This is for the case of `Unit`, `Transform`, `Orthographic3`, `Perspective3`, `Rotation`. +* Deprecate several functions at the root of the crate (replaced by methods). ### Removed + * Remove the `Deref` impl for `MatrixVec` as it could cause hard-to-understand compilation errors. ### nalgebra-glm - * Add several alternative projection computations, e.g., `ortho_lh`, `ortho_lh_no`, `perspective_lh`, etc. - * Add features matching those of nalgebra, in particular: `serde-serialize`, `abmonation-serialize`, std` (enabled by default). + +* Add several alternative projection computations, e.g., `ortho_lh`, `ortho_lh_no`, `perspective_lh`, etc. +* Add features matching those of nalgebra, in particular:`serde-serialize`, `abmonation-serialize`, std` (enabled by + default). ## [0.16.0] + All dependencies have been updated to their latest versions. ## Modified - * Adjust `UnitQuaternion`s, `Rotation3`s, and `Rotation2`s generated from the `Standard` distribution to be uniformly distributed. + +* Adjust `UnitQuaternion`s, `Rotation3`s, and `Rotation2`s generated from the `Standard` distribution to be uniformly + distributed. + ### Added - * Add a feature `stdweb` to activate the dependency feature `rand/stdweb`. - * Add blas-like methods `.imin()` and `.imax()` that return the index of the minimum and maximum entry of a vector. - * Add construction of a `Point` from an array by implementing the `From` trait. - * Add support for generating uniformly distributed random unit column vectors using the `Standard` distribution. + +* Add a feature `stdweb` to activate the dependency feature `rand/stdweb`. +* Add blas-like methods `.imin()` and `.imax()` that return the index of the minimum and maximum entry of a vector. +* Add construction of a `Point` from an array by implementing the `From` trait. +* Add support for generating uniformly distributed random unit column vectors using the `Standard` distribution. ## [0.15.0] + The most notable change of this release is the support for using part of the library without the rust standard -library (i.e. it supports `#![no_std]`). See the corresponding [documentation](https://nalgebra.org/wasm_and_embedded_programming/). +library (i.e. it supports `#![no_std]`). See the +corresponding [documentation](https://nalgebra.org/wasm_and_embedded_programming/). + ### Modified - * Rename the `core` module to `base` to avoid conflicts with the `core` crate implicitly imported when - `#![no_std]` is enabled. - * Constructors of the `MatrixSlice*` types have been renamed from `new_*` to `from_slice_*`. This was - necessary to avoid the `incoherent_fundamental_impls` lint that is going to become a hard error. + +* Rename the `core` module to `base` to avoid conflicts with the `core` crate implicitly imported when + `#![no_std]` is enabled. +* Constructors of the `MatrixSlice*` types have been renamed from `new_*` to `from_slice_*`. This was + necessary to avoid the `incoherent_fundamental_impls` lint that is going to become a hard error. + ### Added - * Add `UnitQuaternion` constructor `::new_eps(...)` and `::from_scaled_axis_eps(...)` that return the - identity if the magnitude of the input axisangle is smaller than the epsilon provided. - * Add methods `.rotation_between_axis(...)` and `.scaled_rotation_between_axis(...)` to `UnitComplex` - to compute the rotation matrix between two 2D **unit** vectors. - * Add methods `.axis_angle()` to `UnitComplex` and `UnitQuaternion` in order to retrieve both the - unit rotation axis, and the rotation angle simultaneously. - * Add functions to construct a random matrix with a user-defined distribution: `::from_distribution(...)`. + +* Add `UnitQuaternion` constructor `::new_eps(...)` and `::from_scaled_axis_eps(...)` that return the + identity if the magnitude of the input axisangle is smaller than the epsilon provided. +* Add methods `.rotation_between_axis(...)` and `.scaled_rotation_between_axis(...)` to `UnitComplex` + to compute the rotation matrix between two 2D **unit** vectors. +* Add methods `.axis_angle()` to `UnitComplex` and `UnitQuaternion` in order to retrieve both the + unit rotation axis, and the rotation angle simultaneously. +* Add functions to construct a random matrix with a user-defined distribution: `::from_distribution(...)`. ## [0.14.0] + ### Modified - * Allow the `Isometry * Unit` multiplication. + +* Allow the `Isometry * Unit` multiplication. + ### Added - * Add blas-like operations: `.quadform(...)` and `.quadform_tr(...)` to compute respectively - the quadratic forms `self = alpha * A.transpose() * B * A + beta * self` and - `alpha * A * B * A.transpose() + beta * self`. Here, `A, B` are matrices with - `B` square, and `alpha, beta` are reals. - * Add blas-like operations: `.gemv_tr(...)` that behaves like `.gemv` except that the - provided matrix is assumed to be transposed. - * Add blas-like operations: `cmpy, cdpy` for component-wise multiplications and - division with scalar factors: - - `self <- alpha * self + beta * a * b` - - `self <- alpha * self + beta * a / b` - * `.cross_matrix()` returns the cross-product matrix of a given 3D vector, i.e., - the matrix `M` such that for all vector `v` we have - `M * v == self.cross(&v)`. - * `.iamin()` that returns the index of the vector entry with - the smallest absolute value. - * 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. - * Aliases for matrix and vector slices. Their are named by adding `Slice` - before the dimension numbers, i.e., a 3x5 matrix slice with dimensions known - at compile-time is called `MatrixSlice3x5`. A vector slice with dimensions - unknown at compile-time is called `DVectorSlice`. - * Add functions for constructing matrix slices from a slice `&[N]`, e.g., - `MatrixSlice2::new(...)` and `MatrixSlice2::new_with_strides(...)`. - * The `::repeat(...)` constructor that is an alternative name to - `::from_element(...)`. - * `UnitQuaternion::scaled_rotation_between_axis(...)` and - `UnitQuaternion::rotation_between_axis(...)` that take Unit vectors instead of - Vector as arguments. - +* Add blas-like operations: `.quadform(...)` and `.quadform_tr(...)` to compute respectively + the quadratic forms `self = alpha * A.transpose() * B * A + beta * self` and + `alpha * A * B * A.transpose() + beta * self`. Here, `A, B` are matrices with + `B` square, and `alpha, beta` are reals. +* Add blas-like operations: `.gemv_tr(...)` that behaves like `.gemv` except that the + provided matrix is assumed to be transposed. +* Add blas-like operations: `cmpy, cdpy` for component-wise multiplications and + division with scalar factors: + - `self <- alpha * self + beta * a * b` + - `self <- alpha * self + beta * a / b` +* `.cross_matrix()` returns the cross-product matrix of a given 3D vector, i.e., + the matrix `M` such that for all vector `v` we have + `M * v == self.cross(&v)`. +* `.iamin()` that returns the index of the vector entry with + the smallest absolute value. +* 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. +* Aliases for matrix and vector slices. Their are named by adding `Slice` + before the dimension numbers, i.e., a 3x5 matrix slice with dimensions known + at compile-time is called `MatrixSlice3x5`. A vector slice with dimensions + unknown at compile-time is called `DVectorSlice`. +* Add functions for constructing matrix slices from a slice `&[N]`, e.g., + `MatrixSlice2::new(...)` and `MatrixSlice2::new_with_strides(...)`. +* The `::repeat(...)` constructor that is an alternative name to + `::from_element(...)`. +* `UnitQuaternion::scaled_rotation_between_axis(...)` and + `UnitQuaternion::rotation_between_axis(...)` that take Unit vectors instead of + Vector as arguments. ## [0.13.0] @@ -625,157 +744,175 @@ This adds support for serialization using the [abomonation](https://crates.io/crates/abomonation) crate. ### Breaking semantic change - * The implementation of slicing with steps now matches the documentation. - Before, step identified the number to add to pass from one column/row index - to the next one. This made 0 step invalid. Now (and on the documentation so - far), the step is the number of ignored row/columns between each - row/column. Thus, a step of 0 means that no row/column is ignored. For - example, a step of, say, 3 on previous versions should now bet set to 2. + +* The implementation of slicing with steps now matches the documentation. + Before, step identified the number to add to pass from one column/row index + to the next one. This made 0 step invalid. Now (and on the documentation so + far), the step is the number of ignored row/columns between each + row/column. Thus, a step of 0 means that no row/column is ignored. For + example, a step of, say, 3 on previous versions should now bet set to 2. ### Modified - * The trait `Axpy` has been replaced by a method `.axpy`. - * The alias `MatrixNM` is now deprecated. Use `MatrixMN` instead (we - reordered M and N to be in alphabetical order). - * In-place componentwise multiplication and division - `.component_mul_mut(...)` and `.component_div_mut(...)` have been deprecated - for a future renaming. Use `.component_mul_assign(...)` and - `.component_div_assign(...)` instead. + +* The trait `Axpy` has been replaced by a method `.axpy`. +* The alias `MatrixNM` is now deprecated. Use `MatrixMN` instead (we + reordered M and N to be in alphabetical order). +* In-place componentwise multiplication and division + `.component_mul_mut(...)` and `.component_div_mut(...)` have been deprecated + for a future renaming. Use `.component_mul_assign(...)` and + `.component_div_assign(...)` instead. ### Added - * `alga::general::Real` is now re-exported by nalgebra. - elements.) - * `::zeros(...)` that creates a matrix filled with zeroes. - * `::from_partial_diagonal(...)` that creates a matrix from diagonal elements. - The matrix can be rectangular. If not enough elements are provided, the rest - of the diagonal is set to 0. - * `.conjugate_transpose()` computes the transposed conjugate of a - complex matrix. - * `.conjugate_transpose_to(...)` computes the transposed conjugate of a - complex matrix. The result written into a user-provided matrix. - * `.transpose_to(...)` is the same as `.transpose()` but stores the result in - the provided matrix. - * `.conjugate_transpose_to(...)` is the same as `.conjugate_transpose()` but - stores the result in the provided matrix. - * Implements `IntoIterator` for `&Matrix`, `&mut Matrix` and `Matrix`. - * `.mul_to(...)` multiplies two matrices and stores the result to the given buffer. - * `.tr_mul_to(...)` left-multiplies `self.transpose()` to another matrix and stores the result to the given buffer. - * `.add_scalar(...)` that adds a scalar to each component of a matrix. - * `.add_scalar_mut(...)` that adds in-place a scalar to each component of a matrix. - * `.kronecker(a, b)` computes the kronecker product (i.e. matrix tensor - product) of two matrices. - * `.apply(f)` replaces each component of a matrix with the results of the - closure `f` called on each of them. + +* `alga::general::Real` is now re-exported by nalgebra. + elements.) +* `::zeros(...)` that creates a matrix filled with zeroes. +* `::from_partial_diagonal(...)` that creates a matrix from diagonal elements. + The matrix can be rectangular. If not enough elements are provided, the rest + of the diagonal is set to 0. +* `.conjugate_transpose()` computes the transposed conjugate of a + complex matrix. +* `.conjugate_transpose_to(...)` computes the transposed conjugate of a + complex matrix. The result written into a user-provided matrix. +* `.transpose_to(...)` is the same as `.transpose()` but stores the result in + the provided matrix. +* `.conjugate_transpose_to(...)` is the same as `.conjugate_transpose()` but + stores the result in the provided matrix. +* Implements `IntoIterator` for `&Matrix`, `&mut Matrix` and `Matrix`. +* `.mul_to(...)` multiplies two matrices and stores the result to the given buffer. +* `.tr_mul_to(...)` left-multiplies `self.transpose()` to another matrix and stores the result to the given buffer. +* `.add_scalar(...)` that adds a scalar to each component of a matrix. +* `.add_scalar_mut(...)` that adds in-place a scalar to each component of a matrix. +* `.kronecker(a, b)` computes the kronecker product (i.e. matrix tensor + product) of two matrices. +* `.apply(f)` replaces each component of a matrix with the results of the + closure `f` called on each of them. Pure Rust implementation of some Blas operations: - * `.iamax()` returns the index of the maximum value of a vector. - * `.axpy(...)` computes `self = a * x + b * self`. - * `.gemv(...)` computes `self = alpha * a * x + beta * self` with a matrix and vector `a` and `x`. - * `.ger(...)` computes `self = alpha * x^t * y + beta * self` where `x` and `y` are vectors. - * `.gemm(...)` computes `self = alpha * a * b + beta * self` where `a` and `b` are matrices. - * `.gemv_symm(...)` is the same as `.gemv` except that `self` is assumed symmetric. - * `.ger_symm(...)` is the same as `.ger` except that `self` is assumed symmetric. +* `.iamax()` returns the index of the maximum value of a vector. +* `.axpy(...)` computes `self = a * x + b * self`. +* `.gemv(...)` computes `self = alpha * a * x + beta * self` with a matrix and vector `a` and `x`. +* `.ger(...)` computes `self = alpha * x^t * y + beta * self` where `x` and `y` are vectors. +* `.gemm(...)` computes `self = alpha * a * b + beta * self` where `a` and `b` are matrices. +* `.gemv_symm(...)` is the same as `.gemv` except that `self` is assumed symmetric. +* `.ger_symm(...)` is the same as `.ger` except that `self` is assumed symmetric. New slicing methods: - * `.rows_range(...)` that retrieves a reference to a range of rows. - * `.rows_range_mut(...)` that retrieves a mutable reference to a range of rows. - * `.columns_range(...)` that retrieves a reference to a range of columns. - * `.columns_range_mut(...)` that retrieves a mutable reference to a range of columns. + +* `.rows_range(...)` that retrieves a reference to a range of rows. +* `.rows_range_mut(...)` that retrieves a mutable reference to a range of rows. +* `.columns_range(...)` that retrieves a reference to a range of columns. +* `.columns_range_mut(...)` that retrieves a mutable reference to a range of columns. Matrix decompositions implemented in pure Rust: - * Cholesky, SVD, LU, QR, Hessenberg, Schur, Symmetric eigendecompositions, - Bidiagonal, Symmetric tridiagonal - * Computation of householder reflectors and givens rotations. + +* Cholesky, SVD, LU, QR, Hessenberg, Schur, Symmetric eigendecompositions, + Bidiagonal, Symmetric tridiagonal +* Computation of householder reflectors and givens rotations. Matrix edition: - * `.upper_triangle()` extracts the upper triangle of a matrix, including the diagonal. - * `.lower_triangle()` extracts the lower triangle of a matrix, including the diagonal. - * `.fill(...)` fills the matrix with a single value. - * `.fill_with_identity(...)` fills the matrix with the identity. - * `.fill_diagonal(...)` fills the matrix diagonal with a single value. - * `.fill_row(...)` fills a selected matrix row with a single value. - * `.fill_column(...)` fills a selected matrix column with a single value. - * `.set_diagonal(...)` sets the matrix diagonal. - * `.set_row(...)` sets a selected row. - * `.set_column(...)` sets a selected column. - * `.fill_lower_triangle(...)` fills some sub-diagonals below the main diagonal with a value. - * `.fill_upper_triangle(...)` fills some sub-diagonals above the main diagonal with a value. - * `.swap_rows(...)` swaps two rows. - * `.swap_columns(...)` swaps two columns. + +* `.upper_triangle()` extracts the upper triangle of a matrix, including the diagonal. +* `.lower_triangle()` extracts the lower triangle of a matrix, including the diagonal. +* `.fill(...)` fills the matrix with a single value. +* `.fill_with_identity(...)` fills the matrix with the identity. +* `.fill_diagonal(...)` fills the matrix diagonal with a single value. +* `.fill_row(...)` fills a selected matrix row with a single value. +* `.fill_column(...)` fills a selected matrix column with a single value. +* `.set_diagonal(...)` sets the matrix diagonal. +* `.set_row(...)` sets a selected row. +* `.set_column(...)` sets a selected column. +* `.fill_lower_triangle(...)` fills some sub-diagonals below the main diagonal with a value. +* `.fill_upper_triangle(...)` fills some sub-diagonals above the main diagonal with a value. +* `.swap_rows(...)` swaps two rows. +* `.swap_columns(...)` swaps two columns. Column removal: - * `.remove_column(...)` removes one column. - * `.remove_fixed_columns(...)` removes `D` columns. - * `.remove_columns(...)` removes a number of columns known at run-time. + +* `.remove_column(...)` removes one column. +* `.remove_fixed_columns(...)` removes `D` columns. +* `.remove_columns(...)` removes a number of columns known at run-time. Row removal: - * `.remove_row(...)` removes one row. - * `.remove_fixed_rows(...)` removes `D` rows. - * `.remove_rows(...)` removes a number of rows known at run-time. + +* `.remove_row(...)` removes one row. +* `.remove_fixed_rows(...)` removes `D` rows. +* `.remove_rows(...)` removes a number of rows known at run-time. Column insertion: - * `.insert_column(...)` adds one column at the given position. - * `.insert_fixed_columns(...)` adds `D` columns at the given position. - * `.insert_columns(...)` adds at the given position a number of columns known at run-time. + +* `.insert_column(...)` adds one column at the given position. +* `.insert_fixed_columns(...)` adds `D` columns at the given position. +* `.insert_columns(...)` adds at the given position a number of columns known at run-time. Row insertion: - * `.insert_row(...)` adds one row at the given position. - * `.insert_fixed_rows(...)` adds `D` rows at the given position. - * `.insert_rows(...)` adds at the given position a number of rows known at run-time. + +* `.insert_row(...)` adds one row at the given position. +* `.insert_fixed_rows(...)` adds `D` rows at the given position. +* `.insert_rows(...)` adds at the given position a number of rows known at run-time. ## [0.12.0] + The main change of this release is the update of the dependency serde to 1.0. ### Added - * `.trace()` that computes the trace of a matrix (the sum of its diagonal - elements.) + +* `.trace()` that computes the trace of a matrix (the sum of its diagonal + elements.) ## [0.11.0] + The [website](https://nalgebra.org) has been fully rewritten and gives a good overview of all the added/modified features. This version is a major rewrite of the library. Major changes are: - * Algebraic traits are now defined by the [alga](https://crates.io/crates/alga) crate. - All other mathematical traits, except `Axpy` have been removed from - **nalgebra**. - * Methods are now preferred to free functions because they do not require any - trait to be used anymore. - * Most algebraic entities can be parametrized by type-level integers - to specify their dimensions. Using `Dynamic` instead of a type-level - integer indicates that the dimension known at run-time only. - * Statically-sized **rectangular** matrices. - * More transformation types have been added: unit-sized complex numbers (for - 2D rotations), affine/projective/general transformations with `Affine2/3`, - `Projective2/3`, and `Transform2/3`. - * Serde serialization is now supported instead of `rustc_serialize`. Enable - it with the `serde-serialize` feature. - * Matrix **slices** are now implemented. + +* Algebraic traits are now defined by the [alga](https://crates.io/crates/alga) crate. + All other mathematical traits, except `Axpy` have been removed from + **nalgebra**. +* Methods are now preferred to free functions because they do not require any + trait to be used anymore. +* Most algebraic entities can be parametrized by type-level integers + to specify their dimensions. Using `Dynamic` instead of a type-level + integer indicates that the dimension known at run-time only. +* Statically-sized **rectangular** matrices. +* More transformation types have been added: unit-sized complex numbers (for + 2D rotations), affine/projective/general transformations with `Affine2/3`, + `Projective2/3`, and `Transform2/3`. +* Serde serialization is now supported instead of `rustc_serialize`. Enable + it with the `serde-serialize` feature. +* Matrix **slices** are now implemented. ### Added + Lots of features including rectangular matrices, slices, and Serde serialization. Refer to the brand new [website](https://nalgebra.org) for more details. The following free-functions have been added as well: - * `::id()` that returns the universal [identity element](https://nalgebra.org/performance_tricks/#the-id-type) - of type `Id`. - * `::inf_sup()` that returns both the infimum and supremum of a value at the - same time. - * `::partial_sort2()` that attempts to sort two values in increasing order. - * `::wrap()` that moves a value to the given interval by adding or removing - the interval width to it. + +* `::id()` that returns the universal [identity element](https://nalgebra.org/performance_tricks/#the-id-type) + of type `Id`. +* `::inf_sup()` that returns both the infimum and supremum of a value at the + same time. +* `::partial_sort2()` that attempts to sort two values in increasing order. +* `::wrap()` that moves a value to the given interval by adding or removing + the interval width to it. ### Modified - * `::cast` -> `::convert` - * `point.as_vector()` -> `point.coords` - * `na::origin` -> `P::origin()` - * `na::is_zero` -> `.is_zero()` (from num::Zero) - * `.transform` -> `.transform_point`/`.transform_vector` - * `.translate` -> `.translate_point` - * `::dimension::

` -> `::dimension::` - * `::angle_between` -> `::angle` + +* `::cast` -> `::convert` +* `point.as_vector()` -> `point.coords` +* `na::origin` -> `P::origin()` +* `na::is_zero` -> `.is_zero()` (from num::Zero) +* `.transform` -> `.transform_point`/`.transform_vector` +* `.translate` -> `.translate_point` +* `::dimension::

` -> `::dimension::` +* `::angle_between` -> `::angle` Componentwise multiplication and division has been replaced by methods: - * multiplication -> `.componentwise_mul`, `.componentwise_mul_mut`. - * division -> `.componentwise_div`, `.componentwise_div_mut`. + +* multiplication -> `.componentwise_mul`, `.componentwise_mul_mut`. +* division -> `.componentwise_div`, `.componentwise_div_mut`. The following free-functions are now replaced by methods (with the same names) only: @@ -783,63 +920,66 @@ only: `.eig`), `::hessenberg`, `::qr`, `::to_homogeneous`, `::to_rotation_matrix`, `::transpose`, `::shape`. - The following free-functions are now replaced by static methods only: - * `::householder_matrix` under the name `::new_householder_generic` - * `::identity` - * `::new_identity` under the name `::identity` - * `::from_homogeneous` - * `::repeat` under the name `::from_element` + +* `::householder_matrix` under the name `::new_householder_generic` +* `::identity` +* `::new_identity` under the name `::identity` +* `::from_homogeneous` +* `::repeat` under the name `::from_element` The following free-function are now replaced methods accessible through traits only: - * `::transform` -> methods `.transform_point` and `.transform_vector` of the `alga::linear::Transformation` trait. - * `::inverse_transform` -> methods `.inverse_transform_point` and - `.inverse_transform_vector` of the `alga::linear::ProjectiveTransformation` - trait. - * `::translate`, `::inverse_translate`, `::rotate`, `::inverse_rotate` -> - methods from the `alga::linear::Similarity` trait instead. Those have the - same names but end with `_point` or `_vector`, e.g., `.translate_point` and - `.translate_vector`. - * `::orthonormal_subspace_basis` -> method with the same name from - `alga::linear::FiniteDimInnerSpace`. - * `::canonical_basis_element` and `::canonical_basis` -> methods with the - same names from `alga::linear::FiniteDimVectorSpace`. - * `::rotation_between` -> method with the same name from the - `alga::linear::Rotation` trait. - * `::is_zero` -> method with the same name from `num::Zero`. - +* `::transform` -> methods `.transform_point` and `.transform_vector` of the `alga::linear::Transformation` trait. +* `::inverse_transform` -> methods `.inverse_transform_point` and + `.inverse_transform_vector` of the `alga::linear::ProjectiveTransformation` + trait. +* `::translate`, `::inverse_translate`, `::rotate`, `::inverse_rotate` -> + methods from the `alga::linear::Similarity` trait instead. Those have the + same names but end with `_point` or `_vector`, e.g., `.translate_point` and + `.translate_vector`. +* `::orthonormal_subspace_basis` -> method with the same name from + `alga::linear::FiniteDimInnerSpace`. +* `::canonical_basis_element` and `::canonical_basis` -> methods with the + same names from `alga::linear::FiniteDimVectorSpace`. +* `::rotation_between` -> method with the same name from the + `alga::linear::Rotation` trait. +* `::is_zero` -> method with the same name from `num::Zero`. ### Removed - * The free functions `::prepend_rotation`, `::append_rotation`, - `::append_rotation_wrt_center`, `::append_rotation_wrt_point`, - `::append_transformation`, and `::append_translation ` have been removed. - Instead, create the rotation or translation object explicitly and use - multiplication to compose it with anything else. - * The free function `::outer` has been removed. Use column-vector × - row-vector multiplication instead. +* The free functions `::prepend_rotation`, `::append_rotation`, + `::append_rotation_wrt_center`, `::append_rotation_wrt_point`, + `::append_transformation`, and `::append_translation ` have been removed. + Instead, create the rotation or translation object explicitly and use + multiplication to compose it with anything else. - * `::approx_eq`, `::approx_eq_eps` have been removed. Use the `relative_eq!` - macro from the [approx](https://crates.io/crates/approx) crate instead. +* The free function `::outer` has been removed. Use column-vector × + row-vector multiplication instead. - * `::covariance` has been removed. There is no replacement for now. - * `::mean` has been removed. There is no replacement for now. - * `::sample_sphere` has been removed. There is no replacement for now. - * `::cross_matrix` has been removed. There is no replacement for now. - * `::absolute_rotate` has been removed. There is no replacement for now. - * `::rotation`, `::transformation`, `::translation`, `::inverse_rotation`, - `::inverse_transformation`, `::inverse_translation` have been removed. Use - the appropriate methods/field of each transformation type, e.g., - `rotation.angle()` and `rotation.axis()`. +* `::approx_eq`, `::approx_eq_eps` have been removed. Use the `relative_eq!` + macro from the [approx](https://crates.io/crates/approx) crate instead. + +* `::covariance` has been removed. There is no replacement for now. +* `::mean` has been removed. There is no replacement for now. +* `::sample_sphere` has been removed. There is no replacement for now. +* `::cross_matrix` has been removed. There is no replacement for now. +* `::absolute_rotate` has been removed. There is no replacement for now. +* `::rotation`, `::transformation`, `::translation`, `::inverse_rotation`, + `::inverse_transformation`, `::inverse_translation` have been removed. Use + the appropriate methods/field of each transformation type, e.g., + `rotation.angle()` and `rotation.axis()`. ## [0.10.0] + ### Added + Binary operations are now allowed between references as well. For example `Vector3 + &Vector3` is now possible. ### Modified + Removed unused parameters to methods from the `ApproxEq` trait. Those were 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`: @@ -847,8 +987,10 @@ since it now allowed to write for a type `T` that implements `ApproxEq`: `ApproxEq::approx_epsilon(None::)`. ## [0.9.0] + ### Modified - * Renamed: + +* Renamed: - `::from_col_vector` -> `::from_column_vector` - `::from_col_iter` -> `::from_column_iter` - `.col_slice` -> `.column_slice` @@ -869,18 +1011,20 @@ Other similar trait changes are to be expected in the future, e.g., for the Methods marked `unsafe` for reasons unrelated to memory safety are no longer unsafe. Instead, their name end with `_unchecked`. In particular: + * `Rotation3::new_with_matrix` -> `Rotation3::from_matrix_unchecked` * `PerspectiveMatrix3::new_with_matrix` -> `PerspectiveMatrix3::from_matrix_unchecked` * `OrthographicMatrix3::new_with_matrix` -> `OrthographicMatrix3::from_matrix_unchecked` ### Added + - A `Unit` type that wraps normalized values. In particular, `UnitQuaternion` is now an alias for `Unit>`. - `.ln()`, `.exp()` and `.powf(..)` for quaternions and unit quaternions. - `::from_parts(...)` to build a quaternion from its scalar and vector parts. - The `Norm` trait now has a `try_normalize()` that returns `None` if the -norm is too small. + norm is too small. - The `BaseFloat` and `FloatVector` traits now inherit from `ApproxEq` as well. It is clear that performing computations with floats requires approximate equality. @@ -890,51 +1034,61 @@ crate for vectors, rotations and points. To enable them, activate the `abstract_algebra` feature. ## [0.8.0] + ### Modified - * Almost everything (types, methods, and traits) now use fulls names instead - of abbreviations (e.g. `Vec3` becomes `Vector3`). Most changes are obvious. - Note however that: + +* Almost everything (types, methods, and traits) now use fulls names instead + of abbreviations (e.g. `Vec3` becomes `Vector3`). Most changes are obvious. + Note however that: - `::sqnorm` becomes `::norm_squared`. - `::sqdist` becomes `::distance_squared`. - `::abs`, `::min`, etc. did not change as this is a common name for absolute values on, e.g., the libc. - Dynamically sized structures keep the `D` prefix, e.g., `DMat` becomes `DMatrix`. - * All files with abbreviated names have been renamed to their full version, - e.g., `vec.rs` becomes `vector.rs`. +* All files with abbreviated names have been renamed to their full version, + e.g., `vec.rs` becomes `vector.rs`. ## [0.7.0] -### Added - * Added implementation of assignment operators (+=, -=, etc.) for - everything. -### Modified - * Points and vectors are now linked to each other with associated types - (on the PointAsVector trait). +### Added + +* Added implementation of assignment operators (+=, -=, etc.) for + everything. + +### Modified + +* Points and vectors are now linked to each other with associated types + (on the PointAsVector trait). ## [0.6.0] + **Announcement:** a users forum has been created for `nalgebra`, `ncollide`, and `nphysics`. See you [there](https://users.nphysics.org)! ### Added - * Added a dependency to [generic-array](https://crates.io/crates/generic-array). Feature-gated: - requires `features="generic_sizes"`. - * Added statically sized vectors with user-defined sizes: `VectorN`. Feature-gated: requires - `features="generic_sizes"`. - * Added similarity transformations (an uniform scale followed by a rotation followed by a - translation): `Similarity2`, `Similarity3`. + +* Added a dependency to [generic-array](https://crates.io/crates/generic-array). Feature-gated: + requires `features="generic_sizes"`. +* Added statically sized vectors with user-defined sizes: `VectorN`. Feature-gated: requires + `features="generic_sizes"`. +* Added similarity transformations (an uniform scale followed by a rotation followed by a + translation): `Similarity2`, `Similarity3`. ### Removed - * Removed zero-sized elements `Vector0`, `Point0`. - * Removed 4-dimensional transformations `Rotation4` and `Isometry4` (which had an implementation too incomplete to be useful). + +* Removed zero-sized elements `Vector0`, `Point0`. +* Removed 4-dimensional transformations `Rotation4` and `Isometry4` (which had an implementation too incomplete to be + useful). ### Modified - * 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). - * `{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` - variant to build a view matrix that - may be successfully used with `Persp` and `Ortho`. - * The old `{Isometry3, Rotation3}::look_at` implementations are now called `::new_observer_frame`. - * Rename every `fov` on `Persp` to `fovy`. - * Fixed the perspective and orthographic projection matrices. + +* 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). +* `{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` + variant to build a view matrix that + may be successfully used with `Persp` and `Ortho`. +* The old `{Isometry3, Rotation3}::look_at` implementations are now called `::new_observer_frame`. +* Rename every `fov` on `Persp` to `fovy`. +* Fixed the perspective and orthographic projection matrices. diff --git a/Cargo.toml b/Cargo.toml index eacfd09f..3141f9e4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,15 +1,15 @@ [package] -name = "nalgebra" -version = "0.32.5" -authors = [ "Sébastien Crozet " ] +name = "nalgebra" +version = "0.32.6" +authors = ["Sébastien Crozet "] description = "General-purpose linear algebra library with transformations and statically-sized or dynamically-sized matrices." documentation = "https://www.nalgebra.org/docs" homepage = "https://nalgebra.org" repository = "https://github.com/dimforge/nalgebra" readme = "README.md" -categories = [ "science", "mathematics", "wasm", "no-std" ] -keywords = [ "linear", "algebra", "matrix", "vector", "math" ] +categories = ["science", "mathematics", "wasm", "no-std"] +keywords = ["linear", "algebra", "matrix", "vector", "math"] license = "BSD-3-Clause" edition = "2018" exclude = ["/ci/*", "/.travis.yml", "/Makefile"] @@ -22,108 +22,108 @@ name = "nalgebra" path = "src/lib.rs" [features] -default = [ "std", "macros" ] -std = [ "matrixmultiply", "simba/std" ] -sparse = [ ] -debug = [ "approx/num-complex", "rand" ] -alloc = [ ] -io = [ "pest", "pest_derive" ] -compare = [ "matrixcompare-core" ] -libm = [ "simba/libm" ] -libm-force = [ "simba/libm_force" ] -macros = [ "nalgebra-macros" ] -cuda = [ "cust_core", "simba/cuda" ] +default = ["std", "macros"] +std = ["matrixmultiply", "simba/std"] +sparse = [] +debug = ["approx/num-complex", "rand"] +alloc = [] +io = ["pest", "pest_derive"] +compare = ["matrixcompare-core"] +libm = ["simba/libm"] +libm-force = ["simba/libm_force"] +macros = ["nalgebra-macros"] +cuda = ["cust_core", "simba/cuda"] # Conversion -convert-mint = [ "mint" ] -convert-bytemuck = [ "bytemuck" ] -convert-glam014 = [ "glam014" ] -convert-glam015 = [ "glam015" ] -convert-glam016 = [ "glam016" ] -convert-glam017 = [ "glam017" ] -convert-glam018 = [ "glam018" ] -convert-glam019 = [ "glam019" ] -convert-glam020 = [ "glam020" ] -convert-glam021 = [ "glam021" ] -convert-glam022 = [ "glam022" ] -convert-glam023 = [ "glam023" ] -convert-glam024 = [ "glam024" ] -convert-glam025 = [ "glam025" ] -convert-glam027 = [ "glam027" ] +convert-mint = ["mint"] +convert-bytemuck = ["bytemuck"] +convert-glam014 = ["glam014"] +convert-glam015 = ["glam015"] +convert-glam016 = ["glam016"] +convert-glam017 = ["glam017"] +convert-glam018 = ["glam018"] +convert-glam019 = ["glam019"] +convert-glam020 = ["glam020"] +convert-glam021 = ["glam021"] +convert-glam022 = ["glam022"] +convert-glam023 = ["glam023"] +convert-glam024 = ["glam024"] +convert-glam025 = ["glam025"] +convert-glam027 = ["glam027"] # Serialization ## To use serde in a #[no-std] environment, enable the ## `serde-serialize-no-std` feature instead of `serde-serialize`. ## Serialization of dynamically-sized matrices/vectors require ## `serde-serialize`. -serde-serialize-no-std = [ "serde", "num-complex/serde" ] -serde-serialize = [ "serde-serialize-no-std", "serde/std" ] -rkyv-serialize-no-std = [ "rkyv/size_32" ] -rkyv-serialize = [ "rkyv-serialize-no-std", "rkyv/std", "rkyv/validation" ] +serde-serialize-no-std = ["serde", "num-complex/serde"] +serde-serialize = ["serde-serialize-no-std", "serde/std"] +rkyv-serialize-no-std = ["rkyv/size_32"] +rkyv-serialize = ["rkyv-serialize-no-std", "rkyv/std", "rkyv/validation"] # Randomness ## To use rand in a #[no-std] environment, enable the ## `rand-no-std` feature instead of `rand`. -rand-no-std = [ "rand-package" ] -rand = [ "rand-no-std", "rand-package/std", "rand-package/std_rng", "rand_distr" ] +rand-no-std = ["rand-package"] +rand = ["rand-no-std", "rand-package/std", "rand-package/std_rng", "rand_distr"] # Tests -arbitrary = [ "quickcheck" ] -proptest-support = [ "proptest" ] -slow-tests = [] -rkyv-safe-deser = [ "rkyv-serialize", "rkyv/validation" ] +arbitrary = ["quickcheck"] +proptest-support = ["proptest"] +slow-tests = [] +rkyv-safe-deser = ["rkyv-serialize", "rkyv/validation"] [dependencies] nalgebra-macros = { version = "0.2.1", path = "nalgebra-macros", optional = true } -typenum = "1.12" -rand-package = { package = "rand", version = "0.8", optional = true, default-features = false } -num-traits = { version = "0.2", default-features = false } -num-complex = { version = "0.4", default-features = false } -num-rational = { version = "0.4", default-features = false } -approx = { version = "0.5", default-features = false } -simba = { version = "0.8", default-features = false } -alga = { version = "0.9", default-features = false, optional = true } -rand_distr = { version = "0.4", default-features = false, optional = true } +typenum = "1.12" +rand-package = { package = "rand", version = "0.8", optional = true, default-features = false } +num-traits = { version = "0.2", default-features = false } +num-complex = { version = "0.4", default-features = false } +num-rational = { version = "0.4", default-features = false } +approx = { version = "0.5", default-features = false } +simba = { version = "0.8", default-features = false } +alga = { version = "0.9", default-features = false, optional = true } +rand_distr = { version = "0.4", default-features = false, optional = true } matrixmultiply = { version = "0.3", optional = true } -serde = { version = "1.0", default-features = false, features = [ "derive" ], optional = true } -rkyv = { version = "0.7.41", default-features = false, optional = true } -mint = { version = "0.5", optional = true } -quickcheck = { version = "1", optional = true } -pest = { version = "2", optional = true } -pest_derive = { version = "2", optional = true } -bytemuck = { version = "1.5", optional = true } +serde = { version = "1.0", default-features = false, features = ["derive"], optional = true } +rkyv = { version = "0.7.41", default-features = false, optional = true } +mint = { version = "0.5", optional = true } +quickcheck = { version = "1", optional = true } +pest = { version = "2", optional = true } +pest_derive = { version = "2", optional = true } +bytemuck = { version = "1.5", optional = true } matrixcompare-core = { version = "0.1", optional = true } -proptest = { version = "1", optional = true, default-features = false, features = ["std"] } -glam014 = { package = "glam", version = "0.14", optional = true } -glam015 = { package = "glam", version = "0.15", optional = true } -glam016 = { package = "glam", version = "0.16", optional = true } -glam017 = { package = "glam", version = "0.17", optional = true } -glam018 = { package = "glam", version = "0.18", optional = true } -glam019 = { package = "glam", version = "0.19", optional = true } -glam020 = { package = "glam", version = "0.20", optional = true } -glam021 = { package = "glam", version = "0.21", optional = true } -glam022 = { package = "glam", version = "0.22", optional = true } -glam023 = { package = "glam", version = "0.23", optional = true } -glam024 = { package = "glam", version = "0.24", optional = true } -glam025 = { package = "glam", version = "0.25", optional = true } -glam027 = { package = "glam", version = "0.27", optional = true } -cust_core = { version = "0.1", optional = true } -rayon = { version = "1.6", optional = true } +proptest = { version = "1", optional = true, default-features = false, features = ["std"] } +glam014 = { package = "glam", version = "0.14", optional = true } +glam015 = { package = "glam", version = "0.15", optional = true } +glam016 = { package = "glam", version = "0.16", optional = true } +glam017 = { package = "glam", version = "0.17", optional = true } +glam018 = { package = "glam", version = "0.18", optional = true } +glam019 = { package = "glam", version = "0.19", optional = true } +glam020 = { package = "glam", version = "0.20", optional = true } +glam021 = { package = "glam", version = "0.21", optional = true } +glam022 = { package = "glam", version = "0.22", optional = true } +glam023 = { package = "glam", version = "0.23", optional = true } +glam024 = { package = "glam", version = "0.24", optional = true } +glam025 = { package = "glam", version = "0.25", optional = true } +glam027 = { package = "glam", version = "0.27", optional = true } +cust_core = { version = "0.1", optional = true } +rayon = { version = "1.6", optional = true } [dev-dependencies] serde_json = "1.0" rand_xorshift = "0.3" rand_isaac = "0.3" criterion = { version = "0.4", features = ["html_reports"] } -nalgebra = { path = ".", features = ["debug", "compare", "rand", "macros"]} +nalgebra = { path = ".", features = ["debug", "compare", "rand", "macros"] } # For matrix comparison macro matrixcompare = "0.3.0" itertools = "0.10" [workspace] -members = [ "nalgebra-lapack", "nalgebra-glm", "nalgebra-sparse", "nalgebra-macros" ] +members = ["nalgebra-lapack", "nalgebra-glm", "nalgebra-sparse", "nalgebra-macros"] resolver = "2" [[example]]