All Versions
51
Avg Release Cycle
70 days
Latest Release
616 days ago

Changelog History Page 3

• v0.23.1 Changes

📚 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` directly (instead of being aliases for other aliases).
• v0.23.0 Changes

• 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<Vector2/3>`.
• 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<Vector3<f32>>` 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.
• v0.22.0 Changes

🚀 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 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.

• 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 use 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`.
• v0.21.1

June 07, 2020
• v0.21.0 Changes

April 05, 2020

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 crate which are both simpler, and allow for significant optimizations like AoSoA SIMD.

• 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. ### ✂ 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.
• v0.20.0 Changes

• `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.
• v0.19.0 Changes

October 28, 2019

• `.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.

• Some infinite and reversed perspectives: `::infinite_perspective_rh_no`, `::infinite_perspective_rh_zo`, `::reversed_perspective_rh_zo`, and `::reversed_infinite_perspective_rh_zo`.
• v0.18.2

September 01, 2019
• v0.18.1

August 27, 2019
• v0.18.0 Changes

March 31, 2019

🚀 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.

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.

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`.

👍 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.

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.