1# Change Log 2All notable changes to `nalgebra`, starting with the version 0.6.0 will be 3documented here. 4 5This project adheres to [Semantic Versioning](https://semver.org/). 6 7## [0.19.0] - WIP 8### Added 9 * `.remove_rows_at` and `remove_columns_at` which removes a set of rows or columns (specified by indices) from a matrix. 10 11## [0.18.0] 12This release adds full complex number support to nalgebra. This includes all common vector/matrix operations as well 13as matrix decomposition. This excludes geometric type (like `Isometry`, `Rotation`, `Translation`, etc.) from the 14`geometry` module. 15 16### Added 17#### Quaternion and geometric operations 18 * Add trigonometric functions for quaternions: `.cos, .sin, .tan, .acos, .asin, .atan, .cosh, .sinh, .tanh, .acosh, .asinh, .atanh`. 19 * Add geometric algebra operations for quaternions: `.inner, .outer, .project, .rejection` 20 * Add `.left_div, .right_div` for quaternions. 21 * Add `.renormalize` to `Unit<...>` and `Rotation3` to correct potential drift due to repeated operations. 22 Those drifts could cause them not to be pure rotations anymore. 23 24#### Convolution 25 * `.convolve_full(kernel)` returns the convolution of `self` by `kernel`. 26 * `.convolve_valid(kernel)` returns the convolution of `self` by `kernel` after removal of all the elements relying on zero-padding. 27 * `.convolve_same(kernel)` returns the convolution of `self` by `kernel` with a result of the same size as `self`. 28 29#### Complex number support 30 * Add the `::from_matrix` constructor too all rotation types to extract a rotation from a raw matrix. 31 * Add the `::from_matrix_eps` constructor too all rotation types to extract a rotation from a raw matrix. This takes 32 more argument than `::from_matrix` to control the convergence of the underlying optimization algorithm. 33 * Add `.camax()` which returns the matrix component with the greatest L1-norm. 34 * Add `.camin()` which returns the matrix component with the smallest L1-norm. 35 * Add `.ad_mul(b)` for matrix-multiplication of `self.adjoint() * b`. 36 * 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. 37 * Add BLAS operations involving complex conjugation (following similar names as the original BLAS spec): 38 * `.dotc(rhs)` equal to `self.adjoint() * rhs`. 39 * `.gerc(alpha, x, y, beta)` equivalent to `self = alpha * x * y.adjoint() + beta * self` 40 * `.hegerc` which is like `gerc` but for Hermitian matrices. 41 * `.syger` which is the new name of `.ger_symm` which is equivalent to `self = alpha * x * y.transpose() + beta * self`. 42 * `.sygemv` which is the new name of `.gemv_symm` which is equivalent to `self = alpha * a * x + beta * self` with `a` symmetric. 43 * `.hegemv(alpha, a, x, beta)` which is like `.sygemv` but with `a` Hermitian. 44 * `.gemv_ad(alpha, a, x, beta)` which is equivalent to `self = alpha * a.adjoint() * x + beta * self`. 45 * `.gemm_ad(alpha, a, b, beta)` which is equivalent to `self = alpha * a.adjoint() * b + beta * self`. 46 * `.icamax()` which returns the index of the complex vector component with the greatest L1-norm. 47 48Note that all the other BLAS operation will continue to work for all fields, including floats and complex numbers. 49 50### Renamed 51 * `RealSchur` has been renamed `Schur` because it can now work with complex matrices. 52 53 54## [0.17.0] 55 56### Added 57 * 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)`. 58 * 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)`. 59 * Add `.copy_from_slice` to copy matrix components from a slice in column-major order. 60 * Add `.dot` to quaternions. 61 * Add `.zip_zip_map` for iterating on three matrices simultaneously, and applying a closure to them. 62 * Add `.slerp` and `.try_slerp` to unit vectors. 63 * Add `.lerp` to vectors. 64 * Add `.to_projective` and `.as_projective` to `Perspective3` and `Orthographic3` in order to 65 use them as `Projective3` structures. 66 * Add `From/Into` impls to allow the conversion of any transformation type to a matrix. 67 * Add `Into` impls to convert a matrix slice into an owned matrix. 68 * Add `Point*::from_slice` to create a point from a slice. 69 * Add `.map_with_location` to matrices to apply a map which passes the component indices to the user-defined closure alongside 70 the component itself. 71 * Add impl `From<Vector>` for `Point`. 72 * Add impl `From<Vector4>` for `Quaternion`. 73 * Add impl `From<Vector>` for `Translation`. 74 * Add the `::from_vec` constructor to construct a matrix from a `Vec` (a `DMatrix` will reuse the original `Vec` 75 as-is for its storage). 76 * Add `.to_homogeneous` to square matrices (and with dimensions higher than 1x1). This will increase their number of row 77 and columns by 1. The new column and row are filled with 0, except for the diagonal element which is set to 1. 78 * Implement `Extend<Vec>` for matrices with a dynamic storage. The provided `Vec` is assumed to represent a column-major 79 matrix with the same number of rows as the one being extended. This will effectively append new columns on the right of 80 the matrix being extended. 81 * Implement `Extend<Vec>` for vectors with a dynamic storage. This will concatenate the vector with the given `Vec`. 82 * Implement `Extend<Matrix<...>>` for matrices with dynamic storage. This will concatenate the columns of both matrices. 83 * Implement `Into<Vec>` for the `MatrixVec` storage. 84 * Implement `Hash` for all matrices. 85 * Add a `.len()` method to retrieve the size of a `MatrixVec`. 86 87### Modified 88 * The orthographic projection no longer require that `bottom < top`, that `left < right`, and that `znear < zfar`. The 89 only restriction now ith that they must not be equal (in which case the projection would be singular). 90 * The `Point::from_coordinates` methods is deprecated. Use `Point::from` instead. 91 * The `.transform_point` and `.transform_vector` methods are now inherent methods for matrices so that the user does not have to 92 explicitly import the `Transform` trait from the alga crate. 93 * Renamed the matrix storage types: `MatrixArray` -> `ArrayStorage` and `MatrixVec` -> `VecStorage`. 94 * Renamed `.unwrap()` to `.into_inner()` for geometric types that wrap another type. 95 This is for the case of `Unit`, `Transform`, `Orthographic3`, `Perspective3`, `Rotation`. 96 * Deprecate several functions at the root of the crate (replaced by methods). 97 98### Removed 99 * Remove the `Deref` impl for `MatrixVec` as it could cause hard-to-understand compilation errors. 100 101### nalgebra-glm 102 * Add several alternative projection computations, e.g., `ortho_lh`, `ortho_lh_no`, `perspective_lh`, etc. 103 * Add features matching those of nalgebra, in particular: `serde-serialize`, `abmonation-serialize`, std` (enabled by default). 104 105## [0.16.0] 106All dependencies have been updated to their latest versions. 107 108## Modified 109 * Adjust `UnitQuaternion`s, `Rotation3`s, and `Rotation2`s generated from the `Standard` distribution to be uniformly distributed. 110### Added 111 * Add a feature `stdweb` to activate the dependency feature `rand/stdweb`. 112 * Add blas-like methods `.imin()` and `.imax()` that return the index of the minimum and maximum entry of a vector. 113 * Add construction of a `Point` from an array by implementing the `From` trait. 114 * Add support for generating uniformly distributed random unit column vectors using the `Standard` distribution. 115 116## [0.15.0] 117The most notable change of this release is the support for using part of the library without the rust standard 118library (i.e. it supports `#![no_std]`). See the corresponding [documentation](https://nalgebra.org/wasm_and_embedded_programming/). 119### Modified 120 * Rename the `core` module to `base` to avoid conflicts with the `core` crate implicitly imported when 121 `#![no_std]` is enabled. 122 * Constructors of the `MatrixSlice*` types have been renamed from `new_*` to `from_slice_*`. This was 123 necessary to avoid the `incoherent_fundamental_impls` lint that is going to become a hard error. 124### Added 125 * Add `UnitQuaternion` constructor `::new_eps(...)` and `::from_scaled_axis_eps(...)` that return the 126 identity if the magnitude of the input axisangle is smaller than the epsilon provided. 127 * Add methods `.rotation_between_axis(...)` and `.scaled_rotation_between_axis(...)` to `UnitComplex` 128 to compute the rotation matrix between two 2D **unit** vectors. 129 * Add methods `.axis_angle()` to `UnitComplex` and `UnitQuaternion` in order to retrieve both the 130 unit rotation axis and the rotation angle simultaneously. 131 * Add functions to construct a random matrix with a user-defined distribution: `::from_distribution(...)`. 132 133## [0.14.0] 134### Modified 135 * Allow the `Isometry * Unit<Vector>` multiplication. 136### Added 137 * Add blas-like operations: `.quadform(...)` and `.quadform_tr(...)` to compute respectively 138 the quadratic forms `self = alpha * A.transpose() * B * A + beta * self` and 139 `alpha * A * B * A.transpose() + beta * self`. Here, `A, B` are matrices with 140 `B` square, and `alpha, beta` are reals. 141 * Add blas-like operations: `.gemv_tr(...)` that behaves like `.gemv` except that the 142 provided matrix is assumed to be transposed. 143 * Add blas-like operations: `cmpy, cdpy` for component-wise multiplications and 144 division with scalar factors: 145 - `self <- alpha * self + beta * a * b` 146 - `self <- alpha * self + beta * a / b` 147 * `.cross_matrix()` returns the cross-product matrix of a given 3D vector, i.e., 148 the matrix `M` such that for all vector `v` we have 149 `M * v == self.cross(&v)`. 150 * `.iamin()` that returns the index of the vector entry with 151 smallest absolute value. 152 * The `mint` feature that can be enabled in order to allow conversions from 153 and to types of the [mint](https://crates.io/crates/mint) crate. 154 * Aliases for matrix and vector slices. Their are named by adding `Slice` 155 before the dimension numbers, i.e., a 3x5 matrix slice with dimensions known 156 at compile-time is called `MatrixSlice3x5`. A vector slice with dimensions 157 unknown at compile-time is called `DVectorSlice`. 158 * Add functions for constructing matrix slices from a slice `&[N]`, e.g., 159 `MatrixSlice2::new(...)` and `MatrixSlice2::new_with_strides(...)`. 160 * The `::repeat(...)` constructor that is an alternative name to 161 `::from_element(...)`. 162 * `UnitQuaternion::scaled_rotation_between_axis(...)` and 163 `UnitQuaternion::rotation_between_axis(...)` that take Unit vectors instead of 164 Vector as arguments. 165 166 167 168## [0.13.0] 169 170The **nalgebra-lapack** crate has been updated. This now includes a broad range 171matrix decompositions using LAPACK bindings. 172 173This adds support for serialization using the 174[abomonation](https://crates.io/crates/abomonation) crate. 175 176### Breaking semantic change 177 * The implementation of slicing with steps now matches the documentation. 178 Before, step identified the number to add to pass from one column/row index 179 to the next one. This made 0 step invalid. Now (and on the documentation so 180 far), the step is the number of ignored row/columns between each 181 row/column. Thus, a step of 0 means that no row/column is ignored. For 182 example, a step of, say, 3 on previous versions should now bet set to 2. 183 184### Modified 185 * The trait `Axpy` has been replaced by a method `.axpy`. 186 * The alias `MatrixNM` is now deprecated. Use `MatrixMN` instead (we 187 reordered M and N to be in alphabetical order). 188 * In-place componentwise multiplication and division 189 `.component_mul_mut(...)` and `.component_div_mut(...)` have bee deprecated 190 for a future renaming. Use `.component_mul_assign(...)` and 191 `.component_div_assign(...)` instead. 192 193### Added 194 * `alga::general::Real` is now re-exported by nalgebra. 195 elements.) 196 * `::zeros(...)` that creates a matrix filled with zeroes. 197 * `::from_partial_diagonal(...)` that creates a matrix from diagonal elements. 198 The matrix can be rectangular. If not enough elements are provided, the rest 199 of the diagonal is set to 0. 200 * `.conjugate_transpose()` computes the transposed conjugate of a 201 complex matrix. 202 * `.conjugate_transpose_to(...)` computes the transposed conjugate of a 203 complex matrix. The result written into a user-provided matrix. 204 * `.transpose_to(...)` is the same as `.transpose()` but stores the result in 205 the provided matrix. 206 * `.conjugate_transpose_to(...)` is the same as `.conjugate_transpose()` but 207 stores the result in the provided matrix. 208 * Implements `IntoIterator` for `&Matrix`, `&mut Matrix` and `Matrix`. 209 * `.mul_to(...)` multiplies two matrices and stores the result to the given buffer. 210 * `.tr_mul_to(...)` left-multiplies `self.transpose()` to another matrix and stores the result to the given buffer. 211 * `.add_scalar(...)` that adds a scalar to each component of a matrix. 212 * `.add_scalar_mut(...)` that adds in-place a scalar to each component of a matrix. 213 * `.kronecker(a, b)` computes the kronecker product (i.e. matrix tensor 214 product) of two matrices. 215 * `.apply(f)` replaces each component of a matrix with the results of the 216 closure `f` called on each of them. 217 218Pure Rust implementation of some Blas operations: 219 220 * `.iamax()` returns the index of the maximum value of a vector. 221 * `.axpy(...)` computes `self = a * x + b * self`. 222 * `.gemv(...)` computes `self = alpha * a * x + beta * self` with a matrix and vector `a` and `x`. 223 * `.ger(...)` computes `self = alpha * x^t * y + beta * self` where `x` and `y` are vectors. 224 * `.gemm(...)` computes `self = alpha * a * b + beta * self` where `a` and `b` are matrices. 225 * `.gemv_symm(...)` is the same as `.gemv` except that `self` is assumed symmetric. 226 * `.ger_symm(...)` is the same as `.ger` except that `self` is assumed symmetric. 227 228New slicing methods: 229 * `.rows_range(...)` that retrieves a reference to a range of rows. 230 * `.rows_range_mut(...)` that retrieves a mutable reference to a range of rows. 231 * `.columns_range(...)` that retrieves a reference to a range of columns. 232 * `.columns_range_mut(...)` that retrieves a mutable reference to a range of columns. 233 234Matrix decompositions implemented in pure Rust: 235 * Cholesky, SVD, LU, QR, Hessenberg, Schur, Symmetric eigendecompositions, 236 Bidiagonal, Symmetric tridiagonal 237 * Computation of householder reflectors and givens rotations. 238 239Matrix edition: 240 * `.upper_triangle()` extracts the upper triangle of a matrix, including the diagonal. 241 * `.lower_triangle()` extracts the lower triangle of a matrix, including the diagonal. 242 * `.fill(...)` fills the matrix with a single value. 243 * `.fill_with_identity(...)` fills the matrix with the identity. 244 * `.fill_diagonal(...)` fills the matrix diagonal with a single value. 245 * `.fill_row(...)` fills a selected matrix row with a single value. 246 * `.fill_column(...)` fills a selected matrix column with a single value. 247 * `.set_diagonal(...)` sets the matrix diagonal. 248 * `.set_row(...)` sets a selected row. 249 * `.set_column(...)` sets a selected column. 250 * `.fill_lower_triangle(...)` fills some sub-diagonals below the main diagonal with a value. 251 * `.fill_upper_triangle(...)` fills some sub-diagonals above the main diagonal with a value. 252 * `.swap_rows(...)` swaps two rows. 253 * `.swap_columns(...)` swaps two columns. 254 255Column removal: 256 * `.remove_column(...)` removes one column. 257 * `.remove_fixed_columns<D>(...)` removes `D` columns. 258 * `.remove_columns(...)` removes a number of columns known at run-time. 259 260Row removal: 261 * `.remove_row(...)` removes one row. 262 * `.remove_fixed_rows<D>(...)` removes `D` rows. 263 * `.remove_rows(...)` removes a number of rows known at run-time. 264 265Column insertion: 266 * `.insert_column(...)` adds one column at the given position. 267 * `.insert_fixed_columns<D>(...)` adds `D` columns at the given position. 268 * `.insert_columns(...)` adds at the given position a number of columns known at run-time. 269 270Row insertion: 271 * `.insert_row(...)` adds one row at the given position. 272 * `.insert_fixed_rows<D>(...)` adds `D` rows at the given position. 273 * `.insert_rows(...)` adds at the given position a number of rows known at run-time. 274 275## [0.12.0] 276The main change of this release is the update of the dependency serde to 1.0. 277 278### Added 279 * `.trace()` that computes the trace of a matrix (the sum of its diagonal 280 elements.) 281 282## [0.11.0] 283The [website](https://nalgebra.org) has been fully rewritten and gives a good 284overview of all the added/modified features. 285 286This version is a major rewrite of the library. Major changes are: 287 * Algebraic traits are now defined by the [alga](https://crates.io/crates/alga) crate. 288 All other mathematical traits, except `Axpy` have been removed from 289 **nalgebra**. 290 * Methods are now preferred to free functions because they do not require any 291 trait to be used any more. 292 * Most algebraic entities can be parametrized by type-level integers 293 to specify their dimensions. Using `Dynamic` instead of a type-level 294 integer indicates that the dimension known at run-time only. 295 * Statically-sized **rectangular** matrices. 296 * More transformation types have been added: unit-sized complex numbers (for 297 2D rotations), affine/projective/general transformations with `Affine2/3`, 298 `Projective2/3`, and `Transform2/3`. 299 * Serde serialization is now supported instead of `rustc_serialize`. Enable 300 it with the `serde-serialize` feature. 301 * Matrix **slices** are now implemented. 302 303### Added 304Lots of features including rectangular matrices, slices, and Serde 305serialization. Refer to the brand new [website](https://nalgebra.org) for more 306details. The following free-functions have been added as well: 307 * `::id()` that returns the universal [identity element](https://nalgebra.org/performance_tricks/#the-id-type) 308 of type `Id`. 309 * `::inf_sup()` that returns both the infimum and supremum of a value at the 310 same time. 311 * `::partial_sort2()` that attempts to sort two values in increasing order. 312 * `::wrap()` that moves a value to the given interval by adding or removing 313 the interval width to it. 314 315### Modified 316 * `::cast` -> `::convert` 317 * `point.as_vector()` -> `point.coords` 318 * `na::origin` -> `P::origin()` 319 * `na::is_zero` -> `.is_zero()` (from num::Zero) 320 * `.transform` -> `.transform_point`/`.transform_vector` 321 * `.translate` -> `.translate_point` 322 * `::dimension::<P>` -> `::dimension::<P::Vector>` 323 * `::angle_between` -> `::angle` 324 325Componentwise multiplication and division has been replaced by methods: 326 * multiplication -> `.componentwise_mul`, `.componentwise_mul_mut`. 327 * division -> `.componentwise_div`, `.componentwise_div_mut`. 328 329The following free-functions are now replaced by methods (with the same names) 330only: 331`::cross`, `::cholesky`, `::determinant`, `::diagonal`, `::eigen_qr` (becomes 332`.eig`), `::hessenberg`, `::qr`, `::to_homogeneous`, `::to_rotation_matrix`, 333`::transpose`, `::shape`. 334 335 336The following free-functions are now replaced by static methods only: 337 * `::householder_matrix` under the name `::new_householder_generic` 338 * `::identity` 339 * `::new_identity` under the name `::identity` 340 * `::from_homogeneous` 341 * `::repeat` under the name `::from_element` 342 343The following free-function are now replaced methods accessible through traits 344only: 345 * `::transform` -> methods `.transform_point` and `.transform_vector` of the `alga::linear::Transformation` trait. 346 * `::inverse_transform` -> methods `.inverse_transform_point` and 347 `.inverse_transform_vector` of the `alga::linear::ProjectiveTransformation` 348 trait. 349 * `::translate`, `::inverse_translate`, `::rotate`, `::inverse_rotate` -> 350 methods from the `alga::linear::Similarity` trait instead. Those have the 351 same names but end with `_point` or `_vector`, e.g., `.translate_point` and 352 `.translate_vector`. 353 * `::orthonormal_subspace_basis` -> method with the same name from 354 `alga::linear::FiniteDimInnerSpace`. 355 * `::canonical_basis_element` and `::canonical_basis` -> methods with the 356 same names from `alga::linear::FiniteDimVectorSpace`. 357 * `::rotation_between` -> method with the same name from the 358 `alga::linear::Rotation` trait. 359 * `::is_zero` -> method with the same name from `num::Zero`. 360 361 362 363### Removed 364 * The free functions `::prepend_rotation`, `::append_rotation`, 365 `::append_rotation_wrt_center`, `::append_rotation_wrt_point`, 366 `::append_transformation`, and `::append_translation ` have been removed. 367 Instead create the rotation or translation object explicitly and use 368 multiplication to compose it with anything else. 369 370 * The free function `::outer` has been removed. Use column-vector × 371 row-vector multiplication instead. 372 373 * `::approx_eq`, `::approx_eq_eps` have been removed. Use the `relative_eq!` 374 macro from the [approx](https://crates.io/crates/approx) crate instead. 375 376 * `::covariance` has been removed. There is no replacement for now. 377 * `::mean` has been removed. There is no replacement for now. 378 * `::sample_sphere` has been removed. There is no replacement for now. 379 * `::cross_matrix` has been removed. There is no replacement for now. 380 * `::absolute_rotate` has been removed. There is no replacement for now. 381 * `::rotation`, `::transformation`, `::translation`, `::inverse_rotation`, 382 `::inverse_transformation`, `::inverse_translation` have been removed. Use 383 the appropriate methods/field of each transformation type, e.g., 384 `rotation.angle()` and `rotation.axis()`. 385 386## [0.10.0] 387### Added 388Binary operations are now allowed between references as well. For example 389`Vector3<f32> + &Vector3<f32>` is now possible. 390 391### Modified 392Removed unused parameters to methods from the `ApproxEq` trait. Those were 393required before rust 1.0 to help type inference. The are not needed any more 394since it now allowed to write for a type `T` that implements `ApproxEq`: 395`<T as ApproxEq>::approx_epsilon()`. This replaces the old form: 396`ApproxEq::approx_epsilon(None::<T>)`. 397 398## [0.9.0] 399### Modified 400 * Renamed: 401 - `::from_col_vector` -> `::from_column_vector` 402 - `::from_col_iter` -> `::from_column_iter` 403 - `.col_slice` -> `.column_slice` 404 - `.set_col` -> `.set_column` 405 - `::canonical_basis_with_dim` -> `::canonical_basis_with_dimension` 406 - `::from_elem` -> `::from_element` 407 - `DiagMut` -> `DiagonalMut` 408 - `UnitQuaternion::new` becomes `UnitQuaternion::from_scaled_axis` or 409 `UnitQuaternion::from_axisangle`. The new `::new` method now requires a 410 not-normalized quaternion. 411 412Methods names starting with `new_with_` now start with `from_`. This is more 413idiomatic in Rust. 414 415The `Norm` trait now uses an associated type instead of a type parameter. 416Other similar trait changes are to be expected in the future, e.g., for the 417`Diagonal` trait. 418 419Methods marked `unsafe` for reasons unrelated to memory safety are no 420longer unsafe. Instead, their name end with `_unchecked`. In particular: 421* `Rotation3::new_with_matrix` -> `Rotation3::from_matrix_unchecked` 422* `PerspectiveMatrix3::new_with_matrix` -> `PerspectiveMatrix3::from_matrix_unchecked` 423* `OrthographicMatrix3::new_with_matrix` -> `OrthographicMatrix3::from_matrix_unchecked` 424 425### Added 426- A `Unit<T>` type that wraps normalized values. In particular, 427 `UnitQuaternion<N>` is now an alias for `Unit<Quaternion<N>>`. 428- `.ln()`, `.exp()` and `.powf(..)` for quaternions and unit quaternions. 429- `::from_parts(...)` to build a quaternion from its scalar and vector 430 parts. 431- The `Norm` trait now has a `try_normalize()` that returns `None` if the 432norm is too small. 433- The `BaseFloat` and `FloatVector` traits now inherit from `ApproxEq` as 434 well. It is clear that performing computations with floats requires 435 approximate equality. 436 437Still WIP: add implementations of abstract algebra traits from the `algebra` 438crate for vectors, rotations and points. To enable them, activate the 439`abstract_algebra` feature. 440 441## [0.8.0] 442### Modified 443 * Almost everything (types, methods, and traits) now use full names instead 444 of abbreviations (e.g. `Vec3` becomes `Vector3`). Most changes are abvious. 445 Note however that: 446 - `::sqnorm` becomes `::norm_squared`. 447 - `::sqdist` becomes `::distance_squared`. 448 - `::abs`, `::min`, etc. did not change as this is a common name for 449 absolute values on, e.g., the libc. 450 - Dynamically sized structures keep the `D` prefix, e.g., `DMat` becomes 451 `DMatrix`. 452 * All files with abbreviated names have been renamed to their full version, 453 e.g., `vec.rs` becomes `vector.rs`. 454 455## [0.7.0] 456### Added 457 * Added implementation of assignment operators (+=, -=, etc.) for 458 everything. 459### Modified 460 * Points and vectors are now linked to each other with associated types 461 (on the PointAsVector trait). 462 463 464## [0.6.0] 465**Announcement:** a users forum has been created for `nalgebra`, `ncollide`, and `nphysics`. See 466you [there](https://users.nphysics.org)! 467 468### Added 469 * Added a dependency to [generic-array](https://crates.io/crates/generic-array). Feature-gated: 470 requires `features="generic_sizes"`. 471 * Added statically sized vectors with user-defined sizes: `VectorN`. Feature-gated: requires 472 `features="generic_sizes"`. 473 * Added similarity transformations (an uniform scale followed by a rotation followed by a 474 translation): `Similarity2`, `Similarity3`. 475 476### Removed 477 * Removed zero-sized elements `Vector0`, `Point0`. 478 * Removed 4-dimensional transformations `Rotation4` and `Isometry4` (which had an implementation to incomplete to be useful). 479 480### Modified 481 * Vectors are now multipliable with isometries. This will result into a pure rotation (this is how 482 vectors differ from point semantically: they design directions so they are not translatable). 483 * `{Isometry3, Rotation3}::look_at` reimplemented and renamed to `::look_at_rh` and `::look_at_lh` to agree 484 with the computer graphics community (in particular, the GLM library). Use the `::look_at_rh` 485 variant to build a view matrix that 486 may be successfully used with `Persp` and `Ortho`. 487 * The old `{Isometry3, Rotation3}::look_at` implementations are now called `::new_observer_frame`. 488 * Rename every `fov` on `Persp` to `fovy`. 489 * Fixed the perspective and orthographic projection matrices. 490