All Versions
31
Latest Version
Avg Release Cycle
61 days
Latest Release
-

Changelog History
Page 1

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

    ๐Ÿš€ 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.

    โž• 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 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

    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.

    Refer to the monthly Rustsim blogpost 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. ### 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

    โž• 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.

    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

    October 28, 2019

    โž• 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."

    Modified

    • 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.
  • v0.18.2

    September 01, 2019
  • v0.18.1

    August 27, 2019
  • v0.18.0

    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.

    โž• 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.

    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.